bruh 1.13.1 → 2.0.0-beta.1

package/dist/reactive/sync/transport/websocket/browser.mjs

@@ -0,0 +1,52 @@
+import { r, reactiveDo } from '../../../../reactive.mjs';
+
+const resolveWebSocketURL = (url = "") => {
+  const resolvedURL = new URL(url, location.href);
+  if (resolvedURL.protocol !== "ws:" && resolvedURL.protocol !== "wss:")
+    resolvedURL.protocol = isSecureContext && resolvedURL.protocol !== "http:" ? "wss:" : "ws:";
+  resolvedURL.hash = "";
+  return resolvedURL;
+};
+const connectToWebSocket = (url, initialReconnectDelay = 2 ** -2 * 1e3, reconnectDelayCeiling = 2 ** 4 * 1e3) => {
+  const resolvedURL = resolveWebSocketURL(url);
+  const reactiveSocket = r();
+  const attemptConnection = (delay = initialReconnectDelay) => {
+    const socket = new WebSocket(resolvedURL);
+    socket.addEventListener("open", () => {
+      reactiveSocket.value = socket;
+      delay = initialReconnectDelay;
+    });
+    socket.addEventListener("close", ({ wasClean }) => {
+      if (wasClean) return;
+      setTimeout(() => {
+        attemptConnection(Math.min(2 * delay, reconnectDelayCeiling));
+      }, delay);
+    });
+  };
+  attemptConnection();
+  return reactiveSocket;
+};
+const handleWebSocket = (maybeReactiveWebSocket, handlers) => {
+  let currentSocket;
+  reactiveDo(maybeReactiveWebSocket, (socket) => {
+    if (!socket) return;
+    currentSocket = socket;
+    socket.addEventListener("message", ({ data }) => {
+      if (typeof data !== "string")
+        handlers.raw?.(data);
+      else {
+        const parsed = JSON.parse(data);
+        if (handlers.byType?.hasOwnProperty(parsed.type))
+          handlers.byType[parsed.type](parsed);
+      }
+    });
+  });
+  return (data) => {
+    currentSocket?.send(
+      data instanceof Blob || data instanceof ArrayBuffer || ArrayBuffer.isView(data) ? data : JSON.stringify(data)
+    );
+  };
+};
+
+export { connectToWebSocket, handleWebSocket, resolveWebSocketURL };
+//# sourceMappingURL=browser.mjs.map

package/dist/reactive/sync/transport/websocket/browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.mjs","sources":["../../../../../src/reactive/sync/transport/websocket/browser.mts"],"sourcesContent":["import { r, reactiveDo, type MaybeReactive } from \"../../../../reactive/index.mts\"\n\n// Intuitive websocket url resolution\nexport const resolveWebSocketURL = (url: URL | string = \"\") => {\n  // Base off of the current location\n  const resolvedURL = new URL(url, location.href)\n  // Handle implicitly selection of ws: or wss: based on the context\n  if (resolvedURL.protocol !== \"ws:\" && resolvedURL.protocol !== \"wss:\")\n    resolvedURL.protocol =\n      isSecureContext && resolvedURL.protocol !== \"http:\"\n        ? \"wss:\"\n        : \"ws:\"\n  // Fragments aren't allowed in websocket urls\n  resolvedURL.hash = \"\"\n  return resolvedURL\n}\n\n// websocket connection with automatic reconnection\n// Returned as a promise to a reactive socket because the underlying socket\n// changes every reconnection\nexport const connectToWebSocket = (\n  url: URL | string,\n  initialReconnectDelay = 2 ** -2 * 1000, // 1/4 second\n  reconnectDelayCeiling = 2 **  4 * 1000  //  16 seconds\n) => {\n  const resolvedURL = resolveWebSocketURL(url)\n  const reactiveSocket = r<WebSocket>()\n\n  // Every attempt makes a new socket, reattempting after a delay\n  const attemptConnection = (delay = initialReconnectDelay) => {\n    const socket = new WebSocket(resolvedURL)\n\n    // The reactive value is updated and the delay reset on success\n    socket.addEventListener(\"open\", () => {\n      reactiveSocket.value = socket\n      delay = initialReconnectDelay\n    })\n\n    // Whether it fails to connect or the connection is lost later\n    socket.addEventListener(\"close\", ({ wasClean }) => {\n      // Don't automatically reconnect an intentionally closed websocket\n      if (wasClean) return\n\n      setTimeout(() => {\n        attemptConnection(Math.min(2 * delay, reconnectDelayCeiling))\n      }, delay)\n    })\n  }\n\n  // kickoff\n  attemptConnection()\n\n  return reactiveSocket\n}\n\nexport type WebSocketHandlers = {\n  raw?: (data: Blob | ArrayBuffer) => void\n  byType?: {\n    [type: string]: (data: any) => void\n  }\n}\n\n// Handle automatic JSON over websockets, where the websocket can be reactive\nexport const handleWebSocket = (maybeReactiveWebSocket: MaybeReactive<WebSocket | undefined>, handlers: WebSocketHandlers) => {\n  let currentSocket: WebSocket | undefined\n\n  // Account for a potentially reactive socket\n  reactiveDo(maybeReactiveWebSocket, socket => {\n    if (!socket) return\n\n    currentSocket = socket\n\n    // Handle messages, parsing strings as JSON\n    socket.addEventListener(\"message\", ({ data }) => {\n      // Raw blob/arraybuffer (socket.binaryType, defaults to blob)\n      if (typeof data !== \"string\")\n        handlers.raw?.(data)\n      // assume strings are JSON with {\"type\":\"messageType\"}\n      else {\n        const parsed = JSON.parse(data)\n        if (handlers.byType?.hasOwnProperty(parsed.type))\n          handlers.byType[parsed.type](parsed)\n      }\n    })\n  })\n\n  // A send function that automatically converts objects to JSON\n  return (data: unknown) => {\n    currentSocket?.send(\n      data instanceof Blob || data instanceof ArrayBuffer || ArrayBuffer.isView(data)\n        ? data\n        : JSON.stringify(data)\n    )\n  }\n}\n"],"names":[],"mappings":";;AAGa,MAAA,mBAAA,GAAsB,CAAC,GAAA,GAAoB,EAAO,KAAA;AAE7D,EAAA,MAAM,WAAc,GAAA,IAAI,GAAI,CAAA,GAAA,EAAK,SAAS,IAAI,CAAA;AAE9C,EAAA,IAAI,WAAY,CAAA,QAAA,KAAa,KAAS,IAAA,WAAA,CAAY,QAAa,KAAA,MAAA;AAC7D,IAAA,WAAA,CAAY,QACV,GAAA,eAAA,IAAmB,WAAY,CAAA,QAAA,KAAa,UACxC,MACA,GAAA,KAAA;AAER,EAAA,WAAA,CAAY,IAAO,GAAA,EAAA;AACnB,EAAO,OAAA,WAAA;AACT;AAKa,MAAA,kBAAA,GAAqB,CAChC,GAAA,EACA,qBAAwB,GAAA,CAAA,IAAK,KAAK,GAClC,EAAA,qBAAA,GAAwB,CAAM,IAAA,CAAA,GAAI,GAC/B,KAAA;AACH,EAAM,MAAA,WAAA,GAAc,oBAAoB,GAAG,CAAA;AAC3C,EAAA,MAAM,iBAAiB,CAAa,EAAA;AAGpC,EAAM,MAAA,iBAAA,GAAoB,CAAC,KAAA,GAAQ,qBAA0B,KAAA;AAC3D,IAAM,MAAA,MAAA,GAAS,IAAI,SAAA,CAAU,WAAW,CAAA;AAGxC,IAAO,MAAA,CAAA,gBAAA,CAAiB,QAAQ,MAAM;AACpC,MAAA,cAAA,CAAe,KAAQ,GAAA,MAAA;AACvB,MAAQ,KAAA,GAAA,qBAAA;AAAA,KACT,CAAA;AAGD,IAAA,MAAA,CAAO,gBAAiB,CAAA,OAAA,EAAS,CAAC,EAAE,UAAe,KAAA;AAEjD,MAAA,IAAI,QAAU,EAAA;AAEd,MAAA,UAAA,CAAW,MAAM;AACf,QAAA,iBAAA,CAAkB,IAAK,CAAA,GAAA,CAAI,CAAI,GAAA,KAAA,EAAO,qBAAqB,CAAC,CAAA;AAAA,SAC3D,KAAK,CAAA;AAAA,KACT,CAAA;AAAA,GACH;AAGA,EAAkB,iBAAA,EAAA;AAElB,EAAO,OAAA,cAAA;AACT;AAUa,MAAA,eAAA,GAAkB,CAAC,sBAAA,EAA8D,QAAgC,KAAA;AAC5H,EAAI,IAAA,aAAA;AAGJ,EAAA,UAAA,CAAW,wBAAwB,CAAU,MAAA,KAAA;AAC3C,IAAA,IAAI,CAAC,MAAQ,EAAA;AAEb,IAAgB,aAAA,GAAA,MAAA;AAGhB,IAAA,MAAA,CAAO,gBAAiB,CAAA,SAAA,EAAW,CAAC,EAAE,MAAW,KAAA;AAE/C,MAAA,IAAI,OAAO,IAAS,KAAA,QAAA;AAClB,QAAA,QAAA,CAAS,MAAM,IAAI,CAAA;AAAA,WAEhB;AACH,QAAM,MAAA,MAAA,GAAS,IAAK,CAAA,KAAA,CAAM,IAAI,CAAA;AAC9B,QAAA,IAAI,QAAS,CAAA,MAAA,EAAQ,cAAe,CAAA,MAAA,CAAO,IAAI,CAAA;AAC7C,UAAA,QAAA,CAAS,MAAO,CAAA,MAAA,CAAO,IAAI,CAAA,CAAE,MAAM,CAAA;AAAA;AACvC,KACD,CAAA;AAAA,GACF,CAAA;AAGD,EAAA,OAAO,CAAC,IAAkB,KAAA;AACxB,IAAe,aAAA,EAAA,IAAA;AAAA,MACb,IAAA,YAAgB,IAAQ,IAAA,IAAA,YAAgB,WAAe,IAAA,WAAA,CAAY,MAAO,CAAA,IAAI,CAC1E,GAAA,IAAA,GACA,IAAK,CAAA,SAAA,CAAU,IAAI;AAAA,KACzB;AAAA,GACF;AACF;;;;"}

package/dist/reactive.mjs

@@ -0,0 +1,160 @@
+const isReactiveSymbol = /* @__PURE__ */ Symbol.for("bruh reactive");
+const isReactive = (x) => (
+  // @ts-ignore
+  x?.[isReactiveSymbol] === true
+);
+class SimpleReactive {
+  [isReactiveSymbol] = true;
+  #value;
+  #reactions = /* @__PURE__ */ new Set();
+  constructor(value) {
+    this.#value = value;
+  }
+  get value() {
+    return this.#value;
+  }
+  set value(newValue) {
+    if (newValue === this.#value)
+      return;
+    this.#value = newValue;
+    for (const reaction of this.#reactions)
+      try {
+        reaction();
+      } catch {
+      }
+  }
+  /**
+   * @param reaction called every time that the value changes
+   * @returns a function that stops the reactions
+   */
+  addReaction(reaction) {
+    this.#reactions.add(reaction);
+    return () => this.#reactions.delete(reaction);
+  }
+}
+class FunctionalReactive {
+  [isReactiveSymbol] = true;
+  #weakRef = new WeakRef(this);
+  // @ts-ignore
+  #value;
+  #reactions = /* @__PURE__ */ new Set();
+  // For derived nodes, this is the derivation function
+  // @ts-ignore
+  #f;
+  // Source nodes are 0 deep in the derivation graph
+  // This is for topological sort
+  #depth = 0;
+  // All nodes have a set of derivatives that update when the node changes
+  #derivatives = /* @__PURE__ */ new Set();
+  // Keep track of all the pending changes from the value setter
+  static #settersQueue = /* @__PURE__ */ new Map();
+  // A queue of derivatives to potentially update, sorted into sets by depth
+  // This starts with depth 1 and can potentially have holes
+  static #derivativesQueue = [];
+  // A queue of reactions to run after the graph is fully updated
+  static #reactionsQueue = [];
+  constructor(x, f) {
+    if (!f) {
+      const this_2 = this;
+      const value = x;
+      this_2.#value = value;
+      return;
+    }
+    const this_ = this;
+    const dependencies = x;
+    try {
+      this_.#value = f();
+    } catch (e) {
+      this_.#value = e;
+    }
+    this_.#f = f;
+    this_.#depth = Math.max(0, ...dependencies.map((dependency) => dependency.#depth)) + 1;
+    dependencies.forEach((dependency) => dependency.#derivatives.add(this_.#weakRef));
+  }
+  get value() {
+    if (FunctionalReactive.#settersQueue.size) {
+      if (this.#depth === 0) {
+        const this_ = this;
+        if (FunctionalReactive.#settersQueue.has(this_))
+          return FunctionalReactive.#settersQueue.get(this_);
+      } else {
+        FunctionalReactive.applyUpdates();
+      }
+    }
+    return this.#value;
+  }
+  set value(newValue) {
+    if (this.#depth !== 0)
+      return;
+    const this_ = this;
+    if (newValue === this.#value) {
+      FunctionalReactive.#settersQueue.delete(this_);
+      return;
+    }
+    if (!FunctionalReactive.#settersQueue.size)
+      queueMicrotask(FunctionalReactive.applyUpdates);
+    FunctionalReactive.#settersQueue.set(this_, newValue);
+  }
+  /**
+   * @param reaction called every time that the value changes
+   * @returns a function that stops the reactions
+   */
+  addReaction(reaction) {
+    this.#reactions.add(reaction);
+    return () => this.#reactions.delete(reaction);
+  }
+  // Apply an update for a node and queue its derivatives if it actually changed
+  #applyUpdate(newValue) {
+    if (newValue === this.#value)
+      return;
+    this.#value = newValue;
+    FunctionalReactive.#reactionsQueue.push(...this.#reactions);
+    this.#derivatives.forEach((weakRef) => {
+      const derivative = weakRef.deref();
+      if (!derivative) {
+        this.#derivatives.delete(weakRef);
+        return;
+      }
+      const depthSet = FunctionalReactive.#derivativesQueue[derivative.#depth] ??= /* @__PURE__ */ new Set();
+      depthSet.add(derivative);
+    });
+  }
+  /**
+   * Apply pending updates from actually changed source nodes
+   */
+  static applyUpdates() {
+    if (!FunctionalReactive.#settersQueue.size)
+      return;
+    for (const [sourceNode, newValue] of FunctionalReactive.#settersQueue.entries())
+      sourceNode.#applyUpdate(newValue);
+    FunctionalReactive.#settersQueue.clear();
+    for (const depthSet of FunctionalReactive.#derivativesQueue) if (depthSet)
+      for (const derivative of depthSet)
+        try {
+          derivative.#applyUpdate(derivative.#f());
+        } catch (e) {
+          derivative.#applyUpdate(e);
+        }
+    FunctionalReactive.#derivativesQueue.length = 0;
+    for (const reaction of FunctionalReactive.#reactionsQueue)
+      try {
+        reaction();
+      } catch {
+      }
+    FunctionalReactive.#reactionsQueue.length = 0;
+  }
+}
+const r = (x, f) => (
+  // @ts-ignore
+  new FunctionalReactive(x, f)
+);
+const reactiveDo = (x, f) => {
+  if (isReactive(x)) {
+    f(x.value);
+    return x.addReaction(() => f(x.value));
+  }
+  f(x);
+};
+
+export { FunctionalReactive, SimpleReactive, isReactive, isReactiveSymbol, r, reactiveDo };
+//# sourceMappingURL=reactive.mjs.map

package/dist/reactive.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive.mjs","sources":["../src/reactive/index.mts"],"sourcesContent":["export const isReactiveSymbol = Symbol.for(\"bruh reactive\")\n\nexport const isReactive = (x: unknown): x is Reactive<unknown> =>\n  // @ts-ignore\n  x?.[isReactiveSymbol] === true\n\ntype Reaction = () => void\ntype StopReacting = () => void\n\nexport interface Reactive<T> {\n  [isReactiveSymbol]: true\n\n  value: T\n\n  addReaction(reaction: Reaction): StopReacting\n}\n\nexport type Unreactive<T> = Exclude<T, { [isReactiveSymbol]: true }>\n\nexport type MaybeReactive<T> = Reactive<T> | Unreactive<T>\n\n/**\n * A super simple and performant reactive value implementation\n */\nexport class SimpleReactive<T> implements Reactive<T> {\n  [isReactiveSymbol] = true as const\n\n  #value: T\n  #reactions = new Set<Reaction>()\n\n  constructor(value: T) {\n    this.#value = value\n  }\n\n  get value() {\n    return this.#value\n  }\n\n  set value(newValue) {\n    if (newValue === this.#value)\n      return\n\n    this.#value = newValue\n    for (const reaction of this.#reactions)\n      try { reaction() } catch {}\n  }\n\n  /**\n   * @param reaction called every time that the value changes\n   * @returns a function that stops the reactions\n   */\n  addReaction(reaction: Reaction) {\n    this.#reactions.add(reaction)\n\n    return () =>\n      this.#reactions.delete(reaction)\n  }\n}\n\nexport type SourceNode<T>     = FunctionalReactive<T, \"source\">\nexport type DerivativeNode<T> = FunctionalReactive<T, \"derivative\">\n\n/**\n * A reactive implementation for building functional reactive graphs.\n * Ensures state consistency, minimal node updates, and transparent update batching.\n */\nexport class FunctionalReactive<T, U extends \"source\" | \"derivative\" = any> implements Reactive<T> {\n  [isReactiveSymbol] = true as const\n\n  #weakRef = new WeakRef(this)\n\n  // @ts-ignore\n  #value: T\n  #reactions = new Set<Reaction>()\n\n  // For derived nodes, this is the derivation function\n  // @ts-ignore\n  #f:\n    U extends \"derivative\"\n      ? () => T\n      : never\n\n  // Source nodes are 0 deep in the derivation graph\n  // This is for topological sort\n  #depth:\n    U extends \"source\"\n      ? 0\n      : number // natural, > 0\n    = 0\n\n  // All nodes have a set of derivatives that update when the node changes\n  #derivatives = new Set<WeakRef<DerivativeNode<unknown>>>()\n\n  // Keep track of all the pending changes from the value setter\n  static #settersQueue = new Map<SourceNode<unknown>, unknown>()\n\n  // A queue of derivatives to potentially update, sorted into sets by depth\n  // This starts with depth 1 and can potentially have holes\n  static #derivativesQueue: Array<Set<DerivativeNode<unknown>> | undefined> = []\n\n  // A queue of reactions to run after the graph is fully updated\n  static #reactionsQueue: Array<Reaction> = []\n\n  constructor(value: T)\n  constructor(\n    dependencies: ReadonlyArray<FunctionalReactive<unknown>>,\n    f: () => T\n  )\n  constructor(\n    x: T | ReadonlyArray<FunctionalReactive<unknown>>,\n    f?: undefined | (() => T)\n  ) {\n    // No derivation function means this is a source node\n    if (!f) {\n      const this_ = this as SourceNode<T>\n      const value = x as T\n\n      this_.#value = value\n      return\n    }\n\n    // Derived node\n    const this_ = this as DerivativeNode<T>\n    const dependencies = x as ReadonlyArray<FunctionalReactive<unknown>>\n\n    try {\n      this_.#value = f()\n    }\n    catch (e: any) {\n      this_.#value = e\n    }\n    this_.#f = f\n\n    this_.#depth = Math.max(0, ...dependencies.map(dependency => dependency.#depth)) + 1\n\n    dependencies.forEach(dependency => dependency.#derivatives.add(this_.#weakRef))\n  }\n\n  get value(): T {\n    // If there are any pending updates\n    if (FunctionalReactive.#settersQueue.size) {\n      // If this is a source node that was updated, just return that\n      // new value without actually updating any derived nodes yet\n      if (this.#depth === 0) {\n        const this_ = this as SourceNode<T>\n        if (FunctionalReactive.#settersQueue.has(this_))\n          return FunctionalReactive.#settersQueue.get(this_) as T\n      }\n      // Heuristic quick invalidation for derived nodes\n      // Apply updates now, it's ok that there's already a microtask queued for this\n      else {\n        FunctionalReactive.applyUpdates()\n      }\n    }\n\n    return this.#value\n  }\n\n  set value(newValue) {\n    // Only allow source nodes to be directly updated\n    if (this.#depth !== 0)\n      return\n\n    const this_ = this as SourceNode<T>\n\n    if (newValue === this.#value) {\n      FunctionalReactive.#settersQueue.delete(this_)\n      return\n    }\n\n    // Unless asked for earlier, these updates are just queued up until the microtasks run\n    if (!FunctionalReactive.#settersQueue.size)\n      queueMicrotask(FunctionalReactive.applyUpdates)\n\n    FunctionalReactive.#settersQueue.set(this_, newValue)\n  }\n\n  /**\n   * @param reaction called every time that the value changes\n   * @returns a function that stops the reactions\n   */\n  addReaction(reaction: Reaction) {\n    this.#reactions.add(reaction)\n\n    return () =>\n      this.#reactions.delete(reaction)\n  }\n\n  // Apply an update for a node and queue its derivatives if it actually changed\n  #applyUpdate(newValue: T) {\n    if (newValue === this.#value)\n      return\n\n    this.#value = newValue\n    FunctionalReactive.#reactionsQueue.push(...this.#reactions)\n\n    this.#derivatives.forEach(weakRef => {\n      const derivative = weakRef.deref()\n      if (!derivative) {\n        this.#derivatives.delete(weakRef)\n        return\n      }\n\n      const depthSet = FunctionalReactive.#derivativesQueue[derivative.#depth] ??= new Set()\n      depthSet.add(derivative)\n    })\n  }\n\n  /**\n   * Apply pending updates from actually changed source nodes\n   */\n  static applyUpdates() {\n    if (!FunctionalReactive.#settersQueue.size)\n      return\n\n    // Bootstrap by applying the updates from the pending setters\n    for (const [sourceNode, newValue] of FunctionalReactive.#settersQueue.entries())\n      sourceNode.#applyUpdate(newValue)\n    FunctionalReactive.#settersQueue.clear()\n\n    // Iterate down the depths, ignoring holes\n    // Note that both the queue (Array) and each depth Set iterators update as items are added\n    for (const depthSet of FunctionalReactive.#derivativesQueue) if (depthSet)\n      for (const derivative of depthSet)\n        try {\n          derivative.#applyUpdate(derivative.#f())\n        }\n        catch (e) {\n          derivative.#applyUpdate(e)\n        }\n    FunctionalReactive.#derivativesQueue.length = 0\n\n    // Call all reactions now that the graph has a fully consistent state\n    for (const reaction of FunctionalReactive.#reactionsQueue)\n      try { reaction() } catch {}\n    FunctionalReactive.#reactionsQueue.length = 0\n  }\n}\n\ntype R = {\n  /**\n   * An initially undefined source node\n   */\n  <T>(): SourceNode<T | undefined>\n\n  /**\n   * A source node\n   */\n  <T>(value: T): SourceNode<T>\n\n  /**\n   * A derived node\n   */\n  <T>(\n    dependencies: ReadonlyArray<FunctionalReactive<unknown>>,\n    f: () => T\n  ): DerivativeNode<T>\n}\n/**\n * A convenient wrapper for FunctionalReactive\n */\nexport const r: R = <T extends unknown>(\n  x?: T | ReadonlyArray<FunctionalReactive<unknown>>,\n  f?: undefined | (() => T)\n) =>\n  // @ts-ignore\n  new FunctionalReactive(x, f)\n\ntype ReactiveDo = {\n  /**\n   * Calls the given function with the reactive's value whenever it changes\n   * @returns a function that stops the reactions\n   */\n  <T>(\n    reactive: Reactive<T>,\n    f: (value: T) => unknown\n  ): StopReacting\n\n  /**\n   * Calls the given function with the value once\n   */\n  <T>(\n    value: Unreactive<T>,\n    f: (value: Unreactive<T>) => unknown\n  ): undefined\n\n  /**\n   * If the value is not reactive, it calls the given function with that value once.\n   * If it is a reactive value, it calls the given function with the reactive's value whenever it changes.\n   * @returns a function that stops the reactions, if the value is reactive\n   */\n  <T>(\n    x: MaybeReactive<T>,\n    f: (value: T) => unknown\n  ): StopReacting | undefined\n}\n/**\n * Do something with a value, updating if it is reactive\n */\nexport const reactiveDo: ReactiveDo = <T extends unknown>(\n  x: MaybeReactive<T>,\n  f: (value: T) => unknown\n): any => {\n  if (isReactive(x)) {\n    f(x.value)\n    return x.addReaction(() => f(x.value))\n  }\n\n  f(x)\n}\n"],"names":["this_"],"mappings":"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"}

package/dist/server/jsx-runtime.mjs

@@ -0,0 +1,2 @@
+export { Fragment, jsx, jsx as jsxDEV, jsx as jsxs } from '../server.mjs';
+//# sourceMappingURL=jsx-runtime.mjs.map

package/dist/server/jsx-runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/server.mjs

@@ -0,0 +1,346 @@
+import { makePromiseQueue } from './utils.mjs';
+
+const isMetaNode = /* @__PURE__ */ Symbol.for("bruh meta node");
+const isMetaTextNode = /* @__PURE__ */ Symbol.for("bruh meta text node");
+const isMetaElement = /* @__PURE__ */ Symbol.for("bruh meta element");
+const isMetaRawString = /* @__PURE__ */ Symbol.for("bruh meta raw string");
+const voidElements = /* @__PURE__ */ new Set([
+  "base",
+  "link",
+  "meta",
+  "hr",
+  "br",
+  "wbr",
+  "area",
+  "img",
+  "track",
+  "embed",
+  "param",
+  "source",
+  "col",
+  "input"
+]);
+const isVoidElement = (element) => voidElements.has(element);
+const escapeForElementReplacer = (match) => match === "&" ? "&" : "<";
+const escapeForElement = (x) => (x + "").replace(/[&<]/g, escapeForElementReplacer);
+const escapeForScript = (x) => (x + "").replace(/<!--/g, "\\x3C!--").replace(/<script/g, "\\x3Cscript").replace(/<\/script/g, "\\x3C/script");
+const escapeForStyle = (x) => (x + "").replace(/<!--/g, "\\x3C!--").replace(/<style/g, "\\x3Cstyle").replace(/<\/style/g, "\\x3C/style");
+const escapeForDoubleQuotedAttributeReplacer = (match) => match === "&" ? "&amp;" : "&quot;";
+const escapeForDoubleQuotedAttribute = (x) => (x + "").replace(/[&"]/g, escapeForDoubleQuotedAttributeReplacer);
+function* attributesToIterator(attributes) {
+  for (const name in attributes) {
+    const value = attributes[name];
+    if (value == null || value === false || value instanceof Promise)
+      continue;
+    yield ` ${name}`;
+    if (value === true || value === "")
+      continue;
+    yield `="${escapeForDoubleQuotedAttribute(value)}"`;
+  }
+}
+async function* attributesToAsyncIterator(attributes) {
+  for (const name in attributes) {
+    try {
+      const value = await attributes[name];
+      if (value == null || value === false)
+        continue;
+      yield ` ${name}`;
+      if (value === true || value === "")
+        continue;
+      yield `="${escapeForDoubleQuotedAttribute(value)}"`;
+    } catch (e) {
+      console.error(e);
+      continue;
+    }
+  }
+}
+class MetaTextNode {
+  [isMetaNode] = true;
+  [isMetaTextNode] = true;
+  textContent;
+  tag;
+  constructor(textContent) {
+    this.textContent = textContent;
+  }
+  *[Symbol.iterator]() {
+    yield `<bruh-text style="all:unset;display:inline"`;
+    if (this.tag)
+      yield* attributesToIterator({ tag: this.tag });
+    yield ">";
+    if (this.textContent instanceof Promise)
+      yield "<!--Promise-->";
+    else
+      yield escapeForElement(this.textContent);
+    yield "</bruh-text>";
+  }
+  async *[Symbol.asyncIterator]() {
+    yield `<bruh-text style="all:unset;display:inline"`;
+    if (this.tag)
+      yield* attributesToAsyncIterator({ tag: this.tag });
+    yield ">";
+    try {
+      yield escapeForElement(await this.textContent);
+    } catch (e) {
+      console.error(e);
+    }
+    yield "</bruh-text>";
+  }
+  toString() {
+    let result = "";
+    for (const chunk of this)
+      result += chunk;
+    return result;
+  }
+  async toStringPromise() {
+    let result = "";
+    for await (const chunk of this)
+      result += chunk;
+    return result;
+  }
+  setTag(tag) {
+    this.tag = tag;
+    return this;
+  }
+}
+class MetaElement {
+  [isMetaNode] = true;
+  [isMetaElement] = true;
+  name;
+  attributes = {};
+  children = [];
+  #isRawTextOnly;
+  #escape;
+  constructor(name) {
+    this.name = name;
+    this.#isRawTextOnly = name === "script" || name === "style";
+    this.#escape = name === "script" ? escapeForScript : name === "style" ? escapeForStyle : escapeForElement;
+  }
+  *#childChunks(children) {
+    const partiallyFlattened = Array.isArray(children) ? children.flat(Infinity) : children;
+    for (const child of partiallyFlattened) {
+      if (child == null || typeof child === "boolean") {
+        if (this.#isRawTextOnly)
+          continue;
+        else
+          yield `<!--${child}-->`;
+      } else if (typeof child === "object") {
+        if (!this.#isRawTextOnly && isMetaNode in child)
+          yield* child;
+        else if (!this.#isRawTextOnly && child instanceof Promise)
+          yield "<!--Promise-->";
+        else if (!this.#isRawTextOnly && Symbol.asyncIterator in child)
+          yield "<!--asyncIterator-->";
+        else if (isMetaRawString in child)
+          yield child;
+        else if (Symbol.iterator in child)
+          yield* this.#childChunks(child);
+      } else
+        yield this.#escape(child);
+    }
+  }
+  async *#asyncChildChunks(children) {
+    const partiallyFlattened = Array.isArray(children) ? children.flat(Infinity) : children;
+    for await (const child of partiallyFlattened) {
+      if (child == null || typeof child === "boolean") {
+        if (this.#isRawTextOnly)
+          continue;
+        else
+          yield `<!--${child}-->`;
+      } else if (typeof child === "object") {
+        if (!this.#isRawTextOnly && isMetaNode in child)
+          yield* child;
+        else if (isMetaRawString in child)
+          yield child;
+        else if (Symbol.iterator in child || Symbol.asyncIterator in child)
+          yield* this.#asyncChildChunks(child);
+      } else
+        yield this.#escape(child);
+    }
+  }
+  *[Symbol.iterator]() {
+    yield `<${this.name}`;
+    yield* attributesToIterator(this.attributes);
+    yield ">";
+    if (isVoidElement(this.name))
+      return;
+    yield* this.#childChunks(this.children);
+    yield `</${this.name}>`;
+  }
+  async *[Symbol.asyncIterator]() {
+    yield `<${this.name}`;
+    yield* attributesToAsyncIterator(this.attributes);
+    yield ">";
+    if (isVoidElement(this.name))
+      return;
+    yield* this.#asyncChildChunks(this.children);
+    yield `</${this.name}>`;
+  }
+  toString() {
+    let result = "";
+    for (const chunk of this)
+      result += chunk;
+    return result;
+  }
+  async toStringPromise() {
+    let result = "";
+    for await (const chunk of this)
+      result += chunk;
+    return result;
+  }
+}
+class MetaRawString extends String {
+  [isMetaRawString] = true;
+  constructor(string) {
+    super(string);
+  }
+}
+const applyStyles = (element, styles) => {
+  const currentStyles = typeof element.attributes.style === "string" ? Object.fromEntries(
+    element.attributes.style.split(";").filter((s) => s.length).map((declaration) => declaration.split(":").map((s) => s.trim()))
+  ) : {};
+  Object.entries(styles).forEach(([property, value]) => {
+    if (value != null && typeof value !== "boolean")
+      currentStyles[property] = value;
+    else
+      delete currentStyles[property];
+  });
+  element.attributes.style = Object.entries(currentStyles).map(([property, value]) => `${property}:${value}`).join(";");
+};
+const applyClasses = (element, classes) => {
+  const currentClasses = new Set(
+    typeof element.attributes.class === "string" ? element.attributes.class.split(/\s+/).filter((s) => s.length) : void 0
+  );
+  Object.entries(classes).forEach(([name, value]) => {
+    if (value)
+      currentClasses.add(name);
+    else
+      currentClasses.delete(name);
+  });
+  element.attributes.class = [...currentClasses].join(" ");
+};
+const applyAttributes = (element, attributes) => {
+  Object.assign(element.attributes, attributes);
+};
+const rawString = (string) => new MetaRawString(string);
+const t = (textContent) => new MetaTextNode(textContent);
+const jsx = (nameOrComponent, props_, key) => {
+  if (key !== void 0)
+    props_.key = key;
+  if (typeof nameOrComponent !== "string") {
+    const component = nameOrComponent;
+    const props2 = props_;
+    return component(props2);
+  }
+  const name = nameOrComponent;
+  const props = props_;
+  if (typeof props.bruh === "object" && !(props.bruh instanceof Promise)) {
+    props.bruh;
+    delete props.bruh;
+  }
+  const element = new MetaElement(name);
+  if ("children" in props) {
+    if (Array.isArray(props.children))
+      element.children.push(...props.children);
+    else
+      element.children.push(props.children);
+    delete props.children;
+  }
+  if ("style" in props && props.style != null && typeof props.style === "object" && !(props.style instanceof Promise)) {
+    applyStyles(element, props.style);
+    delete props.style;
+  }
+  if ("class" in props && props.class != null && typeof props.class === "object" && !(props.class instanceof Promise)) {
+    applyClasses(element, props.class);
+    delete props.class;
+  }
+  applyAttributes(element, props);
+  return element;
+};
+const Fragment = (props) => props.children;
+const replaceDeferredScriptContent = `"use strict";customElements.define("bruh-deferred",class extends HTMLElement{connectedCallback(){const t=this.previousElementSibling;document.getElementById(this.dataset.replace).replaceWith(t.content);t.remove();this.remove()}})`;
+const replaceDeferredHash = "sha512-+xpsela6B2jMNhk2cPpAgB4Z89EeB6yltQ208+kvcbUKlkg11dBjAlj2FbNFxeE0kqOuZhdVVldl3hz1yZD38Q==";
+class MetaDocument {
+  #metaElementOrFunction;
+  constructor(metaElementOrFunction) {
+    this.#metaElementOrFunction = metaElementOrFunction;
+  }
+  *[Symbol.iterator]() {
+    if (!(isMetaElement in this.#metaElementOrFunction))
+      throw new Error("Not a meta element");
+    const metaElement = this.#metaElementOrFunction;
+    yield "<!doctype html>";
+    yield* metaElement;
+  }
+  async *[Symbol.asyncIterator]({ deferred: allowDefer = true } = {}) {
+    yield "<!doctype html>";
+    if (isMetaElement in this.#metaElementOrFunction) {
+      const metaElement = this.#metaElementOrFunction;
+      yield* metaElement;
+      return;
+    }
+    const documentFunction = this.#metaElementOrFunction;
+    if (!allowDefer) {
+      const defer2 = ({ content }) => content;
+      yield* documentFunction({ defer: defer2 });
+      return;
+    }
+    const deferQueue = makePromiseQueue();
+    let deferCount = 0;
+    const defer = ({ placeholder, content }) => {
+      const id = `bruh-deferred-${deferCount++}`;
+      deferQueue.enqueue(content.then((content2) => ({ id, content: content2 })));
+      return placeholder(id);
+    };
+    const deferred = (async function* () {
+      for await (const settled of deferQueue) {
+        if (settled.status === "rejected") {
+          console.error(settled.reason);
+          continue;
+        }
+        const { id, content } = settled.value;
+        yield jsx("template", { children: content });
+        yield jsx("bruh-deferred", { "data-replace": id });
+      }
+    })();
+    const replaceDeferredScript = jsx("script", { children: replaceDeferredScriptContent });
+    yield* documentFunction({ defer, deferred, replaceDeferredScript });
+  }
+  toStream({ deferred = true } = {}) {
+    const encoder = new TextEncoder();
+    const asyncIterator = this[Symbol.asyncIterator]({ deferred });
+    return new ReadableStream({
+      async pull(controller) {
+        const { value, done } = await asyncIterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(
+          encoder.encode(value)
+        );
+      }
+    });
+  }
+  toResponse({ deferred = true } = {}) {
+    return new Response(this.toStream({ deferred }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8"
+      }
+    });
+  }
+  toString() {
+    let result = "";
+    for (const chunk of this)
+      result += chunk;
+    return result;
+  }
+  async toStringPromise({ deferred = false } = {}) {
+    let result = "";
+    for await (const chunk of this[Symbol.asyncIterator]({ deferred }))
+      result += chunk;
+    return result;
+  }
+}
+
+export { Fragment, MetaDocument, MetaElement, MetaRawString, MetaTextNode, applyAttributes, applyClasses, applyStyles, jsx, rawString, replaceDeferredHash, replaceDeferredScriptContent, t };
+//# sourceMappingURL=server.mjs.map