@sorb/leaf 0.2.1 → 0.3.0

package/dist/core.mjs

@@ -0,0 +1,643 @@
+// src/sanitize.js
+var ALLOWED_FUNCTIONS = /* @__PURE__ */ new Set([
+  "rgb",
+  "rgba",
+  "hsl",
+  "hsla",
+  "hwb",
+  "lab",
+  "lch",
+  "oklab",
+  "oklch",
+  "color",
+  "calc",
+  "min",
+  "max",
+  "clamp",
+  "var",
+  "env"
+]);
+var FUNCTION_CALL = /([a-zA-Z_-][\w-]*)\s*\(/g;
+var CONTROL_CHARS = /[\x00-\x1f]/;
+var CONTEXT_BREAK = /[{};]/;
+var sanitizeCssValue = (value) => {
+  if (typeof value !== "string") {
+    return { ok: false, value: "", reason: "not-a-string" };
+  }
+  const raw = value;
+  if (raw.length === 0) {
+    return { ok: false, value: "", reason: "empty" };
+  }
+  if (CONTROL_CHARS.test(raw)) {
+    return { ok: false, value: raw, reason: "control-char" };
+  }
+  if (CONTEXT_BREAK.test(raw)) {
+    return { ok: false, value: raw, reason: "context-break-char" };
+  }
+  const lower = raw.toLowerCase();
+  const collapsed = lower.replace(/\s+/g, "");
+  if (collapsed.includes("@import")) {
+    return { ok: false, value: raw, reason: "at-import" };
+  }
+  if (collapsed.includes("javascript:")) {
+    return { ok: false, value: raw, reason: "javascript-scheme" };
+  }
+  if (collapsed.includes("</")) {
+    return { ok: false, value: raw, reason: "markup-break" };
+  }
+  FUNCTION_CALL.lastIndex = 0;
+  let match;
+  while ((match = FUNCTION_CALL.exec(raw)) !== null) {
+    const name = match[1].toLowerCase();
+    if (!ALLOWED_FUNCTIONS.has(name)) {
+      return { ok: false, value: raw, reason: `disallowed-function:${name}` };
+    }
+  }
+  return { ok: true, value: raw };
+};
+
+// src/apply.js
+var warnRejected = (key, reason) => {
+  try {
+    if (typeof process !== "undefined" && process.env && true) {
+      console.warn(
+        `[sorb] skipped token "--${key}": value failed CSS sanitization` + (reason ? ` (${reason})` : "")
+      );
+    }
+  } catch (e) {
+  }
+};
+var applyTokens = (tokens) => {
+  const root = document.documentElement;
+  Object.entries(tokens).forEach(([key, value]) => {
+    const result = sanitizeCssValue(String(value));
+    if (!result.ok) {
+      warnRejected(key, result.reason);
+      return;
+    }
+    root.style.setProperty(`--${key}`, result.value);
+  });
+};
+var clearTokenOverrides = (tokens) => {
+  const root = document.documentElement;
+  Object.keys(tokens).forEach((key) => {
+    root.style.removeProperty(`--${key}`);
+  });
+};
+var MODE_STYLESHEET_ID = "sorb-tokens";
+var injectModeStylesheet = (css) => {
+  let tag = document.getElementById(MODE_STYLESHEET_ID);
+  if (!tag) {
+    tag = document.createElement("style");
+    tag.id = MODE_STYLESHEET_ID;
+    document.head.appendChild(tag);
+  }
+  tag.textContent = css;
+};
+var clearModeStylesheet = () => {
+  const tag = document.getElementById(MODE_STYLESHEET_ID);
+  if (tag && tag.parentNode) tag.parentNode.removeChild(tag);
+};
+
+// src/modeStylesheet.js
+var buildModeStylesheet = (lightVars, darkVars, darkMode) => {
+  const lightDecls = normalizeDecls(lightVars);
+  const hasDark = !!darkMode && !!darkVars && Object.keys(darkVars).length > 0;
+  if (!hasDark) {
+    return `:root {
+${indent(lightDecls)}
+}
+`;
+  }
+  const darkDecls = normalizeDecls(darkVars);
+  const darkSelector = darkMode.darkSelector;
+  const lightSelector = darkMode.lightSelector;
+  const mediaScopeSelector = lightSelector ? `:root:not(${lightSelector})` : ":root";
+  const lines = [];
+  lines.push(":root {");
+  lines.push(indent([...lightDecls, "color-scheme: light;"]));
+  lines.push("}");
+  lines.push("@media (prefers-color-scheme: dark) {");
+  lines.push(`  ${mediaScopeSelector} {`);
+  lines.push(indent([...darkDecls, "color-scheme: dark;"], 2));
+  lines.push("  }");
+  lines.push("}");
+  lines.push(`${darkSelector} {`);
+  lines.push(indent([...darkDecls, "color-scheme: dark;"]));
+  lines.push("}");
+  if (lightSelector) {
+    lines.push(`${lightSelector} {`);
+    lines.push(indent([...lightDecls, "color-scheme: light;"]));
+    lines.push("}");
+  }
+  return `${lines.join("\n")}
+`;
+};
+var normalizeDecls = (vars) => {
+  if (!vars) return [];
+  return Object.entries(vars).reduce((acc, [key, value]) => {
+    const result = sanitizeCssValue(String(value));
+    if (!result.ok) return acc;
+    const cssVar = key.startsWith("--") ? key : `--${key}`;
+    acc.push(`${cssVar}: ${result.value};`);
+    return acc;
+  }, []);
+};
+var indent = (lines, level = 1) => {
+  const pad = "  ".repeat(level);
+  return lines.map((l) => `${pad}${l}`).join("\n");
+};
+
+// node_modules/@sorb/core/src/index.js
+var TIERS = Object.freeze(["component", "semantic", "primitive"]);
+var TIER_RANK = Object.freeze({ component: 0, semantic: 1, primitive: 2 });
+var connectors = Object.freeze({
+  source: /* @__PURE__ */ new Map(),
+  codeSource: /* @__PURE__ */ new Map(),
+  target: /* @__PURE__ */ new Map()
+});
+function registerTarget(adapter) {
+  connectors.target.set(adapter.id, adapter);
+  return adapter;
+}
+
+// src/targets/reactBootstrap.js
+var SORB_TOKENSET_FORMAT_ID = "sorb/tokenset-esm";
+var reactBootstrapTarget = {
+  id: "react-bootstrap",
+  emitFormat: SORB_TOKENSET_FORMAT_ID,
+  // The Bootstrap-styled vocab namespace (matches `sorb-demo/src/sorbConfig.js`'s
+  // `preview.expectPrefixes: ['bs-']`).
+  expectPrefixes: ["bs-"],
+  // Left undefined on purpose — see file header.
+  inject: void 0,
+  // Bootstrap 5.3's native dark-mode convention (real-dark-mode spec D1): a
+  // `data-bs-theme` attribute on any ancestor (Bootstrap recommends
+  // `<html>`) selects the mode; absent ⇒ OS `prefers-color-scheme` governs.
+  darkMode: {
+    strategy: "attribute",
+    attribute: "data-bs-theme",
+    darkSelector: '[data-bs-theme="dark"]',
+    lightSelector: '[data-bs-theme="light"]'
+  }
+};
+if (typeof registerTarget === "function") {
+  registerTarget(reactBootstrapTarget);
+}
+
+// src/previewGuard.js
+var DEFAULT_ORIGIN = "http://localhost:7777";
+var isLocalhostOrigin = (origin) => {
+  let url;
+  try {
+    url = new URL(origin);
+  } catch (e) {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  const host = url.hostname.toLowerCase();
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+};
+var toOrigin = (value) => {
+  try {
+    return new URL(value).origin;
+  } catch (e) {
+    return null;
+  }
+};
+var shouldLoadPreview = (config) => {
+  const preview = config && config.preview;
+  if (!preview || preview.enabled !== true) {
+    return { allowed: false, origin: null, reason: "preview-disabled" };
+  }
+  const origin = preview.origin ?? DEFAULT_ORIGIN;
+  const normalized = toOrigin(origin);
+  if (!normalized) {
+    return { allowed: false, origin: null, reason: "malformed-origin" };
+  }
+  if (isLocalhostOrigin(origin)) {
+    return { allowed: true, origin };
+  }
+  const extra = Array.isArray(preview.allowedOrigins) ? preview.allowedOrigins : [];
+  const allowed = extra.some((entry) => toOrigin(entry) === normalized);
+  if (allowed) {
+    return { allowed: true, origin };
+  }
+  return { allowed: false, origin, reason: "origin-not-allowlisted" };
+};
+
+// src/previewVocab.js
+var countMatchingPrefixes = (tokens, prefixes) => {
+  const list = Array.isArray(prefixes) ? prefixes : [];
+  return Object.keys(tokens || {}).filter((key) => list.some((p) => key.startsWith(p))).length;
+};
+var checkPreviewVocabulary = ({ tokens, expectPrefixes, previewId }) => {
+  if (!Array.isArray(expectPrefixes) || expectPrefixes.length === 0) return false;
+  const appliedCount = Object.keys(tokens || {}).length;
+  if (appliedCount === 0) return false;
+  const matched = countMatchingPrefixes(tokens, expectPrefixes);
+  if (matched > 0) return false;
+  try {
+    console.warn(
+      `[Sorb] preview ${previewId ? `"${previewId}" ` : ""}applied ${appliedCount} tokens but none match expected prefixes ${JSON.stringify(expectPrefixes)} \u2014 the app may not visibly re-skin (token-vocabulary mismatch).`
+    );
+  } catch (e) {
+  }
+  return true;
+};
+
+// src/bridgeAuth.js
+var bridgeHeaders = (key, base) => {
+  const headers = base ? { ...base } : {};
+  if (typeof key === "string" && key.trim() !== "") {
+    headers.Authorization = `Bearer ${key.trim()}`;
+  }
+  return headers;
+};
+
+// src/connection.js
+var DEFAULT_CLOUD_BASE = "https://api.sorbcloud.com";
+var getOrgKey = (config) => {
+  if (!config) return null;
+  const key = config.orgKey || config.publishableKey;
+  return typeof key === "string" && key.trim() !== "" ? key.trim() : null;
+};
+var shouldResolveOrgConnection = (config) => {
+  const key = getOrgKey(config);
+  if (!key) return false;
+  const explicitOrigin = config && config.preview && config.preview.origin;
+  return !(typeof explicitOrigin === "string" && explicitOrigin.trim() !== "");
+};
+var resolveOrgConnection = async (orgKey, opts) => {
+  const { cloudBase = DEFAULT_CLOUD_BASE, fetchImpl } = opts || {};
+  const doFetch = fetchImpl || (typeof fetch !== "undefined" ? fetch : null);
+  if (!doFetch || typeof orgKey !== "string" || orgKey.trim() === "") return null;
+  try {
+    const base = cloudBase.replace(/\/$/, "");
+    const url = `${base}/api/orgs/resolve?key=${encodeURIComponent(orgKey.trim())}`;
+    const res = await doFetch(url);
+    if (!res || !res.ok) return null;
+    const data = await res.json();
+    if (!data || typeof data !== "object") return null;
+    if (typeof data.bridgeUrl !== "string" || data.bridgeUrl.trim() === "") return null;
+    const bridgeMode = typeof data.bridgeMode === "string" ? data.bridgeMode : "C";
+    return {
+      bridgeMode,
+      bridgeUrl: data.bridgeUrl,
+      orgId: typeof data.orgId === "string" ? data.orgId : null,
+      tokenSource: typeof data.tokenSource === "string" ? data.tokenSource : null,
+      // sorb-cloud's /api/orgs/resolve returns this as a boolean (entitlement
+      // flag), not an object — see cloud src/lib/orgResolve.ts.
+      previewPersistence: typeof data.previewPersistence === "boolean" ? data.previewPersistence : null,
+      transport: data.transport === "poll" || data.transport === "sse" ? data.transport : bridgeMode === "A" ? "sse" : "poll"
+    };
+  } catch (e) {
+    return null;
+  }
+};
+var buildEffectivePreviewConfig = (config, resolved) => {
+  const base = config && config.preview || {};
+  if (!resolved) return base;
+  const orgKey = getOrgKey(config);
+  return {
+    ...base,
+    enabled: true,
+    origin: resolved.bridgeUrl,
+    allowedOrigins: [...Array.isArray(base.allowedOrigins) ? base.allowedOrigins : [], resolved.bridgeUrl],
+    key: base.key || orgKey || void 0
+  };
+};
+var buildEffectiveConfig = (config, resolved) => {
+  if (!resolved) return config;
+  return { ...config, preview: buildEffectivePreviewConfig(config, resolved) };
+};
+
+// src/sse.js
+var buildSubscribeUrl = (bridgeUrl, orgId, previewId, key) => {
+  const base = String(bridgeUrl).replace(/\/$/, "");
+  const path = `${base}/orgs/${encodeURIComponent(orgId)}/preview/${encodeURIComponent(previewId)}/subscribe`;
+  if (typeof key === "string" && key.trim() !== "") {
+    return `${path}?key=${encodeURIComponent(key.trim())}`;
+  }
+  return path;
+};
+var parsePreviewFrame = (raw) => {
+  let frame;
+  try {
+    frame = JSON.parse(raw);
+  } catch (e) {
+    return null;
+  }
+  if (!frame || typeof frame !== "object") return null;
+  if (frame.type === "ping") return { type: "ping" };
+  if (frame.type === "delete") return { type: "delete", tokens: null };
+  if ((frame.type === "snapshot" || frame.type === "update") && frame.tokens && typeof frame.tokens === "object") {
+    return { type: frame.type, tokens: frame.tokens };
+  }
+  return null;
+};
+var createPreviewSubscription = ({ EventSourceImpl, url, onTokens, onDelete, onError }) => {
+  if (typeof EventSourceImpl !== "function") return null;
+  const es = new EventSourceImpl(url);
+  es.onmessage = (evt) => {
+    const parsed = parsePreviewFrame(evt && evt.data);
+    if (!parsed || parsed.type === "ping") return;
+    if (parsed.type === "delete") {
+      if (onDelete) onDelete();
+      return;
+    }
+    onTokens(parsed.tokens);
+  };
+  const handleError = (evt) => {
+    if (onError) onError(evt);
+  };
+  if (typeof es.addEventListener === "function") {
+    es.addEventListener("error", handleError);
+  } else {
+    es.onerror = handleError;
+  }
+  return () => {
+    try {
+      es.close();
+    } catch (e) {
+    }
+  };
+};
+
+// src/previewMode.js
+var isModeAwarePreviewBody = (body) => !!body && typeof body === "object" && !Array.isArray(body) && "tokens" in body;
+var resolvePreviewBody = (body, fallbackDarkMode) => {
+  if (!isModeAwarePreviewBody(body)) {
+    return { kind: "flat", tokens: (
+      /** @type {import('./types').TokenSet} */
+      body
+    ) };
+  }
+  const wrapper = (
+    /** @type {{ tokens: import('./types').TokenSet, darkTokens?: import('./types').TokenSet, darkMode?: import('@sorb/core').DarkModeConvention }} */
+    body
+  );
+  const darkTokens = wrapper.darkTokens;
+  if (darkTokens && Object.keys(darkTokens).length > 0) {
+    return {
+      kind: "mode-aware",
+      lightTokens: wrapper.tokens,
+      darkTokens,
+      darkMode: wrapper.darkMode ?? fallbackDarkMode
+    };
+  }
+  return { kind: "flat", tokens: wrapper.tokens };
+};
+
+// src/modeAction.js
+var darkClassName = (darkModeConvention) => {
+  const selector = String(darkModeConvention?.darkSelector || "").trim();
+  const match = /^\.([a-zA-Z0-9_-]+)$/.exec(selector);
+  return match ? match[1] : "dark";
+};
+var resolveModeAction = (darkModeConvention, next) => {
+  const strategy = darkModeConvention?.strategy || "attribute";
+  if (strategy === "media") {
+    return { type: "none" };
+  }
+  if (strategy === "class") {
+    const className = darkClassName(darkModeConvention);
+    return next === "dark" ? { type: "class-add", className } : { type: "class-remove", className };
+  }
+  const attribute = darkModeConvention?.attribute || "data-bs-theme";
+  return next === "auto" ? { type: "attr-remove", attribute } : { type: "attr-set", attribute, value: next };
+};
+
+// src/core.js
+var EventSourceCtor = typeof EventSource !== "undefined" ? EventSource : null;
+var matchMediaFn = typeof matchMedia !== "undefined" ? matchMedia : null;
+var DARK_MEDIA_QUERY = "(prefers-color-scheme: dark)";
+var devWarn = (msg) => {
+  try {
+    if (typeof process !== "undefined" && process.env && true) {
+      console.warn(`[sorb] ${msg}`);
+    }
+  } catch (e) {
+  }
+};
+var warnedDeprecations = /* @__PURE__ */ new Set();
+function warnDeprecated(resolved) {
+  if (typeof process !== "undefined" && false) return;
+  for (let i = 0; i < resolved.length; i++) {
+    const token = resolved[i];
+    if (!token.deprecated) continue;
+    if (warnedDeprecations.has(token.id)) continue;
+    warnedDeprecations.add(token.id);
+    const replacedBy = token.replacedBy || token.$extensions && token.$extensions.sorb && token.$extensions.sorb.replacedBy || null;
+    if (replacedBy) {
+      console.warn("[@sorb/leaf] Deprecated token: " + token.id + " \u2014 use " + replacedBy + " instead");
+    } else {
+      console.warn("[@sorb/leaf] Deprecated token: " + token.id + " is deprecated");
+    }
+  }
+}
+function sorbInit(config) {
+  let activeTokens = config.tokens;
+  let isPreview = false;
+  let previewId = null;
+  let previewMismatch = false;
+  let pollId = null;
+  let cancelled = false;
+  let unsubscribeSSE = null;
+  const hasDarkMode = !!(config.darkTokens && Object.keys(config.darkTokens).length > 0);
+  const darkModeConvention = config.darkModeConvention || reactBootstrapTarget.darkMode;
+  let mode = "auto";
+  let systemScheme = matchMediaFn ? matchMediaFn(DARK_MEDIA_QUERY).matches ? "dark" : "light" : "light";
+  const listeners = /* @__PURE__ */ new Set();
+  const getState = () => ({
+    tokens: activeTokens,
+    isPreview,
+    previewId,
+    previewMismatch,
+    mode,
+    resolvedScheme: mode === "auto" ? systemScheme : mode
+  });
+  const notify = () => {
+    const state = getState();
+    listeners.forEach((listener) => listener(state));
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  let mql = null;
+  const onSchemeChange = (e) => {
+    systemScheme = e.matches ? "dark" : "light";
+    notify();
+  };
+  if (matchMediaFn) {
+    mql = matchMediaFn(DARK_MEDIA_QUERY);
+    if (typeof mql.addEventListener === "function") mql.addEventListener("change", onSchemeChange);
+    else if (typeof mql.addListener === "function") mql.addListener(onSchemeChange);
+  }
+  let inlineTokens = null;
+  const applyFlat = (tokens) => {
+    clearModeStylesheet();
+    applyTokens(tokens);
+    inlineTokens = tokens;
+  };
+  const applyModeAware = (lightTokens, darkTokens, convention) => {
+    if (inlineTokens) {
+      clearTokenOverrides(inlineTokens);
+      inlineTokens = null;
+    }
+    injectModeStylesheet(buildModeStylesheet(lightTokens, darkTokens, convention));
+  };
+  const loadCommitted = () => {
+    if (hasDarkMode) {
+      applyModeAware(config.tokens, config.darkTokens, darkModeConvention);
+    } else {
+      applyFlat(config.tokens);
+    }
+    activeTokens = config.tokens;
+    isPreview = false;
+    previewId = null;
+    previewMismatch = false;
+    notify();
+  };
+  const applyPreviewTokens = (body, id, effectiveConfig) => {
+    const resolved = resolvePreviewBody(body, darkModeConvention);
+    let flatTokens;
+    if (resolved.kind === "mode-aware") {
+      applyModeAware(resolved.lightTokens, resolved.darkTokens, resolved.darkMode);
+      flatTokens = resolved.lightTokens;
+    } else {
+      applyFlat(resolved.tokens);
+      flatTokens = resolved.tokens;
+    }
+    activeTokens = flatTokens;
+    isPreview = true;
+    previewId = id;
+    previewMismatch = checkPreviewVocabulary({
+      tokens: flatTokens,
+      expectPrefixes: effectiveConfig.preview?.expectPrefixes,
+      previewId: id
+    });
+    notify();
+  };
+  const loadPreview = async (id, effectiveConfig) => {
+    const cfg = effectiveConfig || config;
+    const guard = shouldLoadPreview(cfg);
+    if (!guard.allowed) {
+      loadCommitted();
+      return false;
+    }
+    const origin = guard.origin;
+    try {
+      const res = await fetch(`${origin}/preview/${id}`, {
+        headers: bridgeHeaders(cfg.preview?.key)
+      });
+      if (!res.ok) throw new Error("preview not found");
+      const tokens = await res.json();
+      applyPreviewTokens(tokens, id, cfg);
+      return true;
+    } catch (e) {
+      loadCommitted();
+      return false;
+    }
+  };
+  const clearPreview = () => {
+    if (pollId) {
+      clearInterval(pollId);
+      pollId = null;
+    }
+    if (typeof location !== "undefined" && typeof history !== "undefined") {
+      const params = new URLSearchParams(location.search);
+      params.delete("preview");
+      const qs = params.toString();
+      history.replaceState(null, "", qs ? `?${qs}` : location.pathname);
+    }
+    loadCommitted();
+  };
+  const setMode = (next) => {
+    mode = next;
+    if (typeof document !== "undefined") {
+      const action = resolveModeAction(darkModeConvention, next);
+      switch (action.type) {
+        case "attr-set":
+          document.documentElement.setAttribute(action.attribute, action.value);
+          break;
+        case "attr-remove":
+          document.documentElement.removeAttribute(action.attribute);
+          break;
+        case "class-add":
+          document.documentElement.classList.add(action.className);
+          break;
+        case "class-remove":
+          document.documentElement.classList.remove(action.className);
+          break;
+        case "none":
+        default:
+          break;
+      }
+    }
+    notify();
+  };
+  const destroy = () => {
+    cancelled = true;
+    if (pollId) clearInterval(pollId);
+    if (unsubscribeSSE) unsubscribeSSE();
+    if (mql) {
+      if (typeof mql.removeEventListener === "function") mql.removeEventListener("change", onSchemeChange);
+      else if (typeof mql.removeListener === "function") mql.removeListener(onSchemeChange);
+    }
+    listeners.clear();
+  };
+  const init = async () => {
+    if (config.resolved && config.resolved.length) warnDeprecated(config.resolved);
+    let effectiveConfig = config;
+    let resolvedConnection = null;
+    if (shouldResolveOrgConnection(config)) {
+      resolvedConnection = await resolveOrgConnection(getOrgKey(config), {
+        cloudBase: config.cloudBase
+      });
+      if (cancelled) return;
+      effectiveConfig = buildEffectiveConfig(config, resolvedConnection);
+    }
+    const guard = shouldLoadPreview(effectiveConfig);
+    const id = typeof location !== "undefined" ? new URLSearchParams(location.search).get("preview") : null;
+    if (!guard.allowed || !id) {
+      if (id && !guard.allowed) {
+        devWarn(
+          `ignoring ?preview= \u2014 preview not permitted (${guard.reason ?? "blocked"}); loading committed tokens`
+        );
+      }
+      loadCommitted();
+      return;
+    }
+    const ok = await loadPreview(id, effectiveConfig);
+    if (!ok || cancelled) return;
+    const useSSE = resolvedConnection && resolvedConnection.transport === "sse" && resolvedConnection.orgId && EventSourceCtor;
+    if (useSSE) {
+      const url = buildSubscribeUrl(
+        resolvedConnection.bridgeUrl,
+        resolvedConnection.orgId,
+        id,
+        effectiveConfig.preview?.key
+      );
+      unsubscribeSSE = createPreviewSubscription({
+        EventSourceImpl: EventSourceCtor,
+        url,
+        onTokens: (tokens) => applyPreviewTokens(tokens, id, effectiveConfig),
+        onDelete: () => loadCommitted(),
+        onError: () => devWarn("SSE preview subscription error \u2014 preview may be stale")
+      });
+    }
+    if (!unsubscribeSSE) {
+      const interval = effectiveConfig.preview?.pollInterval ?? 1500;
+      pollId = setInterval(() => loadPreview(id, effectiveConfig), interval);
+    }
+  };
+  init();
+  return { getState, subscribe, setMode, clearPreview, destroy };
+}
+export {
+  sorbInit,
+  warnedDeprecations
+};
+//# sourceMappingURL=core.mjs.map