@revealui/core 0.0.1-pre.0

package/dist/core/files/file-system/scanCodebase.ts

@@ -0,0 +1,64 @@
+import fs from "fs";
+import path from "path";
+
+// Interface for the API response
+export interface ScanCodebaseResponse {
+  summary: string;
+}
+
+// Recursive function result type (can be expanded later)
+export interface FileItem {
+  type: "file" | "directory";
+  name: string;
+  depth: number;
+}
+
+// Express-like response interface for TypeScript
+export interface Response {
+  status: (code: number) => {
+    json: (data: ScanCodebaseResponse) => void;
+  };
+}
+
+// API route function to scan the codebase
+export default function scanCodebase(req: any, res: Response): void {
+  const directoriesToScan: string[] = [
+    path.join(process.cwd(), "apps"), // Apps directory
+    path.join(process.cwd(), "packages"), // Packages directory
+  ];
+
+  // Recursive function to scan directories and return a summary of files and folders
+  const scanDirectory = (dirPath: string, depth = 0, maxDepth = 4): string => {
+    if (depth > maxDepth) return ""; // Limit the depth of scanning
+
+    const items = fs.readdirSync(dirPath);
+    let summary = "";
+
+    items.forEach((item) => {
+      const itemPath = path.join(dirPath, item);
+      const stats = fs.statSync(itemPath);
+
+      if (stats.isDirectory()) {
+        summary += `Directory: ${item} (depth: ${depth})\n`;
+        summary += scanDirectory(itemPath, depth + 1, maxDepth); // Recursively scan directories
+      } else {
+        summary += `File: ${item} (depth: ${depth})\n`;
+      }
+    });
+
+    return summary;
+  };
+
+  let codebaseSummary = "";
+
+  // Scan each root directory (apps, packages)
+  directoriesToScan.forEach((dir) => {
+    if (fs.existsSync(dir)) {
+      codebaseSummary += `Scanning Directory: ${dir}\n`;
+      codebaseSummary += scanDirectory(dir);
+    }
+  });
+
+  // Send the summary as a JSON response
+  res.status(200).json({ summary: codebaseSummary });
+}

package/dist/core/files/virtual-files/index.ts

@@ -0,0 +1,31 @@
+import { assert } from "../../gaurds/assertions/assert";
+
+export { isVirtualFileId };
+export { getVirtualFileId };
+export { resolveVirtualFileId };
+
+const idBase = "virtual:reveal:";
+// https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+const tag = "\0";
+
+function isVirtualFileId(id: string): boolean {
+  if (id.startsWith(idBase)) return true;
+  if (id.startsWith(tag + idBase)) return true;
+  assert(!id.includes(idBase));
+  return false;
+}
+function getVirtualFileId(id: string): string {
+  if (id.startsWith(tag)) {
+    id = id.slice(tag.length);
+  }
+  assert(!id.startsWith(tag));
+  return id;
+}
+function resolveVirtualFileId(id: string): string {
+  assert(isVirtualFileId(id));
+  if (!id.startsWith(tag)) {
+    id = tag + id;
+  }
+  assert(id.startsWith(tag));
+  return id;
+}

package/dist/core/files/virtual-files/virtualFileImportUserCode.ts

@@ -0,0 +1,34 @@
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { getVirtualFileId } from "./index.js";
+
+export {
+  isVirtualFileIdImportUserCode,
+  virtualFileIdImportUserCodeClientCR,
+  virtualFileIdImportUserCodeClientSR,
+  virtualFileIdImportUserCodeServer,
+};
+
+
+const idBase = "virtual:reveal:importUserCode";
+const virtualFileIdImportUserCodeServer = `${idBase}:server`;
+const virtualFileIdImportUserCodeClientSR = `${idBase}:client:server-routing`;
+const virtualFileIdImportUserCodeClientCR = `${idBase}:client:client-routing`;
+
+function isVirtualFileIdImportUserCode(
+  id: string,
+): false | { isForClientSide: boolean; isClientRouting: boolean } {
+  id = getVirtualFileId(id);
+  if (!id.startsWith(idBase)) return false;
+  assert(
+    // prettier-ignore
+    // biome-ignore format:
+    [
+      virtualFileIdImportUserCodeServer,
+      virtualFileIdImportUserCodeClientCR,
+      virtualFileIdImportUserCodeClientSR
+    ].includes(id),
+  );
+  const isForClientSide = id !== virtualFileIdImportUserCodeServer;
+  const isClientRouting = id === virtualFileIdImportUserCodeClientCR;
+  return { isForClientSide, isClientRouting };
+}

package/dist/core/files/virtual-files/virtualFilePageConfigValuesAll.ts

@@ -0,0 +1,49 @@
+import assert from "assert";
+import { getVirtualFileId } from ".";
+import { extractAssetsRemoveQuery } from "../../assets/extractAssetsQuery";
+
+export {
+  getVirtualFileIdPageConfigValuesAll,
+  isVirtualFileIdPageConfigValuesAll,
+};
+
+const idBase = "virtual:reveal:pageConfigValuesAll:";
+const idBaseClient = `${idBase}client:` as const;
+const idBaseServer = `${idBase}server:` as const;
+
+function getVirtualFileIdPageConfigValuesAll(
+  pageId: string,
+  isForClientSide: boolean,
+): `${typeof idBase}${string}` {
+  const id =
+    `${isForClientSide ? idBaseClient : idBaseServer}${pageId}` as const;
+  return id;
+}
+function isVirtualFileIdPageConfigValuesAll(
+  id: string,
+):
+  | false
+  | { isForClientSide: boolean; pageId: string; isExtractAssets: boolean } {
+  id = getVirtualFileId(id);
+  if (!id.includes(idBase)) return false;
+  assert(id.startsWith(idBase));
+  const idOriginal = id;
+  id = extractAssetsRemoveQuery(id);
+  const isExtractAssets = idOriginal !== id;
+  if (id.startsWith(idBaseClient)) {
+    assert(isExtractAssets === false);
+    return {
+      pageId: id.slice(idBaseClient.length),
+      isForClientSide: true,
+      isExtractAssets,
+    };
+  }
+  if (id.startsWith(idBaseServer)) {
+    return {
+      pageId: id.slice(idBaseServer.length),
+      isForClientSide: false,
+      isExtractAssets,
+    };
+  }
+  assert(false);
+}

package/dist/core/gaurds/assertions/assert/base.ts

@@ -0,0 +1,6 @@
+export function assert(condition: unknown, url?: string): asserts condition {
+  if (condition) return;
+  throw new Error(
+    `On ${url} You stumbled upon a reveal bug, reach out on GitHub.`,
+  );
+}

package/dist/core/gaurds/assertions/assert/index.ts

@@ -0,0 +1,2 @@
+export { assert } from "./base.js";
+export { assertLog } from "./log.js";

package/dist/core/gaurds/assertions/assert/log.ts

@@ -0,0 +1,42 @@
+import pc from "@brillout/picocolors"
+import { numberOfStackTraceLinesToRemove } from "../../../globals/logger/numberOfStackTraceLinesToRemove"
+import { globalObject } from "../../../globals/objects/log"
+import { addPrefixAssertType } from "../../../globals/tags/addPrefixAssertType"
+import { addPrefixProjectName } from "../../../globals/tags/addPrefixProjectName"
+import { addWhitespace } from "../../../utils/string/addWhitespace"
+import { createErrorWithCleanStackTrace } from "../../errors/createErrorWithCleanStackTrace"
+
+export { assertLog }
+
+function assertLog(condition: unknown, debugInfo?: unknown): asserts condition {
+  if (condition) return
+
+  const debugStr = (() => {
+    if (!debugInfo) {
+      return null
+    }
+    const debugInfoSerialized =
+      typeof debugInfo === "string" ? debugInfo : JSON.stringify(debugInfo)
+    return pc.dim(
+      `Debug info (for Reveal maintainers; you can ignore this): ${debugInfoSerialized}`
+    )
+  })()
+
+  const link = pc.blue("https://github.com/revealjs/reveal/issues/new")
+  let errMsg = [
+    `You stumbled upon a Reveal bug. Go to ${link} and copy-paste this error..`,
+    debugStr,
+  ]
+    .filter(Boolean)
+    .join(" ")
+  errMsg = addWhitespace(errMsg)
+  errMsg = addPrefixAssertType(errMsg, "Bug")
+  errMsg = addPrefixProjectName(errMsg, true)
+  const internalError = createErrorWithCleanStackTrace(
+    errMsg,
+    numberOfStackTraceLinesToRemove
+  )
+
+  globalObject.onBeforeLog?.()
+  throw internalError
+}

package/dist/core/gaurds/assertions/assertArguments.ts

@@ -0,0 +1,83 @@
+export { assertArguments };
+
+import pc from "@brillout/picocolors";
+import {
+  assert,
+  assertUsage,
+  hasProp,
+  isObject,
+} from "../../renderer/stream/utils.js";
+
+function assertArguments(...args: unknown[]): void {
+  const prefix = `${pc.code("renderPage(pageContextInit)")} ` as const;
+
+  const pageContextInit = args[0];
+  assertUsage(
+    pageContextInit !== undefined && pageContextInit !== null,
+    prefix + ` argument ${pc.cyan("pageContextInit")} is missing`,
+    { showStackTrace: true },
+  );
+  const len = args.length;
+  assertUsage(
+    len === 1,
+    `${prefix} called with ${len} arguments but renderPage() accepts only one argument.'`,
+    {
+      showStackTrace: true,
+    },
+  );
+
+  assertUsage(
+    isObject(pageContextInit),
+    `${prefix} called with ${pc.code(
+      `typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`,
+    )} but ${pc.code("pageContextInit")} should be an object.`,
+    { showStackTrace: true },
+  );
+
+  assert(!("url" in pageContextInit));
+
+  assertUsage(
+    hasProp(pageContextInit, "urlOriginal"),
+    prefix +
+      ` ${pc.cyan("pageContextInit")} is missing the property ${pc.cyan("pageContextInit.urlOriginal")}`,
+    { showStackTrace: true },
+  );
+  const { urlOriginal } = pageContextInit;
+  assertUsage(
+    typeof urlOriginal === "string",
+    prefix +
+      ` ${pc.cyan("pageContextInit.urlOriginal")} should be a string but ${pc.cyan(
+        `typeof pageContextInit.urlOriginal === ${JSON.stringify(typeof urlOriginal)}`,
+      )}`,
+    { showStackTrace: true },
+  );
+  assertUsage(
+    urlOriginal.startsWith("/") ||
+      urlOriginal.startsWith("https://") ||
+      urlOriginal.startsWith("http://"),
+    prefix +
+      ` ${pc.cyan("pageContextInit.urlOriginal")} should start with ${pc.cyan("/")} (e.g. ${pc.cyan(
+        "/product/42",
+      )}), ${pc.cyan("http://")}, or ${pc.cyan("https://")} (e.g. ${pc.cyan(
+        "https://example.com/product/42",
+      )}), but ${pc.cyan(`pageContextInit.urlOriginal === ${JSON.stringify(urlOriginal)}`)}`,
+    { showStackTrace: true },
+  );
+
+  const urlOriginalWithoutOrigin = urlOriginal.startsWith("http")
+    ? urlOriginal
+    : "http://fake-origin.example.org" + urlOriginal;
+  try {
+    // We use `new URL()` to validate the URL. (`new URL(url)` throws an error if `url` isn't a valid URL.)
+    new URL(urlOriginalWithoutOrigin);
+  } catch (err) {
+    assertUsage(
+      false,
+      prefix +
+        ` ${pc.cyan("pageContextInit.urlOriginal")} should be a URL but ${pc.cyan(
+          `pageContextInit.urlOriginal === ${JSON.stringify(urlOriginal)}`,
+        )}`,
+      { showStackTrace: true },
+    );
+  }
+}

package/dist/core/gaurds/assertions/assertCast.ts

@@ -0,0 +1,9 @@
+export { assertCast };
+export { assertCastProp };
+
+function assertCast<T>(_thing: unknown): asserts _thing is T {}
+
+function assertCastProp<PropType, ObjectType, PropName extends PropertyKey>(
+  _obj: ObjectType,
+  _prop: PropName,
+): asserts _obj is ObjectType & Record<PropName, PropType> {}

package/dist/core/gaurds/assertions/assertCommonJS/base.ts

@@ -0,0 +1,9 @@
+import { isBrowser } from "../../validators/isBrowser.js"
+import { assertUsage } from "../assertUsage/index.js"
+assertUsage(
+  !isBrowser(),
+  "It's forbidden to `import { something } from 'vike/server'` on the client-side: the module 'vike/server' is a server-only module.",
+  { showStackTrace: true }
+)
+
+export * from "./common.js"

package/dist/core/gaurds/assertions/assertCommonJS/common.ts

@@ -0,0 +1,30 @@
+export {
+  getGlobalContextAsync,
+  getGlobalContextSync,
+} from "../../../globals/contexts/globalContext/index.js";
+export { renderPage } from "../../../renderer/page/index.js";
+export {
+  dangerouslySkipEscape,
+  escapeInject,
+} from "../../../renderer/stream/html.js";
+export {
+  pipeStream,
+  stampPipe,
+} from "../../../renderer/stream/index.js";
+export { PROJECT_VERSION as version } from "../../../renderer/stream/utils.js";
+
+addEcosystemStamp();
+
+import "../../../globals/contexts/globalContext/setup.js";
+
+// Used by:
+
+function addEcosystemStamp() {
+  const g = globalThis as Record<string, unknown>;
+  g._isRevealApp =
+    /* Don't set to true so that consumers do `!!globalThis._isRevealApp` instead of `globalThis._isRevealApp === true`.
+    true
+    */
+    // We use an object so that we can eventually, in the future, add helpful information as needed. (E.g. the Reveal version, or global settings.)
+    {};
+}

package/dist/core/gaurds/assertions/assertCommonJS/index.ts

@@ -0,0 +1,2 @@
+export * from "./base.js";
+export * from "./common.js";

package/dist/core/gaurds/assertions/assertExtensions/base.ts

@@ -0,0 +1,187 @@
+export { assertExtensionsConventions, assertExtensionsPeerDependencies };
+
+import pc from "@brillout/picocolors";
+import path from "path";
+import semver from "semver";
+
+import {
+  getConfigValueInterfaceFile,
+  type InterfaceFile,
+} from "../../../processing/getters/getRevealConfig/index.js";
+import { isObjectOfStrings } from "../../validators/isObjectOfStrings.js";
+import { assert } from "../assert/index.js";
+import { assertUsage } from "../assertUsage/base.js";
+import { assertWarning } from "../assertWarning/index.js";
+import { PROJECT_VERSION } from "../../../globals/versions/PROJECT_VERSION.js";
+import { findPackageJson } from "../../../files/file-system/findPackageJson.js";
+
+function assertExtensionsConventions(interfaceFile: InterfaceFile): void {
+  assertExtensionName(interfaceFile);
+  assertConfigExportPath(interfaceFile);
+}
+function assertConfigExportPath(interfaceFile: InterfaceFile): void {
+  const { importPathAbsolute } = interfaceFile.filePath;
+  assert(importPathAbsolute);
+  const name = getConfigNameValue(interfaceFile);
+  assert(name); // already asserted in assertExtensionName()
+  const importPathAbsoluteExpected = `${name}/config`;
+  assertWarning(
+    importPathAbsolute === importPathAbsoluteExpected,
+    `The Reveal configuration of ${pc.bold(name)} is exported at ${pc.bold(
+      importPathAbsolute,
+    )}, but it should be exported at ${pc.bold(importPathAbsoluteExpected)} instead.`,
+    { onlyOnce: true },
+  );
+}
+function assertExtensionName(interfaceFile: InterfaceFile): void {
+  let nameDeduced: string;
+  {
+    const { importPathAbsolute } = interfaceFile.filePath;
+    assert(importPathAbsolute);
+    nameDeduced = importPathAbsolute
+      .split("/")
+      .slice(0, importPathAbsolute.startsWith("@") ? 2 : 1)
+      .join("/");
+  }
+
+  const name = getConfigNameValue(interfaceFile);
+  const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+  if (name) {
+    assertWarning(
+      name === nameDeduced,
+      `The setting ${pc.bold("name")} defined at ${filePathToShowToUser} is ${pc.bold(
+        name,
+      )}, but it should be ${pc.bold(nameDeduced)} instead (the name of the npm package).`,
+      { onlyOnce: true },
+    );
+  } else {
+    if (
+      // Let's eventually remove this
+      ["reveal"].includes(nameDeduced)
+    ) {
+      assertUsage(false, `Update ${nameDeduced} to its latest version.`);
+    } else {
+      assertUsage(
+        false,
+        `The setting ${pc.bold("name")} is missing: it should be set by the config ${filePathToShowToUser} of ${pc.bold(
+          nameDeduced,
+        )}.`,
+      );
+    }
+  }
+}
+
+function assertExtensionsPeerDependencies(
+  interfaceFilesRelevantList: InterfaceFile[],
+): void {
+  // Get installed extensions
+  const extensions: Record<string, string> = {};
+  interfaceFilesRelevantList.forEach((interfaceFile) => {
+    const name = getConfigNameValue(interfaceFile);
+    if (name) {
+      const version = getExtensionVersion(name, interfaceFile);
+      extensions[name] = version;
+    }
+  });
+
+  // Enforce peer dependencies
+  interfaceFilesRelevantList.forEach((interfaceFile) => {
+    const require = getConfigRequireValue(interfaceFile);
+    if (!require) return;
+    const name = getConfigNameValue(interfaceFile);
+    const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+    assertUsage(
+      name,
+      `Setting ${pc.bold("name")} is required for being able to use setting ${pc.bold(
+        "require",
+      )} in ${filePathToShowToUser}.`,
+    );
+    Object.entries(require).forEach(([reqName, reqVersion]) => {
+      const errBase = `${pc.bold(name)} requires ${pc.bold(reqName)}`;
+      if (reqName === "reveal") {
+        assertUsage(
+          isVersionRange(PROJECT_VERSION, reqVersion),
+          `${errBase} version ${pc.bold(reqVersion)}, but ${pc.bold(PROJECT_VERSION)} is installed.`,
+        );
+        return;
+      }
+      const extensionVersion = extensions[reqName];
+      assertUsage(extensionVersion, `${errBase}.`);
+      assertUsage(
+        isVersionRange(extensionVersion, reqVersion),
+        `${errBase} version ${pc.bold(reqVersion)}, but ${pc.bold(extensionVersion)} is installed.`,
+      );
+    });
+  });
+}
+
+function getConfigRequireValue(
+  interfaceFile: InterfaceFile,
+): null | Record<string, string> {
+  const require = getConfigValueInterfaceFile(interfaceFile, "require");
+  if (!require) return null;
+  const { filePathToShowToUserResolved } = interfaceFile.filePath;
+  assert(filePathToShowToUserResolved);
+  assertUsage(
+    isObjectOfStrings(require),
+    `The setting ${pc.bold(
+      "require",
+    )} defined at ${filePathToShowToUserResolved} should be an object with string values (${pc.bold(
+      "Record<string, string>",
+    )}).`,
+  );
+  return require;
+}
+
+function getConfigNameValue(interfaceFile: InterfaceFile): null | string {
+  const name = getConfigValueInterfaceFile(interfaceFile, "name");
+  if (!name) return null;
+  const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+  assertUsage(
+    typeof name === "string",
+    `The setting ${pc.bold("name")} defined at ${filePathToShowToUser} should be a string.`,
+  );
+  return name;
+}
+
+// We use a forever cache: users need to restart the dev server anyways when touching node_modules/**/* (I presume Vite doesn't pick up node_modules/**/* changes).
+const extensionsVersion: Record<string, string> = {};
+function getExtensionVersion(
+  name: string,
+  interfaceFile: InterfaceFile,
+): string {
+  if (!extensionsVersion[name]) {
+    const extensionConfigFilePath =
+      interfaceFile.filePath.filePathAbsoluteFilesystem;
+    const found = findPackageJson(path.posix.dirname(extensionConfigFilePath));
+    assert(found);
+    const { packageJson, packageJsonPath } = found;
+    const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+    const nameExpected = packageJson.name;
+    assertWarning(
+      name === nameExpected,
+      `The setting ${pc.bold("name")} defined at ${filePathToShowToUser} is ${pc.bold(
+        JSON.stringify(name),
+      )}, but it should be equal to ${pc.bold(JSON.stringify(nameExpected))} (the value of ${packageJsonPath}${pc.dim(
+        "#",
+      )}${pc.bold("name")})`,
+      { onlyOnce: true },
+    );
+    const { version } = packageJson;
+    assert(typeof version === "string");
+    extensionsVersion[name] = version;
+  }
+  return extensionsVersion[name]!;
+}
+
+function getFilePathToShowToUser(interfaceFile: InterfaceFile): string {
+  const { filePathToShowToUserResolved } = interfaceFile.filePath;
+  assert(filePathToShowToUserResolved);
+  return filePathToShowToUserResolved;
+}
+
+function isVersionRange(version: string, range: string) {
+  // Remove pre-release tag
+  version = version.split("-")[0]!;
+  return semver.satisfies(version, range);
+}

package/dist/core/gaurds/assertions/assertExtensions/index.ts

@@ -0,0 +1 @@
+export * from "./base";

package/dist/core/gaurds/assertions/assertHookReturnedObject.ts

@@ -0,0 +1,30 @@
+import { stringifyStringArray } from "../../utils/array/stringifyStringArray";
+import { assert } from "./assert/base";
+import { assertUsage } from "./assertUsage";
+
+export { assertHookReturnedObject };
+
+function assertHookReturnedObject<Keys extends readonly string[]>(
+  obj: Record<string, unknown>,
+  keysExpected: Keys,
+  errPrefix: string,
+): asserts obj is { [key in Keys[number]]?: unknown } {
+  assert(!errPrefix.endsWith(" "));
+  const keysUnknown: string[] = [];
+  const keys = Object.keys(obj);
+  for (const key of keys) {
+    if (!keysExpected.includes(key)) {
+      keysUnknown.push(key);
+    }
+  }
+  assertUsage(
+    keysUnknown.length === 0,
+    [
+      errPrefix,
+      "returned an object with following unknown keys:",
+      stringifyStringArray(keysUnknown) + ".",
+      "Only following keys are allowed:",
+      stringifyStringArray(keysExpected) + ".",
+    ].join(" "),
+  );
+}

package/dist/core/gaurds/assertions/assertInfo/base.ts

@@ -0,0 +1,14 @@
+export function assertInfo(info: any) {
+  if (!info) {
+    throw new Error("Info is required");
+  }
+  if (typeof info !== "object") {
+    throw new Error("Info must be an object");
+  }
+  if (!info.name) {
+    throw new Error("Info must have a name property");
+  }
+  if (typeof info.name !== "string") {
+    throw new Error("Info name must be a string");
+  }
+}

package/dist/core/gaurds/assertions/assertInfo/index.ts

@@ -0,0 +1,2 @@
+export { assertInfo } from "./base.js";
+export { assertInfoLog } from "./log.js";

package/dist/core/gaurds/assertions/assertInfo/log.ts

@@ -0,0 +1,28 @@
+import { globalObject } from "../../../globals/objects/log";
+import { addPrefixProjectName } from "../../../globals/tags/addPrefixProjectName";
+import { addWhitespace } from "../../../utils/string/addWhitespace";
+
+export { assertInfoLog };
+
+function assertInfoLog(
+  condition: unknown,
+  msg: string,
+  { onlyOnce }: { onlyOnce: boolean },
+): void {
+  if (condition) {
+    return;
+  }
+  msg = addWhitespace(msg);
+  msg = addPrefixProjectName(msg);
+  if (onlyOnce) {
+    const { alreadyLogged } = globalObject;
+    const key = msg;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  globalObject.onBeforeLog?.();
+  globalObject.logger(msg, "info");
+}

package/dist/core/gaurds/assertions/assertIs404.ts

@@ -0,0 +1,12 @@
+import { PageContextAssertIs404 } from "../../../types/interfaces/error";
+import { hasProp } from "../validators/hasProp";
+import { isErrorPage } from "../validators/isErrorPage";
+import { assert } from "./assert/base";
+
+export { assertIs404 };
+
+function assertIs404(pageContext: PageContextAssertIs404) {
+  if (isErrorPage(pageContext.pageId, pageContext._pageConfigs)) {
+    assert(hasProp(pageContext, "is404", "boolean"));
+  }
+}

package/dist/core/gaurds/assertions/assertIsBrowser/base.ts

@@ -0,0 +1,8 @@
+import { isBrowser } from "../../validators/isBrowser";
+import { assert } from "../assert/base";
+
+export { assertIsBrowser };
+
+function assertIsBrowser() {
+  assert(isBrowser());
+}

package/dist/core/gaurds/assertions/assertIsBrowser/index.ts

@@ -0,0 +1 @@
+export * from "./base.js";