houdini-react 1.2.25 → 1.2.26

package/build/runtime-cjs/server/useStream.js

@@ -0,0 +1,44 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useStream_exports = {};
+__export(useStream_exports, {
+  StreamProvider: () => StreamProvider,
+  useStream: () => useStream
+});
+module.exports = __toCommonJS(useStream_exports);
+var import_react = __toESM(require("react"));
+var import_utils = require("./utils");
+const StreamContext = import_react.default.createContext(null);
+const StreamProvider = StreamContext.Provider;
+function useStream() {
+  const streamUtils = (0, import_react.useContext)(StreamContext);
+  (0, import_utils.assert)(streamUtils);
+  return streamUtils;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamProvider,
+  useStream
+});

package/build/runtime-cjs/server/utils/assert.d.ts

@@ -0,0 +1,15 @@
+export { assert };
+export { assertUsage };
+export { assertWarning };
+export { assertInfo };
+export { getProjectError };
+declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
+declare function assertUsage(condition: unknown, errorMessage: string): asserts condition;
+declare function getProjectError(errorMessage: string): Error;
+declare function assertWarning(condition: unknown, errorMessage: string, { onlyOnce, showStackTrace }: {
+    onlyOnce: boolean | string;
+    showStackTrace?: true;
+}): void;
+declare function assertInfo(condition: unknown, errorMessage: string, { onlyOnce }: {
+    onlyOnce: boolean;
+}): void;

package/build/runtime-cjs/server/utils/assert.js

@@ -0,0 +1,119 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var assert_exports = {};
+__export(assert_exports, {
+  assert: () => assert,
+  assertInfo: () => assertInfo,
+  assertUsage: () => assertUsage,
+  assertWarning: () => assertWarning,
+  getProjectError: () => getProjectError
+});
+module.exports = __toCommonJS(assert_exports);
+var import_createErrorWithCleanStackTrace = require("./createErrorWithCleanStackTrace");
+var import_projectInfo = require("./projectInfo");
+const errorPrefix = `[${import_projectInfo.projectInfo.npmPackageName}@${import_projectInfo.projectInfo.projectVersion}]`;
+const internalErrorPrefix = `${errorPrefix}[Bug]`;
+const usageErrorPrefix = `${errorPrefix}[Wrong Usage]`;
+const warningPrefix = `${errorPrefix}[Warning]`;
+const infoPrefix = `${errorPrefix}[Info]`;
+const numberOfStackTraceLinesToRemove = 2;
+function assert(condition, debugInfo) {
+  if (condition) {
+    return;
+  }
+  const debugStr = (() => {
+    if (!debugInfo) {
+      return "";
+    }
+    const debugInfoSerialized = typeof debugInfo === "string" ? debugInfo : "`" + JSON.stringify(debugInfo) + "`";
+    return `Debug info (this is for the ${import_projectInfo.projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}.`;
+  })();
+  const internalError = (0, import_createErrorWithCleanStackTrace.createErrorWithCleanStackTrace)(
+    [
+      `${internalErrorPrefix} You stumbled upon a bug in ${import_projectInfo.projectInfo.projectName}'s source code.`,
+      `Reach out at ${import_projectInfo.projectInfo.githubRepository}/issues/new or ${import_projectInfo.projectInfo.discordInviteToolChannel} and include this error stack (the error stack is usually enough to fix the problem).`,
+      "A maintainer will fix the bug (usually under 24 hours).",
+      `Do not hesitate to reach out as it makes ${import_projectInfo.projectInfo.projectName} more robust.`,
+      debugStr
+    ].join(" "),
+    numberOfStackTraceLinesToRemove
+  );
+  throw internalError;
+}
+function assertUsage(condition, errorMessage) {
+  if (condition) {
+    return;
+  }
+  const whiteSpace = errorMessage.startsWith("[") ? "" : " ";
+  const usageError = (0, import_createErrorWithCleanStackTrace.createErrorWithCleanStackTrace)(
+    `${usageErrorPrefix}${whiteSpace}${errorMessage}`,
+    numberOfStackTraceLinesToRemove
+  );
+  throw usageError;
+}
+function getProjectError(errorMessage) {
+  const pluginError = (0, import_createErrorWithCleanStackTrace.createErrorWithCleanStackTrace)(
+    `${errorPrefix} ${errorMessage}`,
+    numberOfStackTraceLinesToRemove
+  );
+  return pluginError;
+}
+let alreadyLogged = /* @__PURE__ */ new Set();
+function assertWarning(condition, errorMessage, { onlyOnce, showStackTrace }) {
+  if (condition) {
+    return;
+  }
+  const msg = `${warningPrefix} ${errorMessage}`;
+  if (onlyOnce) {
+    const key = onlyOnce === true ? msg : onlyOnce;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  if (showStackTrace) {
+    console.warn(new Error(msg));
+  } else {
+    console.warn(msg);
+  }
+}
+function assertInfo(condition, errorMessage, { onlyOnce }) {
+  if (condition) {
+    return;
+  }
+  const msg = `${infoPrefix} ${errorMessage}`;
+  if (onlyOnce) {
+    const key = msg;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  console.log(msg);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assert,
+  assertInfo,
+  assertUsage,
+  assertWarning,
+  getProjectError
+});

package/build/runtime-cjs/server/utils/createErrorWithCleanStackTrace.d.ts

@@ -0,0 +1,2 @@
+export { createErrorWithCleanStackTrace };
+declare function createErrorWithCleanStackTrace(errorMessage: string, numberOfStackTraceLinesToRemove: number): Error;

package/build/runtime-cjs/server/utils/createErrorWithCleanStackTrace.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createErrorWithCleanStackTrace_exports = {};
+__export(createErrorWithCleanStackTrace_exports, {
+  createErrorWithCleanStackTrace: () => createErrorWithCleanStackTrace
+});
+module.exports = __toCommonJS(createErrorWithCleanStackTrace_exports);
+function createErrorWithCleanStackTrace(errorMessage, numberOfStackTraceLinesToRemove) {
+  let err;
+  {
+    var stackTraceLimit__original = Error.stackTraceLimit;
+    Error.stackTraceLimit = Infinity;
+    err = new Error(errorMessage);
+    Error.stackTraceLimit = stackTraceLimit__original;
+  }
+  err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
+  return err;
+}
+function clean(errStack, numberOfStackTraceLinesToRemove) {
+  if (!errStack) {
+    return errStack;
+  }
+  const stackLines = splitByLine(errStack);
+  let linesRemoved = 0;
+  const stackLine__cleaned = stackLines.filter((line) => {
+    if (line.includes(" (internal/") || line.includes(" (node:internal")) {
+      return false;
+    }
+    if (linesRemoved < numberOfStackTraceLinesToRemove && isStackTraceLine(line)) {
+      linesRemoved++;
+      return false;
+    }
+    return true;
+  }).join("\n");
+  return stackLine__cleaned;
+}
+function isStackTraceLine(line) {
+  return line.startsWith("    at ");
+}
+function splitByLine(str) {
+  return str.split(/\r?\n/);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createErrorWithCleanStackTrace
+});

package/build/runtime-cjs/server/utils/debug.d.ts

@@ -0,0 +1,14 @@
+export { createDebugger };
+export { isDebugEnabled };
+export type { Debug };
+type Debug = ReturnType<typeof createDebugger>;
+type Options = {
+    serialization?: {
+        emptyArray?: string;
+    };
+};
+declare function createDebugger(namespace: string, optionsGlobal?: Options): ((msg: string, info?: unknown) => void) & {
+    options: (options: Options) => (msg: string, info?: unknown) => void;
+    isEnabled: boolean;
+};
+declare function isDebugEnabled(namespace: string): boolean;

package/build/runtime-cjs/server/utils/debug.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var debug_exports = {};
+__export(debug_exports, {
+  createDebugger: () => createDebugger,
+  isDebugEnabled: () => isDebugEnabled
+});
+module.exports = __toCommonJS(debug_exports);
+var import_assert = require("./assert");
+var import_isBrowser = require("./isBrowser");
+var import_isCallable = require("./isCallable");
+var import_objectAssign = require("./objectAssign");
+(0, import_assert.assert)(!(0, import_isBrowser.isBrowser)(), "utils/debug.js loaded in browser");
+globalThis.__brillout_debug_createDebugger = createDebugger;
+function createDebugger(namespace, optionsGlobal) {
+  const debugWithOptions = (options) => {
+    return (msg, info) => {
+      if (!isDebugEnabled(namespace))
+        return;
+      if (info !== void 0) {
+        msg += strInfo(info, { ...optionsGlobal, ...options });
+      }
+      console.log("\x1B[1m%s\x1B[0m", namespace, msg);
+    };
+  };
+  const debug = (msg, info) => debugWithOptions({})(msg, info);
+  (0, import_objectAssign.objectAssign)(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(namespace) });
+  return debug;
+}
+function isDebugEnabled(namespace) {
+  let DEBUG;
+  try {
+    DEBUG = process.env.DEBUG;
+  } catch {
+  }
+  return DEBUG?.includes(namespace) ?? false;
+}
+function strInfo(info, options) {
+  if (info === void 0) {
+    return void 0;
+  }
+  let str = "\n";
+  if (typeof info === "string") {
+    str += info;
+  } else if (Array.isArray(info)) {
+    if (info.length === 0) {
+      str += options.serialization?.emptyArray ?? "[]";
+    } else {
+      str += info.map(strUnknown).join("\n");
+    }
+  } else {
+    str += strUnknown(info);
+  }
+  str = pad(str);
+  return str;
+}
+function pad(str) {
+  const PADDING = "     ";
+  const WIDTH = process.stdout.columns;
+  const lines = [];
+  str.split("\n").forEach((line) => {
+    if (!WIDTH) {
+      lines.push(line);
+    } else {
+      chunk(line, WIDTH - PADDING.length).forEach((chunk2) => {
+        lines.push(chunk2);
+      });
+    }
+  });
+  return lines.join("\n" + PADDING);
+}
+function chunk(str, size) {
+  if (str.length <= size) {
+    return [str];
+  }
+  const chunks = str.match(new RegExp(".{1," + size + "}", "g"));
+  (0, import_assert.assert)(chunks);
+  return chunks;
+}
+function strUnknown(thing) {
+  return typeof thing === "string" ? thing : strObj(thing);
+}
+function strObj(obj, newLines = false) {
+  return JSON.stringify(obj, replaceFunctionSerializer, newLines ? 2 : void 0);
+}
+function replaceFunctionSerializer(_key, value) {
+  if ((0, import_isCallable.isCallable)(value)) {
+    return value.toString().split(/\s+/).join(" ");
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDebugger,
+  isDebugEnabled
+});

package/build/runtime-cjs/server/utils/getGlobalVariable.d.ts

@@ -0,0 +1,4 @@
+export declare function getGlobalVariable<T>(key: string, defaultValue: T): T;
+declare global {
+    var __react_streaming: Record<string, any>;
+}

package/build/runtime-cjs/server/utils/getGlobalVariable.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getGlobalVariable_exports = {};
+__export(getGlobalVariable_exports, {
+  getGlobalVariable: () => getGlobalVariable
+});
+module.exports = __toCommonJS(getGlobalVariable_exports);
+function getGlobalVariable(key, defaultValue) {
+  globalThis.__react_streaming = globalThis.__react_streaming || {};
+  globalThis.__react_streaming[key] = globalThis.__react_streaming[key] || defaultValue;
+  return globalThis.__react_streaming[key];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getGlobalVariable
+});

package/build/runtime-cjs/server/utils/isBrowser.d.ts

@@ -0,0 +1,2 @@
+export { isBrowser };
+declare function isBrowser(): boolean;

package/build/runtime-cjs/server/utils/isBrowser.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isBrowser_exports = {};
+__export(isBrowser_exports, {
+  isBrowser: () => isBrowser
+});
+module.exports = __toCommonJS(isBrowser_exports);
+function isBrowser() {
+  return typeof window !== "undefined" && typeof window.scrollY === "number";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isBrowser
+});

package/build/runtime-cjs/server/utils/isCallable.d.ts

@@ -0,0 +1,2 @@
+export { isCallable };
+declare function isCallable<T extends (...args: unknown[]) => unknown>(thing: T | unknown): thing is T;

package/build/runtime-cjs/server/utils/isCallable.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isCallable_exports = {};
+__export(isCallable_exports, {
+  isCallable: () => isCallable
+});
+module.exports = __toCommonJS(isCallable_exports);
+function isCallable(thing) {
+  return thing instanceof Function || typeof thing === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCallable
+});

package/build/runtime-cjs/server/utils/isClientSide.d.ts

@@ -0,0 +1,2 @@
+export { isClientSide };
+declare function isClientSide(): boolean;

package/build/runtime-cjs/server/utils/isClientSide.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isClientSide_exports = {};
+__export(isClientSide_exports, {
+  isClientSide: () => isClientSide
+});
+module.exports = __toCommonJS(isClientSide_exports);
+function isClientSide() {
+  return typeof window !== "undefined" && typeof window?.getComputedStyle === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isClientSide
+});

package/build/runtime-cjs/server/utils/isPromise.d.ts

@@ -0,0 +1 @@
+export declare function isPromise(val: unknown): val is Promise<unknown>;

package/build/runtime-cjs/server/utils/isPromise.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isPromise_exports = {};
+__export(isPromise_exports, {
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(isPromise_exports);
+var import_isCallable = require("./isCallable");
+function isPromise(val) {
+  return typeof val === "object" && val !== null && "then" in val && (0, import_isCallable.isCallable)(val.then);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPromise
+});

package/build/runtime-cjs/server/utils/isServerSide.d.ts

@@ -0,0 +1,2 @@
+export { isServerSide };
+declare function isServerSide(): boolean;

package/build/runtime-cjs/server/utils/isServerSide.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isServerSide_exports = {};
+__export(isServerSide_exports, {
+  isServerSide: () => isServerSide
+});
+module.exports = __toCommonJS(isServerSide_exports);
+var import_isClientSide = require("./isClientSide");
+function isServerSide() {
+  return !(0, import_isClientSide.isClientSide)();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isServerSide
+});

package/build/runtime-cjs/server/utils/objectAssign.d.ts

@@ -0,0 +1,2 @@
+export { objectAssign };
+declare function objectAssign<Obj extends object, ObjAddendum>(obj: Obj, objAddendum: ObjAddendum): asserts obj is Obj & ObjAddendum;

package/build/runtime-cjs/server/utils/objectAssign.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var objectAssign_exports = {};
+__export(objectAssign_exports, {
+  objectAssign: () => objectAssign
+});
+module.exports = __toCommonJS(objectAssign_exports);
+function objectAssign(obj, objAddendum) {
+  Object.assign(obj, objAddendum);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  objectAssign
+});

package/build/runtime-cjs/server/utils/projectInfo.d.ts

@@ -0,0 +1,10 @@
+export declare const projectInfo: {
+    projectName: "react-streaming";
+    projectVersion: string;
+    npmPackageName: "react-streaming";
+    githubRepository: "https://github.com/brillout/react-streaming";
+    discordInviteToolChannel: "https://discord.com/invite/H23tjRxFvx";
+};
+declare global {
+    var __vite_plugin_ssr__instances: undefined | string[];
+}