reg-cli 0.0.0-experimental-wasm0

package/dist/cli.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const index = require('./index.cjs');
+require('node:events');
+require('node:worker_threads');
+require('./shared/reg-cli.566a78e6.cjs');
+require('path');
+require('url');
+require('node:fs/promises');
+require('node:path');
+
+const emitter = index.run(process.argv.slice(2));
+emitter.on("complete", (data) => {
+  console.log(data);
+});

package/dist/cli.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.mjs

@@ -0,0 +1,13 @@
+import { run } from './index.mjs';
+import 'node:events';
+import 'node:worker_threads';
+import './shared/reg-cli.2f9d9b15.mjs';
+import 'path';
+import 'url';
+import 'node:fs/promises';
+import 'node:path';
+
+const emitter = run(process.argv.slice(2));
+emitter.on("complete", (data) => {
+  console.log(data);
+});

package/dist/entry.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+const fs = require('node:fs');
+const wasmUtil = require('@tybys/wasm-util');
+const node_process = require('node:process');
+const node_worker_threads = require('node:worker_threads');
+const utils = require('./shared/reg-cli.566a78e6.cjs');
+require('path');
+require('url');
+require('node:fs/promises');
+require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+const wasi = new wasmUtil.WASI({
+  version: "preview1",
+  args: node_worker_threads.workerData.argv,
+  env: node_process.env,
+  returnOnExit: true,
+  preopens: { "./": "./" },
+  fs: fs__default
+});
+const imports = wasi.getImportObject();
+const file = utils.readWasm();
+(async () => {
+  try {
+    const wasm = await WebAssembly.compile(await file);
+    const opts = { initial: 256, maximum: 16384, shared: true };
+    const memory = new WebAssembly.Memory(opts);
+    let instance = await WebAssembly.instantiate(wasm, {
+      ...imports,
+      wasi: {
+        "thread-spawn": (startArg) => {
+          const threadIdBuffer = new SharedArrayBuffer(4);
+          const id = new Int32Array(threadIdBuffer);
+          Atomics.store(id, 0, -1);
+          node_worker_threads.parentPort?.postMessage({
+            cmd: "thread-spawn",
+            startArg,
+            threadId: id,
+            memory
+          });
+          Atomics.wait(id, 0, -1);
+          const tid = Atomics.load(id, 0);
+          return tid;
+        }
+      },
+      env: { memory }
+    });
+    wasi.start(instance);
+    const m = instance.exports.wasm_main();
+    const view = new DataView(memory.buffer, m);
+    const len = view.getUint32(0, true);
+    const bufPtr = view.getUint32(4, true);
+    const stringData = new Uint8Array(memory.buffer, bufPtr, len);
+    const decoder = new TextDecoder("utf-8");
+    const string = decoder.decode(stringData);
+    instance.exports.free_wasm_output(m);
+    const report = JSON.parse(string);
+    console.log(report);
+    node_worker_threads.parentPort?.postMessage({ cmd: "complete", data: report });
+  } catch (e) {
+    throw e;
+  }
+})();

package/dist/entry.d.cts

@@ -0,0 +1,14 @@
+type CompareOutput = {
+    failedItems: string[];
+    newItems: string[];
+    deletedItems: string[];
+    passedItems: string[];
+    expectedItems: string[];
+    actualItems: string[];
+    diffItems: string[];
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+};
+
+export type { CompareOutput };

package/dist/entry.d.mts

@@ -0,0 +1,14 @@
+type CompareOutput = {
+    failedItems: string[];
+    newItems: string[];
+    deletedItems: string[];
+    passedItems: string[];
+    expectedItems: string[];
+    actualItems: string[];
+    diffItems: string[];
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+};
+
+export type { CompareOutput };

package/dist/entry.d.ts

@@ -0,0 +1,14 @@
+type CompareOutput = {
+    failedItems: string[];
+    newItems: string[];
+    deletedItems: string[];
+    passedItems: string[];
+    expectedItems: string[];
+    actualItems: string[];
+    diffItems: string[];
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+};
+
+export type { CompareOutput };

package/dist/entry.mjs

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import { WASI } from '@tybys/wasm-util';
+import { env } from 'node:process';
+import { workerData, parentPort } from 'node:worker_threads';
+import { a as readWasm } from './shared/reg-cli.2f9d9b15.mjs';
+import 'path';
+import 'url';
+import 'node:fs/promises';
+import 'node:path';
+
+const wasi = new WASI({
+  version: "preview1",
+  args: workerData.argv,
+  env,
+  returnOnExit: true,
+  preopens: { "./": "./" },
+  fs
+});
+const imports = wasi.getImportObject();
+const file = readWasm();
+(async () => {
+  try {
+    const wasm = await WebAssembly.compile(await file);
+    const opts = { initial: 256, maximum: 16384, shared: true };
+    const memory = new WebAssembly.Memory(opts);
+    let instance = await WebAssembly.instantiate(wasm, {
+      ...imports,
+      wasi: {
+        "thread-spawn": (startArg) => {
+          const threadIdBuffer = new SharedArrayBuffer(4);
+          const id = new Int32Array(threadIdBuffer);
+          Atomics.store(id, 0, -1);
+          parentPort?.postMessage({
+            cmd: "thread-spawn",
+            startArg,
+            threadId: id,
+            memory
+          });
+          Atomics.wait(id, 0, -1);
+          const tid = Atomics.load(id, 0);
+          return tid;
+        }
+      },
+      env: { memory }
+    });
+    wasi.start(instance);
+    const m = instance.exports.wasm_main();
+    const view = new DataView(memory.buffer, m);
+    const len = view.getUint32(0, true);
+    const bufPtr = view.getUint32(4, true);
+    const stringData = new Uint8Array(memory.buffer, bufPtr, len);
+    const decoder = new TextDecoder("utf-8");
+    const string = decoder.decode(stringData);
+    instance.exports.free_wasm_output(m);
+    const report = JSON.parse(string);
+    console.log(report);
+    parentPort?.postMessage({ cmd: "complete", data: report });
+  } catch (e) {
+    throw e;
+  }
+})();

package/dist/index.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+const EventEmitter = require('node:events');
+const node_worker_threads = require('node:worker_threads');
+const utils = require('./shared/reg-cli.566a78e6.cjs');
+require('path');
+require('url');
+require('node:fs/promises');
+require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const EventEmitter__default = /*#__PURE__*/_interopDefaultCompat(EventEmitter);
+
+const run = (argv) => {
+  const emitter = new EventEmitter__default();
+  const worker = new node_worker_threads.Worker(`./entry.${utils.resolveExtention()}`, { workerData: { argv } });
+  let nextTid = 1;
+  const workers = [worker];
+  const spawn = (startArg, threadId, memory) => {
+    const worker2 = new node_worker_threads.Worker(`./worker.${utils.resolveExtention()}`);
+    workers.push(worker2);
+    worker2.on("message", ({ cmd, startArg: startArg2, threadId: threadId2, memory: memory2 }) => {
+      if (cmd === "loaded") {
+        if (typeof worker2.unref === "function") {
+          worker2.unref();
+        }
+      } else if (cmd === "thread-spawn") {
+        spawn(startArg2, threadId2, memory2);
+      }
+    });
+    worker2.on("error", (e) => {
+      workers.forEach((w) => w.terminate());
+      throw new Error(e.message);
+    });
+    const tid = nextTid++;
+    if (threadId) {
+      Atomics.store(threadId, 0, tid);
+      Atomics.notify(threadId, 0);
+    }
+    worker2.postMessage({ startArg, tid, memory });
+    return tid;
+  };
+  worker.on("message", ({ cmd, startArg, threadId, memory, data }) => {
+    if (cmd === "complete") {
+      workers.forEach((w) => w.terminate());
+      emitter.emit("complete", data);
+    }
+    if (cmd === "loaded") {
+      if (typeof worker.unref === "function") {
+        worker.unref();
+      }
+      return;
+    }
+    if (cmd === "thread-spawn") {
+      spawn(startArg, threadId, memory);
+    }
+  });
+  worker.on("error", (err) => {
+    workers.forEach((w) => w.terminate());
+    throw new Error(err.message);
+  });
+  return emitter;
+};
+const compare = (input) => {
+  const args = Object.entries(input).flatMap(([k, v]) => [k, String(v)]);
+  return run(args);
+};
+
+exports.compare = compare;
+exports.run = run;

package/dist/index.d.cts

@@ -0,0 +1,36 @@
+import EventEmitter from 'node:events';
+
+declare const run: (argv: string[]) => EventEmitter;
+type CompareInput = {
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+    report?: string;
+    junitReport?: string;
+    json?: string;
+    update?: boolean;
+    extendedErrors?: boolean;
+    urlPrefix?: string;
+    matchingThreshold?: number;
+    threshold?: number;
+    thresholdRate?: number;
+    thresholdPixel?: number;
+    concurrency?: number;
+    enableAntialias?: boolean;
+    enableClientAdditionalDetection?: boolean;
+};
+type CompareOutput = {
+    failedItems: string[];
+    newItems: string[];
+    deletedItems: string[];
+    passedItems: string[];
+    expectedItems: string[];
+    actualItems: string[];
+    diffItems: string[];
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+};
+declare const compare: (input: CompareInput) => EventEmitter;
+
+export { type CompareInput, type CompareOutput, compare, run };

package/dist/index.d.mts

@@ -0,0 +1,36 @@
+import EventEmitter from 'node:events';
+
+declare const run: (argv: string[]) => EventEmitter;
+type CompareInput = {
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+    report?: string;
+    junitReport?: string;
+    json?: string;
+    update?: boolean;
+    extendedErrors?: boolean;
+    urlPrefix?: string;
+    matchingThreshold?: number;
+    threshold?: number;
+    thresholdRate?: number;
+    thresholdPixel?: number;
+    concurrency?: number;
+    enableAntialias?: boolean;
+    enableClientAdditionalDetection?: boolean;
+};
+type CompareOutput = {
+    failedItems: string[];
+    newItems: string[];
+    deletedItems: string[];
+    passedItems: string[];
+    expectedItems: string[];
+    actualItems: string[];
+    diffItems: string[];
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+};
+declare const compare: (input: CompareInput) => EventEmitter;
+
+export { type CompareInput, type CompareOutput, compare, run };

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import EventEmitter from 'node:events';
+
+declare const run: (argv: string[]) => EventEmitter;
+type CompareInput = {
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+    report?: string;
+    junitReport?: string;
+    json?: string;
+    update?: boolean;
+    extendedErrors?: boolean;
+    urlPrefix?: string;
+    matchingThreshold?: number;
+    threshold?: number;
+    thresholdRate?: number;
+    thresholdPixel?: number;
+    concurrency?: number;
+    enableAntialias?: boolean;
+    enableClientAdditionalDetection?: boolean;
+};
+type CompareOutput = {
+    failedItems: string[];
+    newItems: string[];
+    deletedItems: string[];
+    passedItems: string[];
+    expectedItems: string[];
+    actualItems: string[];
+    diffItems: string[];
+    actualDir: string;
+    expectedDir: string;
+    diffDir: string;
+};
+declare const compare: (input: CompareInput) => EventEmitter;
+
+export { type CompareInput, type CompareOutput, compare, run };

package/dist/index.mjs

@@ -0,0 +1,64 @@
+import EventEmitter from 'node:events';
+import { Worker } from 'node:worker_threads';
+import { r as resolveExtention } from './shared/reg-cli.2f9d9b15.mjs';
+import 'path';
+import 'url';
+import 'node:fs/promises';
+import 'node:path';
+
+const run = (argv) => {
+  const emitter = new EventEmitter();
+  const worker = new Worker(`./entry.${resolveExtention()}`, { workerData: { argv } });
+  let nextTid = 1;
+  const workers = [worker];
+  const spawn = (startArg, threadId, memory) => {
+    const worker2 = new Worker(`./worker.${resolveExtention()}`);
+    workers.push(worker2);
+    worker2.on("message", ({ cmd, startArg: startArg2, threadId: threadId2, memory: memory2 }) => {
+      if (cmd === "loaded") {
+        if (typeof worker2.unref === "function") {
+          worker2.unref();
+        }
+      } else if (cmd === "thread-spawn") {
+        spawn(startArg2, threadId2, memory2);
+      }
+    });
+    worker2.on("error", (e) => {
+      workers.forEach((w) => w.terminate());
+      throw new Error(e.message);
+    });
+    const tid = nextTid++;
+    if (threadId) {
+      Atomics.store(threadId, 0, tid);
+      Atomics.notify(threadId, 0);
+    }
+    worker2.postMessage({ startArg, tid, memory });
+    return tid;
+  };
+  worker.on("message", ({ cmd, startArg, threadId, memory, data }) => {
+    if (cmd === "complete") {
+      workers.forEach((w) => w.terminate());
+      emitter.emit("complete", data);
+    }
+    if (cmd === "loaded") {
+      if (typeof worker.unref === "function") {
+        worker.unref();
+      }
+      return;
+    }
+    if (cmd === "thread-spawn") {
+      spawn(startArg, threadId, memory);
+    }
+  });
+  worker.on("error", (err) => {
+    workers.forEach((w) => w.terminate());
+    throw new Error(err.message);
+  });
+  return emitter;
+};
+const compare = (input) => {
+  const args = Object.entries(input).flatMap(([k, v]) => [k, String(v)]);
+  return run(args);
+};
+
+export { compare, run };

package/dist/shared/reg-cli.2f9d9b15.mjs

@@ -0,0 +1,16 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const isESM = typeof import.meta !== "undefined";
+const readWasm = () => {
+  const dir = isESM ? path.dirname(fileURLToPath(import.meta.url)) : __dirname;
+  const file = readFile(join(dir, "./reg.wasm"));
+  return file;
+};
+const resolveExtention = () => {
+  return isESM ? "mjs" : "cjs";
+};
+
+export { readWasm as a, resolveExtention as r };

package/dist/shared/reg-cli.566a78e6.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const path = require('path');
+const url = require('url');
+const promises = require('node:fs/promises');
+const node_path = require('node:path');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+const isESM = typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/reg-cli.566a78e6.cjs', document.baseURI).href)) }) !== "undefined";
+const readWasm = () => {
+  const dir = isESM ? path__default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/reg-cli.566a78e6.cjs', document.baseURI).href)))) : __dirname;
+  const file = promises.readFile(node_path.join(dir, "./reg.wasm"));
+  return file;
+};
+const resolveExtention = () => {
+  return isESM ? "mjs" : "cjs";
+};
+
+exports.readWasm = readWasm;
+exports.resolveExtention = resolveExtention;

package/dist/worker.cjs

@@ -0,0 +1,119 @@
+'use strict';
+
+const node_worker_threads = require('node:worker_threads');
+const fs = require('node:fs');
+const wasmUtil = require('@tybys/wasm-util');
+const node_process = require('node:process');
+const utils = require('./shared/reg-cli.566a78e6.cjs');
+require('path');
+require('url');
+require('node:fs/promises');
+require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+const kIsProxy = Symbol("kIsProxy");
+const createInstanceProxy = (instance, memory) => {
+  if (instance[kIsProxy])
+    return instance;
+  const originalExports = instance.exports;
+  const createHandler = function(target) {
+    const handlers = [
+      "apply",
+      "construct",
+      "defineProperty",
+      "deleteProperty",
+      "get",
+      "getOwnPropertyDescriptor",
+      "getPrototypeOf",
+      "has",
+      "isExtensible",
+      "ownKeys",
+      "preventExtensions",
+      "set",
+      "setPrototypeOf"
+    ];
+    const handler2 = {};
+    for (let i = 0; i < handlers.length; i++) {
+      const name = handlers[i];
+      handler2[name] = function() {
+        const args = Array.prototype.slice.call(arguments, 1);
+        args.unshift(target);
+        return Reflect[name].apply(Reflect, args);
+      };
+    }
+    return handler2;
+  };
+  const handler = createHandler(originalExports);
+  const _initialize = () => {
+  };
+  const _start = () => 0;
+  handler.get = function(_target, p, receiver) {
+    if (p === "memory") {
+      return (typeof memory === "function" ? memory() : memory) ?? Reflect.get(originalExports, p, receiver);
+    }
+    if (p === "_initialize") {
+      return p in originalExports ? _initialize : void 0;
+    }
+    if (p === "_start") {
+      return p in originalExports ? _start : void 0;
+    }
+    return Reflect.get(originalExports, p, receiver);
+  };
+  handler.has = function(_target, p) {
+    if (p === "memory")
+      return true;
+    return Reflect.has(originalExports, p);
+  };
+  const exportsProxy = new Proxy(/* @__PURE__ */ Object.create(null), handler);
+  return new Proxy(instance, {
+    get(target, p, receiver) {
+      if (p === "exports") {
+        return exportsProxy;
+      }
+      if (p === kIsProxy) {
+        return true;
+      }
+      return Reflect.get(target, p, receiver);
+    }
+  });
+};
+
+const wasi = new wasmUtil.WASI({
+  version: "preview1",
+  args: node_process.argv,
+  env: node_process.env,
+  returnOnExit: true,
+  preopens: { "./": "./" },
+  fs: fs__default
+});
+const imports = wasi.getImportObject();
+const file = utils.readWasm();
+const handler = async ({ startArg, tid, memory }) => {
+  try {
+    const wasm = await WebAssembly.compile(await file);
+    let instance = await WebAssembly.instantiate(wasm, {
+      ...imports,
+      wasi: {
+        "thread-spawn": (startArg2) => {
+          const threadIdBuffer = new SharedArrayBuffer(4);
+          const id = new Int32Array(threadIdBuffer);
+          Atomics.store(id, 0, -1);
+          postMessage({ cmd: "thread-spawn", startArg: startArg2, threadId: id, memory });
+          Atomics.wait(id, 0, -1);
+          const tid2 = Atomics.load(id, 0);
+          return tid2;
+        }
+      },
+      env: { memory }
+    });
+    instance = createInstanceProxy(instance, memory);
+    wasi.start(instance);
+    instance.exports.wasi_thread_start(tid, startArg);
+  } catch (e) {
+    throw e;
+  }
+};
+node_worker_threads.parentPort?.addListener("message", handler);

package/dist/worker.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/worker.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/worker.mjs

@@ -0,0 +1,113 @@
+import { parentPort } from 'node:worker_threads';
+import fs from 'node:fs';
+import { WASI } from '@tybys/wasm-util';
+import { argv, env } from 'node:process';
+import { a as readWasm } from './shared/reg-cli.2f9d9b15.mjs';
+import 'path';
+import 'url';
+import 'node:fs/promises';
+import 'node:path';
+
+const kIsProxy = Symbol("kIsProxy");
+const createInstanceProxy = (instance, memory) => {
+  if (instance[kIsProxy])
+    return instance;
+  const originalExports = instance.exports;
+  const createHandler = function(target) {
+    const handlers = [
+      "apply",
+      "construct",
+      "defineProperty",
+      "deleteProperty",
+      "get",
+      "getOwnPropertyDescriptor",
+      "getPrototypeOf",
+      "has",
+      "isExtensible",
+      "ownKeys",
+      "preventExtensions",
+      "set",
+      "setPrototypeOf"
+    ];
+    const handler2 = {};
+    for (let i = 0; i < handlers.length; i++) {
+      const name = handlers[i];
+      handler2[name] = function() {
+        const args = Array.prototype.slice.call(arguments, 1);
+        args.unshift(target);
+        return Reflect[name].apply(Reflect, args);
+      };
+    }
+    return handler2;
+  };
+  const handler = createHandler(originalExports);
+  const _initialize = () => {
+  };
+  const _start = () => 0;
+  handler.get = function(_target, p, receiver) {
+    if (p === "memory") {
+      return (typeof memory === "function" ? memory() : memory) ?? Reflect.get(originalExports, p, receiver);
+    }
+    if (p === "_initialize") {
+      return p in originalExports ? _initialize : void 0;
+    }
+    if (p === "_start") {
+      return p in originalExports ? _start : void 0;
+    }
+    return Reflect.get(originalExports, p, receiver);
+  };
+  handler.has = function(_target, p) {
+    if (p === "memory")
+      return true;
+    return Reflect.has(originalExports, p);
+  };
+  const exportsProxy = new Proxy(/* @__PURE__ */ Object.create(null), handler);
+  return new Proxy(instance, {
+    get(target, p, receiver) {
+      if (p === "exports") {
+        return exportsProxy;
+      }
+      if (p === kIsProxy) {
+        return true;
+      }
+      return Reflect.get(target, p, receiver);
+    }
+  });
+};
+
+const wasi = new WASI({
+  version: "preview1",
+  args: argv,
+  env,
+  returnOnExit: true,
+  preopens: { "./": "./" },
+  fs
+});
+const imports = wasi.getImportObject();
+const file = readWasm();
+const handler = async ({ startArg, tid, memory }) => {
+  try {
+    const wasm = await WebAssembly.compile(await file);
+    let instance = await WebAssembly.instantiate(wasm, {
+      ...imports,
+      wasi: {
+        "thread-spawn": (startArg2) => {
+          const threadIdBuffer = new SharedArrayBuffer(4);
+          const id = new Int32Array(threadIdBuffer);
+          Atomics.store(id, 0, -1);
+          postMessage({ cmd: "thread-spawn", startArg: startArg2, threadId: id, memory });
+          Atomics.wait(id, 0, -1);
+          const tid2 = Atomics.load(id, 0);
+          return tid2;
+        }
+      },
+      env: { memory }
+    });
+    instance = createInstanceProxy(instance, memory);
+    wasi.start(instance);
+    instance.exports.wasi_thread_start(tid, startArg);
+  } catch (e) {
+    throw e;
+  }
+};
+parentPort?.addListener("message", handler);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "reg-cli",
+  "version": "0.0.0-experimental-wasm0",
+  "description": "",
+  "type": "module",
+  "start": "node ./dist/cli.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "reg-cli": "./dist/cli.mjs"
+  },
+  "scripts": {
+    "build": "unbuild && cp reg.wasm ./dist/shared/reg.wasm"
+  },
+  "keywords": [],
+  "author": "bokuweb",
+  "license": "MIT",
+  "dependencies": {
+    "@tybys/wasm-util": "^0.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.5",
+    "unbuild": "^2.0.0"
+  }
+}