penambahan web socket

examples/nuxt3-websocket-client/node_modules/@parcel/watcher-wasm/index.cjs

@@ -0,0 +1,440 @@
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// wasm/import.meta.url-polyfill.js
+var import_meta_url;
+var init_import_meta_url_polyfill = __esm({
+  "wasm/import.meta.url-polyfill.js"() {
+    import_meta_url = typeof document === "undefined" ? new (require("url".replace("", ""))).URL("file:" + __filename).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+  }
+});
+
+// npm/wasm/wrapper.js
+var require_wrapper = __commonJS({
+  "npm/wasm/wrapper.js"(exports) {
+    init_import_meta_url_polyfill();
+    var path = require("path");
+    var micromatch = require("micromatch");
+    var isGlob = require("is-glob");
+    function normalizeOptions(dir, opts = {}) {
+      const { ignore, ...rest } = opts;
+      if (Array.isArray(ignore)) {
+        opts = { ...rest };
+        for (const value of ignore) {
+          if (isGlob(value)) {
+            if (!opts.ignoreGlobs) {
+              opts.ignoreGlobs = [];
+            }
+            const regex = micromatch.makeRe(value, {
+              // We set `dot: true` to workaround an issue with the
+              // regular expression on Linux where the resulting
+              // negative lookahead `(?!(\\/|^)` was never matching
+              // in some cases. See also https://bit.ly/3UZlQDm
+              dot: true,
+              // C++ does not support lookbehind regex patterns, they
+              // were only added later to JavaScript engines
+              // (https://bit.ly/3V7S6UL)
+              lookbehinds: false
+            });
+            opts.ignoreGlobs.push(regex.source);
+          } else {
+            if (!opts.ignorePaths) {
+              opts.ignorePaths = [];
+            }
+            opts.ignorePaths.push(path.resolve(dir, value));
+          }
+        }
+      }
+      return opts;
+    }
+    exports.createWrapper = (binding) => {
+      return {
+        writeSnapshot(dir, snapshot, opts) {
+          return binding.writeSnapshot(
+            path.resolve(dir),
+            path.resolve(snapshot),
+            normalizeOptions(dir, opts)
+          );
+        },
+        getEventsSince(dir, snapshot, opts) {
+          return binding.getEventsSince(
+            path.resolve(dir),
+            path.resolve(snapshot),
+            normalizeOptions(dir, opts)
+          );
+        },
+        async subscribe(dir, fn, opts) {
+          dir = path.resolve(dir);
+          opts = normalizeOptions(dir, opts);
+          await binding.subscribe(dir, fn, opts);
+          return {
+            unsubscribe() {
+              return binding.unsubscribe(dir, fn, opts);
+            }
+          };
+        },
+        unsubscribe(dir, fn, opts) {
+          return binding.unsubscribe(
+            path.resolve(dir),
+            fn,
+            normalizeOptions(dir, opts)
+          );
+        }
+      };
+    };
+  }
+});
+
+// npm/wasm/index.mjs
+var wasm_exports = {};
+__export(wasm_exports, {
+  getEventsSince: () => getEventsSince,
+  subscribe: () => subscribe,
+  unsubscribe: () => unsubscribe,
+  writeSnapshot: () => writeSnapshot
+});
+module.exports = __toCommonJS(wasm_exports);
+init_import_meta_url_polyfill();
+var import_napi_wasm = require("napi-wasm");
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_wrapper = __toESM(require_wrapper(), 1);
+var env;
+var encoder = new TextEncoder();
+var constants = {
+  O_ACCMODE: 3,
+  O_RDONLY: 0,
+  O_WRONLY: 1,
+  O_RDWR: 2,
+  O_CREAT: 64,
+  O_EXCL: 128,
+  O_NOCTTY: 256,
+  O_TRUNC: 512,
+  O_APPEND: 1024,
+  O_NONBLOCK: 2048,
+  O_SYNC: 4096,
+  FASYNC: 8192,
+  O_DIRECT: 16384,
+  O_LARGEFILE: 32768,
+  O_DIRECTORY: 65536,
+  O_NOFOLLOW: 131072,
+  O_NOATIME: 262144,
+  O_CLOEXEC: 524288
+};
+import_napi_wasm.napi.napi_get_last_error_info = () => {
+};
+var fds = /* @__PURE__ */ new Map();
+var dirs = /* @__PURE__ */ new Map();
+var regexCache = /* @__PURE__ */ new Map();
+var watches = [null];
+var wasm_env = {
+  __syscall_newfstatat(dirfd, path, buf, flags) {
+    let dir = dirfd === -100 ? process.cwd() : fds.get(dirfd).path;
+    let p = import_path.default.resolve(dir, env.getString(path));
+    let nofollow = flags & 256;
+    try {
+      let stat = nofollow ? import_fs.default.lstatSync(p, { bigint: true }) : import_fs.default.statSync(p, { bigint: true });
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_lstat64(path, buf) {
+    let p = env.getString(path);
+    try {
+      let stat = import_fs.default.lstatSync(p, { bigint: true });
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_fstat64(fd, buf) {
+    try {
+      let stat = import_fs.default.fstatSync(fd, { bigint: true });
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_stat64(path, buf) {
+    let p = env.getString(path);
+    try {
+      let stat = import_fs.default.statSync(p, { bigint: true });
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_getdents64(fd, dirp, count) {
+    let p = fds.get(fd).path;
+    let dir = dirs.get(fd);
+    let entries = dir?.entries;
+    if (!entries) {
+      try {
+        entries = import_fs.default.readdirSync(p, { withFileTypes: true });
+      } catch (err) {
+        env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+        return -1;
+      }
+    }
+    let start = dirp;
+    let i = dir?.index || 0;
+    for (; i < entries.length; i++) {
+      let entry = entries[i];
+      let type = entry.isFIFO() ? 1 : entry.isCharacterDevice() ? 2 : entry.isDirectory() ? 4 : entry.isBlockDevice() ? 6 : entry.isFile() ? 8 : entry.isSymbolicLink() ? 10 : entry.isSocket() ? 12 : 0;
+      let len = align(utf8Length(entry.name) + 20, 8);
+      if (dirp - start + len > count) {
+        break;
+      }
+      env.u64[dirp >> 3] = 1n;
+      env.u64[dirp + 8 >> 3] = BigInt(dirp - start + len);
+      env.u16[dirp + 16 >> 1] = len;
+      env.memory[dirp + 18] = type;
+      let { written } = encoder.encodeInto(entry.name, env.memory.subarray(dirp + 19));
+      env.memory[dirp + 19 + written] = 0;
+      dirp += len;
+    }
+    dirs.set(fd, { index: i, entries });
+    return dirp - start;
+  },
+  __syscall_openat(dirfd, path, flags, mode) {
+    let f = 0;
+    for (let c in constants) {
+      if (flags & constants[c]) {
+        f |= import_fs.default.constants[c] || 0;
+      }
+    }
+    let dir = dirfd === -100 ? process.cwd() : fds.get(dirfd)?.path;
+    if (!dir) {
+      env.i32[env.instance.exports.__errno_location >> 2] = 9970;
+      return -1;
+    }
+    let p = import_path.default.resolve(dir, env.getString(path));
+    try {
+      let fd = import_fs.default.openSync(p, f);
+      fds.set(fd, { path: p, flags });
+      return fd;
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_fcntl64(fd, cmd) {
+    switch (cmd) {
+      case 3:
+        return fds.get(fd).flags;
+      case 2:
+        return 0;
+      default:
+        throw new Error("Unknown fcntl64 call: " + cmd);
+    }
+  },
+  __syscall_ioctl() {
+  },
+  emscripten_resize_heap() {
+    return 0;
+  },
+  _abort_js() {
+  },
+  wasm_backend_add_watch(filename, backend) {
+    let path = env.getString(filename);
+    let watch = import_fs.default.watch(path, { encoding: "buffer" }, (eventType, filename2) => {
+      if (filename2) {
+        let type = eventType === "change" ? 1 : 2;
+        let fptr = env.instance.exports.malloc(filename2.byteLength + 1);
+        env.memory.set(filename2, fptr);
+        env.memory[fptr + filename2.byteLength] = 0;
+        env.instance.exports.wasm_backend_event_handler(backend, wd, type, fptr);
+        env.instance.exports.free(fptr);
+      }
+    });
+    let wd = watches.length;
+    watches.push(watch);
+    return wd;
+  },
+  wasm_backend_remove_watch(wd) {
+    watches[wd].close();
+    watches[wd] = void 0;
+  },
+  set_timeout(ms, ctx) {
+    return setTimeout(() => {
+      env.instance.exports.on_timeout(ctx);
+    }, ms);
+  },
+  clear_timeout(t) {
+    clearTimeout(t);
+  },
+  _setitimer_js() {
+  },
+  emscripten_date_now() {
+    return Date.now();
+  },
+  _emscripten_get_now_is_monotonic() {
+    return true;
+  },
+  _emscripten_runtime_keepalive_clear() {
+  },
+  emscripten_get_now() {
+    return performance.now();
+  },
+  wasm_regex_match(string, regex) {
+    let re = regexCache.get(regex);
+    if (!re) {
+      re = new RegExp(env.getString(regex));
+      regexCache.set(regex, re);
+    }
+    return re.test(env.getString(string)) ? 1 : 0;
+  }
+};
+var wasi = {
+  fd_close(fd) {
+    import_fs.default.closeSync(fd);
+    fds.delete(fd);
+    dirs.delete(fd);
+    return 0;
+  },
+  fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+    return 0;
+  },
+  fd_write(fd, iov, iovcnt, pnum) {
+    let buffers = [];
+    for (let i = 0; i < iovcnt; i++) {
+      let ptr = env.u32[iov >> 2];
+      let len = env.u32[iov + 4 >> 2];
+      iov += 8;
+      if (len > 0) {
+        buffers.push(env.memory.subarray(ptr, ptr + len));
+      }
+    }
+    let wrote = import_fs.default.writevSync(fd, buffers);
+    env.u32[pnum >> 2] = wrote;
+    return 0;
+  },
+  fd_read(fd, iov, iovcnt, pnum) {
+    let buffers = [];
+    for (let i = 0; i < iovcnt; i++) {
+      let ptr = env.u32[iov >> 2];
+      let len = env.u32[iov + 4 >> 2];
+      iov += 8;
+      if (len > 0) {
+        buffers.push(env.memory.subarray(ptr, ptr + len));
+      }
+    }
+    let read = import_fs.default.readvSync(fd, buffers);
+    env.u32[pnum >> 2] = read;
+    return 0;
+  },
+  proc_exit() {
+  },
+  clock_time_get() {
+  }
+};
+function writeStat(stat, buf) {
+  env.i32[buf >> 2] = Number(stat.dev);
+  env.i32[buf + 4 >> 2] = Number(stat.mode);
+  env.u32[buf + 8 >> 2] = Number(stat.nlink);
+  env.i32[buf + 12 >> 2] = Number(stat.uid);
+  env.i32[buf + 16 >> 2] = Number(stat.gid);
+  env.i32[buf + 20 >> 2] = Number(stat.rdev);
+  env.u64[buf + 24 >> 3] = stat.size;
+  env.i32[buf + 32 >> 2] = Number(stat.blksize);
+  env.i32[buf + 36 >> 2] = Number(stat.blocks);
+  env.u64[buf + 40 >> 3] = stat.atimeMs;
+  env.u32[buf + 48 >> 2] = Number(stat.atimeNs);
+  env.u64[buf + 56 >> 3] = stat.mtimeMs;
+  env.u32[buf + 64 >> 2] = Number(stat.mtimeNs);
+  env.u64[buf + 72 >> 3] = stat.ctimeMs;
+  env.u32[buf + 80 >> 2] = Number(stat.ctimeNs);
+  env.u64[buf + 88 >> 3] = stat.ino;
+  return 0;
+}
+function utf8Length(string) {
+  let len = 0;
+  for (let i = 0; i < string.length; i++) {
+    let c = string.charCodeAt(i);
+    if (c >= 55296 && c <= 56319 && i < string.length - 1) {
+      let c2 = string.charCodeAt(++i);
+      if ((c2 & 64512) === 56320) {
+        c = ((c & 1023) << 10) + (c2 & 1023) + 65536;
+      } else {
+        i--;
+      }
+    }
+    if ((c & 4294967168) === 0) {
+      len++;
+    } else if ((c & 4294965248) === 0) {
+      len += 2;
+    } else if ((c & 4294901760) === 0) {
+      len += 3;
+    } else if ((c & 4292870144) === 0) {
+      len += 4;
+    }
+  }
+  return len;
+}
+function align(len, p) {
+  return Math.ceil(len / p) * p;
+}
+var wasmBytes = import_fs.default.readFileSync(new URL("watcher.wasm", import_meta_url));
+var wasmModule = new WebAssembly.Module(wasmBytes);
+var instance = new WebAssembly.Instance(wasmModule, {
+  napi: import_napi_wasm.napi,
+  env: wasm_env,
+  wasi_snapshot_preview1: wasi
+});
+env = new import_napi_wasm.Environment(instance);
+var wrapper = (0, import_wrapper.createWrapper)(env.exports);
+function writeSnapshot(dir, snapshot, opts) {
+  return wrapper.writeSnapshot(dir, snapshot, opts);
+}
+function getEventsSince(dir, snapshot, opts) {
+  return wrapper.getEventsSince(dir, snapshot, opts);
+}
+function subscribe(dir, fn, opts) {
+  return wrapper.subscribe(dir, fn, opts);
+}
+function unsubscribe(dir, fn, opts) {
+  return wrapper.unsubscribe(dir, fn, opts);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEventsSince,
+  subscribe,
+  unsubscribe,
+  writeSnapshot
+});