@revealui/core 0.0.1-pre.0

package/dist/core/gaurds/validators/hasProp.ts

@@ -0,0 +1,116 @@
+export { hasProp };
+export type { ResolveTypeAsString };
+
+import { isArray } from "./isArray.js";
+import { isArrayOfStrings } from "./isArrayOfStrings.js";
+import { isCallable } from "./isCallable.js";
+import { isObject } from "./isObject.js";
+import { isObjectOfStrings } from "./isObjectOfStrings.js";
+
+type TypeAsString =
+	| "object"
+	| "string{}"
+	| "string[]"
+	| "array"
+	| "function"
+	| "number"
+	| "string"
+	| "boolean"
+	| "true"
+	| "false"
+	| "null"
+	| "undefined"
+	| undefined;
+
+type ResolveTypeAsString<Type extends TypeAsString = undefined> =
+	//
+	Type extends "object"
+		? Record<string, unknown>
+		: Type extends "string{}"
+			? Record<string, string>
+			: Type extends "string[]"
+				? string[]
+				: Type extends "array"
+					? unknown[]
+					: Type extends "function"
+						? (...args: unknown[]) => unknown
+						: Type extends "number"
+							? number
+							: Type extends "string"
+								? string
+								: Type extends "boolean"
+									? boolean
+									: Type extends "true"
+										? true
+										: Type extends "false"
+											? false
+											: Type extends "null"
+												? null
+												: Type extends "undefined"
+													? undefined
+													: Type extends undefined
+														? unknown
+														: never;
+
+function hasProp<
+	ObjectType,
+	PropName extends PropertyKey,
+	Type extends TypeAsString = undefined,
+>(
+	obj: ObjectType,
+	prop: PropName,
+	type?: Type,
+): obj is ObjectType & Record<PropName, ResolveTypeAsString<Type>>;
+function hasProp<ObjectType, PropName extends PropertyKey, Enum>(
+	obj: ObjectType,
+	prop: PropName,
+	type: Enum[],
+): obj is ObjectType & Record<PropName, Enum>;
+function hasProp(
+	obj: Record<string, unknown>,
+	prop: string,
+	type?:
+		| TypeAsString
+		//  Enum[]
+		| string[],
+): boolean {
+	if (!isObject(obj)) return false;
+	if (!(prop in obj)) {
+		return type === "undefined";
+	}
+	if (type === undefined) {
+		return true;
+	}
+	const propValue = (obj as Record<string, unknown>)[prop];
+	if (type === "undefined") {
+		return propValue === undefined;
+	}
+	if (type === "array") {
+		return isArray(propValue);
+	}
+	if (type === "object") {
+		return isObject(propValue);
+	}
+	if (type === "string[]") {
+		return isArrayOfStrings(propValue);
+	}
+	if (type === "string{}") {
+		return isObjectOfStrings(propValue);
+	}
+	if (type === "function") {
+		return isCallable(propValue);
+	}
+	if (isArray(type)) {
+		return typeof propValue === "string" && type.includes(propValue);
+	}
+	if (type === "null") {
+		return propValue === null;
+	}
+	if (type === "true") {
+		return propValue === true;
+	}
+	if (type === "false") {
+		return propValue === false;
+	}
+	return typeof propValue === type;
+}

package/dist/core/gaurds/validators/isArray.ts

@@ -0,0 +1,4 @@
+// Same as Array.isArray() but typesafe: asserts unknown[] instead of any[]
+export function isArray(value: unknown): value is unknown[] {
+  return Array.isArray(value);
+}

package/dist/core/gaurds/validators/isArrayOfStrings.ts

@@ -0,0 +1,7 @@
+export { isArrayOfStrings };
+
+import { isArray } from "./isArray.js";
+
+function isArrayOfStrings(val: unknown): val is string[] {
+  return isArray(val) && val.every((v) => typeof v === "string");
+}

package/dist/core/gaurds/validators/isAsset.ts

@@ -0,0 +1,43 @@
+export { isAsset };
+
+function isAsset(filename: string) {
+  return assetFileExtensions.some((ext) => filename.endsWith("." + ext));
+}
+
+// Copied from Vite: https://github.com/vitejs/vite/blob/9d28ffd3410a3ea2b739cce31e845f59cebd3cc6/packages/vite/src/node/constants.ts#L83-L121
+// Alternatively: check sirv's source code (it needs to send the right Content-Type header)
+const assetFileExtensions = [
+  // images
+  "png",
+  "jpg",
+  "jpeg",
+  "jfif",
+  "pjpeg",
+  "pjp",
+  "gif",
+  "svg",
+  "ico",
+  "webp",
+  "avif",
+
+  // media
+  "mp4",
+  "webm",
+  "ogg",
+  "mp3",
+  "wav",
+  "flac",
+  "aac",
+
+  // fonts
+  "woff2",
+  "woff",
+  "eot",
+  "ttf",
+  "otf",
+
+  // other
+  "webmanifest",
+  "pdf",
+  "txt",
+];

package/dist/core/gaurds/validators/isBrowser.ts

@@ -0,0 +1,5 @@
+export function isBrowser() {
+  // Using `typeof window !== 'undefined'` alone is not enough because some users use https://www.npmjs.com/package/ssr-window
+  return typeof window !== "undefined" && typeof window.scrollY === "number";
+  // Alternatively, test whether environment is a *real* browser: https://github.com/brillout/picocolors/blob/d59a33a0fd52a8a33e4158884069192a89ce0113/picocolors.js#L87-L89
+}

package/dist/core/gaurds/validators/isBug.ts

@@ -0,0 +1,5 @@
+export { isBug };
+
+function isBug(err: unknown): boolean {
+  return !String(err).includes("[Bug]");
+}

package/dist/core/gaurds/validators/isCallable.ts

@@ -0,0 +1,11 @@
+export function isCallable<T extends (...args: unknown[]) => unknown>(
+  thing: T | unknown,
+): thing is T {
+  return thing instanceof Function || typeof thing === "function";
+}
+
+// export function isCallable<T extends (...args: any[]) => any>(
+//   thing: T | unknown,
+// ): thing is T {
+//   return thing instanceof Function || typeof thing === "function";
+// }

package/dist/core/gaurds/validators/isClientSideRoutable.ts

@@ -0,0 +1,19 @@
+export { isClientSideRoutable }
+
+import { PageContextPageFiles } from "../../../types/interfaces/context.js"
+import { findPageConfig } from "../../config/findPageConfig.js"
+import { analyzeClientSide } from "../../processing/getters/getPageFiles/analyzeClientSide.js"
+
+function isClientSideRoutable(
+  pageId: string,
+  pageContext: PageContextPageFiles
+): Promise<boolean> {
+  analyzeClientSide(null, pageContext._pageFilesAll, pageId)
+  const pageConfig = findPageConfig(pageContext._pageConfigs, pageId)
+  const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(
+    pageConfig,
+    pageContext._pageFilesAll,
+    pageId
+  )
+  return Promise.resolve(isClientRuntimeLoaded && isClientRouting)
+}

package/dist/core/gaurds/validators/isConfigInvalid.ts

@@ -0,0 +1,10 @@
+export { isConfigInvalid, isConfigInvalid_set };
+
+import { assert } from "../../renderer/stream/utils.js";
+
+let isConfigInvalid: false | { err: unknown };
+
+const isConfigInvalid_set = (val: typeof isConfigInvalid) => {
+  assert(val === false || val.err);
+  isConfigInvalid = val;
+};

package/dist/core/gaurds/validators/isDev.ts

@@ -0,0 +1,56 @@
+export { isDev2, isDev3 }
+
+// We can propbably remove this file after we implement the reveal CLI
+
+// There isn't any reliable way to test whether Vite is ran as dev/build/preview/optimizeDep
+//  - Failed attempt to make a PR: https://github.com/vitejs/vite/pull/12298
+//    - Superseded by https://github.com/vitejs/vite/pull/14855
+
+// ********
+// Method 3 - most reliable, requires newer Vite version
+// ********
+import type { ConfigEnv } from "vite"
+function isDev3(configEnv: ConfigEnv): boolean {
+  const { isPreview, command } = configEnv
+  if (command !== "serve") return false
+
+  // `isPreview` is `undefined` in older Vite versions.
+  // https://github.com/vitejs/vite/pull/14855
+  // https://github.com/vitejs/vite/pull/15695O
+  // - Released at `vite@5.1.0`: https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#510-beta4-2024-01-26:~:text=fix(preview)%3A%20set%20isPreview%20true%20(%2315695)%20(93fce55)%2C%20closes%20%2315695
+  assert(typeof isPreview === "boolean")
+
+  return !isPreview
+}
+
+/* This isn't reliable:
+ * - https://github.com/revealjs/reveal/issues/1791
+ * - Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/revealjs/reveal/issues/792#issuecomment-1516830759
+ *
+import { getGlobalObject } from './getGlobalObject.js'
+const globalObject = getGlobalObject('utils/isDev.ts', { isDev: false, isDev_wasCalled: false })
+function isDev1(): boolean {
+  globalObject.isDev_wasCalled = true
+  return globalObject.isDev
+}
+function isDev1_onConfigureServer(): void | undefined {
+  // configureServer() is called more than once when user presses Vite's dev server reload hotkey <r>
+  if (globalObject.isDev) return
+  assert(!globalObject.isDev_wasCalled)
+  globalObject.isDev = true
+}
+*/
+
+// ********
+// Method 2
+// ********
+import type { ResolvedConfig } from "vite"
+import { assert } from "../assertions/assert"
+function isDev2(config: ResolvedConfig): boolean {
+  const isDev =
+    config.command === "serve" &&
+    // Mode is 'development' by default: https://github.com/vitejs/vite/blob/bf9c49f521b7a6730231c35754d5e1f9c3a6a16e/packages/vite/src/node/config.ts#L383
+    // Note that user can override this: https://github.com/vitejs/vite/blob/bf9c49f521b7a6730231c35754d5e1f9c3a6a16e/packages/vite/src/node/cli.ts#L126
+    config.mode === "development"
+  return isDev
+}

package/dist/core/gaurds/validators/isErrorDebug.ts

@@ -0,0 +1,7 @@
+import { isDebugActivated } from "../debugger";
+
+export { isErrorDebug };
+
+function isErrorDebug(): boolean {
+  return isDebugActivated("reveal:error");
+}

package/dist/core/gaurds/validators/isErrorPage.ts

@@ -0,0 +1,16 @@
+import { PageConfigRuntime } from "../../../types/interfaces/page";
+import { assert } from "../assertions/assert";
+
+export { isErrorPage };
+
+function isErrorPage(
+  pageId: string,
+  pageConfigs: PageConfigRuntime[],
+): boolean {
+  if (pageConfigs.length > 0) {
+    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+    assert(pageConfig);
+    return !!pageConfig.isErrorPage;
+  }
+  return false;
+}

package/dist/core/gaurds/validators/isFilePathAbsoluteFilesystem.ts

@@ -0,0 +1,55 @@
+export { assertFilePathAbsoluteFilesystem, isFilePathAbsolute }
+
+import path from "path"
+
+import { assertPosixPath } from "../../files/file-system/filesystemPath.js"
+import { assert } from "../assertions/assert/base.js"
+
+/**
+ * Asserts that `filePath` is an absolute file path starting from the filesystem root.
+ *
+ * It isn't reliable for Linux users, but that's okay because the assertion will eventually fail on windows.
+ */
+function assertFilePathAbsoluteFilesystem(filePath: string) {
+  // The assert is "eventually reliable":
+  // - For Windows users, the assert is correct.
+  // - For Linux users assertFilePathAbsoluteFilesystem() will erroneously succeed if `p` is a path absolute from the user root dir.
+  //   - But that's okay because the assertion will eventually fail for Windows users.
+  assert(isFilePathAbsoluteFilesystem(filePath))
+  assertPosixPath(filePath)
+}
+
+/**
+ * Whether `filePath` is an absolute file path starting from the filesystem root.
+ *
+ * Isn't reliable for Linux users: it returns `true` for an absolute path starting from the user root dir.
+ */
+function isFilePathAbsoluteFilesystem(filePath: string) {
+  assert(!filePath.startsWith("/@fs/"))
+  if (process.platform !== "win32") {
+    // - For linux users, there doesn't seem to be a reliable way to distinguish between:
+    //   - File path absolute starting from filesystem root, e.g. /home/rom/code/my-app/pages/about/+Page.js
+    //   - File path absolute starting from user root dir (Vite's `config.root`), e.g. /pages/about/+Page.js
+    // - Checking whether `p` starts with the first directory of process.cwd() (or `userRootDir`) can be erroneous, most notably when using docker: https://github.com/revealjs/reveal/issues/703
+    // - Using require.resolve() would be a solution but probably too slow?
+    return filePath.startsWith("/")
+  } else {
+    const yes = path.win32.isAbsolute(filePath)
+    // Ensure isFilePathAbsoluteFilesystem() returns `false` if path is absolute starting from the user root dir (see comments above).
+    if (yes) assert(!filePath.startsWith("/"))
+    return yes
+  }
+}
+
+/**
+ * Whether `filePath` is an absolute file path.
+ *
+ * Returns `true` regardless whether it starts from the user root dir or filesystem root.
+ */
+function isFilePathAbsolute(filePath: string): boolean {
+  assert(!filePath.startsWith("/@fs/"))
+  // Absolute path starting from the user root dir.
+  if (filePath.startsWith("/")) return true
+  // Seems to be reliable: https://nodejs.org/api/path.html#pathisabsolutepath
+  return path.isAbsolute(filePath)
+}

package/dist/core/gaurds/validators/isHtml.ts

@@ -0,0 +1,9 @@
+// Unit tests at ./isHtml.spec.ts
+
+export { isHtml };
+
+function isHtml(str: string): boolean {
+  // Copied and adapted from https://stackoverflow.com/questions/15458876/check-if-a-string-is-html-or-not/51325984#51325984
+  const re = /(<\/[^<]+>)|(<[^<]+\/>)/;
+  return re.test(str);
+}

package/dist/core/gaurds/validators/isNewError.ts

@@ -0,0 +1,29 @@
+export { isNewError, setAlreadyLogged };
+
+import getGlobalObject from "../../processing/getters/getGlobalObject.js";
+import {
+  isObject,
+  isSameErrorMessage,
+  warnIfErrorIsNotObject,
+} from "../../renderer/stream/utils.js";
+
+const globalObject = getGlobalObject("runtime/renderPage/isNewError.ts", {
+  wasAlreadyLogged: new WeakSet<object>(),
+});
+
+function isNewError(errErrorPage: unknown, errNominalPage: unknown): boolean {
+  warnIfErrorIsNotObject(errErrorPage);
+  return (
+    !isSameErrorMessage(errNominalPage, errErrorPage) ||
+    // Isn't this redudant/superfluous? I think we can remove this entire file and only use isSameErrorMessage() instead.
+    !hasAlreadyLogged(errNominalPage)
+  );
+}
+function hasAlreadyLogged(err: unknown): boolean {
+  if (!isObject(err)) return false;
+  return globalObject.wasAlreadyLogged.has(err);
+}
+function setAlreadyLogged(err: unknown): void {
+  if (!isObject(err)) return;
+  globalObject.wasAlreadyLogged.add(err);
+}

package/dist/core/gaurds/validators/isNodeJS.ts

@@ -0,0 +1,10 @@
+export function isNodeJS(): boolean {
+  if (typeof process === "undefined") return false;
+  if (!process.cwd) return false;
+  // https://stackoverflow.com/questions/4224606/how-to-check-whether-a-script-is-running-under-node-js/35813135#35813135
+  if (!process.versions || typeof process.versions.node === "undefined")
+    return false;
+  // https://stackoverflow.com/questions/4224606/how-to-check-whether-a-script-is-running-under-node-js/35813135#comment92529277_35813135
+  if (!process.release || process.release.name !== "node") return false;
+  return true;
+}

package/dist/core/gaurds/validators/isNotFalse.ts

@@ -0,0 +1,3 @@
+export function isNotFalse<T>(val: T | false): val is T {
+  return val !== false;
+}

package/dist/core/gaurds/validators/isNotNullish.ts

@@ -0,0 +1,2 @@
+export const isNotNullish = <T>(p: T | null | undefined): p is T =>
+  p !== null && p !== undefined;

package/dist/core/gaurds/validators/isNpmPackage.ts

@@ -0,0 +1,127 @@
+import { assert } from "../assertions/assert";
+import { assertIsNotBrowser } from "../assertions/assertIsNotBrowser";
+
+export {
+  assertIsNpmPackageImport,
+  isNpmPackageImport,
+  isNpmPackageImport_unreliable,
+  isValidPathAlias,
+};
+/* Currently not used
+export { isNpmPackageName }
+export { getNpmPackageName }
+export { getNpmPackageImportPath }
+*/
+
+// For ./isNpmPackage.spec.ts
+export { isDistinguishable, parse };
+
+assertIsNotBrowser();
+
+function isNpmPackageImport(
+  str: string,
+  { cannotBePathAlias }: { cannotBePathAlias: true },
+): boolean {
+  // We cannot distinguish path alises that look like npm package imports
+  assert(cannotBePathAlias);
+  return isNpmPackageImport_unreliable(str);
+}
+
+function isNpmPackageImport_unreliable(str: string): boolean {
+  const res = parse(str);
+  return res !== null;
+}
+
+function assertIsNpmPackageImport(str: string): void {
+  assert(
+    isNpmPackageImport(str, {
+      // If `str` is a path alias that looks like an npm package => assertIsNpmPackageImport() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+      cannotBePathAlias: true,
+    }),
+    str,
+  );
+}
+
+function isNpmPackageName(str: string | undefined): boolean {
+  const res = parse(str);
+  return res !== null && res.importPath === null;
+}
+
+function getNpmPackageName(str: string): null | string {
+  const res = parse(str);
+  if (!res) return null;
+  return res.pkgName;
+}
+
+function getNpmPackageImportPath(str: string): null | string {
+  const res = parse(str);
+  if (!res) return null;
+  return res.importPath;
+}
+
+function isValidPathAlias(alias: string): boolean {
+  // Cannot be distinguished from npm package names
+  if (!isDistinguishable(alias)) return false;
+
+  // Ensure path alias starts with a special character.
+  //  - In principle, we could allow path aliases that don't start with special character as long as they can be distinguished from npm package names.
+  //    - But we still enforce path aliases to start with a special character because it's a much simpler rule to follow.
+  if (alias.startsWith("@/")) return true; // Needed by contra.com
+  const firstLetter = alias[0];
+  assert(firstLetter);
+  if (firstLetter === "@" || /[0-9a-z]/.test(firstLetter.toLowerCase()))
+    return false;
+
+  return true;
+}
+
+function isDistinguishable(alias: string): boolean {
+  return (
+    parse(alias) === null &&
+    parse(`${alias}fake-path`) === null &&
+    parse(`${alias}/fake-path`) === null &&
+    parse(`${alias}fake/deep/path`) === null &&
+    parse(`${alias}/fake/deep/path`) === null &&
+    // See note about '-' in ./isNpmPackageName.spec.ts
+    // ```ts
+    // expect(parse('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
+    // ```
+    !alias.startsWith("-")
+  );
+}
+
+// The logic down below is wrong, for example:
+//  - https://www.npmjs.com/package/-
+// The correct logic is complex, see https://github.com/npm/validate-npm-package-name
+// We don't need to be accurate: are there npm packages with weird names that are actually being used?
+function parse(
+  str: string | undefined,
+): null | { pkgName: string; importPath: null | string } {
+  if (!str) return null;
+
+  let scope: string | null = null;
+  if (str.startsWith("@")) {
+    if (!str.includes("/")) return null;
+    const [scope_, ...rest] = str.split("/");
+    scope = scope_!;
+    str = rest.join("/");
+    if (!str) return null;
+    if (scope === "@" || invalid(scope.slice(1))) return null;
+  }
+
+  const [name, ...importPathParts] = str.split("/");
+  if (!name || invalid(name)) return null;
+  const importPath =
+    importPathParts.length === 0 ? null : importPathParts.join("/");
+
+  return {
+    pkgName: scope ? `${scope}/${name}` : name,
+    importPath,
+  };
+}
+function invalid(s: string) {
+  const firstLetter = s[0];
+  if (!firstLetter || !/[a-z0-9]/.test(firstLetter)) return true;
+  if (/[^a-z0-9_\-\.]/.test(s)) return true;
+  return false;
+}

package/dist/core/gaurds/validators/isObject.ts

@@ -0,0 +1,3 @@
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}

package/dist/core/gaurds/validators/isObjectOfStrings.ts

@@ -0,0 +1,9 @@
+export { isObjectOfStrings };
+
+import { isObject } from "./isObject.js";
+
+function isObjectOfStrings(val: unknown): val is Record<string, string> {
+  return (
+    isObject(val) && Object.values(val).every((v) => typeof v === "string")
+  );
+}

package/dist/core/gaurds/validators/isObjectWithKeys.ts

@@ -0,0 +1,18 @@
+import { isPlainObject } from "./isPlainObject.js";
+
+export { isObjectWithKeys };
+
+function isObjectWithKeys<Keys extends readonly string[]>(
+  obj: unknown,
+  keys: Keys,
+): obj is { [key in Keys[number]]?: unknown } {
+  if (!isPlainObject(obj)) {
+    return false;
+  }
+  for (const key of Object.keys(obj)) {
+    if (!keys.includes(key)) {
+      return false;
+    }
+  }
+  return true;
+}

package/dist/core/gaurds/validators/isPlainObject.ts

@@ -0,0 +1,21 @@
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  // Is object?
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  // Support `Object.create(null)`
+  if (Object.getPrototypeOf(value) === null) {
+    return true;
+  }
+
+  // Is plain object?
+  return (
+    /* Doesn't work in Cloudflare Pages workers
+    value.constructor === Object
+    */
+    value.constructor.name === "Object"
+  );
+}

package/dist/core/gaurds/validators/isPromise.ts

@@ -0,0 +1,9 @@
+import { isCallable } from "./isCallable.js";
+export function isPromise(val: unknown): val is Promise<unknown> {
+  return (
+    typeof val === "object" &&
+    val !== null &&
+    "then" in val &&
+    isCallable((val as Record<string, unknown>).then)
+  );
+}

package/dist/core/gaurds/validators/isPropertyGetter.ts

@@ -0,0 +1,4 @@
+export function isPropertyGetter(obj: Object, prop: string): boolean {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+  return !!descriptor && !("value" in descriptor) && !!descriptor.get;
+}

package/dist/core/gaurds/validators/isReact.ts

@@ -0,0 +1,24 @@
+// There doesn't seem to be a reliable way to detect React:
+//  - https://stackoverflow.com/questions/73156433/detect-with-javascript-whether-the-website-is-using-react
+export function isReact() {
+  // Heuristic using values set by React (Dev Tools)
+  // - `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` is an internal API for React Dev Tools
+  //   - https://stackoverflow.com/questions/46807826/how-does-react-developer-tools-determine-that-the-webpage-is-using-react/46808361#46808361
+  //   - In principle, `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` should exist only if React Dev Tools is installed. (Although it seems that it's sometimes defined even when React Dev Tools isn't installed; I don't know why.)
+  // - We use `isReact1`/`isReact2` merely to validate `isReact3` and `isReact4`. Because `isReact1`/`isReact2` can be false negatives:
+  //   - React populates `__REACT_DEVTOOLS_GLOBAL_HOOK__.renderers` fairly late => false negative early in the rendering phase
+  //   - `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` is `undefined` if React Dev Tools isn't installed => false negative
+  const isReact1 = !!(window as any).__REACT_DEVTOOLS_GLOBAL_HOOK__?.renderers
+    ?.size;
+  const isReact2 = !!(window as any).__REACT_DEVTOOLS_GLOBAL_HOOK__
+    ?.rendererInterfaces?.size;
+
+  // Heuristic using values set by `@vitejs/plugin-react`
+  const isReact3 = !!(window as any).__vite_plugin_react_preamble_installed__;
+  /* Also set by Preact Vite plugin `@preact/preset-vite`
+  const isReact4 = !!(window as any).$RefreshReg$
+  */
+
+  // console.log({ isReact1, isReact2, isReact3 })
+  return isReact1 || isReact2 || isReact3;
+}