keyv-dir-store 0.0.1 → 0.0.2

package/dist/index.js

@@ -0,0 +1,649 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/crypt/crypt.js
+var require_crypt = __commonJS((exports, module) => {
+  (function() {
+    var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", crypt = {
+      rotl: function(n, b) {
+        return n << b | n >>> 32 - b;
+      },
+      rotr: function(n, b) {
+        return n << 32 - b | n >>> b;
+      },
+      endian: function(n) {
+        if (n.constructor == Number) {
+          return crypt.rotl(n, 8) & 16711935 | crypt.rotl(n, 24) & 4278255360;
+        }
+        for (var i = 0;i < n.length; i++)
+          n[i] = crypt.endian(n[i]);
+        return n;
+      },
+      randomBytes: function(n) {
+        for (var bytes = [];n > 0; n--)
+          bytes.push(Math.floor(Math.random() * 256));
+        return bytes;
+      },
+      bytesToWords: function(bytes) {
+        for (var words = [], i = 0, b = 0;i < bytes.length; i++, b += 8)
+          words[b >>> 5] |= bytes[i] << 24 - b % 32;
+        return words;
+      },
+      wordsToBytes: function(words) {
+        for (var bytes = [], b = 0;b < words.length * 32; b += 8)
+          bytes.push(words[b >>> 5] >>> 24 - b % 32 & 255);
+        return bytes;
+      },
+      bytesToHex: function(bytes) {
+        for (var hex = [], i = 0;i < bytes.length; i++) {
+          hex.push((bytes[i] >>> 4).toString(16));
+          hex.push((bytes[i] & 15).toString(16));
+        }
+        return hex.join("");
+      },
+      hexToBytes: function(hex) {
+        for (var bytes = [], c = 0;c < hex.length; c += 2)
+          bytes.push(parseInt(hex.substr(c, 2), 16));
+        return bytes;
+      },
+      bytesToBase64: function(bytes) {
+        for (var base64 = [], i = 0;i < bytes.length; i += 3) {
+          var triplet = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+          for (var j = 0;j < 4; j++)
+            if (i * 8 + j * 6 <= bytes.length * 8)
+              base64.push(base64map.charAt(triplet >>> 6 * (3 - j) & 63));
+            else
+              base64.push("=");
+        }
+        return base64.join("");
+      },
+      base64ToBytes: function(base64) {
+        base64 = base64.replace(/[^A-Z0-9+\/]/ig, "");
+        for (var bytes = [], i = 0, imod4 = 0;i < base64.length; imod4 = ++i % 4) {
+          if (imod4 == 0)
+            continue;
+          bytes.push((base64map.indexOf(base64.charAt(i - 1)) & Math.pow(2, -2 * imod4 + 8) - 1) << imod4 * 2 | base64map.indexOf(base64.charAt(i)) >>> 6 - imod4 * 2);
+        }
+        return bytes;
+      }
+    };
+    module.exports = crypt;
+  })();
+});
+
+// node_modules/charenc/charenc.js
+var require_charenc = __commonJS((exports, module) => {
+  var charenc = {
+    utf8: {
+      stringToBytes: function(str) {
+        return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+      },
+      bytesToString: function(bytes) {
+        return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+      }
+    },
+    bin: {
+      stringToBytes: function(str) {
+        for (var bytes = [], i = 0;i < str.length; i++)
+          bytes.push(str.charCodeAt(i) & 255);
+        return bytes;
+      },
+      bytesToString: function(bytes) {
+        for (var str = [], i = 0;i < bytes.length; i++)
+          str.push(String.fromCharCode(bytes[i]));
+        return str.join("");
+      }
+    }
+  };
+  module.exports = charenc;
+});
+
+// node_modules/is-buffer/index.js
+var require_is_buffer = __commonJS((exports, module) => {
+  var isBuffer = function(obj) {
+    return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+  };
+  var isSlowBuffer = function(obj) {
+    return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
+  };
+  /*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   */
+  module.exports = function(obj) {
+    return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+  };
+});
+
+// node_modules/md5/md5.js
+var require_md5 = __commonJS((exports, module) => {
+  (function() {
+    var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer = require_is_buffer(), bin = require_charenc().bin, md5 = function(message, options) {
+      if (message.constructor == String)
+        if (options && options.encoding === "binary")
+          message = bin.stringToBytes(message);
+        else
+          message = utf8.stringToBytes(message);
+      else if (isBuffer(message))
+        message = Array.prototype.slice.call(message, 0);
+      else if (!Array.isArray(message) && message.constructor !== Uint8Array)
+        message = message.toString();
+      var m = crypt.bytesToWords(message), l = message.length * 8, a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
+      for (var i = 0;i < m.length; i++) {
+        m[i] = (m[i] << 8 | m[i] >>> 24) & 16711935 | (m[i] << 24 | m[i] >>> 8) & 4278255360;
+      }
+      m[l >>> 5] |= 128 << l % 32;
+      m[(l + 64 >>> 9 << 4) + 14] = l;
+      var { _ff: FF, _gg: GG, _hh: HH, _ii: II } = md5;
+      for (var i = 0;i < m.length; i += 16) {
+        var aa = a, bb = b, cc = c, dd = d;
+        a = FF(a, b, c, d, m[i + 0], 7, -680876936);
+        d = FF(d, a, b, c, m[i + 1], 12, -389564586);
+        c = FF(c, d, a, b, m[i + 2], 17, 606105819);
+        b = FF(b, c, d, a, m[i + 3], 22, -1044525330);
+        a = FF(a, b, c, d, m[i + 4], 7, -176418897);
+        d = FF(d, a, b, c, m[i + 5], 12, 1200080426);
+        c = FF(c, d, a, b, m[i + 6], 17, -1473231341);
+        b = FF(b, c, d, a, m[i + 7], 22, -45705983);
+        a = FF(a, b, c, d, m[i + 8], 7, 1770035416);
+        d = FF(d, a, b, c, m[i + 9], 12, -1958414417);
+        c = FF(c, d, a, b, m[i + 10], 17, -42063);
+        b = FF(b, c, d, a, m[i + 11], 22, -1990404162);
+        a = FF(a, b, c, d, m[i + 12], 7, 1804603682);
+        d = FF(d, a, b, c, m[i + 13], 12, -40341101);
+        c = FF(c, d, a, b, m[i + 14], 17, -1502002290);
+        b = FF(b, c, d, a, m[i + 15], 22, 1236535329);
+        a = GG(a, b, c, d, m[i + 1], 5, -165796510);
+        d = GG(d, a, b, c, m[i + 6], 9, -1069501632);
+        c = GG(c, d, a, b, m[i + 11], 14, 643717713);
+        b = GG(b, c, d, a, m[i + 0], 20, -373897302);
+        a = GG(a, b, c, d, m[i + 5], 5, -701558691);
+        d = GG(d, a, b, c, m[i + 10], 9, 38016083);
+        c = GG(c, d, a, b, m[i + 15], 14, -660478335);
+        b = GG(b, c, d, a, m[i + 4], 20, -405537848);
+        a = GG(a, b, c, d, m[i + 9], 5, 568446438);
+        d = GG(d, a, b, c, m[i + 14], 9, -1019803690);
+        c = GG(c, d, a, b, m[i + 3], 14, -187363961);
+        b = GG(b, c, d, a, m[i + 8], 20, 1163531501);
+        a = GG(a, b, c, d, m[i + 13], 5, -1444681467);
+        d = GG(d, a, b, c, m[i + 2], 9, -51403784);
+        c = GG(c, d, a, b, m[i + 7], 14, 1735328473);
+        b = GG(b, c, d, a, m[i + 12], 20, -1926607734);
+        a = HH(a, b, c, d, m[i + 5], 4, -378558);
+        d = HH(d, a, b, c, m[i + 8], 11, -2022574463);
+        c = HH(c, d, a, b, m[i + 11], 16, 1839030562);
+        b = HH(b, c, d, a, m[i + 14], 23, -35309556);
+        a = HH(a, b, c, d, m[i + 1], 4, -1530992060);
+        d = HH(d, a, b, c, m[i + 4], 11, 1272893353);
+        c = HH(c, d, a, b, m[i + 7], 16, -155497632);
+        b = HH(b, c, d, a, m[i + 10], 23, -1094730640);
+        a = HH(a, b, c, d, m[i + 13], 4, 681279174);
+        d = HH(d, a, b, c, m[i + 0], 11, -358537222);
+        c = HH(c, d, a, b, m[i + 3], 16, -722521979);
+        b = HH(b, c, d, a, m[i + 6], 23, 76029189);
+        a = HH(a, b, c, d, m[i + 9], 4, -640364487);
+        d = HH(d, a, b, c, m[i + 12], 11, -421815835);
+        c = HH(c, d, a, b, m[i + 15], 16, 530742520);
+        b = HH(b, c, d, a, m[i + 2], 23, -995338651);
+        a = II(a, b, c, d, m[i + 0], 6, -198630844);
+        d = II(d, a, b, c, m[i + 7], 10, 1126891415);
+        c = II(c, d, a, b, m[i + 14], 15, -1416354905);
+        b = II(b, c, d, a, m[i + 5], 21, -57434055);
+        a = II(a, b, c, d, m[i + 12], 6, 1700485571);
+        d = II(d, a, b, c, m[i + 3], 10, -1894986606);
+        c = II(c, d, a, b, m[i + 10], 15, -1051523);
+        b = II(b, c, d, a, m[i + 1], 21, -2054922799);
+        a = II(a, b, c, d, m[i + 8], 6, 1873313359);
+        d = II(d, a, b, c, m[i + 15], 10, -30611744);
+        c = II(c, d, a, b, m[i + 6], 15, -1560198380);
+        b = II(b, c, d, a, m[i + 13], 21, 1309151649);
+        a = II(a, b, c, d, m[i + 4], 6, -145523070);
+        d = II(d, a, b, c, m[i + 11], 10, -1120210379);
+        c = II(c, d, a, b, m[i + 2], 15, 718787259);
+        b = II(b, c, d, a, m[i + 9], 21, -343485551);
+        a = a + aa >>> 0;
+        b = b + bb >>> 0;
+        c = c + cc >>> 0;
+        d = d + dd >>> 0;
+      }
+      return crypt.endian([a, b, c, d]);
+    };
+    md5._ff = function(a, b, c, d, x, s, t) {
+      var n = a + (b & c | ~b & d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._gg = function(a, b, c, d, x, s, t) {
+      var n = a + (b & d | c & ~d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._hh = function(a, b, c, d, x, s, t) {
+      var n = a + (b ^ c ^ d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._ii = function(a, b, c, d, x, s, t) {
+      var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._blocksize = 16;
+    md5._digestsize = 16;
+    module.exports = function(message, options) {
+      if (message === undefined || message === null)
+        throw new Error("Illegal argument " + message);
+      var digestbytes = crypt.wordsToBytes(md5(message, options));
+      return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
+    };
+  })();
+});
+
+// node_modules/truncate-utf8-bytes/lib/truncate.js
+var require_truncate = __commonJS((exports, module) => {
+  var isHighSurrogate = function(codePoint) {
+    return codePoint >= 55296 && codePoint <= 56319;
+  };
+  var isLowSurrogate = function(codePoint) {
+    return codePoint >= 56320 && codePoint <= 57343;
+  };
+  module.exports = function truncate(getLength, string, byteLength) {
+    if (typeof string !== "string") {
+      throw new Error("Input must be string");
+    }
+    var charLength = string.length;
+    var curByteLength = 0;
+    var codePoint;
+    var segment;
+    for (var i = 0;i < charLength; i += 1) {
+      codePoint = string.charCodeAt(i);
+      segment = string[i];
+      if (isHighSurrogate(codePoint) && isLowSurrogate(string.charCodeAt(i + 1))) {
+        i += 1;
+        segment += string[i];
+      }
+      curByteLength += getLength(segment);
+      if (curByteLength === byteLength) {
+        return string.slice(0, i + 1);
+      } else if (curByteLength > byteLength) {
+        return string.slice(0, i - segment.length + 1);
+      }
+    }
+    return string;
+  };
+});
+
+// node_modules/utf8-byte-length/browser.js
+var require_browser = __commonJS((exports, module) => {
+  var isHighSurrogate = function(codePoint) {
+    return codePoint >= 55296 && codePoint <= 56319;
+  };
+  var isLowSurrogate = function(codePoint) {
+    return codePoint >= 56320 && codePoint <= 57343;
+  };
+  module.exports = function getByteLength(string) {
+    if (typeof string !== "string") {
+      throw new Error("Input must be string");
+    }
+    var charLength = string.length;
+    var byteLength = 0;
+    var codePoint = null;
+    var prevCodePoint = null;
+    for (var i = 0;i < charLength; i++) {
+      codePoint = string.charCodeAt(i);
+      if (isLowSurrogate(codePoint)) {
+        if (prevCodePoint != null && isHighSurrogate(prevCodePoint)) {
+          byteLength += 1;
+        } else {
+          byteLength += 3;
+        }
+      } else if (codePoint <= 127) {
+        byteLength += 1;
+      } else if (codePoint >= 128 && codePoint <= 2047) {
+        byteLength += 2;
+      } else if (codePoint >= 2048 && codePoint <= 65535) {
+        byteLength += 3;
+      }
+      prevCodePoint = codePoint;
+    }
+    return byteLength;
+  };
+});
+
+// node_modules/truncate-utf8-bytes/browser.js
+var require_browser2 = __commonJS((exports, module) => {
+  var truncate = require_truncate();
+  var getLength = require_browser();
+  module.exports = truncate.bind(null, getLength);
+});
+
+// node_modules/sanitize-filename/index.js
+var require_sanitize_filename = __commonJS((exports, module) => {
+  var sanitize = function(input, replacement) {
+    if (typeof input !== "string") {
+      throw new Error("Input must be string");
+    }
+    var sanitized = input.replace(illegalRe, replacement).replace(controlRe, replacement).replace(reservedRe, replacement).replace(windowsReservedRe, replacement).replace(windowsTrailingRe, replacement);
+    return truncate(sanitized, 255);
+  };
+  var truncate = require_browser2();
+  var illegalRe = /[\/\?<>\\:\*\|"]/g;
+  var controlRe = /[\x00-\x1f\x80-\x9f]/g;
+  var reservedRe = /^\.+$/;
+  var windowsReservedRe = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/i;
+  var windowsTrailingRe = /[\. ]+$/;
+  module.exports = function(input, options) {
+    var replacement = options && options.replacement || "";
+    var output = sanitize(input, replacement);
+    if (replacement === "") {
+      return output;
+    }
+    return sanitize(output, "");
+  };
+});
+
+// index.ts
+var import_md5 = __toESM(require_md5(), 1);
+var import_sanitize_filename = __toESM(require_sanitize_filename(), 1);
+var {stat} = (()=>({}));
+var {writeFile} = (()=>({}));
+var {rm} = (()=>({}));
+var {readFile, mkdir} = (()=>({}));
+
+// node:path
+var L = Object.create;
+var b = Object.defineProperty;
+var z = Object.getOwnPropertyDescriptor;
+var D = Object.getOwnPropertyNames;
+var T = Object.getPrototypeOf;
+var R = Object.prototype.hasOwnProperty;
+var _ = (f, e) => () => (e || f((e = { exports: {} }).exports, e), e.exports);
+var E = (f, e) => {
+  for (var r in e)
+    b(f, r, { get: e[r], enumerable: true });
+};
+var C = (f, e, r, l) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let i of D(e))
+      !R.call(f, i) && i !== r && b(f, i, { get: () => e[i], enumerable: !(l = z(e, i)) || l.enumerable });
+  return f;
+};
+var A = (f, e, r) => (C(f, e, "default"), r && C(r, e, "default"));
+var y = (f, e, r) => (r = f != null ? L(T(f)) : {}, C(e || !f || !f.__esModule ? b(r, "default", { value: f, enumerable: true }) : r, f));
+var h = _((F, S) => {
+  function c(f) {
+    if (typeof f != "string")
+      throw new TypeError("Path must be a string. Received " + JSON.stringify(f));
+  }
+  function w(f, e) {
+    for (var r = "", l = 0, i = -1, s = 0, n, t = 0;t <= f.length; ++t) {
+      if (t < f.length)
+        n = f.charCodeAt(t);
+      else {
+        if (n === 47)
+          break;
+        n = 47;
+      }
+      if (n === 47) {
+        if (!(i === t - 1 || s === 1))
+          if (i !== t - 1 && s === 2) {
+            if (r.length < 2 || l !== 2 || r.charCodeAt(r.length - 1) !== 46 || r.charCodeAt(r.length - 2) !== 46) {
+              if (r.length > 2) {
+                var a = r.lastIndexOf("/");
+                if (a !== r.length - 1) {
+                  a === -1 ? (r = "", l = 0) : (r = r.slice(0, a), l = r.length - 1 - r.lastIndexOf("/")), i = t, s = 0;
+                  continue;
+                }
+              } else if (r.length === 2 || r.length === 1) {
+                r = "", l = 0, i = t, s = 0;
+                continue;
+              }
+            }
+            e && (r.length > 0 ? r += "/.." : r = "..", l = 2);
+          } else
+            r.length > 0 ? r += "/" + f.slice(i + 1, t) : r = f.slice(i + 1, t), l = t - i - 1;
+        i = t, s = 0;
+      } else
+        n === 46 && s !== -1 ? ++s : s = -1;
+    }
+    return r;
+  }
+  function J(f, e) {
+    var r = e.dir || e.root, l = e.base || (e.name || "") + (e.ext || "");
+    return r ? r === e.root ? r + l : r + f + l : l;
+  }
+  var g = { resolve: function() {
+    for (var e = "", r = false, l, i = arguments.length - 1;i >= -1 && !r; i--) {
+      var s;
+      i >= 0 ? s = arguments[i] : (l === undefined && (l = process.cwd()), s = l), c(s), s.length !== 0 && (e = s + "/" + e, r = s.charCodeAt(0) === 47);
+    }
+    return e = w(e, !r), r ? e.length > 0 ? "/" + e : "/" : e.length > 0 ? e : ".";
+  }, normalize: function(e) {
+    if (c(e), e.length === 0)
+      return ".";
+    var r = e.charCodeAt(0) === 47, l = e.charCodeAt(e.length - 1) === 47;
+    return e = w(e, !r), e.length === 0 && !r && (e = "."), e.length > 0 && l && (e += "/"), r ? "/" + e : e;
+  }, isAbsolute: function(e) {
+    return c(e), e.length > 0 && e.charCodeAt(0) === 47;
+  }, join: function() {
+    if (arguments.length === 0)
+      return ".";
+    for (var e, r = 0;r < arguments.length; ++r) {
+      var l = arguments[r];
+      c(l), l.length > 0 && (e === undefined ? e = l : e += "/" + l);
+    }
+    return e === undefined ? "." : g.normalize(e);
+  }, relative: function(e, r) {
+    if (c(e), c(r), e === r || (e = g.resolve(e), r = g.resolve(r), e === r))
+      return "";
+    for (var l = 1;l < e.length && e.charCodeAt(l) === 47; ++l)
+      ;
+    for (var i = e.length, s = i - l, n = 1;n < r.length && r.charCodeAt(n) === 47; ++n)
+      ;
+    for (var t = r.length, a = t - n, v = s < a ? s : a, u = -1, o = 0;o <= v; ++o) {
+      if (o === v) {
+        if (a > v) {
+          if (r.charCodeAt(n + o) === 47)
+            return r.slice(n + o + 1);
+          if (o === 0)
+            return r.slice(n + o);
+        } else
+          s > v && (e.charCodeAt(l + o) === 47 ? u = o : o === 0 && (u = 0));
+        break;
+      }
+      var k = e.charCodeAt(l + o), P = r.charCodeAt(n + o);
+      if (k !== P)
+        break;
+      k === 47 && (u = o);
+    }
+    var d = "";
+    for (o = l + u + 1;o <= i; ++o)
+      (o === i || e.charCodeAt(o) === 47) && (d.length === 0 ? d += ".." : d += "/..");
+    return d.length > 0 ? d + r.slice(n + u) : (n += u, r.charCodeAt(n) === 47 && ++n, r.slice(n));
+  }, _makeLong: function(e) {
+    return e;
+  }, dirname: function(e) {
+    if (c(e), e.length === 0)
+      return ".";
+    for (var r = e.charCodeAt(0), l = r === 47, i = -1, s = true, n = e.length - 1;n >= 1; --n)
+      if (r = e.charCodeAt(n), r === 47) {
+        if (!s) {
+          i = n;
+          break;
+        }
+      } else
+        s = false;
+    return i === -1 ? l ? "/" : "." : l && i === 1 ? "//" : e.slice(0, i);
+  }, basename: function(e, r) {
+    if (r !== undefined && typeof r != "string")
+      throw new TypeError('"ext" argument must be a string');
+    c(e);
+    var l = 0, i = -1, s = true, n;
+    if (r !== undefined && r.length > 0 && r.length <= e.length) {
+      if (r.length === e.length && r === e)
+        return "";
+      var t = r.length - 1, a = -1;
+      for (n = e.length - 1;n >= 0; --n) {
+        var v = e.charCodeAt(n);
+        if (v === 47) {
+          if (!s) {
+            l = n + 1;
+            break;
+          }
+        } else
+          a === -1 && (s = false, a = n + 1), t >= 0 && (v === r.charCodeAt(t) ? --t === -1 && (i = n) : (t = -1, i = a));
+      }
+      return l === i ? i = a : i === -1 && (i = e.length), e.slice(l, i);
+    } else {
+      for (n = e.length - 1;n >= 0; --n)
+        if (e.charCodeAt(n) === 47) {
+          if (!s) {
+            l = n + 1;
+            break;
+          }
+        } else
+          i === -1 && (s = false, i = n + 1);
+      return i === -1 ? "" : e.slice(l, i);
+    }
+  }, extname: function(e) {
+    c(e);
+    for (var r = -1, l = 0, i = -1, s = true, n = 0, t = e.length - 1;t >= 0; --t) {
+      var a = e.charCodeAt(t);
+      if (a === 47) {
+        if (!s) {
+          l = t + 1;
+          break;
+        }
+        continue;
+      }
+      i === -1 && (s = false, i = t + 1), a === 46 ? r === -1 ? r = t : n !== 1 && (n = 1) : r !== -1 && (n = -1);
+    }
+    return r === -1 || i === -1 || n === 0 || n === 1 && r === i - 1 && r === l + 1 ? "" : e.slice(r, i);
+  }, format: function(e) {
+    if (e === null || typeof e != "object")
+      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof e);
+    return J("/", e);
+  }, parse: function(e) {
+    c(e);
+    var r = { root: "", dir: "", base: "", ext: "", name: "" };
+    if (e.length === 0)
+      return r;
+    var l = e.charCodeAt(0), i = l === 47, s;
+    i ? (r.root = "/", s = 1) : s = 0;
+    for (var n = -1, t = 0, a = -1, v = true, u = e.length - 1, o = 0;u >= s; --u) {
+      if (l = e.charCodeAt(u), l === 47) {
+        if (!v) {
+          t = u + 1;
+          break;
+        }
+        continue;
+      }
+      a === -1 && (v = false, a = u + 1), l === 46 ? n === -1 ? n = u : o !== 1 && (o = 1) : n !== -1 && (o = -1);
+    }
+    return n === -1 || a === -1 || o === 0 || o === 1 && n === a - 1 && n === t + 1 ? a !== -1 && (t === 0 && i ? r.base = r.name = e.slice(1, a) : r.base = r.name = e.slice(t, a)) : (t === 0 && i ? (r.name = e.slice(1, n), r.base = e.slice(1, a)) : (r.name = e.slice(t, n), r.base = e.slice(t, a)), r.ext = e.slice(n, a)), t > 0 ? r.dir = e.slice(0, t - 1) : i && (r.dir = "/"), r;
+  }, sep: "/", delimiter: ":", win32: null, posix: null };
+  g.posix = g;
+  S.exports = g;
+});
+var m = {};
+E(m, { default: () => q });
+A(m, y(h()));
+var q = y(h());
+
+// index.ts
+var {utimes} = (()=>({}));
+
+class KeyvDirStore {
+  #dir;
+  #cache;
+  #ready;
+  #path;
+  ext = ".json";
+  constructor(dir, {
+    cache = new Map,
+    path,
+    ext
+  } = {}) {
+    this.#ready = mkdir(dir, { recursive: true });
+    this.#cache = cache;
+    this.#dir = dir;
+    this.#path = path ?? this.#defaultPath;
+    this.ext = ext ?? this.ext;
+  }
+  #defaultPath(key) {
+    const readableName = import_sanitize_filename.default(key).slice(4, 16);
+    const hashName = import_md5.default(this.#dir + key).slice(0, 16);
+    const name = readableName + "-" + hashName + this.ext;
+    return q.join(this.#dir, name);
+  }
+  async get(key) {
+    const cached = this.#cache.get(key);
+    if (cached) {
+      if (cached.expires && cached.expires < Date.now()) {
+        await this.delete(key);
+      } else {
+        return cached.value;
+      }
+    }
+    const stats = await stat(this.#path(key)).catch(() => null);
+    if (!stats)
+      return;
+    const expires = +stats.mtime;
+    if (expires !== 0) {
+      const expired = +stats.mtime < +Date.now();
+      if (expired) {
+        await this.delete(key);
+        return;
+      }
+    }
+    return await readFile(this.#path(key), "utf8").catch(() => {
+      return;
+    });
+  }
+  async set(key, value, ttl) {
+    if (!value)
+      return await this.delete(key);
+    const expires = ttl ? Date.now() + ttl : 0;
+    this.#cache.set(key, { value, expires });
+    await this.#ready;
+    await writeFile(this.#path(key), value);
+    await utimes(this.#path(key), +new Date, new Date(expires ?? 0));
+    return true;
+  }
+  async delete(key) {
+    this.#cache.delete(key);
+    await rm(this.#path(key), { force: true });
+    return true;
+  }
+  async clear() {
+    await rm(this.#dir, { recursive: true }).catch(() => {
+      return;
+    });
+    await mkdir(this.#dir, { recursive: true });
+  }
+  async has(key) {
+    return await this.get(key) !== undefined;
+  }
+  static serialize({ value }) {
+    return JSON.stringify(value, null, 2);
+  }
+  static deserialize(str) {
+    return { value: JSON.parse(str), expires: undefined };
+  }
+}
+export {
+  KeyvDirStore
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keyv-dir-store",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "author": "snomiao <snomiao@gmail.com>",
   "type": "module",
   "exports": {
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "build": "bun build index.ts --outdir=dist",
+    "prerelease": "bun run build && bun run test",
     "release": "bunx standard-version && git push --follow-tags && npm publish",
     "test": "bun test"
   },