penambahan web socket

examples/nuxt3-websocket-client/node_modules/.cache/jiti/nuxt3-websocket-client-nuxt.config.08913441.mjs

@@ -0,0 +1,11 @@
+"use strict";Object.defineProperty(exports, "__esModule", { value: true });exports.default = void 0;var _default = exports.default = defineNuxtConfig({
+  devtools: { enabled: true },
+  modules: ["@nuxtjs/tailwindcss"],
+  css: ["~/assets/css/main.css"],
+  runtimeConfig: {
+    public: {
+      websocketUrl:
+      process.env.WEBSOCKET_URL || "ws://localhost:8080/api/v1/ws"
+    }
+  }
+}); /* v9-10e3a3a66cd66ecf */

examples/nuxt3-websocket-client/node_modules/.cache/nuxt/chrome-workspace.json

@@ -0,0 +1 @@
+{"uuid":"04581a6c-1421-4294-80bd-ea453d796298"}

examples/nuxt3-websocket-client/node_modules/.cache/vite/client/deps/@vue_devtools-core.js

@@ -0,0 +1,661 @@
+import {
+  DevToolsContextHookKeys,
+  DevToolsMessagingHookKeys,
+  createRpcClient,
+  createRpcServer,
+  devtools,
+  devtoolsRouter,
+  devtoolsRouterInfo,
+  getActiveInspectors,
+  getInspector,
+  getInspectorActions,
+  getInspectorInfo,
+  getInspectorNodeActions,
+  getRpcClient,
+  getRpcServer,
+  getViteRpcClient,
+  isBrowser,
+  stringify2,
+  target,
+  toggleClientConnected,
+  updateDevToolsClientDetected,
+  updateTimelineLayersState
+} from "./chunk-OT3Q6CPD.js";
+
+// node_modules/@vue/devtools-core/dist/index.js
+import { computed, inject, onUnmounted, ref, watch } from "vue";
+function setDevToolsClientUrl(url) {
+  target.__VUE_DEVTOOLS_CLIENT_URL__ = url;
+}
+function getDevToolsClientUrl() {
+  var _a;
+  return (_a = target.__VUE_DEVTOOLS_CLIENT_URL__) != null ? _a : (() => {
+    if (isBrowser) {
+      const devtoolsMeta = document.querySelector("meta[name=__VUE_DEVTOOLS_CLIENT_URL__]");
+      if (devtoolsMeta)
+        return devtoolsMeta.getAttribute("content");
+    }
+    return "";
+  })();
+}
+function flatHooks(configHooks, hooks3 = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks3, name);
+    } else if (typeof subHook === "function") {
+      hooks3[name] = subHook;
+    }
+  }
+  return hooks3;
+}
+var defaultTask = { run: (function_) => function_() };
+var _createTask = () => defaultTask;
+var createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks3, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return hooks3.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks3, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return Promise.all(hooks3.map((hook) => task.run(() => hook(...args))));
+}
+function callEachWith(callbacks, arg0) {
+  for (const callback of [...callbacks]) {
+    callback(arg0);
+  }
+}
+var Hookable = class {
+  constructor() {
+    this._hooks = {};
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
+    this._deprecatedHooks = {};
+    this.hook = this.hook.bind(this);
+    this.callHook = this.callHook.bind(this);
+    this.callHookWith = this.callHookWith.bind(this);
+  }
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
+      return () => {
+      };
+    }
+    const originalName = name;
+    let dep;
+    while (this._deprecatedHooks[name]) {
+      dep = this._deprecatedHooks[name];
+      name = dep.to;
+    }
+    if (dep && !options.allowDeprecated) {
+      let message = dep.message;
+      if (!message) {
+        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+      }
+      if (!this._deprecatedMessages) {
+        this._deprecatedMessages = /* @__PURE__ */ new Set();
+      }
+      if (!this._deprecatedMessages.has(message)) {
+        console.warn(message);
+        this._deprecatedMessages.add(message);
+      }
+    }
+    if (!function_.name) {
+      try {
+        Object.defineProperty(function_, "name", {
+          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+          configurable: true
+        });
+      } catch (e) {
+      }
+    }
+    this._hooks[name] = this._hooks[name] || [];
+    this._hooks[name].push(function_);
+    return () => {
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
+      }
+    };
+  }
+  hookOnce(name, function_) {
+    let _unreg;
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
+    };
+    _unreg = this.hook(name, _function);
+    return _unreg;
+  }
+  removeHook(name, function_) {
+    if (this._hooks[name]) {
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
+      }
+      if (this._hooks[name].length === 0) {
+        delete this._hooks[name];
+      }
+    }
+  }
+  deprecateHook(name, deprecated) {
+    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+    const _hooks = this._hooks[name] || [];
+    delete this._hooks[name];
+    for (const hook of _hooks) {
+      this.hook(name, hook);
+    }
+  }
+  deprecateHooks(deprecatedHooks) {
+    Object.assign(this._deprecatedHooks, deprecatedHooks);
+    for (const name in deprecatedHooks) {
+      this.deprecateHook(name, deprecatedHooks[name]);
+    }
+  }
+  addHooks(configHooks) {
+    const hooks3 = flatHooks(configHooks);
+    const removeFns = Object.keys(hooks3).map(
+      (key) => this.hook(key, hooks3[key])
+    );
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks3 = flatHooks(configHooks);
+    for (const key in hooks3) {
+      this.removeHook(key, hooks3[key]);
+    }
+  }
+  removeAllHooks() {
+    for (const key in this._hooks) {
+      delete this._hooks[key];
+    }
+  }
+  callHook(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(serialTaskCaller, name, ...arguments_);
+  }
+  callHookParallel(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
+  }
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
+    if (this._before) {
+      callEachWith(this._before, event);
+    }
+    const result = caller(
+      name in this._hooks ? [...this._hooks[name]] : [],
+      arguments_
+    );
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after && event) {
+          callEachWith(this._after, event);
+        }
+      });
+    }
+    if (this._after && event) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(function_) {
+    this._before = this._before || [];
+    this._before.push(function_);
+    return () => {
+      if (this._before !== void 0) {
+        const index = this._before.indexOf(function_);
+        if (index !== -1) {
+          this._before.splice(index, 1);
+        }
+      }
+    };
+  }
+  afterEach(function_) {
+    this._after = this._after || [];
+    this._after.push(function_);
+    return () => {
+      if (this._after !== void 0) {
+        const index = this._after.indexOf(function_);
+        if (index !== -1) {
+          this._after.splice(index, 1);
+        }
+      }
+    };
+  }
+};
+function createHooks() {
+  return new Hookable();
+}
+var hooks = createHooks();
+var DevToolsMessagingEvents = ((DevToolsMessagingEvents2) => {
+  DevToolsMessagingEvents2["INSPECTOR_TREE_UPDATED"] = "inspector-tree-updated";
+  DevToolsMessagingEvents2["INSPECTOR_STATE_UPDATED"] = "inspector-state-updated";
+  DevToolsMessagingEvents2["DEVTOOLS_STATE_UPDATED"] = "devtools-state-updated";
+  DevToolsMessagingEvents2["ROUTER_INFO_UPDATED"] = "router-info-updated";
+  DevToolsMessagingEvents2["TIMELINE_EVENT_UPDATED"] = "timeline-event-updated";
+  DevToolsMessagingEvents2["INSPECTOR_UPDATED"] = "inspector-updated";
+  DevToolsMessagingEvents2["ACTIVE_APP_UNMOUNTED"] = "active-app-updated";
+  DevToolsMessagingEvents2["DESTROY_DEVTOOLS_CLIENT"] = "destroy-devtools-client";
+  DevToolsMessagingEvents2["RELOAD_DEVTOOLS_CLIENT"] = "reload-devtools-client";
+  return DevToolsMessagingEvents2;
+})(DevToolsMessagingEvents || {});
+function getDevToolsState() {
+  var _a;
+  const state = devtools.ctx.state;
+  return {
+    connected: state.connected,
+    clientConnected: true,
+    vueVersion: ((_a = state == null ? void 0 : state.activeAppRecord) == null ? void 0 : _a.version) || "",
+    tabs: state.tabs,
+    commands: state.commands,
+    vitePluginDetected: state.vitePluginDetected,
+    appRecords: state.appRecords.map((item) => ({
+      id: item.id,
+      name: item.name,
+      version: item.version,
+      routerId: item.routerId,
+      iframe: item.iframe
+    })),
+    activeAppRecordId: state.activeAppRecordId,
+    timelineLayersState: state.timelineLayersState
+  };
+}
+var functions = {
+  on: (event, handler) => {
+    hooks.hook(event, handler);
+  },
+  off: (event, handler) => {
+    hooks.removeHook(event, handler);
+  },
+  once: (event, handler) => {
+    hooks.hookOnce(event, handler);
+  },
+  emit: (event, ...args) => {
+    hooks.callHook(event, ...args);
+  },
+  heartbeat: () => {
+    return true;
+  },
+  devtoolsState: () => {
+    return getDevToolsState();
+  },
+  async getInspectorTree(payload) {
+    const res = await devtools.ctx.api.getInspectorTree(payload);
+    return stringify2(res);
+  },
+  async getInspectorState(payload) {
+    const inspector = getInspector(payload.inspectorId);
+    if (inspector)
+      inspector.selectedNodeId = payload.nodeId;
+    const res = await devtools.ctx.api.getInspectorState(payload);
+    return stringify2(res);
+  },
+  async editInspectorState(payload) {
+    return await devtools.ctx.api.editInspectorState(payload);
+  },
+  sendInspectorState(id) {
+    return devtools.ctx.api.sendInspectorState(id);
+  },
+  inspectComponentInspector() {
+    return devtools.ctx.api.inspectComponentInspector();
+  },
+  cancelInspectComponentInspector() {
+    return devtools.ctx.api.cancelInspectComponentInspector();
+  },
+  getComponentRenderCode(id) {
+    return devtools.ctx.api.getComponentRenderCode(id);
+  },
+  scrollToComponent(id) {
+    return devtools.ctx.api.scrollToComponent(id);
+  },
+  inspectDOM(id) {
+    return devtools.ctx.api.inspectDOM(id);
+  },
+  getInspectorNodeActions(id) {
+    return getInspectorNodeActions(id);
+  },
+  getInspectorActions(id) {
+    return getInspectorActions(id);
+  },
+  updateTimelineLayersState(state) {
+    return updateTimelineLayersState(state);
+  },
+  callInspectorNodeAction(inspectorId, actionIndex, nodeId) {
+    var _a;
+    const nodeActions = getInspectorNodeActions(inspectorId);
+    if (nodeActions == null ? void 0 : nodeActions.length) {
+      const item = nodeActions[actionIndex];
+      (_a = item.action) == null ? void 0 : _a.call(item, nodeId);
+    }
+  },
+  callInspectorAction(inspectorId, actionIndex) {
+    var _a;
+    const actions = getInspectorActions(inspectorId);
+    if (actions == null ? void 0 : actions.length) {
+      const item = actions[actionIndex];
+      (_a = item.action) == null ? void 0 : _a.call(item);
+    }
+  },
+  openInEditor(options) {
+    return devtools.ctx.api.openInEditor(options);
+  },
+  async checkVueInspectorDetected() {
+    return !!await devtools.ctx.api.getVueInspector();
+  },
+  async enableVueInspector() {
+    var _a, _b, _c;
+    const inspector = await ((_c = (_b = (_a = devtools) == null ? void 0 : _a.api) == null ? void 0 : _b.getVueInspector) == null ? void 0 : _c.call(_b));
+    if (inspector)
+      await inspector.enable();
+  },
+  async toggleApp(id, options) {
+    return devtools.ctx.api.toggleApp(id, options);
+  },
+  updatePluginSettings(pluginId, key, value) {
+    return devtools.ctx.api.updatePluginSettings(pluginId, key, value);
+  },
+  getPluginSettings(pluginId) {
+    return devtools.ctx.api.getPluginSettings(pluginId);
+  },
+  getRouterInfo() {
+    return devtoolsRouterInfo;
+  },
+  navigate(path) {
+    var _a;
+    return (_a = devtoolsRouter.value) == null ? void 0 : _a.push(path).catch(() => ({}));
+  },
+  getMatchedRoutes(path) {
+    var _a, _b, _c;
+    const c = console.warn;
+    console.warn = () => {
+    };
+    const matched = (_c = (_b = (_a = devtoolsRouter.value) == null ? void 0 : _a.resolve) == null ? void 0 : _b.call(_a, {
+      path: path || "/"
+    }).matched) != null ? _c : [];
+    console.warn = c;
+    return matched;
+  },
+  toggleClientConnected(state) {
+    toggleClientConnected(state);
+  },
+  getCustomInspector() {
+    return getActiveInspectors();
+  },
+  getInspectorInfo(id) {
+    return getInspectorInfo(id);
+  },
+  highlighComponent(uid) {
+    return devtools.ctx.hooks.callHook(DevToolsContextHookKeys.COMPONENT_HIGHLIGHT, { uid });
+  },
+  unhighlight() {
+    return devtools.ctx.hooks.callHook(DevToolsContextHookKeys.COMPONENT_UNHIGHLIGHT);
+  },
+  updateDevToolsClientDetected(params) {
+    updateDevToolsClientDetected(params);
+  },
+  // listen to devtools server events
+  initDevToolsServerListener() {
+    const rpcServer2 = getRpcServer();
+    const broadcast = rpcServer2.broadcast;
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_TREE_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-tree-updated", stringify2(payload));
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_STATE_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-state-updated", stringify2(payload));
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.DEVTOOLS_STATE_UPDATED, () => {
+      broadcast.emit("devtools-state-updated", getDevToolsState());
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.ROUTER_INFO_UPDATED, ({ state }) => {
+      broadcast.emit("router-info-updated", state);
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_TIMELINE_EVENT_TO_CLIENT, (payload) => {
+      broadcast.emit("timeline-event-updated", stringify2(payload));
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_INSPECTOR_TO_CLIENT, (payload) => {
+      broadcast.emit("inspector-updated", payload);
+    });
+    devtools.ctx.hooks.hook(DevToolsMessagingHookKeys.SEND_ACTIVE_APP_UNMOUNTED_TO_CLIENT, () => {
+      broadcast.emit(
+        "active-app-updated"
+        /* ACTIVE_APP_UNMOUNTED */
+      );
+    });
+  }
+};
+var rpc = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = getRpcClient();
+    if (property === "value") {
+      return _rpc;
+    } else if (property === "functions") {
+      return _rpc.$functions;
+    }
+  }
+});
+var rpcServer = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = getRpcServer();
+    if (property === "value") {
+      return _rpc;
+    } else if (property === "functions") {
+      return _rpc.functions;
+    }
+  }
+});
+function onRpcConnected(callback) {
+  let timer = null;
+  let retryCount = 0;
+  function heartbeat() {
+    var _a, _b;
+    (_b = (_a = rpc.value) == null ? void 0 : _a.heartbeat) == null ? void 0 : _b.call(_a).then(() => {
+      callback();
+      clearTimeout(timer);
+    }).catch(() => {
+    });
+  }
+  timer = setInterval(() => {
+    if (retryCount >= 30) {
+      clearTimeout(timer);
+    }
+    retryCount++;
+    heartbeat();
+  }, retryCount * 200 + 200);
+  heartbeat();
+}
+function onRpcSeverReady(callback) {
+  let timer = null;
+  const timeout = 120;
+  function heartbeat() {
+    if (rpcServer.value.clients.length > 0) {
+      callback();
+      clearTimeout(timer);
+    }
+  }
+  timer = setInterval(() => {
+    heartbeat();
+  }, timeout);
+}
+var hooks2 = createHooks();
+var viteRpcFunctions = {
+  on: (event, handler) => {
+    hooks2.hook(event, handler);
+  },
+  off: (event, handler) => {
+    hooks2.removeHook(event, handler);
+  },
+  once: (event, handler) => {
+    hooks2.hookOnce(event, handler);
+  },
+  emit: (event, ...args) => {
+    hooks2.callHook(event, ...args);
+  },
+  heartbeat: () => {
+    return true;
+  }
+};
+var viteRpc = new Proxy({
+  value: {},
+  functions: {}
+}, {
+  get(target2, property) {
+    const _rpc = getViteRpcClient();
+    if (property === "value") {
+      return _rpc;
+    } else if (property === "functions") {
+      return _rpc == null ? void 0 : _rpc.$functions;
+    }
+  }
+});
+function onViteRpcConnected(callback) {
+  let timer = null;
+  function heartbeat() {
+    var _a, _b;
+    (_b = (_a = viteRpc.value) == null ? void 0 : _a.heartbeat) == null ? void 0 : _b.call(_a).then(() => {
+      clearTimeout(timer);
+      callback();
+    }).catch(() => ({}));
+    timer = setTimeout(() => {
+      heartbeat();
+    }, 80);
+  }
+  heartbeat();
+}
+function createViteClientRpc() {
+  createRpcClient(viteRpcFunctions, {
+    preset: "vite"
+  });
+}
+function createViteServerRpc(functions2) {
+  createRpcServer(functions2, {
+    preset: "vite"
+  });
+}
+var VueDevToolsStateSymbol = Symbol.for("__VueDevToolsStateSymbol__");
+function VueDevToolsVuePlugin() {
+  return {
+    install(app) {
+      const state = createDevToolsStateContext();
+      state.getDevToolsState();
+      app.provide(VueDevToolsStateSymbol, state);
+      app.config.globalProperties.$getDevToolsState = state.getDevToolsState;
+      app.config.globalProperties.$disconnectDevToolsClient = () => {
+        state.clientConnected.value = false;
+        state.connected.value = false;
+      };
+    }
+  };
+}
+function createDevToolsStateContext() {
+  const connected = ref(false);
+  const clientConnected = ref(false);
+  const vueVersion = ref("");
+  const tabs = ref([]);
+  const commands = ref([]);
+  const vitePluginDetected = ref(false);
+  const appRecords = ref([]);
+  const activeAppRecordId = ref("");
+  const timelineLayersState = ref({});
+  function updateState(data) {
+    connected.value = data.connected;
+    clientConnected.value = data.clientConnected;
+    vueVersion.value = data.vueVersion || "";
+    tabs.value = data.tabs;
+    commands.value = data.commands;
+    vitePluginDetected.value = data.vitePluginDetected;
+    appRecords.value = data.appRecords;
+    activeAppRecordId.value = data.activeAppRecordId;
+    timelineLayersState.value = data.timelineLayersState;
+  }
+  function getDevToolsState2() {
+    onRpcConnected(() => {
+      rpc.value.devtoolsState().then((data) => {
+        updateState(data);
+      });
+      rpc.functions.off("devtools-state-updated", updateState);
+      rpc.functions.on("devtools-state-updated", updateState);
+    });
+  }
+  return {
+    getDevToolsState: getDevToolsState2,
+    connected,
+    clientConnected,
+    vueVersion,
+    tabs,
+    commands,
+    vitePluginDetected,
+    appRecords,
+    activeAppRecordId,
+    timelineLayersState
+  };
+}
+function useDevToolsState() {
+  return inject(VueDevToolsStateSymbol);
+}
+var fns = [];
+function onDevToolsConnected(fn) {
+  const { connected, clientConnected } = useDevToolsState();
+  fns.push(fn);
+  onUnmounted(() => {
+    fns.splice(fns.indexOf(fn), 1);
+  });
+  const devtoolsReady = computed(() => clientConnected.value && connected.value);
+  if (devtoolsReady.value) {
+    fn();
+  } else {
+    const stop = watch(devtoolsReady, (v) => {
+      if (v) {
+        fn();
+        stop();
+      }
+    });
+  }
+  return () => {
+    fns.splice(fns.indexOf(fn), 1);
+  };
+}
+function refreshCurrentPageData() {
+  fns.forEach((fn) => fn());
+}
+export {
+  DevToolsMessagingEvents,
+  VueDevToolsVuePlugin,
+  createDevToolsStateContext,
+  createViteClientRpc,
+  createViteServerRpc,
+  functions,
+  getDevToolsClientUrl,
+  onDevToolsConnected,
+  onRpcConnected,
+  onRpcSeverReady,
+  onViteRpcConnected,
+  refreshCurrentPageData,
+  rpc,
+  rpcServer,
+  setDevToolsClientUrl,
+  useDevToolsState,
+  viteRpc,
+  viteRpcFunctions
+};
+//# sourceMappingURL=@vue_devtools-core.js.map

examples/nuxt3-websocket-client/node_modules/.cache/vite/client/deps/@vue_devtools-kit.js

@@ -0,0 +1,168 @@
+import {
+  DevToolsContextHookKeys,
+  DevToolsMessagingHookKeys,
+  DevToolsV6PluginAPIHookKeys,
+  INFINITY,
+  NAN,
+  NEGATIVE_INFINITY,
+  ROUTER_INFO_KEY,
+  ROUTER_KEY,
+  UNDEFINED,
+  activeAppRecord,
+  addCustomCommand,
+  addCustomTab,
+  addDevToolsAppRecord,
+  addDevToolsPluginToBuffer,
+  addInspector,
+  callConnectedUpdatedHook,
+  callDevToolsPluginSetupFn,
+  callInspectorUpdatedHook,
+  callStateUpdatedHook,
+  createComponentsDevToolsPlugin,
+  createDevToolsApi,
+  createDevToolsCtxHooks,
+  createRpcClient,
+  createRpcProxy,
+  createRpcServer,
+  devtools,
+  devtoolsAppRecords,
+  devtoolsContext,
+  devtoolsInspector,
+  devtoolsPluginBuffer,
+  devtoolsRouter,
+  devtoolsRouterInfo,
+  devtoolsState,
+  escape,
+  formatInspectorStateValue,
+  getActiveInspectors,
+  getDevToolsEnv,
+  getExtensionClientContext,
+  getInspector,
+  getInspectorActions,
+  getInspectorInfo,
+  getInspectorNodeActions,
+  getInspectorStateValueType,
+  getRaw,
+  getRpcClient,
+  getRpcServer,
+  getViteRpcClient,
+  getViteRpcServer,
+  initDevTools,
+  isPlainObject,
+  onDevToolsClientConnected,
+  onDevToolsConnected,
+  parse2,
+  registerDevToolsPlugin,
+  removeCustomCommand,
+  removeDevToolsAppRecord,
+  removeRegisteredPluginApp,
+  resetDevToolsState,
+  setActiveAppRecord,
+  setActiveAppRecordId,
+  setDevToolsEnv,
+  setElectronClientContext,
+  setElectronProxyContext,
+  setElectronServerContext,
+  setExtensionClientContext,
+  setIframeServerContext,
+  setOpenInEditorBaseUrl,
+  setRpcServerToGlobal,
+  setViteClientContext,
+  setViteRpcClientToGlobal,
+  setViteRpcServerToGlobal,
+  setViteServerContext,
+  setupDevToolsPlugin,
+  stringify2,
+  toEdit,
+  toSubmit,
+  toggleClientConnected,
+  toggleComponentInspectorEnabled,
+  toggleHighPerfMode,
+  updateDevToolsClientDetected,
+  updateDevToolsState,
+  updateTimelineLayersState
+} from "./chunk-OT3Q6CPD.js";
+export {
+  DevToolsContextHookKeys,
+  DevToolsMessagingHookKeys,
+  DevToolsV6PluginAPIHookKeys,
+  INFINITY,
+  NAN,
+  NEGATIVE_INFINITY,
+  ROUTER_INFO_KEY,
+  ROUTER_KEY,
+  UNDEFINED,
+  activeAppRecord,
+  addCustomCommand,
+  addCustomTab,
+  addDevToolsAppRecord,
+  addDevToolsPluginToBuffer,
+  addInspector,
+  callConnectedUpdatedHook,
+  callDevToolsPluginSetupFn,
+  callInspectorUpdatedHook,
+  callStateUpdatedHook,
+  createComponentsDevToolsPlugin,
+  createDevToolsApi,
+  createDevToolsCtxHooks,
+  createRpcClient,
+  createRpcProxy,
+  createRpcServer,
+  devtools,
+  devtoolsAppRecords,
+  devtoolsContext,
+  devtoolsInspector,
+  devtoolsPluginBuffer,
+  devtoolsRouter,
+  devtoolsRouterInfo,
+  devtoolsState,
+  escape,
+  formatInspectorStateValue,
+  getActiveInspectors,
+  getDevToolsEnv,
+  getExtensionClientContext,
+  getInspector,
+  getInspectorActions,
+  getInspectorInfo,
+  getInspectorNodeActions,
+  getInspectorStateValueType,
+  getRaw,
+  getRpcClient,
+  getRpcServer,
+  getViteRpcClient,
+  getViteRpcServer,
+  initDevTools,
+  isPlainObject,
+  onDevToolsClientConnected,
+  onDevToolsConnected,
+  parse2 as parse,
+  registerDevToolsPlugin,
+  removeCustomCommand,
+  removeDevToolsAppRecord,
+  removeRegisteredPluginApp,
+  resetDevToolsState,
+  setActiveAppRecord,
+  setActiveAppRecordId,
+  setDevToolsEnv,
+  setElectronClientContext,
+  setElectronProxyContext,
+  setElectronServerContext,
+  setExtensionClientContext,
+  setIframeServerContext,
+  setOpenInEditorBaseUrl,
+  setRpcServerToGlobal,
+  setViteClientContext,
+  setViteRpcClientToGlobal,
+  setViteRpcServerToGlobal,
+  setViteServerContext,
+  setupDevToolsPlugin,
+  stringify2 as stringify,
+  toEdit,
+  toSubmit,
+  toggleClientConnected,
+  toggleComponentInspectorEnabled,
+  toggleHighPerfMode,
+  updateDevToolsClientDetected,
+  updateDevToolsState,
+  updateTimelineLayersState
+};

examples/nuxt3-websocket-client/node_modules/.cache/vite/client/deps/@vue_devtools-kit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

examples/nuxt3-websocket-client/node_modules/.cache/vite/client/deps/_metadata.json

@@ -0,0 +1,31 @@
+{
+  "hash": "f54ed532",
+  "configHash": "01f573b3",
+  "lockfileHash": "5d9967a9",
+  "browserHash": "5dc87c14",
+  "optimized": {
+    "errx": {
+      "src": "../../../../errx/dist/index.js",
+      "file": "errx.js",
+      "fileHash": "1b21f254",
+      "needsInterop": false
+    },
+    "@vue/devtools-core": {
+      "src": "../../../../@vue/devtools-core/dist/index.js",
+      "file": "@vue_devtools-core.js",
+      "fileHash": "3bb70a4f",
+      "needsInterop": false
+    },
+    "@vue/devtools-kit": {
+      "src": "../../../../@vue/devtools-kit/dist/index.js",
+      "file": "@vue_devtools-kit.js",
+      "fileHash": "a750d1f7",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-OT3Q6CPD": {
+      "file": "chunk-OT3Q6CPD.js"
+    }
+  }
+}

examples/nuxt3-websocket-client/node_modules/.cache/vite/client/deps/errx.js

@@ -0,0 +1,51 @@
+// node_modules/errx/dist/index.js
+var IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[a-z]:[/\\]/i;
+var LINE_RE = /^\s+at (?:(?<function>[^)]+) \()?(?<source>[^)]+)\)?$/u;
+var SOURCE_RE = /^(?<source>.+):(?<line>\d+):(?<column>\d+)$/u;
+function captureRawStackTrace() {
+  if (!Error.captureStackTrace) {
+    return;
+  }
+  const stack = new Error();
+  Error.captureStackTrace(stack);
+  return stack.stack;
+}
+function captureStackTrace() {
+  const stack = captureRawStackTrace();
+  return stack ? parseRawStackTrace(stack) : [];
+}
+function parseRawStackTrace(stacktrace) {
+  const trace = [];
+  for (const line of stacktrace.split("\n")) {
+    const parsed = LINE_RE.exec(line)?.groups;
+    if (!parsed) {
+      continue;
+    }
+    if (!parsed.source) {
+      continue;
+    }
+    const parsedSource = SOURCE_RE.exec(parsed.source)?.groups;
+    if (parsedSource) {
+      Object.assign(parsed, parsedSource);
+    }
+    if (IS_ABSOLUTE_RE.test(parsed.source)) {
+      parsed.source = `file://${parsed.source}`;
+    }
+    if (parsed.source === import.meta.url) {
+      continue;
+    }
+    for (const key of ["line", "column"]) {
+      if (parsed[key]) {
+        parsed[key] = Number(parsed[key]);
+      }
+    }
+    trace.push(parsed);
+  }
+  return trace;
+}
+export {
+  captureRawStackTrace,
+  captureStackTrace,
+  parseRawStackTrace
+};
+//# sourceMappingURL=errx.js.map

examples/nuxt3-websocket-client/node_modules/.cache/vite/client/deps/errx.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../errx/dist/index.js"],
+  "sourcesContent": ["const IS_ABSOLUTE_RE = /^[/\\\\](?![/\\\\])|^[/\\\\]{2}(?!\\.)|^[a-z]:[/\\\\]/i;\nconst LINE_RE = /^\\s+at (?:(?<function>[^)]+) \\()?(?<source>[^)]+)\\)?$/u;\nconst SOURCE_RE = /^(?<source>.+):(?<line>\\d+):(?<column>\\d+)$/u;\nfunction captureRawStackTrace() {\n  if (!Error.captureStackTrace) {\n    return;\n  }\n  const stack = new Error();\n  Error.captureStackTrace(stack);\n  return stack.stack;\n}\nfunction captureStackTrace() {\n  const stack = captureRawStackTrace();\n  return stack ? parseRawStackTrace(stack) : [];\n}\nfunction parseRawStackTrace(stacktrace) {\n  const trace = [];\n  for (const line of stacktrace.split(\"\\n\")) {\n    const parsed = LINE_RE.exec(line)?.groups;\n    if (!parsed) {\n      continue;\n    }\n    if (!parsed.source) {\n      continue;\n    }\n    const parsedSource = SOURCE_RE.exec(parsed.source)?.groups;\n    if (parsedSource) {\n      Object.assign(parsed, parsedSource);\n    }\n    if (IS_ABSOLUTE_RE.test(parsed.source)) {\n      parsed.source = `file://${parsed.source}`;\n    }\n    if (parsed.source === import.meta.url) {\n      continue;\n    }\n    for (const key of [\"line\", \"column\"]) {\n      if (parsed[key]) {\n        parsed[key] = Number(parsed[key]);\n      }\n    }\n    trace.push(parsed);\n  }\n  return trace;\n}\n\nexport { captureRawStackTrace, captureStackTrace, parseRawStackTrace };\n"],
+  "mappings": ";AAAA,IAAM,iBAAiB;AACvB,IAAM,UAAU;AAChB,IAAM,YAAY;AAClB,SAAS,uBAAuB;AAC9B,MAAI,CAAC,MAAM,mBAAmB;AAC5B;AAAA,EACF;AACA,QAAM,QAAQ,IAAI,MAAM;AACxB,QAAM,kBAAkB,KAAK;AAC7B,SAAO,MAAM;AACf;AACA,SAAS,oBAAoB;AAC3B,QAAM,QAAQ,qBAAqB;AACnC,SAAO,QAAQ,mBAAmB,KAAK,IAAI,CAAC;AAC9C;AACA,SAAS,mBAAmB,YAAY;AACtC,QAAM,QAAQ,CAAC;AACf,aAAW,QAAQ,WAAW,MAAM,IAAI,GAAG;AACzC,UAAM,SAAS,QAAQ,KAAK,IAAI,GAAG;AACnC,QAAI,CAAC,QAAQ;AACX;AAAA,IACF;AACA,QAAI,CAAC,OAAO,QAAQ;AAClB;AAAA,IACF;AACA,UAAM,eAAe,UAAU,KAAK,OAAO,MAAM,GAAG;AACpD,QAAI,cAAc;AAChB,aAAO,OAAO,QAAQ,YAAY;AAAA,IACpC;AACA,QAAI,eAAe,KAAK,OAAO,MAAM,GAAG;AACtC,aAAO,SAAS,UAAU,OAAO,MAAM;AAAA,IACzC;AACA,QAAI,OAAO,WAAW,YAAY,KAAK;AACrC;AAAA,IACF;AACA,eAAW,OAAO,CAAC,QAAQ,QAAQ,GAAG;AACpC,UAAI,OAAO,GAAG,GAAG;AACf,eAAO,GAAG,IAAI,OAAO,OAAO,GAAG,CAAC;AAAA,MAClC;AAAA,IACF;AACA,UAAM,KAAK,MAAM;AAAA,EACnB;AACA,SAAO;AACT;",
+  "names": []
+}

examples/nuxt3-websocket-client/node_modules/.cache/vite/client/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}