@stacksjs/stx 0.2.95 → 0.2.97

package/dist/render.js

@@ -1,2 +1,165 @@
-// @bun
-import{yi as a,zi as b}from"./chunk-rw7937v4.js";import"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";export{a as renderTemplate,b as renderString};
+import { dirname, resolve } from "node:path";
+import { defaultConfig } from "./config.js";
+import { extractVariables } from "./variable-extractor.js";
+import { injectRouterScript, processDirectives } from "./process.js";
+import { extractBridgeData, processClientScript } from "./client-script.js";
+function parseTemplate(content) {
+  let workingContent = content;
+  const templateOpenMatch = content.match(/<template\b(?![^>]*(?:\b(?:id|x-for|x-if|@for|@if|:for|:if)\s*=|\s#[\w-]|\bv-slot|\bslot\s*=))[^>]*>/i);
+  if (templateOpenMatch && templateOpenMatch.index !== void 0) {
+    const openEnd = templateOpenMatch.index + templateOpenMatch[0].length;
+    let depth = 1, pos = openEnd;
+    while (depth > 0 && pos < content.length) {
+      const nextOpen = content.indexOf("<template", pos), nextClose = content.indexOf("</template>", pos);
+      if (nextClose === -1)
+        break;
+      if (nextOpen !== -1 && nextOpen < nextClose) {
+        const after = content[nextOpen + 9];
+        if (after === ">" || after === " " || after === `
+` || after === "\t")
+          depth++;
+        pos = nextOpen + 9;
+      } else {
+        depth--;
+        if (depth === 0) {
+          workingContent = content.slice(openEnd, nextClose).trim();
+          break;
+        }
+        pos = nextClose + 11;
+      }
+    }
+  }
+  const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi, clientScripts = [], serverScripts = [], signalsScripts = [], usesSignalsAPI = (scriptContent) => /\b(?:state|derived|effect|batch)\s*(?:<[^<>()]*>)?\s*\(/.test(scriptContent);
+  let scriptMatch;
+  while ((scriptMatch = scriptRegex.exec(content)) !== null) {
+    const attrs = scriptMatch[1], scriptContent = scriptMatch[2], fullScript = scriptMatch[0], isServerScript = attrs.includes("server");
+    if (usesSignalsAPI(scriptContent))
+      signalsScripts.push(fullScript);
+    else if (isServerScript)
+      serverScripts.push(scriptContent);
+    else
+      clientScripts.push(fullScript);
+  }
+  let templateContent = workingContent;
+  {
+    const serverScriptOpenRe = /<script\b(?![^>]*\b(?:client|type\s*=\s*["']module["']|src\s*=))[^>]*>/gi;
+    let sMatch;
+    const removeRanges = [];
+    while ((sMatch = serverScriptOpenRe.exec(templateContent)) !== null) {
+      const tagEnd = sMatch.index + sMatch[0].length;
+      let sDepth = 1, sPos = tagEnd;
+      while (sPos < templateContent.length && sDepth > 0) {
+        const nextOpen = templateContent.indexOf("<script", sPos), nextClose = templateContent.indexOf("</script>", sPos);
+        if (nextClose === -1)
+          break;
+        if (nextOpen !== -1 && nextOpen < nextClose) {
+          sDepth++;
+          sPos = nextOpen + 7;
+        } else {
+          sDepth--;
+          if (sDepth === 0) {
+            removeRanges.push({ start: sMatch.index, end: nextClose + 9 });
+            break;
+          }
+          sPos = nextClose + 9;
+        }
+      }
+    }
+    for (let ri = removeRanges.length - 1;ri >= 0; ri--)
+      templateContent = templateContent.substring(0, removeRanges[ri].start) + templateContent.substring(removeRanges[ri].end);
+  }
+  for (const script of clientScripts)
+    templateContent = templateContent.replace(script, "");
+  return { templateContent, serverScripts, clientScripts, signalsScripts };
+}
+function wrapInHtmlDocument(html, title) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${(title || "stx").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}</title>
+</head>
+<body>
+${html}
+</body>
+</html>`;
+}
+export async function renderTemplate(filePath, renderOptions = {}) {
+  const resolvedPath = resolve(filePath), file = Bun.file(resolvedPath);
+  if (!await file.exists())
+    throw Error(`Template file not found: ${resolvedPath}`);
+  const content = await file.text();
+  if (renderOptions.layout) {
+    const layoutPath = resolve(renderOptions.layout), layoutFile = Bun.file(layoutPath);
+    if (!await layoutFile.exists())
+      throw Error(`Layout template not found: ${layoutPath}`);
+    const { layout, injectCSS, ...pageOptions } = renderOptions, pageHtml = await renderTemplateString(content, resolvedPath, { ...pageOptions, injectCSS: !1 }), layoutContent = await layoutFile.text(), layoutContext = {
+      ...renderOptions.context || {},
+      content: pageHtml
+    }, layoutOptions = {
+      ...pageOptions,
+      context: layoutContext,
+      injectCSS
+    };
+    return renderTemplateString(layoutContent, layoutPath, layoutOptions);
+  }
+  return renderTemplateString(content, resolvedPath, renderOptions);
+}
+export async function renderString(template, context = {}, options) {
+  return renderTemplateString(template, process.cwd(), { context, ...options });
+}
+async function renderTemplateString(content, filePath, renderOptions = {}) {
+  const { templateContent, serverScripts, clientScripts } = parseTemplate(content), options = {
+    ...defaultConfig,
+    ...renderOptions.options
+  }, context = {
+    __filename: filePath,
+    __dirname: dirname(filePath),
+    __stx: {},
+    __stx_options: options,
+    __stx_sfc_mode: !0,
+    __stx_inject_css: renderOptions.injectCSS !== !1,
+    ...renderOptions.context || {}
+  };
+  for (const scriptContent of serverScripts)
+    await extractVariables(scriptContent, context, filePath);
+  const dependencies = new Set;
+  let output = templateContent;
+  output = await processDirectives(output, context, filePath, options, dependencies);
+  if (renderOptions.templateOnly) {
+    output = output.replace(/<script data-stx-scoped>[\s\S]*?<\/script>\s*/gi, "");
+    output = output.replace(/<!-- stx SEO Tags -->[\s\S]*?(?=<)/i, "");
+    if (clientScripts.length > 0)
+      output += `
+${clientScripts.join(`
+`)}`;
+  } else {
+    if (renderOptions.processClientScripts !== !1 && clientScripts.length > 0) {
+      const eventBindings = context.__stx_event_bindings || [], serverData = extractBridgeData(context), scriptsHtml = (await Promise.all(clientScripts.map(async (fullScript) => {
+        const contentMatch = fullScript.match(/<script\b[^>]*>([\s\S]*?)<\/script>/);
+        if (!contentMatch)
+          return fullScript;
+        return await processClientScript(contentMatch[1], { eventBindings, templateContent: output, serverData });
+      }))).join(`
+`);
+      if (output.match(/(<\/body>)/i))
+        output = output.replace(/(<\/body>)/i, `${scriptsHtml}
+$1`);
+      else
+        output += `
+${scriptsHtml}`;
+    }
+    output = await injectRouterScript(output);
+  }
+  if (renderOptions.wrapInDocument) {
+    if (!output.trim().toLowerCase().startsWith("<!doctype") && !output.trim().toLowerCase().startsWith("<html"))
+      output = wrapInHtmlDocument(output, renderOptions.title);
+  }
+  if (renderOptions.injectCSS)
+    try {
+      const { injectCrosswindCSS } = await import("./dev-server/crosswind.js");
+      output = await injectCrosswindCSS(output);
+    } catch {}
+  return output;
+}

package/dist/route-middleware.js

@@ -1,2 +1,17 @@
-// @bun
-import{Ah as m,Bh as n,Ch as o,oh as a,ph as b,qh as c,rh as d,sh as e,th as f,uh as g,vh as h,wh as i,xh as j,yh as k,zh as l}from"./chunk-ynhngsdh.js";import"./chunk-xv34zbp4.js";export{o as runMiddleware,n as registerMiddleware,m as navigateTo,l as loadMiddlewareFromDirectory,k as hasMiddleware,j as getMiddlewareNames,i as getMiddleware,h as defineMiddleware,g as createStorageManager,f as createServerCookieManager,e as createRouteLocation,d as createMiddlewareContext,c as createClientCookieManager,b as clearMiddleware,a as abortNavigation};
+export {
+  abortNavigation,
+  clearMiddleware,
+  createClientCookieManager,
+  createMiddlewareContext,
+  createRouteLocation,
+  createServerCookieManager,
+  createStorageManager,
+  defineMiddleware,
+  getMiddleware,
+  getMiddlewareNames,
+  hasMiddleware,
+  loadMiddlewareFromDirectory,
+  navigateTo,
+  registerMiddleware,
+  runMiddleware
+} from "stx-router";

package/dist/router.js

@@ -1,2 +1,9 @@
-// @bun
-import{Gi as a,Hi as b,Ii as c,Ji as d,Ki as e,Li as f,Mi as g}from"./chunk-t0c9wvpr.js";import"./chunk-xv34zbp4.js";export{g as matchRoute,b as getRouteParams,f as generateRouteTypes,e as generateRouteManifest,d as formatRoutes,c as findErrorPage,a as createRouter};
+import { matchRoute, Router as _Router } from "stx-router";
+export { findErrorPage, formatRoutes, generateRouteManifest, generateRouteTypes, matchRoute } from "stx-router";
+export function createRouter(baseDir, options = {}) {
+  return new _Router(baseDir, options).routes;
+}
+export function getRouteParams(pathname, routes) {
+  const result = matchRoute(pathname, routes);
+  return result ? result.params : null;
+}

package/dist/routes.js

@@ -1,2 +1,14 @@
-// @bun
-import{Jt as a,Kt as b,Lt as c,Mt as d,Nt as e,Ot as f}from"./chunk-krqn0ddk.js";import"./chunk-w3b6m427.js";import"./chunk-xv34zbp4.js";export{f as setAppUrl,e as route,d as resetRoutes,a as processRouteDirectives,c as defineRoutes,b as defineRoute};
+export { defineRoute, defineRoutes, resetRoutes, route, setAppUrl } from "stx-router";
+import { route } from "stx-router";
+import { safeEvaluateObject } from "./safe-evaluator.js";
+export function processRouteDirectives(template) {
+  return template.replace(/@route\(\s*(['"])([^'"]+)\1(?:\s*,\s*(\{[^}]+\}))?\s*(?:,\s*(true|false)\s*)?\)/g, (_, _quote, routeName, paramsJson, absolute) => {
+    try {
+      const params = paramsJson ? safeEvaluateObject(paramsJson, {}) : {};
+      return route(routeName, params, absolute === "true");
+    } catch (error) {
+      console.error(`Error processing @route directive: ${error}`);
+      return "#route-error";
+    }
+  });
+}

package/dist/runtime-injection.js

@@ -1,2 +1,120 @@
-// @bun
-import{Pt as a,Qt as b,Rt as c}from"./chunk-y1k17c8b.js";import"./chunk-xv34zbp4.js";export{b as injectSignalsRuntime,c as injectRouterScript,a as injectBrowserRuntime};
+export function injectBrowserRuntime(template) {
+  if (template.includes("window.StacksBrowser") || template.includes("StacksBrowser ="))
+    return template;
+  const clientScriptRegex = /<script\b(?![^>]*\bserver\b)[^>]*>([\s\S]*?)<\/script>/gi;
+  let clientCode = "", match;
+  while ((match = clientScriptRegex.exec(template)) !== null)
+    clientCode += match[1] + `
+`;
+  const templateExprRegex = /\{\{([\s\S]*?)\}\}/g;
+  while ((match = templateExprRegex.exec(template)) !== null)
+    clientCode += match[1] + `
+`;
+  if (!clientCode.trim())
+    return template;
+  const usesCoreSymbols = [
+    "browserQuery",
+    "BrowserQueryBuilder",
+    "configureBrowser",
+    "createBrowserModel"
+  ].some((sym) => {
+    return new RegExp(`\\b${sym}\\b`).test(clientCode);
+  }), jsBuiltins = new Set(["Promise", "Object", "Array", "Map", "Set", "Date", "Error", "JSON", "Math", "Number", "String", "RegExp", "Symbol", "WeakMap", "WeakSet", "Proxy", "Reflect", "Intl", "URL", "URLSearchParams", "FormData", "Headers", "Request", "Response", "AbortController", "EventTarget", "Element", "Document", "Node", "Window", "Console", "Storage", "Navigator", "Blob", "File", "FileReader", "HTMLElement", "SVGElement", "Event", "CustomEvent", "DOMParser", "XMLSerializer", "WebSocket", "Worker", "SharedWorker", "IntersectionObserver", "MutationObserver", "ResizeObserver", "PerformanceObserver", "Notification", "Bun", "Buffer", "Process"]), modelPattern = /\b([A-Z][a-zA-Z0-9]*)\s*\.\s*(all|find|first|get|where|orderBy|orderByDesc|limit|select|pluck|create|update|delete)\s*\(/g;
+  let modelMatch, usesModels = !1;
+  while ((modelMatch = modelPattern.exec(clientCode)) !== null)
+    if (!jsBuiltins.has(modelMatch[1])) {
+      usesModels = !0;
+      break;
+    }
+  if (!usesCoreSymbols && !usesModels)
+    return template;
+  const browserScript = `<script type="module">
+// STX: Auto-load @stacksjs/browser (auto-initializes API and loads models)
+import '@stacksjs/browser'
+</script>`;
+  if (template.includes("</head>")) {
+    const headEndPos = template.indexOf("</head>"), firstScriptPos = template.slice(0, headEndPos).indexOf("<script");
+    if (firstScriptPos !== -1)
+      return template.slice(0, firstScriptPos) + browserScript + `
+` + template.slice(firstScriptPos);
+    return template.replace("</head>", `${browserScript}
+</head>`);
+  }
+  if (template.includes("<body"))
+    return template.replace(/<body([^>]*)>/, `<body$1>
+${browserScript}`);
+  return browserScript + `
+` + template;
+}
+export async function injectSignalsRuntime(template, options) {
+  if (template.includes("window.stx.state") || template.includes("STX Signals Runtime"))
+    return template;
+  if (options.buildMode === "compile") {
+    const runtimeScript = '<script src="/__stx/runtime.__STX_HASH__.js"></script>', firstScriptInDoc = template.indexOf("<script");
+    if (firstScriptInDoc !== -1)
+      return template.slice(0, firstScriptInDoc) + runtimeScript + `
+` + template.slice(firstScriptInDoc);
+    if (template.includes("</head>")) {
+      const idx = template.indexOf("</head>");
+      return template.slice(0, idx) + runtimeScript + `
+` + template.slice(idx);
+    }
+    return runtimeScript + `
+` + template;
+  }
+  const { getCachedSignalsRuntime } = await import("./caching.js"), runtimeScript = `<script data-stx-scoped>${await getCachedSignalsRuntime(options.debug)}</script>`, firstScriptInDoc = template.indexOf("<script");
+  if (firstScriptInDoc !== -1)
+    return template.slice(0, firstScriptInDoc) + runtimeScript + `
+` + template.slice(firstScriptInDoc);
+  if (template.includes("</head>")) {
+    const idx = template.indexOf("</head>");
+    return template.slice(0, idx) + runtimeScript + `
+` + template.slice(idx);
+  }
+  if (template.includes("<body")) {
+    const idx = template.indexOf("<body"), closeIdx = template.indexOf(">", idx);
+    return template.slice(0, closeIdx + 1) + `
+` + runtimeScript + template.slice(closeIdx + 1);
+  }
+  return runtimeScript + `
+` + template;
+}
+export async function injectRouterScript(template, options) {
+  if (!template.includes("</body>"))
+    return template;
+  if (template.includes("__stxRouter)return") || template.includes("__stxRouter=true"))
+    return template;
+  const routerConfig = options?.router;
+  let configScript = "";
+  if (routerConfig) {
+    const configObj = {};
+    if (routerConfig.container)
+      configObj.container = routerConfig.container;
+    if (routerConfig.interceptAllLinks !== void 0)
+      configObj.interceptAllLinks = routerConfig.interceptAllLinks;
+    if (routerConfig.progress !== void 0)
+      configObj.progress = routerConfig.progress;
+    if (routerConfig.viewTransitions !== void 0)
+      configObj.viewTransitions = routerConfig.viewTransitions;
+    if (routerConfig.viewTransitionDuration !== void 0)
+      configObj.viewTransitionDuration = routerConfig.viewTransitionDuration;
+    if (routerConfig.viewTransitionEasing !== void 0)
+      configObj.viewTransitionEasing = routerConfig.viewTransitionEasing;
+    if (routerConfig.scrollToTop !== void 0)
+      configObj.scrollToTop = routerConfig.scrollToTop;
+    if (routerConfig.prefetch !== void 0)
+      configObj.prefetch = routerConfig.prefetch;
+    if (routerConfig.cache !== void 0)
+      configObj.cache = routerConfig.cache;
+    if (routerConfig.progressColor !== void 0)
+      configObj.progressColor = routerConfig.progressColor;
+    if (routerConfig.progressHeight !== void 0)
+      configObj.progressHeight = routerConfig.progressHeight;
+    if (Object.keys(configObj).length > 0)
+      configScript = `<script>window.__stxRouterConfig=${JSON.stringify(configObj)};</script>
+`;
+  }
+  const { getCachedRouterScript } = await import("./caching.js"), routerScript = options?.buildMode === "compile" ? '<script src="/__stx/router.__STX_HASH__.js"></script>' : `<script>${await getCachedRouterScript()}</script>`, bodyCloseIdx = template.lastIndexOf("</body>");
+  return template.slice(0, bodyCloseIdx) + configScript + routerScript + `
+</body>` + template.slice(bodyCloseIdx + 7);
+}

package/dist/runtime.js

@@ -1,2 +1,94 @@
-// @bun
-import{Dh as a,Eh as b,Fh as c,Gh as d,Hh as e,Ih as f,Jh as g,Kh as h,Lh as i,Mh as j,Nh as k,Oh as l,Ph as m,Qh as n,Rh as o,Sh as p,Th as q,Uh as r,Vh as s}from"./chunk-0p1h3p3w.js";import"./chunk-xv34zbp4.js";export{e as waitForStore,b as useStoreOrThrow,a as useStore,f as useRouteParams,h as useRouteParamOrThrow,g as useRouteParam,j as useMiddlewareValue,i as useMiddlewareState,n as setRouteParams,o as setMiddlewareState,l as registerStore,s as onServer,r as onClient,p as isServer,q as isClient,k as initStoreRegistry,c as hasStore,d as getStoreNames,m as getHydratedStoreState};
+const STX_STORES_KEY = "__STX_STORES__", STX_ROUTE_PARAMS_KEY = "__STX_ROUTE_PARAMS__", STX_MIDDLEWARE_STATE_KEY = "__STX_MIDDLEWARE_STATE__", STX_HYDRATE_STORES_KEY = "__STX_HYDRATE_STORES__", STX_STORE_STATE_KEY = "__STX_STORE_STATE__";
+function getGlobal(key, defaultValue) {
+  if (typeof window > "u")
+    return defaultValue;
+  return window[key] ?? defaultValue;
+}
+function setGlobal(key, value) {
+  if (typeof window > "u")
+    return;
+  window[key] = value;
+}
+export function useStore(name) {
+  const store = getGlobal(STX_STORES_KEY, {})[name];
+  if (!store)
+    throw Error(`Store "${name}" not found. Make sure it's defined with defineStore().`);
+  return store;
+}
+export function useStoreOrThrow(name) {
+  return useStore(name);
+}
+export function hasStore(name) {
+  const stores = getGlobal(STX_STORES_KEY, {});
+  return name in stores;
+}
+export function getStoreNames() {
+  const stores = getGlobal(STX_STORES_KEY, {});
+  return Object.keys(stores);
+}
+export function waitForStore(name, timeout = 5000) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now(), check = () => {
+      const store = useStore(name);
+      if (store)
+        resolve(store);
+      else if (Date.now() - startTime > timeout)
+        reject(Error(`Timeout waiting for store "${name}"`));
+      else
+        requestAnimationFrame(check);
+    };
+    check();
+  });
+}
+export function useRouteParams() {
+  return getGlobal(STX_ROUTE_PARAMS_KEY, {});
+}
+export function useRouteParam(name) {
+  return useRouteParams()[name];
+}
+export function useRouteParamOrThrow(name) {
+  const value = useRouteParam(name);
+  if (value === void 0)
+    throw Error(`Route parameter "${name}" not found`);
+  return value;
+}
+export function useMiddlewareState() {
+  return getGlobal(STX_MIDDLEWARE_STATE_KEY, {});
+}
+export function useMiddlewareValue(key) {
+  return useMiddlewareState()[key];
+}
+export function initStoreRegistry() {
+  if (typeof window > "u")
+    return;
+  if (!getGlobal(STX_STORES_KEY, null))
+    setGlobal(STX_STORES_KEY, {});
+}
+export function registerStore(name, store) {
+  const stores = getGlobal(STX_STORES_KEY, {});
+  stores[name] = store;
+  setGlobal(STX_STORES_KEY, stores);
+}
+export function getHydratedStoreState() {
+  return getGlobal(STX_STORE_STATE_KEY, null);
+}
+export function setRouteParams(params) {
+  setGlobal(STX_ROUTE_PARAMS_KEY, params);
+}
+export function setMiddlewareState(state) {
+  setGlobal(STX_MIDDLEWARE_STATE_KEY, state);
+}
+export function isServer() {
+  return typeof window > "u";
+}
+export function isClient() {
+  return typeof window < "u";
+}
+export function onClient(callback) {
+  if (isClient())
+    callback();
+}
+export function onServer(callback) {
+  if (isServer())
+    callback();
+}