npm - voodoojs - Versions diffs - 0.4.6 - Mend

voodoojs 0.4.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/README.md +77 -0
package/dist/chunk-234ZLC6W.js +401 -0
package/dist/chunk-4HQEOXTK.js +10271 -0
package/dist/chunk-5777LJVW.js +64 -0
package/dist/chunk-5CKGDARU.js +1845 -0
package/dist/chunk-A2UOVQBP.js +82 -0
package/dist/chunk-E27NRARW.js +16 -0
package/dist/chunk-JZIYRIY6.js +1196 -0
package/dist/chunk-NNU6WOOU.js +641 -0
package/dist/chunk-PQZEVFVZ.js +448 -0
package/dist/chunk-RJUNPXQF.js +946 -0
package/dist/chunk-U76IRJKH.js +72 -0
package/dist/essential.cjs +13889 -0
package/dist/essential.d.cts +24 -0
package/dist/essential.d.ts +24 -0
package/dist/essential.js +51 -0
package/dist/gpu.cjs +2008 -0
package/dist/gpu.d.cts +68 -0
package/dist/gpu.d.ts +68 -0
package/dist/gpu.js +273 -0
package/dist/http.cjs +467 -0
package/dist/http.d.cts +148 -0
package/dist/http.d.ts +148 -0
package/dist/http.js +7 -0
package/dist/index-CaLD-0oh.d.cts +608 -0
package/dist/index-CaLD-0oh.d.ts +608 -0
package/dist/index-DTllqUtj.d.cts +261 -0
package/dist/index-DTllqUtj.d.ts +261 -0
package/dist/index.cjs +23063 -0
package/dist/index.d.cts +1603 -0
package/dist/index.d.ts +1603 -0
package/dist/index.js +6924 -0
package/dist/query-CKJ4oSpG.d.cts +1595 -0
package/dist/query-DQFRmu3u.d.ts +1595 -0
package/dist/reactivity.cjs +676 -0
package/dist/reactivity.d.cts +188 -0
package/dist/reactivity.d.ts +188 -0
package/dist/reactivity.js +4 -0
package/dist/socket.cjs +2685 -0
package/dist/socket.d.cts +167 -0
package/dist/socket.d.ts +167 -0
package/dist/socket.js +238 -0
package/dist/style-XEUAGGJK.js +5 -0
package/dist/utils.cjs +397 -0
package/dist/utils.d.cts +111 -0
package/dist/utils.d.ts +111 -0
package/dist/utils.js +4 -0
package/dist/voodoo.core.js +8213 -0
package/dist/voodoo.core.min.js +146 -0
package/dist/voodoo.full.js +21193 -0
package/dist/voodoo.full.min.js +1784 -0
package/dist/voodoo.js +14185 -0
package/dist/voodoo.min.js +420 -0
package/package.json +127 -0

package/dist/socket.d.cts ADDED Viewed

@@ -0,0 +1,167 @@
+export { R as RoomOptions, a as RoomState, h as Socket, i as SocketDefaults, j as SocketFactory, k as SocketInterceptor, l as SocketListener, S as SocketMessage, b as SocketOptions, c as SocketRoom, d as SocketState, e as SocketTransport, V as VoodooSocket, W as WebSocketCtor, m as WebSocketLike, f as createSocket, r as resolveSocketURL, s as socket, g as socketSupported } from './index-DTllqUtj.cjs';
+/**
+ * @module socket/protocol
+ *
+ * The Engine.IO/Socket.IO protocol written by hand, without the library.
+ *
+ * It's worth explaining why this file exists. `socket.io-client` weighs over 30
+ * KB compressed, and Voodoo has no runtime dependencies. It happens
+ * that the piece of the protocol a page actually uses is small: one
+ * handshake, six packet codes and some JSON. This fits in plain text over
+ * native WebSocket, and that's exactly what's here.
+ *
+ * An Engine.IO v4 text frame has the form `<code><body>`:
+ *
+ * ```text
+ * 0{"sid":"abc","pingInterval":25000,"pingTimeout":20000}   open
+ * 2                                                          server ping
+ * 3                                                          client pong
+ * 40                                                         enter namespace
+ * 42["mensagem",{"texto":"oi"}]                              event
+ * 421["salvar",{...}]                                        event requesting ack 1
+ * 431[{"ok":true}]                                           ack 1 response
+ * ```
+ *
+ * The body of a `4` (message) packet is a Socket.IO packet, which in turn has
+ * the form `<type>[<namespace>,][<ack>]<JSON>`. The two layers are decoded
+ * here, in pure functions, because pure-function protocol is testable protocol.
+ *
+ * What **is not** implemented is declared in `docs/websocket.md`, and the
+ * short list is: binary attachments (`45`/`46`), polling transport and upgrade,
+ * and namespaces other than `/`.
+ */
+/** Codigos de pacote do Engine.IO v4. */
+declare const ENGINE: {
+    readonly OPEN: "0";
+    readonly CLOSE: "1";
+    readonly PING: "2";
+    readonly PONG: "3";
+    readonly MESSAGE: "4";
+    readonly UPGRADE: "5";
+    readonly NOOP: "6";
+};
+/** Tipos de pacote do Socket.IO v5 (protocolo do servidor v4). */
+declare const SIO: {
+    readonly CONNECT: 0;
+    readonly DISCONNECT: 1;
+    readonly EVENT: 2;
+    readonly ACK: 3;
+    readonly CONNECT_ERROR: 4;
+    readonly BINARY_EVENT: 5;
+    readonly BINARY_ACK: 6;
+};
+/** Data the server sends in the open packet. */
+interface EngineHandshake {
+    sid: string;
+    /** Interval between server pings, in ms. */
+    pingInterval: number;
+    /** How long the server waits for pong before giving up, in ms. */
+    pingTimeout: number;
+    upgrades?: string[];
+    maxPayload?: number;
+}
+/** Socket.IO packet already split into its parts. */
+interface SocketIoPacket {
+    /** One of the values of `SIO`. */
+    type: number;
+    /** Namespace. This implementation only supports `/`. */
+    namespace: string;
+    /** Ack number, when the packet requests or responds with acknowledgment. */
+    ack?: number;
+    /** Body already converted from JSON. For events, `[name, ...args]`. */
+    data?: unknown;
+}
+/** Engine.IO packet already classified. */
+type EnginePacket = {
+    kind: 'open';
+    handshake: EngineHandshake;
+} | {
+    kind: 'close';
+} | {
+    kind: 'ping';
+} | {
+    kind: 'pong';
+} | {
+    kind: 'message';
+    packet: SocketIoPacket;
+} | {
+    kind: 'noop';
+}
+/** Frame this client can't read: binary, upgrade or garbage. */
+ | {
+    kind: 'unknown';
+    raw: string;
+};
+/**
+ * Reads the body of an Engine.IO `4` (message) packet.
+ *
+ * The order of parts is fixed and each only appears when it exists, so
+ * reading is positional: type, optional namespace ending in comma, optional ack
+ * in digits, and the rest is JSON.
+ */
+declare function decodeSocketIo(body: string): SocketIoPacket | null;
+/**
+ * Classifies a text frame received from the server.
+ *
+ * Binary frames arrive as `Blob` or `ArrayBuffer` and become `unknown`: they're
+ * valid in the protocol, this implementation just doesn't read them.
+ */
+declare function decodeEngine(raw: unknown): EnginePacket;
+/**
+ * Builds a `4` (message) packet ready for the wire.
+ *
+ * `encodeSocketIo({ type: SIO.EVENT, data: ['oi', 1] })` returns `42["oi",1]`.
+ */
+declare function encodeSocketIo(packet: SocketIoPacket): string;
+/**
+ * Builds the Engine.IO endpoint URL.
+ *
+ * The path becomes `<path>?EIO=4&transport=websocket`, because this implementation
+ * opens directly in WebSocket and never uses polling.
+ */
+declare function engineURL(base: string, path?: string): string;
+/**
+ * @module socket/plugin
+ *
+ * Separate entry for the real-time layer.
+ *
+ * The reason is measured, not aesthetic: with the module in the complete build,
+ * the file went from 127.58 KB to 134.22 KB compressed, and the ceiling is 133. Instead
+ * of raising the target, which is the same as having no target, the module became its own
+ * entry, as the GPU layer already had for the same reason. Those using
+ * WebSocket pay for WebSocket; those not using it keep the file the same size as before.
+ *
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/voodoojs/dist/voodoo.min.js" defer></script>
+ * <script type="module">
+ *   import 'https://cdn.jsdelivr.net/npm/voodoojs/dist/socket.js'
+ * </script>
+ * ```
+ *
+ * ```js
+ * import V from 'voodoojs'
+ * import 'voodoojs/dist/socket.js'   // registers v-socket, v-room and sets up V.socket
+ * ```
+ *
+ * Importing this file has two effects: registers the `v-socket`,
+ * `v-room` and `v-on-socket` directives, and makes `V.socket` available. In ESM builds
+ * both sides share the same runtime, because common parts go out in
+ * shared chunks.
+ */
+/**
+ * Plugin in the format accepted by `V.use()`.
+ *
+ * ```js
+ * import { voodooSocket } from 'voodoojs/dist/socket.js'
+ * V.use(voodooSocket)
+ * ```
+ */
+declare const voodooSocket: {
+    name: string;
+    install(V: Record<string, unknown>): void;
+};
+export { ENGINE, type EngineHandshake, type EnginePacket, SIO, type SocketIoPacket, decodeEngine, decodeSocketIo, voodooSocket as default, encodeSocketIo, engineURL, voodooSocket };

package/dist/socket.d.ts ADDED Viewed

@@ -0,0 +1,167 @@
+export { R as RoomOptions, a as RoomState, h as Socket, i as SocketDefaults, j as SocketFactory, k as SocketInterceptor, l as SocketListener, S as SocketMessage, b as SocketOptions, c as SocketRoom, d as SocketState, e as SocketTransport, V as VoodooSocket, W as WebSocketCtor, m as WebSocketLike, f as createSocket, r as resolveSocketURL, s as socket, g as socketSupported } from './index-DTllqUtj.js';
+/**
+ * @module socket/protocol
+ *
+ * The Engine.IO/Socket.IO protocol written by hand, without the library.
+ *
+ * It's worth explaining why this file exists. `socket.io-client` weighs over 30
+ * KB compressed, and Voodoo has no runtime dependencies. It happens
+ * that the piece of the protocol a page actually uses is small: one
+ * handshake, six packet codes and some JSON. This fits in plain text over
+ * native WebSocket, and that's exactly what's here.
+ *
+ * An Engine.IO v4 text frame has the form `<code><body>`:
+ *
+ * ```text
+ * 0{"sid":"abc","pingInterval":25000,"pingTimeout":20000}   open
+ * 2                                                          server ping
+ * 3                                                          client pong
+ * 40                                                         enter namespace
+ * 42["mensagem",{"texto":"oi"}]                              event
+ * 421["salvar",{...}]                                        event requesting ack 1
+ * 431[{"ok":true}]                                           ack 1 response
+ * ```
+ *
+ * The body of a `4` (message) packet is a Socket.IO packet, which in turn has
+ * the form `<type>[<namespace>,][<ack>]<JSON>`. The two layers are decoded
+ * here, in pure functions, because pure-function protocol is testable protocol.
+ *
+ * What **is not** implemented is declared in `docs/websocket.md`, and the
+ * short list is: binary attachments (`45`/`46`), polling transport and upgrade,
+ * and namespaces other than `/`.
+ */
+/** Codigos de pacote do Engine.IO v4. */
+declare const ENGINE: {
+    readonly OPEN: "0";
+    readonly CLOSE: "1";
+    readonly PING: "2";
+    readonly PONG: "3";
+    readonly MESSAGE: "4";
+    readonly UPGRADE: "5";
+    readonly NOOP: "6";
+};
+/** Tipos de pacote do Socket.IO v5 (protocolo do servidor v4). */
+declare const SIO: {
+    readonly CONNECT: 0;
+    readonly DISCONNECT: 1;
+    readonly EVENT: 2;
+    readonly ACK: 3;
+    readonly CONNECT_ERROR: 4;
+    readonly BINARY_EVENT: 5;
+    readonly BINARY_ACK: 6;
+};
+/** Data the server sends in the open packet. */
+interface EngineHandshake {
+    sid: string;
+    /** Interval between server pings, in ms. */
+    pingInterval: number;
+    /** How long the server waits for pong before giving up, in ms. */
+    pingTimeout: number;
+    upgrades?: string[];
+    maxPayload?: number;
+}
+/** Socket.IO packet already split into its parts. */
+interface SocketIoPacket {
+    /** One of the values of `SIO`. */
+    type: number;
+    /** Namespace. This implementation only supports `/`. */
+    namespace: string;
+    /** Ack number, when the packet requests or responds with acknowledgment. */
+    ack?: number;
+    /** Body already converted from JSON. For events, `[name, ...args]`. */
+    data?: unknown;
+}
+/** Engine.IO packet already classified. */
+type EnginePacket = {
+    kind: 'open';
+    handshake: EngineHandshake;
+} | {
+    kind: 'close';
+} | {
+    kind: 'ping';
+} | {
+    kind: 'pong';
+} | {
+    kind: 'message';
+    packet: SocketIoPacket;
+} | {
+    kind: 'noop';
+}
+/** Frame this client can't read: binary, upgrade or garbage. */
+ | {
+    kind: 'unknown';
+    raw: string;
+};
+/**
+ * Reads the body of an Engine.IO `4` (message) packet.
+ *
+ * The order of parts is fixed and each only appears when it exists, so
+ * reading is positional: type, optional namespace ending in comma, optional ack
+ * in digits, and the rest is JSON.
+ */
+declare function decodeSocketIo(body: string): SocketIoPacket | null;
+/**
+ * Classifies a text frame received from the server.
+ *
+ * Binary frames arrive as `Blob` or `ArrayBuffer` and become `unknown`: they're
+ * valid in the protocol, this implementation just doesn't read them.
+ */
+declare function decodeEngine(raw: unknown): EnginePacket;
+/**
+ * Builds a `4` (message) packet ready for the wire.
+ *
+ * `encodeSocketIo({ type: SIO.EVENT, data: ['oi', 1] })` returns `42["oi",1]`.
+ */
+declare function encodeSocketIo(packet: SocketIoPacket): string;
+/**
+ * Builds the Engine.IO endpoint URL.
+ *
+ * The path becomes `<path>?EIO=4&transport=websocket`, because this implementation
+ * opens directly in WebSocket and never uses polling.
+ */
+declare function engineURL(base: string, path?: string): string;
+/**
+ * @module socket/plugin
+ *
+ * Separate entry for the real-time layer.
+ *
+ * The reason is measured, not aesthetic: with the module in the complete build,
+ * the file went from 127.58 KB to 134.22 KB compressed, and the ceiling is 133. Instead
+ * of raising the target, which is the same as having no target, the module became its own
+ * entry, as the GPU layer already had for the same reason. Those using
+ * WebSocket pay for WebSocket; those not using it keep the file the same size as before.
+ *
+ * ```html
+ * <script src="https://cdn.jsdelivr.net/npm/voodoojs/dist/voodoo.min.js" defer></script>
+ * <script type="module">
+ *   import 'https://cdn.jsdelivr.net/npm/voodoojs/dist/socket.js'
+ * </script>
+ * ```
+ *
+ * ```js
+ * import V from 'voodoojs'
+ * import 'voodoojs/dist/socket.js'   // registers v-socket, v-room and sets up V.socket
+ * ```
+ *
+ * Importing this file has two effects: registers the `v-socket`,
+ * `v-room` and `v-on-socket` directives, and makes `V.socket` available. In ESM builds
+ * both sides share the same runtime, because common parts go out in
+ * shared chunks.
+ */
+/**
+ * Plugin in the format accepted by `V.use()`.
+ *
+ * ```js
+ * import { voodooSocket } from 'voodoojs/dist/socket.js'
+ * V.use(voodooSocket)
+ * ```
+ */
+declare const voodooSocket: {
+    name: string;
+    install(V: Record<string, unknown>): void;
+};
+export { ENGINE, type EngineHandshake, type EnginePacket, SIO, type SocketIoPacket, decodeEngine, decodeSocketIo, voodooSocket as default, encodeSocketIo, engineURL, voodooSocket };

package/dist/socket.js ADDED Viewed

@@ -0,0 +1,238 @@
+import { socketSupported, createSocket, socket } from './chunk-RJUNPXQF.js';
+export { ENGINE, SIO, createSocket, decodeEngine, decodeSocketIo, encodeSocketIo, engineURL, resolveSocketURL, socket, socketSupported } from './chunk-RJUNPXQF.js';
+import { evaluateIn, readAttr } from './chunk-5CKGDARU.js';
+import { reactive } from './chunk-NNU6WOOU.js';
+import { warnAlias } from './chunk-A2UOVQBP.js';
+import { parseDuration } from './chunk-234ZLC6W.js';
+import { defineDirective, PRIORITY, config } from './chunk-5777LJVW.js';
+import './chunk-E27NRARW.js';
+/**
+ * Voodoo.js v0.4.6
+ * JavaScript feels like magic.
+ * (c) 2026 Voodoo.js contributors. MIT License.
+ */
+// src/directives/socket.ts
+function aliasLegacy(view, pairs) {
+  for (const [old, canonical] of pairs) {
+    Object.defineProperty(view, old, {
+      enumerable: false,
+      configurable: true,
+      get() {
+        warnAlias(old, canonical);
+        return view[canonical];
+      },
+      set(value) {
+        warnAlias(old, canonical);
+        view[canonical] = value;
+      }
+    });
+  }
+}
+function attr(el, name) {
+  return readAttr(el, `${config.prefix}${name}`);
+}
+var connections = /* @__PURE__ */ new WeakMap();
+function closest(el, map) {
+  let current = el;
+  while (current) {
+    const found = map.get(current);
+    if (found) return found;
+    current = current.parentElement;
+  }
+  return null;
+}
+function resolveText(expression, scope, context) {
+  const text = expression.trim();
+  if (!text) return "";
+  if (/^[A-Za-z_$][\w$]*$/.test(text)) {
+    const value2 = scope.has(text) ? scope.get(text) : void 0;
+    return typeof value2 === "string" && value2 ? value2 : text;
+  }
+  if (/^(wss?|https?):\/\//i.test(text) || /^[\w:.\-/]+$/.test(text)) return text;
+  const value = evaluateIn(text, scope, context);
+  return typeof value === "string" && value ? value : text;
+}
+function dispatch(el, type, detail) {
+  el.dispatchEvent(new CustomEvent(type, { detail, bubbles: true }));
+}
+defineDirective(
+  "socket",
+  ({ el, scope, expression, modifiers, cleanup, effect }) => {
+    const name = attr(el, "socket-as") || "$socket";
+    if (!socketSupported()) {
+      el.setAttribute("data-socket", "unsupported");
+      scope.set(
+        name,
+        reactive({
+          connected: false,
+          state: "closed",
+          error: "WebSocket unavailable in this environment",
+          attempts: 0,
+          messages: [],
+          send: () => false,
+          open: () => void 0,
+          close: () => void 0,
+          socket: null
+        })
+      );
+      dispatch(el, "voodoo:socket-unsupported", { url: expression });
+      return;
+    }
+    const limit = Number(attr(el, "socket-buffer") ?? 50);
+    const transport = attr(el, "socket-transport") || "ws";
+    const reconnect = !modifiers["no-reconnect"] && modifiers.reconnect !== "false" && attr(el, "socket-reconnect") !== "false";
+    const options = {
+      transport: transport === "socket.io" ? "socket.io" : "ws",
+      manual: !!modifiers.manual,
+      reconnect
+    };
+    if (modifiers.json) options.json = modifiers.json !== "false";
+    const path = attr(el, "socket-path");
+    if (path) options.path = path;
+    const heartbeat = attr(el, "socket-heartbeat");
+    if (heartbeat !== null) options.heartbeat = parseDuration(heartbeat, 25e3);
+    const s = createSocket(resolveText(expression, scope, "v-socket") || "/", options);
+    connections.set(el, s);
+    el.setAttribute("data-socket", "ready");
+    function send(event, ...rest) {
+      if (typeof event !== "string") return s.send(event);
+      return rest.length ? s.emit(event, rest[0]) : s.emit(event);
+    }
+    const view = reactive({
+      connected: s.connected,
+      state: s.state,
+      error: s.error,
+      attempts: s.attempts,
+      messages: [],
+      send,
+      open: () => s.open(),
+      close: () => s.close(),
+      socket: s
+    });
+    aliasLegacy(view, [
+      ["conectado", "connected"],
+      ["estado", "state"],
+      ["mensagens", "messages"],
+      ["erro", "error"],
+      ["tentativas", "attempts"],
+      ["enviar", "send"],
+      ["abrir", "open"],
+      ["fechar", "close"]
+    ]);
+    scope.set(name, view);
+    effect(() => {
+      view.connected = s.connected;
+      view.state = s.state;
+      view.error = s.error;
+      view.attempts = s.attempts;
+    });
+    const unsubscribe = [
+      s.on("message", (data) => {
+        view.messages.push(data);
+        if (view.messages.length > limit) {
+          view.messages.splice(0, view.messages.length - limit);
+        }
+      }),
+      s.on("open", () => dispatch(el, "voodoo:socket-open", { url: s.url })),
+      s.on("close", (d) => dispatch(el, "voodoo:socket-close", d)),
+      s.on("error", (d) => dispatch(el, "voodoo:socket-error", d))
+    ];
+    cleanup(() => {
+      for (const stop of unsubscribe) stop();
+      s.off();
+      s.close();
+      connections.delete(el);
+    });
+  },
+  { priority: PRIORITY.DATA }
+);
+defineDirective(
+  "room",
+  ({ el, scope, expression, modifiers, cleanup, effect }) => {
+    const s = closest(el, connections);
+    if (!s) return;
+    const roomName = resolveText(expression, scope, "v-room");
+    if (!roomName) return;
+    const room = s.join(roomName, {
+      private: !!modifiers.private || !!modifiers.privada,
+      buffer: Number(attr(el, "room-buffer") ?? 50)
+    });
+    const view = reactive({
+      name: roomName,
+      private: room.private,
+      state: room.state,
+      members: room.members,
+      messages: room.messages,
+      /** Sends to the room. With `to`, only to that recipient. */
+      send: (event, data, to) => to ? room.to(to).emit(event, data) : room.emit(event, data),
+      leave: () => room.leave(),
+      room
+    });
+    aliasLegacy(view, [
+      ["membros", "members"],
+      ["mensagens", "messages"],
+      ["estado", "state"],
+      ["nome", "name"],
+      ["privada", "private"],
+      ["enviar", "send"],
+      ["sair", "leave"]
+    ]);
+    scope.set(attr(el, "room-as") || "$room", view);
+    effect(() => {
+      view.state = room.state;
+      view.members = room.members;
+      view.messages = room.messages;
+    });
+    const unsubscribe = [
+      room.on("joined", (m) => dispatch(el, "voodoo:room-join", m)),
+      room.on("left", (m) => dispatch(el, "voodoo:room-leave", m))
+    ];
+    cleanup(() => {
+      for (const stop of unsubscribe) stop();
+      room.off();
+      room.leave();
+    });
+  },
+  // After `v-socket`, so the connection exists when the room asks to join.
+  { priority: PRIORITY.DATA - 1 }
+);
+defineDirective("on-socket", ({ el, scope, arg, expression, cleanup }) => {
+  if (!arg) return;
+  const target2 = closest(el, connections);
+  if (!target2) return;
+  const unsubscribe = target2.on(arg, (data, ack) => {
+    const local = scope.child({ $event: data, $ack: ack, $el: el });
+    const value = evaluateIn(expression, local, `v-on-socket:${arg}`);
+    if (typeof value === "function") value.call(scope.data, data);
+  });
+  cleanup(unsubscribe);
+});
+for (const nome of [
+  "socket-transport",
+  "socket-as",
+  "socket-buffer",
+  "socket-path",
+  "socket-heartbeat",
+  "socket-reconnect",
+  "room-as",
+  "room-buffer"
+]) {
+  defineDirective(nome, () => void 0, { priority: PRIORITY.TRANSITION });
+}
+// src/socket/plugin.ts
+var voodooSocket = {
+  name: "socket",
+  install(V) {
+    if (!V.socket) V.socket = socket;
+  }
+};
+var target = globalThis.V;
+if (target && typeof target === "object" && !target.socket) target.socket = socket;
+var plugin_default = voodooSocket;
+export { plugin_default as default, voodooSocket };
+//# sourceMappingURL=socket.js.map
+//# sourceMappingURL=socket.js.map

package/dist/style-XEUAGGJK.js ADDED Viewed

@@ -0,0 +1,5 @@
+export { BASE_TOKENS, ensureTokens, injectStyle } from './chunk-U76IRJKH.js';
+import './chunk-5777LJVW.js';
+import './chunk-E27NRARW.js';
+//# sourceMappingURL=style-XEUAGGJK.js.map
+//# sourceMappingURL=style-XEUAGGJK.js.map