@domql/state 3.2.3 → 3.2.8

package/dist/iife/index.js

@@ -0,0 +1,1051 @@
+"use strict";
+var DomqlState = (() => {
+  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);
+
+  // index.js
+  var index_exports = {};
+  __export(index_exports, {
+    add: () => add,
+    apply: () => apply,
+    applyFunction: () => applyFunction,
+    applyInitialState: () => applyInitialState,
+    applyReplace: () => applyReplace,
+    applyStateMethods: () => applyStateMethods,
+    clean: () => clean,
+    createState: () => createState,
+    destroy: () => destroy,
+    getByPath: () => getByPath,
+    hoistStateUpdate: () => hoistStateUpdate,
+    keys: () => keys,
+    parentUpdate: () => parentUpdate,
+    parse: () => parse,
+    quietReplace: () => quietReplace,
+    quietUpdate: () => quietUpdate,
+    remove: () => remove,
+    removeByPath: () => removeByPath,
+    removePathCollection: () => removePathCollection,
+    replace: () => replace,
+    reset: () => reset,
+    rootUpdate: () => rootUpdate,
+    set: () => set,
+    setByPath: () => setByPath,
+    setPathCollection: () => setPathCollection,
+    toggle: () => toggle,
+    updateState: () => updateState,
+    values: () => values
+  });
+
+  // ../utils/dist/esm/globals.js
+  var window = globalThis;
+  var document2 = window.document;
+
+  // ../utils/dist/esm/node.js
+  var isNode = (obj) => {
+    return (typeof Node === "object" ? obj instanceof window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+  };
+  var isHtmlElement = (obj) => {
+    return (typeof HTMLElement === "object" ? obj instanceof window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+  };
+  var isDOMNode = (obj) => {
+    return typeof window !== "undefined" && (obj instanceof window.Node || obj instanceof window.Window || obj === window || obj === document);
+  };
+
+  // ../utils/dist/esm/types.js
+  var isObject = (arg) => {
+    if (arg === null) return false;
+    return typeof arg === "object" && arg.constructor === Object;
+  };
+  var isString = (arg) => typeof arg === "string";
+  var isNumber = (arg) => typeof arg === "number";
+  var isFunction = (arg) => typeof arg === "function";
+  var isBoolean = (arg) => arg === true || arg === false;
+  var isNull = (arg) => arg === null;
+  var isArray = (arg) => Array.isArray(arg);
+  var isDate = (d) => d instanceof Date;
+  var isObjectLike = (arg) => {
+    if (arg === null) return false;
+    return typeof arg === "object";
+  };
+  var isDefined = (arg) => arg !== void 0;
+  var isUndefined = (arg) => arg === void 0;
+  var TYPES = {
+    boolean: isBoolean,
+    array: isArray,
+    object: isObject,
+    string: isString,
+    date: isDate,
+    number: isNumber,
+    null: isNull,
+    function: isFunction,
+    objectLike: isObjectLike,
+    node: isNode,
+    htmlElement: isHtmlElement,
+    defined: isDefined
+  };
+  var is = (arg) => {
+    return (...args) => args.some((val) => TYPES[val](arg));
+  };
+
+  // ../utils/dist/esm/array.js
+  var removeFromArray = (arr, index) => {
+    if (isString(index)) index = parseInt(index);
+    if (isNumber(index)) {
+      if (index < 0 || index >= arr.length || isNaN(index)) {
+        throw new Error("Invalid index");
+      }
+      arr.splice(index, 1);
+    } else {
+      throw new Error("Invalid index");
+    }
+    return arr;
+  };
+  var unstackArrayOfObjects = (arr, exclude = []) => {
+    return arr.reduce(
+      (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+      {}
+    );
+  };
+  var 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
+      });
+    }
+  };
+
+  // ../utils/dist/esm/keys.js
+  var STATE_METHODS = /* @__PURE__ */ new Set([
+    "update",
+    "parse",
+    "clean",
+    "create",
+    "destroy",
+    "add",
+    "toggle",
+    "remove",
+    "apply",
+    "set",
+    "reset",
+    "replace",
+    "quietReplace",
+    "quietUpdate",
+    "applyReplace",
+    "applyFunction",
+    "keys",
+    "values",
+    "ref",
+    "rootUpdate",
+    "parentUpdate",
+    "parent",
+    "__element",
+    "__depends",
+    "__ref",
+    "__children",
+    "root",
+    "setByPath",
+    "setPathCollection",
+    "removeByPath",
+    "removePathCollection",
+    "getByPath"
+  ]);
+  var PROPS_METHODS = /* @__PURE__ */ new Set(["update", "__element"]);
+  var METHODS = /* @__PURE__ */ new Set([
+    "set",
+    "reset",
+    "update",
+    "remove",
+    "updateContent",
+    "removeContent",
+    "lookup",
+    "lookdown",
+    "lookdownAll",
+    "getRef",
+    "getPath",
+    "setNodeStyles",
+    "spotByPath",
+    "keys",
+    "parse",
+    "setProps",
+    "parseDeep",
+    "variables",
+    "if",
+    "log",
+    "verbose",
+    "warn",
+    "error",
+    "call",
+    "nextElement",
+    "previousElement",
+    "getRootState",
+    "getRoot",
+    "getRootData",
+    "getRootContext",
+    "getContext",
+    "getChildren"
+  ]);
+  var METHODS_EXL = /* @__PURE__ */ new Set([
+    "node",
+    "context",
+    "extends",
+    "__element",
+    "__ref",
+    ...METHODS,
+    ...STATE_METHODS,
+    ...PROPS_METHODS
+  ]);
+
+  // ../utils/dist/esm/object.js
+  var _startsWithDunder = (e) => e.charCodeAt(0) === 95 && e.charCodeAt(1) === 95;
+  var exec = (param, element, state, context) => {
+    if (isFunction(param)) {
+      if (!element) return;
+      const result = param.call(
+        element,
+        element,
+        state || element.state,
+        context || element.context
+      );
+      if (result && typeof result.then === "function") {
+        let resolved;
+        result.then((value) => {
+          resolved = value;
+        });
+        return resolved;
+      }
+      return result;
+    }
+    return param;
+  };
+  var merge = (element, obj, excludeFrom = []) => {
+    const useSet = excludeFrom instanceof Set;
+    for (const e in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, e)) continue;
+      if (_startsWithDunder(e)) continue;
+      if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+      if (element[e] === void 0) {
+        element[e] = obj[e];
+      }
+    }
+    return element;
+  };
+  var deepMerge = (element, extend, excludeFrom = METHODS_EXL) => {
+    const useSet = excludeFrom instanceof Set;
+    for (const e in extend) {
+      if (!Object.prototype.hasOwnProperty.call(extend, e)) continue;
+      if (_startsWithDunder(e)) continue;
+      if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+      const elementProp = element[e];
+      const extendProp = extend[e];
+      if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
+        deepMerge(elementProp, extendProp, excludeFrom);
+      } else if (elementProp === void 0) {
+        element[e] = extendProp;
+      }
+    }
+    return element;
+  };
+  var deepClone = (obj, options = {}) => {
+    const {
+      exclude = [],
+      cleanUndefined = false,
+      cleanNull = false,
+      window: targetWindow,
+      visited = /* @__PURE__ */ new WeakMap(),
+      handleExtends = false
+    } = options;
+    const contentWindow = targetWindow || window || globalThis;
+    if (!isObjectLike(obj) || isDOMNode(obj)) {
+      return obj;
+    }
+    if (visited.has(obj)) {
+      return visited.get(obj);
+    }
+    const isArr = isArray(obj);
+    const clone2 = isArr ? [] : {};
+    visited.set(obj, clone2);
+    const excludeSet = exclude instanceof Set ? exclude : exclude.length > 3 ? new Set(exclude) : null;
+    for (const key in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      if (_startsWithDunder(key) || key === "__proto__") continue;
+      if (excludeSet ? excludeSet.has(key) : exclude.includes(key)) continue;
+      const value = obj[key];
+      if (cleanUndefined && value === void 0) continue;
+      if (cleanNull && value === null) continue;
+      if (isDOMNode(value)) {
+        clone2[key] = value;
+        continue;
+      }
+      if (handleExtends && key === "extends" && isArray(value)) {
+        clone2[key] = unstackArrayOfObjects(value, exclude);
+        continue;
+      }
+      if (isFunction(value) && options.window) {
+        clone2[key] = contentWindow.eval("(" + value.toString() + ")");
+        continue;
+      }
+      if (isObjectLike(value)) {
+        clone2[key] = deepClone(value, {
+          ...options,
+          visited
+        });
+      } else {
+        clone2[key] = value;
+      }
+    }
+    return clone2;
+  };
+  var overwriteShallow = (obj, params, excludeFrom = []) => {
+    const useSet = excludeFrom instanceof Set;
+    for (const e in params) {
+      if (_startsWithDunder(e)) continue;
+      if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+      obj[e] = params[e];
+    }
+    return obj;
+  };
+  var overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new WeakMap()) => {
+    if (!isObjectLike(obj) || !isObjectLike(params) || isDOMNode(obj) || isDOMNode(params)) {
+      return params;
+    }
+    if (visited.has(obj)) return visited.get(obj);
+    visited.set(obj, obj);
+    const excl = opts.exclude;
+    const exclSet = excl ? excl instanceof Set ? excl : new Set(excl) : null;
+    const forcedExclude = !opts.preventForce;
+    for (const e in params) {
+      if (!Object.prototype.hasOwnProperty.call(params, e)) continue;
+      if (exclSet && exclSet.has(e) || forcedExclude && _startsWithDunder(e)) continue;
+      const objProp = obj[e];
+      const paramsProp = params[e];
+      if (isDOMNode(paramsProp)) {
+        obj[e] = paramsProp;
+      } else if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
+        obj[e] = overwriteDeep(objProp, paramsProp, opts, visited);
+      } else if (paramsProp !== void 0) {
+        obj[e] = paramsProp;
+      }
+    }
+    return obj;
+  };
+  var removeFromObject = (obj, props) => {
+    if (props === void 0 || props === null) return obj;
+    if (is(props)("string", "number")) {
+      delete obj[props];
+    } else if (isArray(props)) {
+      for (let i = 0; i < props.length; i++) delete obj[props[i]];
+    } else {
+      throw new Error(
+        "Invalid input: props must be a string or an array of strings"
+      );
+    }
+    return obj;
+  };
+  var createNestedObject = (arr, lastValue) => {
+    if (arr.length === 0) return lastValue;
+    const nestedObject = {};
+    let current = nestedObject;
+    for (let i = 0; i < arr.length; i++) {
+      if (i === arr.length - 1 && lastValue) {
+        current[arr[i]] = lastValue;
+      } else {
+        current[arr[i]] = {};
+        current = current[arr[i]];
+      }
+    }
+    return nestedObject;
+  };
+  var removeNestedKeyByPath = (obj, path) => {
+    if (!Array.isArray(path)) {
+      throw new Error("Path must be an array.");
+    }
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+      if (current[path[i]] === void 0) return;
+      current = current[path[i]];
+    }
+    const lastKey = path[path.length - 1];
+    if (current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+      delete current[lastKey];
+    }
+  };
+  var setInObjectByPath = (obj, path, value) => {
+    if (!Array.isArray(path)) {
+      throw new Error("Path must be an array.");
+    }
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+      if (!current[path[i]] || typeof current[path[i]] !== "object") {
+        current[path[i]] = {};
+      }
+      current = current[path[i]];
+    }
+    current[path[path.length - 1]] = value;
+    return obj;
+  };
+  var getInObjectByPath = (obj, path) => {
+    if (!Array.isArray(path)) {
+      throw new Error("Path must be an array.");
+    }
+    let current = obj;
+    for (let i = 0; i < path.length; i++) {
+      if (current === void 0 || current === null) {
+        return void 0;
+      }
+      current = current[path[i]];
+    }
+    return current;
+  };
+
+  // ../utils/dist/esm/state.js
+  var checkForStateTypes = (element) => {
+    const { state: orig, props, __ref: ref } = element;
+    const state = props?.state || orig;
+    if (isFunction(state)) {
+      ref.__state = state;
+      return exec(state, element);
+    } else if (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;
+    }
+  };
+  var getRootStateInKey = (stateKey, parentState) => {
+    if (!stateKey.includes("~/")) return;
+    const arr = stateKey.split("~/");
+    if (arr.length > 1) return parentState.root;
+  };
+  var 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;
+  };
+  var getChildStateInKey = (stateKey, parentState, options = {}) => {
+    const arr = 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];
+  };
+  var 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);
+  };
+  var createInheritedState = (element, parent) => {
+    const ref = element.__ref;
+    const inheritedState = findInheritedState(element, parent);
+    if (inheritedState === void 0) return element.state;
+    if (is(inheritedState)("object", "array")) {
+      return deepClone(inheritedState);
+    } else if (is(inheritedState)("string", "number", "boolean")) {
+      ref.__stateType = typeof inheritedState;
+      return { value: inheritedState };
+    }
+    console.warn(ref.__state, "is not present. Replacing with", {});
+  };
+  var checkIfInherits = (element) => {
+    const { __ref: ref } = element;
+    const stateKey = ref?.__state;
+    if (stateKey && is(stateKey)("number", "string", "boolean")) return true;
+    return false;
+  };
+  var createNestedObjectByKeyPath = (path, value) => {
+    if (!path) {
+      return value || {};
+    }
+    const keys2 = path.split("/");
+    const obj = {};
+    let ref = obj;
+    const lastIdx = keys2.length - 1;
+    for (let i = 0; i <= lastIdx; i++) {
+      ref[keys2[i]] = i === lastIdx ? value || {} : {};
+      ref = ref[keys2[i]];
+    }
+    return obj;
+  };
+  var applyDependentState = (element, state) => {
+    const { __element } = state;
+    const origState = exec(__element?.state, element);
+    if (!origState) return;
+    const dependentState = deepClone(origState, STATE_METHODS);
+    const newDepends = { [element.key]: dependentState };
+    const __depends = isObject(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
+    if (Array.isArray(origState)) {
+      addProtoToArray(origState, {
+        ...Object.getPrototypeOf(origState),
+        __depends
+      });
+    } else {
+      Object.setPrototypeOf(origState, {
+        ...Object.getPrototypeOf(origState),
+        __depends
+      });
+    }
+    return dependentState;
+  };
+  var overwriteState = (state, obj, options = {}) => {
+    const { overwrite } = options;
+    if (!overwrite) return;
+    const shallow = overwrite === "shallow";
+    const merge2 = overwrite === "merge";
+    if (merge2) {
+      deepMerge(state, obj, STATE_METHODS);
+      return;
+    }
+    const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+    overwriteFunc(state, obj, STATE_METHODS);
+  };
+
+  // ../utils/dist/esm/triggerEvent.js
+  var getOnOrPropsEvent = (param, element) => {
+    const onEvent = element.on?.[param];
+    if (onEvent) return onEvent;
+    const props = element.props;
+    if (!props) return;
+    const propKey = "on" + param.charAt(0).toUpperCase() + param.slice(1);
+    return props[propKey];
+  };
+  var applyEvent = (param, element, state, context, options) => {
+    if (!isFunction(param)) return;
+    const result = param.call(
+      element,
+      element,
+      state || element.state,
+      context || element.context,
+      options
+    );
+    if (result && typeof result.then === "function") {
+      result.catch(() => {
+      });
+    }
+    return result;
+  };
+  var triggerEventOn = (param, element, options) => {
+    if (!element) {
+      throw new Error("Element is required");
+    }
+    const appliedFunction = getOnOrPropsEvent(param, element);
+    if (appliedFunction) {
+      const { state, context } = element;
+      return applyEvent(appliedFunction, element, state, context, options);
+    }
+  };
+  var applyEventUpdate = (param, updatedObj, element, state, context, options) => {
+    if (!isFunction(param)) return;
+    const result = param.call(
+      element,
+      updatedObj,
+      element,
+      state || element.state,
+      context || element.context,
+      options
+    );
+    if (result && typeof result.then === "function") {
+      result.catch(() => {
+      });
+    }
+    return result;
+  };
+  var triggerEventOnUpdate = (param, updatedObj, element, options) => {
+    const appliedFunction = getOnOrPropsEvent(param, element);
+    if (appliedFunction) {
+      const { state, context } = element;
+      return applyEventUpdate(
+        appliedFunction,
+        updatedObj,
+        element,
+        state,
+        context,
+        options
+      );
+    }
+  };
+
+  // ../../plugins/report/index.js
+  var ERRORS_REGISTRY = {
+    en: {
+      DocumentNotDefined: {
+        title: "Document is undefined",
+        description: "To tweak with DOM, you should use browser."
+      },
+      OverwriteToBuiltin: {
+        title: "Overwriting to builtin method",
+        description: "Overwriting a builtin method in the window define is not possible, please choose different name"
+      },
+      BrowserNotDefined: {
+        title: "Can't recognize environment",
+        description: "Environment should be browser application, that can run Javascript"
+      },
+      SetQuickPreferancesIsNotObject: {
+        title: "Quick preferances object is required",
+        description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+      },
+      InvalidParams: {
+        title: "Params are invalid",
+        description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+      },
+      CantCreateWithoutNode: {
+        title: "You must provide node",
+        description: "Can't create DOM element without setting node or text"
+      },
+      HTMLInvalidTag: {
+        title: "Element tag name (or DOM nodeName) is invalid",
+        description: "To create element, you must provide valid DOM node. See full list of them at here: http://www.w3schools.com/tags/"
+      },
+      HTMLInvalidAttr: {
+        title: "Attibutes object is invalid",
+        description: "Please pass a valid plain object to apply as an attributes for a DOM node"
+      },
+      HTMLInvalidData: {
+        title: "Data object is invalid",
+        description: "Please pass a valid plain object to apply as an dataset for a DOM node"
+      },
+      HTMLInvalidStyles: {
+        title: "Styles object is invalid",
+        description: "Please pass a valid plain object to apply as an style for a DOM node"
+      },
+      HTMLInvalidText: {
+        title: "Text string is invalid",
+        description: "Please pass a valid string to apply text to DOM node"
+      },
+      ElementOnStateIsNotDefined: {
+        title: "Element on state is not defined",
+        description: "Please check the element object"
+      }
+    }
+  };
+  var report = (err, arg, element) => {
+    const currentLang = "en";
+    let errObj;
+    if (err && typeof err === "string") errObj = ERRORS_REGISTRY[currentLang][err];
+    const description = errObj ? `
+
+${errObj.description}` : "";
+    const context = element ? `
+
+${element}` : "";
+    return new Error(`"${err}", "${arg}"${description}${context}`);
+  };
+
+  // updateState.js
+  var STATE_UPDATE_OPTIONS = {
+    overwrite: true,
+    preventHoistElementUpdate: false,
+    updateByState: true,
+    isHoisted: true,
+    execStateFunction: true
+  };
+  var updateState = function(obj, options = STATE_UPDATE_OPTIONS) {
+    const state = this;
+    const element = state.__element;
+    if (options.onEach) options.onEach(element, state, element.context, options);
+    if (!options.updateByState) merge(options, STATE_UPDATE_OPTIONS);
+    if (!state.__element) report("ElementOnStateIsNotDefined");
+    if (options.preventInheritAtCurrentState === true) {
+      options.preventInheritAtCurrentState = state;
+    } else if (options.preventInheritAtCurrentState) return;
+    if (!options.preventBeforeStateUpdateListener) {
+      const beforeStateUpdateReturns = triggerEventOnUpdate(
+        "beforeStateUpdate",
+        obj,
+        element,
+        options
+      );
+      if (beforeStateUpdateReturns === false) return element;
+    }
+    overwriteState(state, obj, options);
+    const updateIsHoisted = hoistStateUpdate(state, obj, options);
+    if (updateIsHoisted) return state;
+    updateDependentState(state, obj, options);
+    applyElementUpdate(state, obj, options);
+    if (!options.preventStateUpdateListener) {
+      triggerEventOnUpdate("stateUpdate", obj, element, options);
+    }
+    return state;
+  };
+  var hoistStateUpdate = (state, obj, options) => {
+    const element = state.__element;
+    const { parent, __ref: ref } = element;
+    const stateKey = ref?.__state;
+    const stateType = ref?.__stateType;
+    if (!stateKey) return;
+    const asksForInherit = checkIfInherits(element);
+    const inheritedState = findInheritedState(element, parent, {
+      returnParent: true
+    });
+    const shouldPropagateState = asksForInherit && inheritedState && !options.stopStatePropagation;
+    if (!shouldPropagateState) return;
+    const isStringState = stateType === "string" || stateType === "number" || stateType === "boolean";
+    const value = isStringState ? state.value : state.parse();
+    const passedValue = isStringState ? state.value : obj;
+    const findRootState = getRootStateInKey(stateKey, parent.state);
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    const changesValue = createNestedObjectByKeyPath(stateKey, passedValue);
+    const targetParent = findRootState || findGrandParentState || parent.state;
+    if (options.replace) overwriteDeep(targetParent, changesValue || value);
+    targetParent.update(changesValue, {
+      execStateFunction: false,
+      isHoisted: true,
+      preventUpdate: options.preventHoistElementUpdate,
+      overwrite: !options.replace,
+      ...options
+    });
+    const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
+    if (!options.preventStateUpdateListener && hasNotUpdated) {
+      triggerEventOnUpdate("stateUpdate", obj, element, options);
+    }
+    return true;
+  };
+  var updateDependentState = (state, obj, options) => {
+    if (!state.__depends) return;
+    for (const el in state.__depends) {
+      const dependentState = state.__depends[el];
+      const cleanState = dependentState.clean();
+      cleanState.update(state.parse(), options);
+    }
+  };
+  var applyElementUpdate = (state, obj, options) => {
+    const element = state.__element;
+    if (options.preventUpdate !== true) {
+      element.update(
+        {},
+        {
+          ...options,
+          updateByState: true
+        }
+      );
+    } else if (options.preventUpdate === "recursive") {
+      element.update(
+        {},
+        {
+          ...options,
+          isHoisted: false,
+          updateByState: true,
+          preventUpdate: true
+        }
+      );
+    }
+  };
+
+  // methods.js
+  var parse = function() {
+    const state = this;
+    if (isObject(state)) {
+      const obj = {};
+      for (const param in state) {
+        if (!STATE_METHODS.has(param)) {
+          obj[param] = state[param];
+        }
+      }
+      return obj;
+    } else if (isArray(state)) {
+      return state.filter((item) => !STATE_METHODS.has(item));
+    }
+  };
+  var clean = function(options = {}) {
+    const state = this;
+    for (const param in state) {
+      if (!STATE_METHODS.has(param) && Object.prototype.hasOwnProperty.call(state, param)) {
+        delete state[param];
+      }
+    }
+    if (!options.preventStateUpdate) {
+      state.update(state, { replace: true, ...options });
+    }
+    return state;
+  };
+  var destroy = function(options = {}) {
+    const state = this;
+    const element = state.__element;
+    const stateKey = element.__ref.__state;
+    if (isString(stateKey)) {
+      element.parent.state.remove(stateKey, { isHoisted: true, ...options });
+      return element.state;
+    }
+    delete element.state;
+    element.state = state.parent;
+    if (state.parent) {
+      delete state.parent.__children[element.key];
+    }
+    if (state.__children) {
+      for (const key in state.__children) {
+        const child = state.__children[key];
+        if (child.state) {
+          if (isArray(child.state)) {
+            Object.defineProperty(child.state, "parent", {
+              value: state.parent,
+              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
+            });
+          } else {
+            Object.setPrototypeOf(child, { parent: state.parent });
+          }
+        }
+      }
+    }
+    element.state.update({}, { isHoisted: true, ...options });
+    return element.state;
+  };
+  var parentUpdate = function(obj, options = {}) {
+    const state = this;
+    if (!state || !state.parent) return;
+    return state.parent.update(obj, { isHoisted: true, ...options });
+  };
+  var rootUpdate = function(obj, options = {}) {
+    const state = this;
+    if (!state) return;
+    const rootState = state.__element.__ref.root.state;
+    return rootState.update(obj, { isHoisted: false, ...options });
+  };
+  var add = function(value, options = {}) {
+    const state = this;
+    if (isArray(state)) {
+      state.push(value);
+      state.update(state.parse(), { overwrite: true, ...options });
+    } else if (isObject(state)) {
+      const key = Object.keys(state).length;
+      state.update({ [key]: value }, options);
+    }
+  };
+  var toggle = function(key, options = {}) {
+    const state = this;
+    state.update({ [key]: !state[key] }, options);
+  };
+  var remove = function(key, options = {}) {
+    const state = this;
+    if (isArray(state)) removeFromArray(state, key);
+    else if (isObject(state)) removeFromObject(state, key);
+    if (options.applyReset) {
+      return state.set(state.parse(), { replace: true, ...options });
+    }
+    return state.update({}, options);
+  };
+  var set = function(val, options = {}) {
+    const state = this;
+    const value = deepClone(val);
+    const cleanState = state.clean({ preventStateUpdate: true, ...options });
+    return cleanState.update(value, { replace: true, ...options });
+  };
+  var setByPath = function(path, val, options = {}) {
+    const state = this;
+    const value = deepClone(val);
+    if (!options.preventReplace) setInObjectByPath(state, path, val);
+    const update = createNestedObject(path, value);
+    if (options.preventStateUpdate) return update;
+    return state.update(update, options);
+  };
+  var setPathCollection = function(changes, options = {}) {
+    const state = this;
+    const update = changes.reduce((acc, change) => {
+      if (change[0] === "update") {
+        const result = setByPath.call(state, change[1], change[2], {
+          preventStateUpdate: true
+        });
+        return overwriteDeep(acc, result);
+      } else if (change[0] === "delete") {
+        removeByPath.call(state, change[1], {
+          ...options,
+          preventUpdate: true
+        });
+      }
+      return acc;
+    }, {});
+    return state.update(update, options);
+  };
+  var removeByPath = function(path, options = {}) {
+    const state = this;
+    removeNestedKeyByPath(state, path);
+    if (options.preventUpdate) return path;
+    return state.update({}, options);
+  };
+  var removePathCollection = function(changes, options = {}) {
+    const state = this;
+    for (let i = 0; i < changes.length; i++) {
+      removeByPath(changes[i], { preventUpdate: true });
+    }
+    return state.update({}, options);
+  };
+  var getByPath = function(path, options = {}) {
+    const state = this;
+    return getInObjectByPath(state, path);
+  };
+  var reset = function(options = {}) {
+    const state = this;
+    const value = deepClone(state.parse());
+    return state.set(value, { replace: true, ...options });
+  };
+  var apply = function(func, options = {}) {
+    const state = this;
+    if (isFunction(func)) {
+      const value = func(state);
+      return state.update(value, { replace: true, ...options });
+    }
+  };
+  var applyReplace = function(func, options = {}) {
+    const state = this;
+    if (isFunction(func)) {
+      const value = func(state);
+      return state.replace(value, options);
+    }
+  };
+  var applyFunction = function(func, options = {}) {
+    const state = this;
+    if (isFunction(func)) {
+      func(state);
+      return state.update(state.parse(), { replace: true, ...options });
+    }
+  };
+  var quietUpdate = function(obj, options = {}) {
+    const state = this;
+    return state.update(obj, { preventUpdate: true, ...options });
+  };
+  var replace = function(obj, options = {}) {
+    const state = this;
+    for (const param in obj) {
+      state[param] = obj[param];
+    }
+    return state.update(obj, options);
+  };
+  var quietReplace = function(obj, options = {}) {
+    const state = this;
+    return state.replace(obj, { preventUpdate: true, ...options });
+  };
+  var keys = function(obj, options = {}) {
+    const state = this;
+    return Object.keys(state);
+  };
+  var values = function(obj, options = {}) {
+    const state = this;
+    return Object.values(state);
+  };
+  var applyStateMethods = (element) => {
+    const state = element.state;
+    const ref = element.__ref;
+    const proto = {
+      clean: clean.bind(state),
+      parse: parse.bind(state),
+      destroy: destroy.bind(state),
+      update: updateState.bind(state),
+      rootUpdate: rootUpdate.bind(state),
+      parentUpdate: parentUpdate.bind(state),
+      create: createState.bind(state),
+      add: add.bind(state),
+      toggle: toggle.bind(state),
+      remove: remove.bind(state),
+      apply: apply.bind(state),
+      applyReplace: applyReplace.bind(state),
+      applyFunction: applyFunction.bind(state),
+      set: set.bind(state),
+      quietUpdate: quietUpdate.bind(state),
+      replace: replace.bind(state),
+      quietReplace: quietReplace.bind(state),
+      reset: reset.bind(state),
+      parent: element.parent?.state || state,
+      setByPath: setByPath.bind(state),
+      setPathCollection: setPathCollection.bind(state),
+      removeByPath: removeByPath.bind(state),
+      removePathCollection: removePathCollection.bind(state),
+      getByPath: getByPath.bind(state),
+      keys: keys.bind(state),
+      values: values.bind(state),
+      __element: element,
+      __children: {},
+      root: ref?.root ? ref.root.state : state
+    };
+    if (isArray(state)) {
+      addProtoToArray(state, proto);
+    } else {
+      Object.setPrototypeOf(state, proto);
+    }
+    if (state.parent && state.parent.__children) {
+      state.parent.__children[element.key] = state;
+    }
+  };
+
+  // create.js
+  var createState = function(element, parent, options) {
+    element.state = applyInitialState(element, parent, options);
+    return element.state;
+  };
+  var applyInitialState = function(element, parent, options) {
+    const objectizeState = checkForStateTypes(element);
+    if (objectizeState === false) return parent.state || {};
+    else element.state = objectizeState;
+    const whatInitReturns = triggerEventOn("stateInit", element, options);
+    if (whatInitReturns === false) return element.state;
+    if (checkIfInherits(element)) {
+      const inheritedState = createInheritedState(element, parent);
+      element.state = isUndefined(inheritedState) ? {} : inheritedState;
+    }
+    const dependentState = applyDependentState(
+      element,
+      element.state || parent.state || {}
+    );
+    if (dependentState) element.state = dependentState;
+    applyStateMethods(element);
+    triggerEventOn("stateCreated", element);
+    return element.state;
+  };
+  return __toCommonJS(index_exports);
+})();