@xylex-group/athena 2.12.1 → 2.13.0

package/dist/next/client.cjs

@@ -162,7 +162,7 @@ var getSessionCookie = (request2, config) => {
 
 // src/utils/athena-request-headers.ts
 var NO_CACHE_HEADER_VALUE = "no-cache";
-var API_KEY_HEADER_CANDIDATES = ["X-Api-Key", "x-api-key", "apikey"];
+var API_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key", "X-Api-Key", "x-api-key", "apikey"];
 var ATHENA_KEY_HEADER_CANDIDATES = ["X-Athena-Key", "x-athena-key"];
 var SESSION_TOKEN_HEADER_CANDIDATES = ["X-Athena-Auth-Session-Token"];
 var BEARER_MIRROR_HEADER_CANDIDATES = ["X-Athena-Auth-Bearer-Token"];
@@ -264,17 +264,6 @@ function buildServiceRequestHeaders(profile, sdkHeaderValue, config, options, ex
   });
 }
 function applyAthenaApiKeyHeaders(headers, apiKey, athenaKey) {
-  if (apiKey) {
-    if (!hasHeaderIgnoreCase(headers, "apikey")) {
-      headers.apikey = apiKey;
-    }
-    if (!Object.hasOwn(headers, "x-api-key")) {
-      headers["x-api-key"] = apiKey;
-    }
-    if (!Object.hasOwn(headers, "X-Api-Key")) {
-      headers["X-Api-Key"] = apiKey;
-    }
-  }
   const resolvedAthenaKey = normalizeHeaderValue(athenaKey) ?? normalizeHeaderValue(apiKey);
   if (resolvedAthenaKey && !hasHeaderIgnoreCase(headers, "X-Athena-Key")) {
     headers["X-Athena-Key"] = resolvedAthenaKey;
@@ -400,7 +389,7 @@ function buildAthenaRequestHeaders(input) {
 
 // package.json
 var package_default = {
-  version: "2.12.1"
+  version: "2.13.0"
 };
 
 // src/sdk-version.ts
@@ -2829,38 +2818,6 @@ async function withRetry(config, fn) {
   throw new Error("withRetry reached an unexpected state");
 }
 
-// src/db/module.ts
-function createDbModule(input) {
-  const db = {
-    from: input.from,
-    select(table, first, second) {
-      if (first && typeof first === "object" && !Array.isArray(first)) {
-        return input.from(table).select(void 0, first);
-      }
-      return input.from(table).select(first, second);
-    },
-    insert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).insert(values, options) : input.from(table).insert(values, options);
-    },
-    upsert(table, values, options) {
-      return Array.isArray(values) ? input.from(table).upsert(values, options) : input.from(table).upsert(values, options);
-    },
-    update(table, values, options) {
-      return input.from(table).update(values, options);
-    },
-    delete(table, options) {
-      return input.from(table).delete(options);
-    },
-    rpc(fn, args, options) {
-      return input.rpc(fn, args, options);
-    },
-    query(query, options) {
-      return input.query(query, options);
-    }
-  };
-  return db;
-}
-
 // src/storage/file.ts
 function createStorageFileModule(base, config = {}) {
   const upload = async (input, options) => {
@@ -8439,7 +8396,30 @@ function createClientFromConfig(config, sourceConfig) {
     config.experimental,
     queryTracer
   );
-  const db = createDbModule({ from, rpc, query });
+  const untypedDbFrom = from;
+  const db = {
+    from,
+    select(table, first, second) {
+      if (first && typeof first === "object" && !Array.isArray(first)) {
+        return untypedDbFrom(table).select(void 0, first);
+      }
+      return untypedDbFrom(table).select(first, second);
+    },
+    insert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).insert(values, options) : untypedDbFrom(table).insert(values, options);
+    },
+    upsert(table, values, options) {
+      return Array.isArray(values) ? untypedDbFrom(table).upsert(values, options) : untypedDbFrom(table).upsert(values, options);
+    },
+    update(table, values, options) {
+      return untypedDbFrom(table).update(values, options);
+    },
+    delete(table, options) {
+      return untypedDbFrom(table).delete(options);
+    },
+    rpc,
+    query
+  };
   const chat = createChatModule({
     baseUrl: config.chatUrl,
     apiKey: config.apiKey,
@@ -8590,7 +8570,9 @@ function createClientFromConfig(config, sourceConfig) {
 var AthenaClient = class {
   /** Create a fluent builder for a strongly-typed Athena SDK client. */
   static builder() {
-    return createAthenaClientBuilder((config) => createClientFromInput(config));
+    return createAthenaClientBuilder(
+      (config) => createClientFromInput(config)
+    );
   }
   static fromEnvironment(options = {}) {
     const env = options.env ?? process.env;
@@ -8621,11 +8603,12 @@ var AthenaClient = class {
     });
   }
 };
-function createClient(configOrUrl, apiKey, options) {
+function createClient(...args) {
+  const [configOrUrl, apiKey, options] = args;
   if (typeof configOrUrl === "string" || configOrUrl === null || configOrUrl === void 0) {
     return createClientFromInput({
       url: configOrUrl,
-      key: "",
+      key: apiKey ?? "",
       ...options
     });
   }
@@ -8669,6 +8652,403 @@ function createAdapterClient(options, context) {
   return client;
 }
 
+// src/next/session-bridge/constants.ts
+var ATHENA_AUTH_SESSION_BRIDGE_ROUTE = "/api/athena-auth/session";
+var ATHENA_AUTH_SESSION_COOKIE_NAME = "athena-auth.session-token";
+var ATHENA_AUTH_SESSION_COOKIE_NAMES = [
+  ATHENA_AUTH_SESSION_COOKIE_NAME,
+  "athena-auth.session_token"
+];
+
+// src/next/session-bridge/client.ts
+var JSON_CONTENT_TYPE = "application/json";
+function isBrowserRuntime() {
+  return typeof globalThis !== "undefined" && "window" in globalThis;
+}
+async function persistAthenaAuthSessionOnAppHost(payload, options) {
+  if (!(payload && isBrowserRuntime())) {
+    return;
+  }
+  const route = options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+  const fetchImpl = options?.fetch ?? fetch;
+  const response = await fetchImpl(route, {
+    body: JSON.stringify(payload),
+    credentials: "same-origin",
+    headers: {
+      "Content-Type": JSON_CONTENT_TYPE
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new Error("Failed to persist the Athena Auth session on the app host");
+  }
+}
+async function clearAthenaAuthSessionOnAppHost(options) {
+  if (!isBrowserRuntime()) {
+    return;
+  }
+  const route = options?.route ?? ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+  const fetchImpl = options?.fetch ?? fetch;
+  const response = await fetchImpl(route, {
+    credentials: "same-origin",
+    method: "DELETE"
+  });
+  if (!response.ok) {
+    throw new Error("Failed to clear the Athena Auth session on the app host");
+  }
+}
+
+// src/next/session-bridge/payload.ts
+function resolveSessionBridgePayload(payload) {
+  const token = payload?.session?.token ?? payload?.token;
+  if (typeof token !== "string") {
+    return null;
+  }
+  const normalizedToken = token.trim();
+  if (!normalizedToken) {
+    return null;
+  }
+  return {
+    token: normalizedToken,
+    expiresAt: typeof payload?.session?.expiresAt === "string" ? payload.session.expiresAt : void 0
+  };
+}
+
+// src/utils/hostname.ts
+var LOCAL_IPV4_PATTERN = /^127(?:\.\d{1,3}){3}$/;
+function isLocalHostname(hostname) {
+  const normalized = hostname.trim().replace(/\.$/, "").toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "localhost" || normalized.endsWith(".localhost")) {
+    return true;
+  }
+  if (normalized === "127.0.0.1" || LOCAL_IPV4_PATTERN.test(normalized) || normalized === "::1" || normalized === "[::1]" || normalized === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  return false;
+}
+
+// src/utils/auth-cookies.ts
+var ATHENA_AUTH_COOKIE_PREFIXES = [
+  "athena-auth",
+  "__Secure-athena-auth",
+  "better-auth",
+  "__Secure-better-auth"
+];
+function extractCookieNames(cookieHeader) {
+  const names = /* @__PURE__ */ new Set();
+  for (const rawCookie of cookieHeader.split(";")) {
+    const trimmed = rawCookie.trim();
+    if (!trimmed) continue;
+    const eqPos = trimmed.indexOf("=");
+    const name = (eqPos > -1 ? trimmed.slice(0, eqPos) : trimmed).trim();
+    if (name) {
+      names.add(name);
+    }
+  }
+  return Array.from(names);
+}
+function buildCookieDomainCandidates(hostname) {
+  const normalized = hostname.trim().replace(/\.$/, "").toLowerCase();
+  if (!normalized || isLocalHostname(normalized)) {
+    return [];
+  }
+  const labels = normalized.split(".").filter(Boolean);
+  if (labels.length < 2) {
+    return [normalized, `.${normalized}`];
+  }
+  const domains = /* @__PURE__ */ new Set();
+  for (let index = 0; index <= labels.length - 2; index += 1) {
+    const domain = labels.slice(index).join(".");
+    domains.add(domain);
+    domains.add(`.${domain}`);
+  }
+  return Array.from(domains);
+}
+function getCookieStore() {
+  const candidate = globalThis.document;
+  if (!candidate || typeof candidate.cookie !== "string") {
+    return null;
+  }
+  return candidate;
+}
+function getRuntimeHostname() {
+  const fromWindow = globalThis.window?.location?.hostname;
+  if (typeof fromWindow === "string") {
+    return fromWindow;
+  }
+  const fromLocation = globalThis.location?.hostname;
+  if (typeof fromLocation === "string") {
+    return fromLocation;
+  }
+  return "";
+}
+function writeExpiredCookie(cookieStore, name, path, domain) {
+  const domainClause = domain ? ` domain=${domain};` : "";
+  cookieStore.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0; path=${path};${domainClause}`;
+}
+function clearAuthCookies(options = {}) {
+  const cookieStore = getCookieStore();
+  if (!cookieStore) {
+    return [];
+  }
+  const cookieHeader = options.cookieHeader ?? cookieStore.cookie;
+  if (!cookieHeader?.trim()) {
+    return [];
+  }
+  const prefixes = options.prefixes?.length ? options.prefixes : [...ATHENA_AUTH_COOKIE_PREFIXES];
+  const cookieNames = extractCookieNames(cookieHeader);
+  const namesToClear = cookieNames.filter(
+    (name) => prefixes.some((prefix) => name.startsWith(prefix))
+  );
+  if (namesToClear.length === 0) {
+    return [];
+  }
+  const path = options.path?.trim() || "/";
+  const hostname = options.hostname ?? getRuntimeHostname();
+  const domainCandidates = buildCookieDomainCandidates(hostname);
+  for (const name of namesToClear) {
+    writeExpiredCookie(cookieStore, name, path);
+    for (const domain of domainCandidates) {
+      writeExpiredCookie(cookieStore, name, path, domain);
+    }
+  }
+  return namesToClear;
+}
+
+// src/utils/auth-routes.ts
+var AUTH_DEFAULT_VIEW = "sign-in";
+var AUTH_VIEW_BY_SEGMENT = {
+  "accept-invitation": "accept-invitation",
+  "check-email": "check-email",
+  "forget-password": "forgot-password",
+  "forgot-password": "forgot-password",
+  logout: "logout",
+  "reset-email-sent": "reset-email-sent",
+  "reset-password": "reset-password",
+  "sign-in": "sign-in",
+  "sign-up": "sign-up"
+};
+var AUTHENTICATED_REDIRECT_VIEW_SET = /* @__PURE__ */ new Set([
+  "sign-in",
+  "sign-up",
+  "forgot-password"
+]);
+function resolveAuthViewFromSegment(segment) {
+  if (!segment) {
+    return AUTH_DEFAULT_VIEW;
+  }
+  return AUTH_VIEW_BY_SEGMENT[segment] ?? null;
+}
+function shouldRedirectAuthenticatedAuthView(view) {
+  return AUTHENTICATED_REDIRECT_VIEW_SET.has(view);
+}
+var AUTH_ROUTES = {
+  acceptInvitation: "/auth/accept-invitation",
+  appHome: "/",
+  checkEmail: "/auth/check-email",
+  forgotPassword: "/auth/forgot-password",
+  logout: "/auth/logout",
+  resetEmailSent: "/auth/reset-email-sent",
+  resetPassword: "/auth/reset-password",
+  signIn: "/auth/sign-in",
+  signUp: "/auth/sign-up",
+  socialCallback: "/auth/social-callback"
+};
+function createAuthModeRedirects(routes = AUTH_ROUTES) {
+  return {
+    "forgot-password": routes.forgotPassword,
+    login: routes.signIn,
+    logout: routes.logout,
+    "reset-password": routes.resetPassword,
+    signup: routes.signUp
+  };
+}
+var AUTH_MODE_REDIRECTS = createAuthModeRedirects();
+new Set(Object.keys(AUTH_MODE_REDIRECTS));
+
+// src/utils/athena-auth-url.ts
+var ATHENA_AUTH_PATH = "/api/auth";
+var LOCAL_DEV_ORIGIN = "http://localhost:3000";
+var DEFAULT_ATHENA_AUTH_ORIGIN = "https://auth.athena-auth.com";
+var ATHENA_AUTH_UPSTREAM_ENV_KEYS = [
+  "ATHENA_AUTH_UPSTREAM_URL",
+  "ATHENA_AUTH_URL",
+  "NEXT_PUBLIC_ATHENA_AUTH_UPSTREAM_URL",
+  "NEXT_PUBLIC_ATHENA_AUTH_URL"
+];
+var ATHENA_AUTH_UPSTREAM_URL_ENV_NAMES = ATHENA_AUTH_UPSTREAM_ENV_KEYS;
+var LEADING_SLASHES_REGEX = /^\/+/;
+function stripTrailingSlashes(value) {
+  return value.replace(/\/+$/g, "");
+}
+function ensureLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function ensureAthenaAuthPath(pathname) {
+  const normalizedPath = stripTrailingSlashes(
+    ensureLeadingSlash(pathname.trim())
+  );
+  if (!normalizedPath || normalizedPath === "/") {
+    return ATHENA_AUTH_PATH;
+  }
+  if (normalizedPath.endsWith(ATHENA_AUTH_PATH)) {
+    return normalizedPath;
+  }
+  return `${normalizedPath}${ATHENA_AUTH_PATH}`;
+}
+function stripAthenaAuthPath(pathname) {
+  const normalizedPath = stripTrailingSlashes(
+    ensureLeadingSlash(pathname.trim())
+  );
+  if (!normalizedPath || normalizedPath === "/") {
+    return "/";
+  }
+  if (normalizedPath === ATHENA_AUTH_PATH) {
+    return "/";
+  }
+  if (normalizedPath.endsWith(ATHENA_AUTH_PATH)) {
+    const withoutAuthPath = normalizedPath.slice(0, -ATHENA_AUTH_PATH.length);
+    return withoutAuthPath ? ensureLeadingSlash(withoutAuthPath) : "/";
+  }
+  return normalizedPath;
+}
+function readProcessEnv2() {
+  try {
+    const maybeProcess = globalThis.process;
+    return maybeProcess?.env;
+  } catch {
+    return void 0;
+  }
+}
+function getBrowserOrigin() {
+  try {
+    const origin = globalThis.window?.location?.origin;
+    return typeof origin === "string" && origin.length > 0 ? origin : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isAbsoluteUrl(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith("http://") || trimmed.startsWith("https://");
+}
+function readAthenaAuthUpstreamUrlFromEnv(env) {
+  for (const key of ATHENA_AUTH_UPSTREAM_ENV_KEYS) {
+    const value = env[key]?.trim();
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl) {
+  if (typeof rawUpstreamUrl === "string") {
+    const trimmed = rawUpstreamUrl.trim();
+    return trimmed || void 0;
+  }
+  if (rawUpstreamUrl) {
+    return readAthenaAuthUpstreamUrlFromEnv(rawUpstreamUrl);
+  }
+  const processEnv = readProcessEnv2();
+  return processEnv ? readAthenaAuthUpstreamUrlFromEnv(processEnv) : void 0;
+}
+function normalizeAthenaAuthBaseUrl(urlOrPath) {
+  const trimmed = urlOrPath.trim();
+  if (!trimmed) {
+    return ATHENA_AUTH_PATH;
+  }
+  if (isAbsoluteUrl(trimmed)) {
+    const url = new URL(trimmed);
+    url.pathname = ensureAthenaAuthPath(url.pathname);
+    url.search = "";
+    url.hash = "";
+    return stripTrailingSlashes(url.toString());
+  }
+  return ensureAthenaAuthPath(trimmed);
+}
+function resolveAthenaAuthUpstreamUrl(rawUpstreamUrl) {
+  const configuredUpstream = resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl) || DEFAULT_ATHENA_AUTH_ORIGIN;
+  if (isAbsoluteUrl(configuredUpstream)) {
+    const upstreamUrl = new URL(configuredUpstream);
+    upstreamUrl.pathname = stripAthenaAuthPath(upstreamUrl.pathname);
+    upstreamUrl.search = "";
+    upstreamUrl.hash = "";
+    return stripTrailingSlashes(upstreamUrl.toString());
+  }
+  const normalizedPath = stripAthenaAuthPath(configuredUpstream);
+  return stripTrailingSlashes(
+    new URL(normalizedPath, LOCAL_DEV_ORIGIN).toString()
+  );
+}
+function resolveBrowserFacingOrigin(rawUpstreamUrl) {
+  if (resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl)) {
+    return `${resolveAthenaAuthUpstreamUrl(rawUpstreamUrl)}/`;
+  }
+  const browserOrigin = getBrowserOrigin();
+  if (browserOrigin) {
+    return `${browserOrigin}/`;
+  }
+  return `${LOCAL_DEV_ORIGIN}/`;
+}
+function resolvePreservedAthenaAuthBaseUrl(configuredAuthBaseUrl, rawUpstreamUrl) {
+  const trimmed = configuredAuthBaseUrl.trim();
+  const preservedConfiguredBaseUrl = trimmed || ATHENA_AUTH_PATH;
+  if (isAbsoluteUrl(preservedConfiguredBaseUrl)) {
+    return stripTrailingSlashes(preservedConfiguredBaseUrl);
+  }
+  return stripTrailingSlashes(
+    new URL(
+      ensureLeadingSlash(preservedConfiguredBaseUrl),
+      resolveBrowserFacingOrigin(rawUpstreamUrl)
+    ).toString()
+  );
+}
+function resolveAthenaAuthClientBaseUrl(configuredAuthBaseUrl, rawUpstreamUrl, options = {}) {
+  let baseInput;
+  if (typeof configuredAuthBaseUrl === "string") {
+    baseInput = configuredAuthBaseUrl;
+  } else if (configuredAuthBaseUrl) {
+    baseInput = readAthenaAuthUpstreamUrlFromEnv(configuredAuthBaseUrl) ?? ATHENA_AUTH_PATH;
+  } else {
+    const fromEnv = resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl);
+    baseInput = fromEnv ?? ATHENA_AUTH_PATH;
+  }
+  if (options.appendAuthPath === false) {
+    return resolvePreservedAthenaAuthBaseUrl(baseInput, rawUpstreamUrl);
+  }
+  const normalizedConfiguredBaseUrl = normalizeAthenaAuthBaseUrl(baseInput);
+  if (isAbsoluteUrl(normalizedConfiguredBaseUrl)) {
+    return normalizedConfiguredBaseUrl;
+  }
+  const browserOrigin = getBrowserOrigin();
+  if (browserOrigin) {
+    return stripTrailingSlashes(
+      new URL(normalizedConfiguredBaseUrl, browserOrigin).toString()
+    );
+  }
+  if (resolveConfiguredAthenaAuthUpstreamUrl(rawUpstreamUrl)) {
+    const upstream = resolveAthenaAuthUpstreamUrl(rawUpstreamUrl);
+    return stripTrailingSlashes(
+      new URL(ATHENA_AUTH_PATH, `${upstream}/`).toString()
+    );
+  }
+  return stripTrailingSlashes(
+    new URL(normalizedConfiguredBaseUrl, LOCAL_DEV_ORIGIN).toString()
+  );
+}
+function resolveAthenaAuthRequestUrl(path, rawBaseUrl) {
+  const normalizedPath = path.replace(LEADING_SLASHES_REGEX, "");
+  const base = resolveAthenaAuthClientBaseUrl(rawBaseUrl);
+  return new URL(normalizedPath, `${base}/`).toString();
+}
+var ATHENA_AUTH_VERIFY_EMAIL_PATH = "verify-email";
+function resolveEmailVerificationCallbackUrl(rawBaseUrl) {
+  return resolveAthenaAuthRequestUrl(ATHENA_AUTH_VERIFY_EMAIL_PATH, rawBaseUrl);
+}
+
 // src/next/client.ts
 var cachedBrowserClient = null;
 function createAthenaBrowserClient(options) {
@@ -8682,6 +9062,29 @@ function createAthenaBrowserClient(options) {
   return createAdapterClient(options);
 }
 
+exports.ATHENA_AUTH_COOKIE_PREFIXES = ATHENA_AUTH_COOKIE_PREFIXES;
+exports.ATHENA_AUTH_PATH = ATHENA_AUTH_PATH;
+exports.ATHENA_AUTH_SESSION_BRIDGE_ROUTE = ATHENA_AUTH_SESSION_BRIDGE_ROUTE;
+exports.ATHENA_AUTH_SESSION_COOKIE_NAME = ATHENA_AUTH_SESSION_COOKIE_NAME;
+exports.ATHENA_AUTH_SESSION_COOKIE_NAMES = ATHENA_AUTH_SESSION_COOKIE_NAMES;
+exports.ATHENA_AUTH_UPSTREAM_ENV_KEYS = ATHENA_AUTH_UPSTREAM_ENV_KEYS;
+exports.ATHENA_AUTH_UPSTREAM_URL_ENV_NAMES = ATHENA_AUTH_UPSTREAM_URL_ENV_NAMES;
+exports.AUTH_DEFAULT_VIEW = AUTH_DEFAULT_VIEW;
+exports.AUTH_ROUTES = AUTH_ROUTES;
+exports.AUTH_VIEW_BY_SEGMENT = AUTH_VIEW_BY_SEGMENT;
+exports.DEFAULT_ATHENA_AUTH_ORIGIN = DEFAULT_ATHENA_AUTH_ORIGIN;
+exports.clearAthenaAuthSessionOnAppHost = clearAthenaAuthSessionOnAppHost;
+exports.clearAuthCookies = clearAuthCookies;
 exports.createAthenaBrowserClient = createAthenaBrowserClient;
+exports.isAbsoluteUrl = isAbsoluteUrl;
+exports.normalizeAthenaAuthBaseUrl = normalizeAthenaAuthBaseUrl;
+exports.persistAthenaAuthSessionOnAppHost = persistAthenaAuthSessionOnAppHost;
+exports.resolveAthenaAuthClientBaseUrl = resolveAthenaAuthClientBaseUrl;
+exports.resolveAthenaAuthRequestUrl = resolveAthenaAuthRequestUrl;
+exports.resolveAthenaAuthUpstreamUrl = resolveAthenaAuthUpstreamUrl;
+exports.resolveAuthViewFromSegment = resolveAuthViewFromSegment;
+exports.resolveEmailVerificationCallbackUrl = resolveEmailVerificationCallbackUrl;
+exports.resolveSessionBridgePayload = resolveSessionBridgePayload;
+exports.shouldRedirectAuthenticatedAuthView = shouldRedirectAuthenticatedAuthView;
 //# sourceMappingURL=client.cjs.map
 //# sourceMappingURL=client.cjs.map