@mustrd/core 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,293 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  INTERNAL_KEYS: () => INTERNAL_KEYS,
+  ITERATORS: () => ITERATORS,
+  MUTATORS: () => MUTATORS,
+  buildNested: () => buildNested,
+  createMustard: () => createMustard,
+  getAtPath: () => getAtPath,
+  record: () => record,
+  setPathValue: () => setPathValue,
+  squeeze: () => squeeze,
+  unwrap: () => unwrap
+});
+module.exports = __toCommonJS(index_exports);
+var MUTATORS = /* @__PURE__ */ new Set(["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin"]);
+var ITERATORS = /* @__PURE__ */ new Set(["forEach", "map", "filter", "find", "findIndex", "some", "every", "reduce", "reduceRight", "flatMap"]);
+var INTERNAL_KEYS = /* @__PURE__ */ new Set(["_MST_STORE_", "_MST_SOURCE_", "_MST_RECORD_", "$", "reset"]);
+var unwrap = (obj) => {
+  if (obj != null && typeof obj === "object") {
+    const source = obj._MST_SOURCE_;
+    if (source !== void 0) return source;
+  }
+  return obj;
+};
+var record = (obj) => obj._MST_RECORD_;
+var squeeze = (obj) => {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) {
+    const arr = [...obj];
+    for (let i = 0, len = arr.length; i < len; i++) {
+      if (typeof arr[i] === "object" && arr[i] !== null) arr[i] = squeeze(arr[i]);
+    }
+    return arr;
+  }
+  const copy = { ...obj };
+  const keys = Object.keys(copy);
+  for (let i = 0, len = keys.length; i < len; i++) {
+    if (typeof copy[keys[i]] === "object" && copy[keys[i]] !== null) copy[keys[i]] = squeeze(copy[keys[i]]);
+  }
+  return copy;
+};
+var setPathValue = (curr, path, callback, depth = 0) => {
+  if (depth === path.length) {
+    const next2 = Array.isArray(curr) ? [...curr] : { ...curr };
+    const result = callback(next2);
+    return result !== void 0 ? result : next2;
+  }
+  const key = path[depth];
+  const next = Array.isArray(curr) ? [...curr] : { ...curr };
+  next[key] = setPathValue(curr[key], path, callback, depth + 1);
+  return next;
+};
+var getAtPath = (state, path) => {
+  let current = state;
+  for (let i = 0; i < path.length; i++) {
+    if (current == null) return void 0;
+    current = current[path[i]];
+  }
+  return current;
+};
+var buildNested = (entries) => {
+  const result = {};
+  for (const entry of entries) {
+    const segs = entry.path.split(".");
+    let current = result;
+    for (let i = 0; i < segs.length - 1; i++) {
+      if (current[segs[i]] == null) current[segs[i]] = {};
+      current = current[segs[i]];
+    }
+    current[segs[segs.length - 1]] = entry.after;
+  }
+  return result;
+};
+var createMustard = (initialState) => {
+  let state = squeeze(initialState);
+  let version = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  let history = [];
+  let pendingNotify = false;
+  const notify = () => {
+    version++;
+    if (!pendingNotify) {
+      pendingNotify = true;
+      Promise.resolve().then(() => {
+        pendingNotify = false;
+        listeners.forEach((l) => l());
+      });
+    }
+  };
+  const pushRecord = (path, key, before, after) => {
+    const fullPath = [...path, key].join(".");
+    history.push({
+      path: fullPath,
+      before: typeof before === "object" && before !== null ? squeeze(before) : before,
+      after: typeof after === "object" && after !== null ? squeeze(after) : after
+    });
+  };
+  const applyUndo = (entry) => {
+    const segs = entry.path.split(".");
+    const parentPath = segs.slice(0, -1);
+    const key = segs[segs.length - 1];
+    if (parentPath.length === 0) {
+      state = { ...state, [key]: entry.before };
+    } else {
+      state = setPathValue(state, parentPath, (parent) => {
+        parent[key] = entry.before;
+      });
+    }
+  };
+  const recordApi = {
+    data: () => {
+      const latest = /* @__PURE__ */ new Map();
+      for (const entry of history) {
+        const existing = latest.get(entry.path);
+        if (existing) {
+          existing.after = entry.after;
+        } else {
+          latest.set(entry.path, { ...entry });
+        }
+      }
+      return buildNested(Array.from(latest.values()));
+    },
+    paths: () => [...new Set(history.map((e) => e.path))],
+    undo: () => {
+      const entry = history.pop();
+      if (!entry) return;
+      applyUndo(entry);
+      notify();
+    },
+    undoAll: () => {
+      if (history.length === 0) return;
+      while (history.length > 0) applyUndo(history.pop());
+      notify();
+    },
+    undoTo: (index) => {
+      if (index < 0 || index >= history.length) return;
+      while (history.length > index) applyUndo(history.pop());
+      notify();
+    },
+    clear: () => {
+      history = [];
+    },
+    size: () => history.length
+  };
+  const proxyCache = /* @__PURE__ */ new Map();
+  const createProxy = (path = []) => {
+    const getCurrent = path.length === 0 ? () => state : () => getAtPath(state, path);
+    const curr = getCurrent();
+    const target = Array.isArray(curr) ? [] : {};
+    const proxy2 = new Proxy(target, {
+      get: (_, key) => {
+        if (typeof key === "symbol") {
+          const curr3 = getCurrent();
+          if (curr3 == null) return void 0;
+          const val = curr3[key];
+          return typeof val === "function" ? val.bind(curr3) : val;
+        }
+        if (key === "_MST_STORE_") return store;
+        if (key === "_MST_SOURCE_") return getCurrent();
+        if (key === "_MST_RECORD_") return recordApi;
+        if (key === "$") return getCurrent();
+        if (key === "reset") return (data) => {
+          state = typeof data === "function" ? squeeze(data()) : squeeze(data);
+          notify();
+        };
+        const curr2 = getCurrent();
+        if (curr2 == null) return void 0;
+        const value = curr2[key];
+        if (Array.isArray(curr2) && typeof value === "function" && MUTATORS.has(key)) {
+          return (...args) => {
+            const cleanArgs = args.map((a) => typeof a === "object" && a !== null ? squeeze(a) : a);
+            const beforeArr = squeeze(curr2);
+            let result;
+            state = setPathValue(state, path, (arr) => {
+              result = arr[key](...cleanArgs);
+              return arr;
+            });
+            const afterArr = squeeze(getAtPath(state, path));
+            const fullPath = path.join(".");
+            history.push({
+              path: fullPath,
+              before: beforeArr,
+              after: afterArr
+            });
+            notify();
+            return result;
+          };
+        }
+        if (Array.isArray(curr2) && typeof value === "function" && ITERATORS.has(key)) {
+          return value.bind(proxy2);
+        }
+        if (typeof value === "function") return value.bind(curr2);
+        if (typeof value === "object" && value !== null) {
+          const cacheKey = path.length === 0 ? key : path.join("\0") + "\0" + key;
+          let child = proxyCache.get(cacheKey);
+          if (!child) {
+            child = createProxy([...path, key]);
+            proxyCache.set(cacheKey, child);
+          }
+          return child;
+        }
+        return value;
+      },
+      set: (_, key, val) => {
+        const curr2 = getCurrent();
+        if (curr2 == null) return true;
+        if (curr2[key] === val) return true;
+        const before = curr2[key];
+        if (typeof val === "object" && val !== null) val = squeeze(val);
+        state = setPathValue(state, path, (parent) => {
+          parent[key] = val;
+        });
+        pushRecord(path, key, before, val);
+        notify();
+        return true;
+      },
+      ownKeys: () => {
+        const curr2 = getCurrent();
+        return curr2 ? Reflect.ownKeys(curr2) : [];
+      },
+      getOwnPropertyDescriptor: (_, key) => {
+        const curr2 = getCurrent();
+        if (curr2 != null && key in curr2) {
+          if (key === "length" && Array.isArray(curr2)) {
+            return { configurable: false, enumerable: false, writable: true, value: curr2.length };
+          }
+          return { configurable: true, enumerable: true, writable: true, value: curr2[key] };
+        }
+        return void 0;
+      },
+      deleteProperty: (_, key) => {
+        const curr2 = getCurrent();
+        if (curr2 == null || !(key in curr2)) return true;
+        const before = curr2[key];
+        state = setPathValue(state, path, (parent) => {
+          delete parent[key];
+        });
+        pushRecord(path, key, before, void 0);
+        notify();
+        return true;
+      },
+      has: (_, key) => {
+        const curr2 = getCurrent();
+        return curr2 != null && key in curr2;
+      }
+    });
+    return proxy2;
+  };
+  const proxy = createProxy();
+  const store = {
+    getState: () => state,
+    getVersion: () => version,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    proxy
+  };
+  return store;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTERNAL_KEYS,
+  ITERATORS,
+  MUTATORS,
+  buildNested,
+  createMustard,
+  getAtPath,
+  record,
+  setPathValue,
+  squeeze,
+  unwrap
+});

package/dist/index.d.cts

@@ -0,0 +1,45 @@
+interface RecordEntry {
+    path: string;
+    before: any;
+    after: any;
+}
+interface RecordApi {
+    /** Changed fields as nested object (for partial updates) */
+    data: () => any;
+    /** List of changed paths (dot notation) */
+    paths: () => string[];
+    /** Revert last change */
+    undo: () => void;
+    /** Revert all changes */
+    undoAll: () => void;
+    /** Revert to specific history index (exclusive, keeps 0..index-1) */
+    undoTo: (index: number) => void;
+    /** Clear all records (new baseline) */
+    clear: () => void;
+    /** Number of recorded changes */
+    size: () => number;
+}
+interface MustardStore<T = any> {
+    getState: () => T;
+    getVersion: () => number;
+    subscribe: (listener: () => void) => () => void;
+    proxy: any;
+}
+declare const MUTATORS: Set<string>;
+declare const ITERATORS: Set<string>;
+declare const INTERNAL_KEYS: Set<string>;
+/** Unwrap proxy to get raw value */
+declare const unwrap: (obj: any) => any;
+/** Get record API from a mustard proxy */
+declare const record: (obj: any) => RecordApi;
+/** Deep clone (strips proxy references) */
+declare const squeeze: (obj: any) => any;
+/** Structural sharing: create new references along path */
+declare const setPathValue: (curr: any, path: any[], callback: Function, depth?: number) => any;
+/** Traverse state by path segments */
+declare const getAtPath: (state: any, path: string[]) => any;
+/** Build nested object from flat record entries (aggregated) */
+declare const buildNested: (entries: RecordEntry[]) => any;
+declare const createMustard: <T extends object>(initialState: T) => MustardStore<T>;
+
+export { INTERNAL_KEYS, ITERATORS, MUTATORS, type MustardStore, type RecordApi, buildNested, createMustard, getAtPath, record, setPathValue, squeeze, unwrap };

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+interface RecordEntry {
+    path: string;
+    before: any;
+    after: any;
+}
+interface RecordApi {
+    /** Changed fields as nested object (for partial updates) */
+    data: () => any;
+    /** List of changed paths (dot notation) */
+    paths: () => string[];
+    /** Revert last change */
+    undo: () => void;
+    /** Revert all changes */
+    undoAll: () => void;
+    /** Revert to specific history index (exclusive, keeps 0..index-1) */
+    undoTo: (index: number) => void;
+    /** Clear all records (new baseline) */
+    clear: () => void;
+    /** Number of recorded changes */
+    size: () => number;
+}
+interface MustardStore<T = any> {
+    getState: () => T;
+    getVersion: () => number;
+    subscribe: (listener: () => void) => () => void;
+    proxy: any;
+}
+declare const MUTATORS: Set<string>;
+declare const ITERATORS: Set<string>;
+declare const INTERNAL_KEYS: Set<string>;
+/** Unwrap proxy to get raw value */
+declare const unwrap: (obj: any) => any;
+/** Get record API from a mustard proxy */
+declare const record: (obj: any) => RecordApi;
+/** Deep clone (strips proxy references) */
+declare const squeeze: (obj: any) => any;
+/** Structural sharing: create new references along path */
+declare const setPathValue: (curr: any, path: any[], callback: Function, depth?: number) => any;
+/** Traverse state by path segments */
+declare const getAtPath: (state: any, path: string[]) => any;
+/** Build nested object from flat record entries (aggregated) */
+declare const buildNested: (entries: RecordEntry[]) => any;
+declare const createMustard: <T extends object>(initialState: T) => MustardStore<T>;
+
+export { INTERNAL_KEYS, ITERATORS, MUTATORS, type MustardStore, type RecordApi, buildNested, createMustard, getAtPath, record, setPathValue, squeeze, unwrap };

package/dist/index.js

@@ -0,0 +1,259 @@
+// src/index.ts
+var MUTATORS = /* @__PURE__ */ new Set(["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin"]);
+var ITERATORS = /* @__PURE__ */ new Set(["forEach", "map", "filter", "find", "findIndex", "some", "every", "reduce", "reduceRight", "flatMap"]);
+var INTERNAL_KEYS = /* @__PURE__ */ new Set(["_MST_STORE_", "_MST_SOURCE_", "_MST_RECORD_", "$", "reset"]);
+var unwrap = (obj) => {
+  if (obj != null && typeof obj === "object") {
+    const source = obj._MST_SOURCE_;
+    if (source !== void 0) return source;
+  }
+  return obj;
+};
+var record = (obj) => obj._MST_RECORD_;
+var squeeze = (obj) => {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) {
+    const arr = [...obj];
+    for (let i = 0, len = arr.length; i < len; i++) {
+      if (typeof arr[i] === "object" && arr[i] !== null) arr[i] = squeeze(arr[i]);
+    }
+    return arr;
+  }
+  const copy = { ...obj };
+  const keys = Object.keys(copy);
+  for (let i = 0, len = keys.length; i < len; i++) {
+    if (typeof copy[keys[i]] === "object" && copy[keys[i]] !== null) copy[keys[i]] = squeeze(copy[keys[i]]);
+  }
+  return copy;
+};
+var setPathValue = (curr, path, callback, depth = 0) => {
+  if (depth === path.length) {
+    const next2 = Array.isArray(curr) ? [...curr] : { ...curr };
+    const result = callback(next2);
+    return result !== void 0 ? result : next2;
+  }
+  const key = path[depth];
+  const next = Array.isArray(curr) ? [...curr] : { ...curr };
+  next[key] = setPathValue(curr[key], path, callback, depth + 1);
+  return next;
+};
+var getAtPath = (state, path) => {
+  let current = state;
+  for (let i = 0; i < path.length; i++) {
+    if (current == null) return void 0;
+    current = current[path[i]];
+  }
+  return current;
+};
+var buildNested = (entries) => {
+  const result = {};
+  for (const entry of entries) {
+    const segs = entry.path.split(".");
+    let current = result;
+    for (let i = 0; i < segs.length - 1; i++) {
+      if (current[segs[i]] == null) current[segs[i]] = {};
+      current = current[segs[i]];
+    }
+    current[segs[segs.length - 1]] = entry.after;
+  }
+  return result;
+};
+var createMustard = (initialState) => {
+  let state = squeeze(initialState);
+  let version = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  let history = [];
+  let pendingNotify = false;
+  const notify = () => {
+    version++;
+    if (!pendingNotify) {
+      pendingNotify = true;
+      Promise.resolve().then(() => {
+        pendingNotify = false;
+        listeners.forEach((l) => l());
+      });
+    }
+  };
+  const pushRecord = (path, key, before, after) => {
+    const fullPath = [...path, key].join(".");
+    history.push({
+      path: fullPath,
+      before: typeof before === "object" && before !== null ? squeeze(before) : before,
+      after: typeof after === "object" && after !== null ? squeeze(after) : after
+    });
+  };
+  const applyUndo = (entry) => {
+    const segs = entry.path.split(".");
+    const parentPath = segs.slice(0, -1);
+    const key = segs[segs.length - 1];
+    if (parentPath.length === 0) {
+      state = { ...state, [key]: entry.before };
+    } else {
+      state = setPathValue(state, parentPath, (parent) => {
+        parent[key] = entry.before;
+      });
+    }
+  };
+  const recordApi = {
+    data: () => {
+      const latest = /* @__PURE__ */ new Map();
+      for (const entry of history) {
+        const existing = latest.get(entry.path);
+        if (existing) {
+          existing.after = entry.after;
+        } else {
+          latest.set(entry.path, { ...entry });
+        }
+      }
+      return buildNested(Array.from(latest.values()));
+    },
+    paths: () => [...new Set(history.map((e) => e.path))],
+    undo: () => {
+      const entry = history.pop();
+      if (!entry) return;
+      applyUndo(entry);
+      notify();
+    },
+    undoAll: () => {
+      if (history.length === 0) return;
+      while (history.length > 0) applyUndo(history.pop());
+      notify();
+    },
+    undoTo: (index) => {
+      if (index < 0 || index >= history.length) return;
+      while (history.length > index) applyUndo(history.pop());
+      notify();
+    },
+    clear: () => {
+      history = [];
+    },
+    size: () => history.length
+  };
+  const proxyCache = /* @__PURE__ */ new Map();
+  const createProxy = (path = []) => {
+    const getCurrent = path.length === 0 ? () => state : () => getAtPath(state, path);
+    const curr = getCurrent();
+    const target = Array.isArray(curr) ? [] : {};
+    const proxy2 = new Proxy(target, {
+      get: (_, key) => {
+        if (typeof key === "symbol") {
+          const curr3 = getCurrent();
+          if (curr3 == null) return void 0;
+          const val = curr3[key];
+          return typeof val === "function" ? val.bind(curr3) : val;
+        }
+        if (key === "_MST_STORE_") return store;
+        if (key === "_MST_SOURCE_") return getCurrent();
+        if (key === "_MST_RECORD_") return recordApi;
+        if (key === "$") return getCurrent();
+        if (key === "reset") return (data) => {
+          state = typeof data === "function" ? squeeze(data()) : squeeze(data);
+          notify();
+        };
+        const curr2 = getCurrent();
+        if (curr2 == null) return void 0;
+        const value = curr2[key];
+        if (Array.isArray(curr2) && typeof value === "function" && MUTATORS.has(key)) {
+          return (...args) => {
+            const cleanArgs = args.map((a) => typeof a === "object" && a !== null ? squeeze(a) : a);
+            const beforeArr = squeeze(curr2);
+            let result;
+            state = setPathValue(state, path, (arr) => {
+              result = arr[key](...cleanArgs);
+              return arr;
+            });
+            const afterArr = squeeze(getAtPath(state, path));
+            const fullPath = path.join(".");
+            history.push({
+              path: fullPath,
+              before: beforeArr,
+              after: afterArr
+            });
+            notify();
+            return result;
+          };
+        }
+        if (Array.isArray(curr2) && typeof value === "function" && ITERATORS.has(key)) {
+          return value.bind(proxy2);
+        }
+        if (typeof value === "function") return value.bind(curr2);
+        if (typeof value === "object" && value !== null) {
+          const cacheKey = path.length === 0 ? key : path.join("\0") + "\0" + key;
+          let child = proxyCache.get(cacheKey);
+          if (!child) {
+            child = createProxy([...path, key]);
+            proxyCache.set(cacheKey, child);
+          }
+          return child;
+        }
+        return value;
+      },
+      set: (_, key, val) => {
+        const curr2 = getCurrent();
+        if (curr2 == null) return true;
+        if (curr2[key] === val) return true;
+        const before = curr2[key];
+        if (typeof val === "object" && val !== null) val = squeeze(val);
+        state = setPathValue(state, path, (parent) => {
+          parent[key] = val;
+        });
+        pushRecord(path, key, before, val);
+        notify();
+        return true;
+      },
+      ownKeys: () => {
+        const curr2 = getCurrent();
+        return curr2 ? Reflect.ownKeys(curr2) : [];
+      },
+      getOwnPropertyDescriptor: (_, key) => {
+        const curr2 = getCurrent();
+        if (curr2 != null && key in curr2) {
+          if (key === "length" && Array.isArray(curr2)) {
+            return { configurable: false, enumerable: false, writable: true, value: curr2.length };
+          }
+          return { configurable: true, enumerable: true, writable: true, value: curr2[key] };
+        }
+        return void 0;
+      },
+      deleteProperty: (_, key) => {
+        const curr2 = getCurrent();
+        if (curr2 == null || !(key in curr2)) return true;
+        const before = curr2[key];
+        state = setPathValue(state, path, (parent) => {
+          delete parent[key];
+        });
+        pushRecord(path, key, before, void 0);
+        notify();
+        return true;
+      },
+      has: (_, key) => {
+        const curr2 = getCurrent();
+        return curr2 != null && key in curr2;
+      }
+    });
+    return proxy2;
+  };
+  const proxy = createProxy();
+  const store = {
+    getState: () => state,
+    getVersion: () => version,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    proxy
+  };
+  return store;
+};
+export {
+  INTERNAL_KEYS,
+  ITERATORS,
+  MUTATORS,
+  buildNested,
+  createMustard,
+  getAtPath,
+  record,
+  setPathValue,
+  squeeze,
+  unwrap
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mustrd/core",
+  "version": "0.2.0",
+  "description": "Proxy-based state engine — direct assignment, diff tracking, undo. Zero dependencies.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run"
+  }
+}