@domql/utils 2.5.200 → 3.0.0

package/dist/cjs/state.js

@@ -0,0 +1,175 @@
+"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);
+var state_exports = {};
+__export(state_exports, {
+  applyDependentState: () => applyDependentState,
+  checkForStateTypes: () => checkForStateTypes,
+  checkIfInherits: () => checkIfInherits,
+  createInheritedState: () => createInheritedState,
+  createNestedObjectByKeyPath: () => createNestedObjectByKeyPath,
+  findInheritedState: () => findInheritedState,
+  getChildStateInKey: () => getChildStateInKey,
+  getParentStateInKey: () => getParentStateInKey,
+  getRootStateInKey: () => getRootStateInKey,
+  isState: () => isState,
+  overwriteState: () => overwriteState
+});
+module.exports = __toCommonJS(state_exports);
+var import_array = require("./array.js");
+var import_keys = require("./keys.js");
+var import_object = require("./object.js");
+var import_types = require("./types.js");
+const checkForStateTypes = async (element) => {
+  const { state: orig, props, __ref: ref } = element;
+  const state = (props == null ? void 0 : props.state) || orig;
+  if ((0, import_types.isFunction)(state)) {
+    ref.__state = state;
+    return await (0, import_object.execPromise)(state, element);
+  } else if ((0, import_types.is)(state)("string", "number")) {
+    ref.__state = state;
+    return { value: state };
+  } else if (state === true) {
+    ref.__state = element.key;
+    return {};
+  } else if (state) {
+    ref.__hasRootState = true;
+    return state;
+  } else {
+    return false;
+  }
+};
+const getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/")) return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1) return parentState.root;
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../")) return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent) return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = (0, import_types.isString)(stateKey) ? stateKey.split("/") : [stateKey];
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+    let childInParent = parentState[childKey];
+    if (!childInParent) childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent) return parentState;
+  return parentState[stateKey];
+};
+const findInheritedState = (element, parent, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element)) return;
+  const rootState = getRootStateInKey(stateKey, parent.state);
+  let parentState = parent.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState) return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+const createInheritedState = (element, parent) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent);
+  if ((0, import_types.isUndefined)(inheritedState)) return element.state;
+  if ((0, import_types.is)(inheritedState)("object", "array")) {
+    return (0, import_object.deepClone)(inheritedState);
+  } else if ((0, import_types.is)(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const { __ref: ref } = element;
+  const stateKey = ref == null ? void 0 : ref.__state;
+  if (stateKey && (0, import_types.is)(stateKey)("number", "string", "boolean")) return true;
+  return false;
+};
+const isState = function(state) {
+  if (!(0, import_types.isObjectLike)(state)) return false;
+  return Boolean(
+    state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.keys && state.values && state.toggle && state.replace && state.quietUpdate && state.quietReplace && state.add && state.apply && state.applyReplace && state.setByPath && state.setPathCollection && state.removeByPath && state.removePathCollection && state.getByPath && state.applyFunction && state.__element && state.__children
+  );
+};
+const createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys = path.split("/");
+  const obj = {};
+  let ref = obj;
+  keys.forEach((key, index) => {
+    ref[key] = index === keys.length - 1 ? value || {} : {};
+    ref = ref[key];
+  });
+  return obj;
+};
+const applyDependentState = async (element, state) => {
+  const { __element } = state;
+  const origState = await (0, import_object.execPromise)(__element == null ? void 0 : __element.state, element);
+  if (!origState) return;
+  const dependentState = (0, import_object.deepClone)(origState, import_keys.STATE_METHODS);
+  const newDepends = { [element.key]: dependentState };
+  const __depends = (0, import_types.isObject)(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
+  if (Array.isArray(origState)) {
+    (0, import_array.addProtoToArray)(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  } else {
+    Object.setPrototypeOf(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  }
+  return dependentState;
+};
+const overwriteState = (state, obj, options = {}) => {
+  const { overwrite } = options;
+  if (!overwrite) return;
+  const shallow = overwrite === "shallow";
+  const merge = overwrite === "merge";
+  if (merge) {
+    (0, import_object.deepMerge)(state, obj, import_keys.STATE_METHODS);
+    return;
+  }
+  const overwriteFunc = shallow ? import_object.overwriteShallow : import_object.overwriteDeep;
+  overwriteFunc(state, obj, import_keys.STATE_METHODS);
+};

package/dist/cjs/string.js

@@ -43,28 +43,37 @@ const trimStringFromSymbols = (str, characters) => {
   return str.replace(pattern, "");
 };
 const brackRegex = {
-  2: /\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}/g,
-  3: /\{\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}\}/g
+  2: /{{\s*((?:\.\.\/)*)([\w\d.]+)\s*}}/g,
+  3: /{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*}}}/g
 };
-function replaceLiteralsWithObjectFields(str, options = {}, forcedState) {
-  if (!str.includes(options.bracketsLength === 3 ? "{{{" : "{{")) return str;
-  const reg = brackRegex[options.bracketsLength || 2];
-  const obj = forcedState || (this == null ? void 0 : this.state) || {};
+const getNestedValue = (obj, path) => {
+  return path.split(".").reduce((acc, part) => {
+    return acc && acc[part] !== void 0 ? acc[part] : void 0;
+  }, obj);
+};
+function replaceLiteralsWithObjectFields(str, state = {}, options = {}) {
+  const { bracketsLength = 2 } = options;
+  const bracketPattern = bracketsLength === 3 ? "{{{" : "{{";
+  if (!str.includes(bracketPattern)) return str;
+  const reg = brackRegex[bracketsLength];
+  const obj = state || {};
   return str.replace(reg, (_, parentPath, variable) => {
     if (parentPath) {
-      const parentLevels = parentPath.match(options.bracketsLength === 3 ? /\.\.\.\//g : /\.\.\//g).length;
+      const parentLevels = (parentPath.match(/\.\.\//g) || []).length;
       let parentState = obj;
       for (let i = 0; i < parentLevels; i++) {
+        if (!parentState || !parentState.parent) return "";
         parentState = parentState.parent;
-        if (!parentState) {
-          return "";
-        }
       }
-      const value = parentState[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const key = variable.trim();
+      if (key === "parent") {
+        return parentState.value !== void 0 ? String(parentState.value) : "";
+      }
+      const value = getNestedValue(parentState, key);
+      return value !== void 0 ? String(value) : "";
     } else {
-      const value = obj[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const value = getNestedValue(obj, variable.trim());
+      return value !== void 0 ? String(value) : "";
     }
   });
 }
@@ -140,5 +149,8 @@ const customEncodeURIComponent = (str) => {
   }).join("");
 };
 const customDecodeURIComponent = (encodedStr) => {
-  return encodedStr.replace(/%[0-9A-Fa-f]{2}/g, (match) => String.fromCharCode(parseInt(match.slice(1), 16)));
+  return encodedStr.replace(
+    /%[0-9A-Fa-f]{2}/g,
+    (match) => String.fromCharCode(parseInt(match.slice(1), 16))
+  );
 };

package/dist/cjs/update.js

@@ -0,0 +1,42 @@
+"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);
+var update_exports = {};
+__export(update_exports, {
+  captureSnapshot: () => captureSnapshot
+});
+module.exports = __toCommonJS(update_exports);
+var import_key = require("./key.js");
+const snapshot = {
+  snapshotId: import_key.createSnapshotId
+};
+const captureSnapshot = (element, options) => {
+  const ref = element.__ref;
+  const { currentSnapshot, calleeElement } = options;
+  const isCallee = calleeElement === element;
+  if (!calleeElement || isCallee) {
+    const createdStanpshot = snapshot.snapshotId();
+    ref.__currentSnapshot = createdStanpshot;
+    return [createdStanpshot, element];
+  }
+  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
+  if (currentSnapshot < snapshotOnCallee) {
+    return [snapshotOnCallee, calleeElement, true];
+  }
+  return [snapshotOnCallee, calleeElement];
+};

package/dist/esm/array.js

@@ -15,24 +15,23 @@ const removeFromArray = (arr, index) => {
       throw new Error("Invalid index");
     }
     arr.splice(index, 1);
-  } else if (isArray(index)) {
-    index.forEach((idx) => removeFromArray(arr, idx));
   } else {
     throw new Error("Invalid index");
   }
   return arr;
 };
 const swapItemsInArray = (arr, i, j) => {
+  ;
   [arr[i], arr[j]] = [arr[j], arr[i]];
 };
 const joinArrays = (...arrays) => {
   return [].concat(...arrays);
 };
-const mergeArray = (arr, exclude = []) => {
-  return arr.reduce((a, c) => deepMerge(a, deepClone(c, { exclude }), exclude), {});
-};
-const mergeAndCloneIfArray = (obj) => {
-  return isArray(obj) ? mergeArray(obj) : deepClone(obj);
+const unstackArrayOfObjects = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+    {}
+  );
 };
 const cutArrayBeforeValue = (arr, value) => {
   const index = arr.indexOf(value);
@@ -104,8 +103,26 @@ const checkIfStringIsInArray = (string, arr) => {
   if (!string) return;
   return arr.filter((v) => string.includes(v)).length;
 };
+const removeDuplicatesInArray = (arr) => {
+  if (!isArray(arr)) return arr;
+  return [...new Set(arr)];
+};
+const addProtoToArray = (state, proto) => {
+  for (const key in proto) {
+    Object.defineProperty(state, key, {
+      value: proto[key],
+      enumerable: false,
+      // Set this to true if you want the method to appear in for...in loops
+      configurable: true,
+      // Set this to true if you want to allow redefining/removing the property later
+      writable: true
+      // Set this to true if you want to allow changing the function later
+    });
+  }
+};
 export {
   addItemAfterEveryElement,
+  addProtoToArray,
   arrayContainsOtherArray,
   arraysEqual,
   checkIfStringIsInArray,
@@ -115,11 +132,11 @@ export {
   filterArraysFast,
   getFrequencyInArray,
   joinArrays,
-  mergeAndCloneIfArray,
-  mergeArray,
+  removeDuplicatesInArray,
   removeFromArray,
   removeValueFromArray,
   removeValueFromArrayAll,
   reorderArrayByValues,
-  swapItemsInArray
+  swapItemsInArray,
+  unstackArrayOfObjects
 };

package/dist/esm/cache.js

@@ -0,0 +1,6 @@
+const cache = {};
+const OPTIONS = {};
+export {
+  OPTIONS,
+  cache
+};

package/dist/esm/component.js

@@ -1,236 +1,27 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { joinArrays } from "./array.js";
-import { deepClone, exec } from "./object.js";
-import { isArray, isFunction, isObject, isString } from "./types.js";
-const ENV = "development";
-const checkIfKeyIsComponent = (key) => {
+import { createExtendsFromKeys } from "./extends.js";
+import { isString } from "./types.js";
+const matchesComponentNaming = (key) => {
   const isFirstKeyString = isString(key);
   if (!isFirstKeyString) return;
   const firstCharKey = key.slice(0, 1);
   return /^[A-Z]*$/.test(firstCharKey);
 };
-const checkIfKeyIsProperty = (key) => {
-  const isFirstKeyString = isString(key);
-  if (!isFirstKeyString) return;
-  const firstCharKey = key.slice(0, 1);
-  return /^[a-z]*$/.test(firstCharKey);
-};
-const addAdditionalExtend = (newExtend, element) => {
-  if (!newExtend) return element;
-  const { extend: elementExtend } = element;
-  const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
-  const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
-  const extend = joinArrays(receivedArray, originalArray);
-  return __spreadProps(__spreadValues({}, element), { extend });
-};
-const checkIfSugar = (element, parent, key) => {
-  var _a;
-  const {
-    extend,
-    props,
-    childExtend,
-    extends: extendProps,
-    childExtends,
-    childProps,
-    children,
-    on,
-    $collection,
-    $stateCollection,
-    $propsCollection
-  } = element;
-  const hasComponentAttrs = extend || childExtend || props || on || $collection || $stateCollection || $propsCollection;
-  if (hasComponentAttrs && (childProps || extendProps || children || childExtends)) {
-    const logErr = (_a = parent || element) == null ? void 0 : _a.error;
-    if (logErr) logErr.call(element, "Sugar component includes params for builtin components", { verbose: true });
-  }
-  return !hasComponentAttrs || childProps || extendProps || children || childExtends;
-};
-const extractComponentKeyFromKey = (key) => {
-  return key.includes("+") ? key.split("+") : key.includes("_") ? [key.split("_")[0]] : key.includes(".") && !checkIfKeyIsComponent(key.split(".")[1]) ? [key.split(".")[0]] : [key];
-};
-const extendizeByKey = (element, parent, key) => {
-  const { context } = parent;
-  const { tag, extend, childExtends } = element;
-  const isSugar = checkIfSugar(element, parent, key);
-  const extendFromKey = extractComponentKeyFromKey(key);
-  const isExtendKeyComponent = context && context.components[extendFromKey];
-  if (element === isExtendKeyComponent) return element;
-  else if (isSugar) {
-    const newElem = addAdditionalExtend(element.extends, {
-      extend: extendFromKey,
-      tag,
-      props: __spreadValues({}, element)
-    });
-    if (newElem.props.data) {
-      newElem.data = newElem.props.data;
-      delete newElem.props.data;
-    }
-    if (newElem.props.state) {
-      newElem.state = newElem.props.state;
-      delete newElem.props.state;
-    }
-    if (newElem.props.attr) {
-      newElem.attr = newElem.props.attr;
-      delete newElem.props.attr;
-    }
-    if (newElem.props.if) {
-      newElem.if = newElem.props.if;
-      delete newElem.props.if;
-    }
-    if (childExtends) newElem.childExtend = childExtends;
-    return newElem;
-  } else if (!extend || extend === true) {
-    return __spreadProps(__spreadValues({}, element), {
-      tag,
-      extend: extendFromKey
-    });
-  } else if (extend) {
-    return addAdditionalExtend(extendFromKey, element);
-  } else if (isFunction(element)) {
-    return {
-      extend: extendFromKey,
-      tag,
-      props: __spreadValues({}, exec(element, parent))
-    };
-  }
-};
 function getCapitalCaseKeys(obj) {
   return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
 }
-const addChildrenIfNotInOriginal = (element, parent, key) => {
-  const childElems = getCapitalCaseKeys(element.props);
-  if (!childElems.length) return element;
-  for (const i in childElems) {
-    const childKey = childElems[i];
-    const childElem = element[childKey];
-    const newChild = element.props[childKey];
-    const assignChild = (val) => {
-      element[childKey] = val;
-      delete element.props[childKey];
-    };
-    if (newChild == null ? void 0 : newChild.ignoreExtend) continue;
-    if (newChild === null) assignChild(null);
-    else if (!childElem) assignChild(deepClone(newChild));
-    else {
-      const isSugarChildElem = checkIfSugar(childElem, parent, key);
-      if (isSugarChildElem) continue;
-      assignChild({
-        extend: element[childKey],
-        props: newChild
-      });
-    }
-  }
-};
-const applyKeyComponentAsExtend = (element, parent, key) => {
-  return extendizeByKey(element, parent, key) || element;
-};
-const applyComponentFromContext = (element, parent, options) => {
-  const { context } = element;
-  if (!context || !context.components) return;
-  const { components } = context;
-  const { extend } = element;
-  const execExtend = exec(extend, element);
-  if (isString(execExtend)) {
-    const componentExists = components[execExtend] || components["smbls." + execExtend];
-    if (componentExists) element.extend = componentExists;
-    else {
-      if ((ENV === "test" || ENV === "development") && options.verbose) {
-        console.warn(execExtend, "is not in library", components, element);
-        console.warn("replacing with ", {});
-      }
-      element.extend = {};
-    }
-  }
-};
-const isVariant = (param) => {
-  if (!isString(param)) return;
-  const firstCharKey = param.slice(0, 1);
-  return firstCharKey === ".";
-};
-const hasVariantProp = (element) => {
-  const { props } = element;
-  if (isObject(props) && isString(props.variant)) return true;
-};
-const getChildrenComponentsByKey = (key, el) => {
-  if (key === el.key || el.__ref.__componentKey === key) {
-    return el;
-  }
-  if (el.extend) {
-    const foundString = isString(el.extend) && el.extend === key;
-    const foundInArray = isArray(el.extend) && el.extend.filter((v) => v === key).length;
-    if (foundString || foundInArray) return el;
-  }
-  if (el.parent && el.parent.childExtend) {
-    const foundString = isString(el.parent.childExtend) && el.parent.childExtend === key;
-    const foundInArray = isArray(el.parent.childExtend) && el.parent.childExtend.filter((v) => v === key).length;
-    if (foundString || foundInArray) return el;
-  }
-};
-const getExtendsInElement = (obj) => {
-  let result = [];
-  function traverse(o) {
-    for (const key in o) {
-      if (Object.hasOwnProperty.call(o, key)) {
-        if (checkIfKeyIsComponent(key)) {
-          result.push(key);
-        }
-        if (key === "extend" || key === "extends") {
-          if (typeof o[key] === "string") {
-            result.push(o[key]);
-          } else if (Array.isArray(o[key])) {
-            result = result.concat(o[key]);
-          }
-        }
-        if (typeof o[key] === "object" && o[key] !== null) {
-          traverse(o[key]);
-        }
-      }
-    }
-  }
-  traverse(obj);
-  return result;
-};
-const setContentKey = (el, opts = {}) => {
-  const { __ref: ref } = el;
-  const contentElementKey = opts.contentElementKey;
-  if (contentElementKey !== "content" && contentElementKey !== ref.contentElementKey || !ref.contentElementKey) {
-    ref.contentElementKey = contentElementKey || "content";
-  } else ref.contentElementKey = "content";
-  if (contentElementKey !== "content") opts.contentElementKey = "content";
-  return ref.contentElementKey;
-};
+function getSpreadChildren(obj) {
+  return Object.keys(obj).filter((key) => /^\d+$/.test(key));
+}
+function isContextComponent(element, parent, passedKey) {
+  var _a, _b;
+  const { context } = parent || {};
+  const [extendsKey] = createExtendsFromKeys(passedKey);
+  const key = passedKey || extendsKey;
+  return ((_a = context == null ? void 0 : context.components) == null ? void 0 : _a[key]) || ((_b = context == null ? void 0 : context.pages) == null ? void 0 : _b[key]);
+}
 export {
-  addAdditionalExtend,
-  addChildrenIfNotInOriginal,
-  applyComponentFromContext,
-  applyKeyComponentAsExtend,
-  checkIfKeyIsComponent,
-  checkIfKeyIsProperty,
-  checkIfSugar,
-  extendizeByKey,
-  extractComponentKeyFromKey,
   getCapitalCaseKeys,
-  getChildrenComponentsByKey,
-  getExtendsInElement,
-  hasVariantProp,
-  isVariant,
-  setContentKey
+  getSpreadChildren,
+  isContextComponent,
+  matchesComponentNaming
 };

package/dist/esm/cookie.js

@@ -25,25 +25,25 @@ const removeCookie = (cname) => {
   document.cookie = cname + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
 };
 function getLocalStorage(key) {
-  let savedJSON;
-  if (window.localStorage) {
-    try {
-      savedJSON = JSON.parse(window.localStorage.getItem(key));
-    } catch (e) {
-    }
+  if (!window.localStorage) {
+    return void 0;
   }
-  if (typeof savedJSON !== "undefined") {
-    return savedJSON;
+  const item = window.localStorage.getItem(key);
+  if (item === null) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(item);
+  } catch (e) {
+    return void 0;
   }
 }
 function setLocalStorage(key, data) {
-  if (data && window.localStorage) {
-    if (typeof data === "object") {
-      window.localStorage.setItem(key, JSON.stringify(data));
-    } else {
-      window.localStorage.setItem(key, data);
-    }
+  if (!window.localStorage || data === void 0 || data === null) {
+    return;
   }
+  const value = typeof data === "object" ? JSON.stringify(data) : data;
+  window.localStorage.setItem(key, value);
 }
 export {
   getCookie,