@croct/sdk 0.17.9 → 0.17.10

package/activeRecord.cjs

@@ -0,0 +1,135 @@
+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);
+var activeRecord_exports = {};
+__export(activeRecord_exports, {
+  ActiveRecord: () => ActiveRecord
+});
+module.exports = __toCommonJS(activeRecord_exports);
+var import_schema = require("./schema");
+const operationSchema = {
+  add: import_schema.addOperation,
+  set: import_schema.setOperation,
+  merge: import_schema.mergeOperation,
+  combine: import_schema.combineOperation,
+  increment: import_schema.incrementOperation,
+  decrement: import_schema.decrementOperation,
+  clear: import_schema.clearOperation,
+  unset: import_schema.unsetOperation,
+  remove: import_schema.removeOperation
+};
+class ActiveRecord {
+  constructor() {
+    this.operations = [];
+  }
+  set(propertyOrValue, value) {
+    if (typeof propertyOrValue === "string") {
+      return this.pushOperation({
+        type: "set",
+        path: propertyOrValue,
+        value
+      });
+    }
+    return this.pushOperation({
+      type: "set",
+      path: ".",
+      value: propertyOrValue
+    });
+  }
+  add(property, value) {
+    return this.pushOperation({
+      type: "add",
+      path: property,
+      value
+    });
+  }
+  combine(property, value) {
+    return this.pushOperation({
+      type: "combine",
+      path: property,
+      value
+    });
+  }
+  merge(propertyOrValue, value) {
+    if (typeof propertyOrValue === "string") {
+      return this.pushOperation({
+        type: "merge",
+        path: propertyOrValue,
+        value
+      });
+    }
+    return this.pushOperation({
+      type: "merge",
+      path: ".",
+      value: propertyOrValue
+    });
+  }
+  increment(property, amount = 1) {
+    return this.pushOperation({
+      type: "increment",
+      path: property,
+      value: amount
+    });
+  }
+  decrement(property, amount = 1) {
+    return this.pushOperation({
+      type: "decrement",
+      path: property,
+      value: amount
+    });
+  }
+  clear(property) {
+    return this.pushOperation({
+      type: "clear",
+      path: property
+    });
+  }
+  unset(property) {
+    return this.pushOperation({
+      type: "unset",
+      path: property
+    });
+  }
+  remove(property, value) {
+    return this.pushOperation({
+      type: "remove",
+      path: property,
+      value
+    });
+  }
+  pushOperation(operation) {
+    const { type, ...data } = operation;
+    operationSchema[type].validate(data);
+    this.operations.push(operation);
+    return this;
+  }
+  reset() {
+    this.operations.splice(0);
+    return this;
+  }
+  isDirty() {
+    return this.operations.length > 0;
+  }
+  buildPatch() {
+    return { operations: this.operations.slice() };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActiveRecord
+});
+//# sourceMappingURL=activeRecord.cjs.map

package/apiKey.cjs

@@ -0,0 +1,178 @@
+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);
+var apiKey_exports = {};
+__export(apiKey_exports, {
+  ApiKey: () => ApiKey
+});
+module.exports = __toCommonJS(apiKey_exports);
+const _ApiKey = class _ApiKey {
+  constructor(identifier, privateKey) {
+    this.identifier = identifier;
+    this.privateKey = privateKey;
+  }
+  static from(apiKey) {
+    if (apiKey instanceof _ApiKey) {
+      return apiKey;
+    }
+    return _ApiKey.parse(apiKey);
+  }
+  static parse(apiKey) {
+    const parts = apiKey.split(":");
+    if (parts.length > 2) {
+      throw new Error("Invalid API key format.");
+    }
+    return _ApiKey.of(parts[0], parts[1]);
+  }
+  static of(identifier, privateKey) {
+    if (!_ApiKey.IDENTIFIER_PATTERN.test(identifier)) {
+      throw new Error("The identifier must be a UUID.");
+    }
+    if (privateKey === void 0 || privateKey === "") {
+      return new _ApiKey(identifier);
+    }
+    if (!_ApiKey.PRIVATE_KEY_PATTERN.test(privateKey)) {
+      throw new Error("The private key is malformed.");
+    }
+    const [algorithmName, encodedKey] = privateKey.split(";");
+    if (!(algorithmName in _ApiKey.ALGORITHMS)) {
+      throw new Error(`Unsupported signing algorithm "${algorithmName}".`);
+    }
+    return new _ApiKey(identifier, {
+      algorithm: algorithmName,
+      encodedKey
+    });
+  }
+  getIdentifier() {
+    return this.identifier;
+  }
+  async getIdentifierHash() {
+    const identifierBytes = _ApiKey.createByteArrayFromHexString(this.identifier.replace(/-/g, ""));
+    const rawHash = await crypto.subtle.digest("SHA-256", identifierBytes);
+    return _ApiKey.convertBufferToHexString(rawHash);
+  }
+  hasPrivateKey() {
+    return this.privateKey !== void 0;
+  }
+  getPrivateKey() {
+    if (this.privateKey === void 0) {
+      throw new Error("The API key does not have a private key.");
+    }
+    return `${this.privateKey.algorithm};${this.privateKey.encodedKey}`;
+  }
+  async sign(data) {
+    const key = await this.importKey();
+    const algorithm = this.getSigningAlgorithm();
+    return _ApiKey.convertBufferToString(
+      await crypto.subtle.sign(
+        _ApiKey.ALGORITHMS[algorithm].signatureAlgorithm,
+        key,
+        _ApiKey.createByteArrayFromString(data)
+      )
+    );
+  }
+  getSigningAlgorithm() {
+    const { algorithm } = this.getParsedPrivateKey();
+    return algorithm;
+  }
+  importKey() {
+    const { algorithm, encodedKey } = this.getParsedPrivateKey();
+    if (this.importedKey === void 0) {
+      this.importedKey = crypto.subtle.importKey(
+        "pkcs8",
+        _ApiKey.createByteArrayFromString(atob(encodedKey)),
+        _ApiKey.ALGORITHMS[algorithm].keyAlgorithm,
+        false,
+        ["sign"]
+      );
+    }
+    return this.importedKey;
+  }
+  getParsedPrivateKey() {
+    if (this.privateKey === void 0) {
+      throw new Error("The API key does not have a private key.");
+    }
+    return this.privateKey;
+  }
+  export() {
+    return this.identifier + (this.hasPrivateKey() ? `:${this.getPrivateKey()}` : "");
+  }
+  toString() {
+    return "[redacted]";
+  }
+  /**
+   * Create an array buffer from a string.
+   *
+   * @see https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
+   *
+   * @param data The string to convert.
+   * @returns The array buffer.
+   */
+  static createByteArrayFromString(data) {
+    const byteArray = new Uint8Array(data.length);
+    for (let i = 0; i < byteArray.length; i++) {
+      byteArray[i] = data.charCodeAt(i);
+    }
+    return byteArray;
+  }
+  static createByteArrayFromHexString(data) {
+    const byteArray = new Uint8Array(data.length / 2);
+    for (let i = 0; i < byteArray.length; i++) {
+      byteArray[i] = parseInt(data.substring(i * 2, i * 2 + 2), 16);
+    }
+    return byteArray;
+  }
+  /**
+   * Convert an array buffer to a string.
+   *
+   * @see https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
+   *
+   * @param buffer The buffer to convert.
+   * @returns The string.
+   */
+  static convertBufferToString(buffer) {
+    return String.fromCharCode(...new Uint8Array(buffer));
+  }
+  static convertBufferToHexString(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let hexString = "";
+    for (let i = 0; i < bytes.length; i++) {
+      hexString += bytes[i].toString(16).padStart(2, "0");
+    }
+    return hexString;
+  }
+};
+_ApiKey.IDENTIFIER_PATTERN = /^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$/i;
+_ApiKey.PRIVATE_KEY_PATTERN = /^[a-z0-9]+;[^;]+$/i;
+_ApiKey.ALGORITHMS = {
+  ES256: {
+    keyAlgorithm: {
+      name: "ECDSA",
+      namedCurve: "P-256"
+    },
+    signatureAlgorithm: {
+      name: "ECDSA",
+      hash: "SHA-256"
+    }
+  }
+};
+let ApiKey = _ApiKey;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiKey
+});
+//# sourceMappingURL=apiKey.cjs.map

package/base64Url.cjs

@@ -0,0 +1,41 @@
+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);
+var base64Url_exports = {};
+__export(base64Url_exports, {
+  base64UrlDecode: () => base64UrlDecode,
+  base64UrlEncode: () => base64UrlEncode
+});
+module.exports = __toCommonJS(base64Url_exports);
+function base64Unescape(value) {
+  return (value + "===".slice((value.length + 3) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+}
+function base64Escape(value) {
+  return value.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function base64UrlEncode(value, utf8 = false) {
+  return utf8 ? base64Escape(btoa(String.fromCodePoint(...new TextEncoder().encode(value)))) : base64Escape(btoa(value));
+}
+function base64UrlDecode(value, utf8 = false) {
+  return utf8 ? new TextDecoder().decode(Uint8Array.from(atob(base64Unescape(value)), (m) => m.codePointAt(0))) : atob(base64Unescape(value));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64UrlDecode,
+  base64UrlEncode
+});
+//# sourceMappingURL=base64Url.cjs.map

package/cache/cache.cjs

@@ -0,0 +1,34 @@
+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);
+var cache_exports = {};
+__export(cache_exports, {
+  ObservableCache: () => ObservableCache
+});
+module.exports = __toCommonJS(cache_exports);
+var ObservableCache;
+((ObservableCache2) => {
+  function isObservable(cache) {
+    return typeof cache.addListener === "function" && typeof cache.removeListener === "function";
+  }
+  ObservableCache2.isObservable = isObservable;
+})(ObservableCache || (ObservableCache = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObservableCache
+});
+//# sourceMappingURL=cache.cjs.map

package/cache/cookieCache.cjs

@@ -0,0 +1,85 @@
+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);
+var cookieCache_exports = {};
+__export(cookieCache_exports, {
+  CookieCache: () => CookieCache
+});
+module.exports = __toCommonJS(cookieCache_exports);
+class CookieCache {
+  constructor(config, defaultSecure = window.location.protocol === "https:") {
+    this.config = {
+      ...config,
+      path: config.path ?? "/"
+    };
+    if (defaultSecure && this.config.secure === void 0) {
+      this.config.secure = true;
+    }
+    if (this.config.secure === true && this.config.sameSite === void 0) {
+      this.config.sameSite = "none";
+    }
+  }
+  get() {
+    const entries = document.cookie.split(";");
+    for (const entry of entries) {
+      const [name, value] = entry.split("=");
+      if (CookieCache.decode(name).trim() === this.config.name) {
+        return CookieCache.decode(value.trim());
+      }
+    }
+    return null;
+  }
+  put(value) {
+    document.cookie = CookieCache.serializeCookie(value, this.config);
+  }
+  clear() {
+    document.cookie = CookieCache.serializeCookie("", {
+      ...this.config,
+      maxAge: 0
+    });
+  }
+  static serializeCookie(value, config) {
+    const cookie = [`${CookieCache.encode(config.name)}=${CookieCache.encode(value)}`];
+    if (config.maxAge !== void 0) {
+      cookie.push(`Max-Age=${config.maxAge}`);
+    }
+    if (config.domain !== void 0) {
+      cookie.push(`Domain=${CookieCache.encode(config.domain)}`);
+    }
+    if (config.path !== void 0) {
+      cookie.push(`Path=${CookieCache.encode(config.path)}`);
+    }
+    if (config.secure === true) {
+      cookie.push("Secure");
+    }
+    if (config.sameSite !== void 0) {
+      cookie.push(`SameSite=${{ strict: "Strict", lax: "Lax", none: "None" }[config.sameSite]}`);
+    }
+    return cookie.join("; ");
+  }
+  static encode(value) {
+    return value.replace(/[,; ]+/g, encodeURIComponent);
+  }
+  static decode(value) {
+    return decodeURIComponent(value);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CookieCache
+});
+//# sourceMappingURL=cookieCache.cjs.map

package/cache/fallbackCache.cjs

@@ -0,0 +1,47 @@
+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);
+var fallbackCache_exports = {};
+__export(fallbackCache_exports, {
+  FallbackCache: () => FallbackCache
+});
+module.exports = __toCommonJS(fallbackCache_exports);
+class FallbackCache {
+  constructor(...caches) {
+    this.caches = caches;
+  }
+  get() {
+    for (const cache of this.caches) {
+      const value = cache.get();
+      if (value !== null) {
+        return value;
+      }
+    }
+    return null;
+  }
+  put(value) {
+    this.caches.forEach((cache) => cache.put(value));
+  }
+  clear() {
+    this.caches.forEach((cache) => cache.clear());
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FallbackCache
+});
+//# sourceMappingURL=fallbackCache.cjs.map

package/cache/inMemoryCache.cjs

@@ -0,0 +1,41 @@
+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);
+var inMemoryCache_exports = {};
+__export(inMemoryCache_exports, {
+  InMemoryCache: () => InMemoryCache
+});
+module.exports = __toCommonJS(inMemoryCache_exports);
+class InMemoryCache {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  get() {
+    return this.cache ?? null;
+  }
+  put(value) {
+    this.cache = value;
+  }
+  clear() {
+    delete this.cache;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryCache
+});
+//# sourceMappingURL=inMemoryCache.cjs.map

package/cache/index.cjs

@@ -0,0 +1,37 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  FallbackCache: () => import_fallbackCache.FallbackCache,
+  InMemoryCache: () => import_inMemoryCache.InMemoryCache,
+  LocalStorageCache: () => import_localStorageCache.LocalStorageCache
+});
+module.exports = __toCommonJS(cache_exports);
+__reExport(cache_exports, require("./cache"), module.exports);
+var import_fallbackCache = require("./fallbackCache");
+var import_inMemoryCache = require("./inMemoryCache");
+var import_localStorageCache = require("./localStorageCache");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FallbackCache,
+  InMemoryCache,
+  LocalStorageCache,
+  ...require("./cache")
+});
+//# sourceMappingURL=index.cjs.map

package/cache/localStorageCache.cjs

@@ -0,0 +1,81 @@
+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);
+var localStorageCache_exports = {};
+__export(localStorageCache_exports, {
+  LocalStorageCache: () => LocalStorageCache
+});
+module.exports = __toCommonJS(localStorageCache_exports);
+class LocalStorageCache {
+  constructor(storage, key) {
+    this.listeners = [];
+    this.storage = storage;
+    this.key = key;
+    this.value = storage.getItem(key);
+  }
+  static autoSync(cache) {
+    const listener = cache.sync.bind(cache);
+    window.addEventListener("storage", listener);
+    return () => window.removeEventListener("storage", listener);
+  }
+  get() {
+    return this.value;
+  }
+  put(value) {
+    this.storage.setItem(this.key, value);
+    if (this.value !== value) {
+      this.value = value;
+      this.notifyChange(value);
+    }
+  }
+  clear() {
+    this.storage.removeItem(this.key);
+    if (this.value !== null) {
+      this.value = null;
+      this.notifyChange(null);
+    }
+  }
+  addListener(listener) {
+    if (!this.listeners.includes(listener)) {
+      this.listeners.push(listener);
+    }
+  }
+  removeListener(listener) {
+    const index = this.listeners.indexOf(listener);
+    if (index > -1) {
+      this.listeners.splice(index, 1);
+    }
+  }
+  notifyChange(value) {
+    this.listeners.forEach((listener) => listener(value));
+  }
+  sync(event) {
+    if (event.storageArea !== this.storage || event.key !== null && event.key !== this.key) {
+      return;
+    }
+    const value = this.storage.getItem(this.key);
+    if (this.value !== value) {
+      this.value = value;
+      this.notifyChange(value);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalStorageCache
+});
+//# sourceMappingURL=localStorageCache.cjs.map