@domql/utils 3.1.2 → 3.2.7

package/dist/iife/index.js

@@ -0,0 +1,2779 @@
+"use strict";
+var DomqlUtils = (() => {
+  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, {
+    DOMQL_EVENTS: () => DOMQL_EVENTS,
+    DOMQ_PROPERTIES: () => DOMQ_PROPERTIES,
+    ENV: () => ENV2,
+    HTML_TAGS: () => HTML_TAGS,
+    METHODS: () => METHODS,
+    METHODS_EXL: () => METHODS_EXL,
+    NODE_ENV: () => NODE_ENV,
+    OPTIONS: () => OPTIONS,
+    PARSED_DOMQ_PROPERTIES: () => PARSED_DOMQ_PROPERTIES,
+    PROPS_METHODS: () => PROPS_METHODS,
+    STATE_METHODS: () => STATE_METHODS,
+    STATE_PROPERTIES: () => STATE_PROPERTIES,
+    SVG_TAGS: () => SVG_TAGS,
+    TYPES: () => TYPES,
+    addCaching: () => addCaching,
+    addContext: () => addContext,
+    addExtend: () => addExtend,
+    addExtends: () => addExtends,
+    addItemAfterEveryElement: () => addItemAfterEveryElement,
+    addProtoToArray: () => addProtoToArray,
+    addRef: () => addRef,
+    applyDependentState: () => applyDependentState,
+    applyEvent: () => applyEvent,
+    applyEventUpdate: () => applyEventUpdate,
+    applyExtends: () => applyExtends,
+    applyProps: () => applyProps,
+    arrayContainsOtherArray: () => arrayContainsOtherArray,
+    arraysEqual: () => arraysEqual,
+    cache: () => cache,
+    call: () => call,
+    captureSnapshot: () => captureSnapshot,
+    checkForStateTypes: () => checkForStateTypes,
+    checkIfInherits: () => checkIfInherits,
+    checkIfStringIsInArray: () => checkIfStringIsInArray,
+    clone: () => clone,
+    cloneAndMergeArrayExtend: () => cloneAndMergeArrayExtend,
+    cloneFunction: () => cloneFunction,
+    concatAddExtends: () => concatAddExtends,
+    createBasedOnType: () => createBasedOnType,
+    createElement: () => createElement,
+    createElementExtends: () => createElementExtends,
+    createExtends: () => createExtends,
+    createExtendsFromKeys: () => createExtendsFromKeys,
+    createExtendsStack: () => createExtendsStack,
+    createIfConditionFlag: () => createIfConditionFlag,
+    createInheritedState: () => createInheritedState,
+    createKey: () => createKey,
+    createNestedObject: () => createNestedObject,
+    createNestedObjectByKeyPath: () => createNestedObjectByKeyPath,
+    createObjectWithoutPrototype: () => createObjectWithoutPrototype,
+    createParent: () => createParent,
+    createPath: () => createPath,
+    createProps: () => createProps,
+    createPropsStack: () => createPropsStack,
+    createRoot: () => createRoot,
+    createScope: () => createScope,
+    createSnapshotId: () => createSnapshotId,
+    customDecodeURIComponent: () => customDecodeURIComponent,
+    customEncodeURIComponent: () => customEncodeURIComponent,
+    cutArrayAfterValue: () => cutArrayAfterValue,
+    cutArrayBeforeValue: () => cutArrayBeforeValue,
+    debounce: () => debounce,
+    debounceOnContext: () => debounceOnContext,
+    decodeNewlines: () => decodeNewlines,
+    deepClone: () => deepClone,
+    deepContains: () => deepContains,
+    deepDestringify: () => deepDestringify,
+    deepExtend: () => deepExtend,
+    deepMerge: () => deepMerge,
+    deepMergeExtends: () => deepMergeExtends,
+    deepStringify: () => deepStringify,
+    defineSetter: () => defineSetter,
+    detectInfiniteLoop: () => detectInfiniteLoop,
+    document: () => document2,
+    encodeNewlines: () => encodeNewlines,
+    error: () => error,
+    excludeKeysFromObject: () => excludeKeysFromObject,
+    exec: () => exec,
+    extendCachedRegistry: () => extendCachedRegistry,
+    extendStackRegistry: () => extendStackRegistry,
+    extractArrayExtend: () => extractArrayExtend,
+    filterArrays: () => filterArrays,
+    filterArraysFast: () => filterArraysFast,
+    finalizeExtends: () => finalizeExtends,
+    findInheritedState: () => findInheritedState,
+    findKeyPosition: () => findKeyPosition,
+    flattenExtend: () => flattenExtend,
+    generateHash: () => generateHash,
+    generateKey: () => generateKey,
+    get: () => get,
+    getCapitalCaseKeys: () => getCapitalCaseKeys,
+    getChildStateInKey: () => getChildStateInKey,
+    getChildren: () => getChildren,
+    getContext: () => getContext,
+    getCookie: () => getCookie,
+    getExtendsInElement: () => getExtendsInElement,
+    getExtendsStack: () => getExtendsStack,
+    getExtendsStackRegistry: () => getExtendsStackRegistry,
+    getFrequencyInArray: () => getFrequencyInArray,
+    getHashedExtend: () => getHashedExtend,
+    getInObjectByPath: () => getInObjectByPath,
+    getLocalStorage: () => getLocalStorage,
+    getNev: () => getNev,
+    getParentStateInKey: () => getParentStateInKey,
+    getPath: () => getPath,
+    getRef: () => getRef,
+    getRoot: () => getRoot,
+    getRootContext: () => getRootContext,
+    getRootData: () => getRootData,
+    getRootState: () => getRootState,
+    getRootStateInKey: () => getRootStateInKey,
+    getSpreadChildren: () => getSpreadChildren,
+    global: () => global,
+    hasFunction: () => hasFunction,
+    hasOwnProperty: () => hasOwnProperty,
+    inheritChildExtends: () => inheritChildExtends,
+    inheritChildPropsExtends: () => inheritChildPropsExtends,
+    inheritParentProps: () => inheritParentProps,
+    inheritRecursiveChildExtends: () => inheritRecursiveChildExtends,
+    initProps: () => initProps,
+    is: () => is,
+    isArray: () => isArray,
+    isBoolean: () => isBoolean,
+    isContextComponent: () => isContextComponent,
+    isCyclic: () => isCyclic,
+    isDOMNode: () => isDOMNode,
+    isDate: () => isDate,
+    isDefined: () => isDefined,
+    isDevelopment: () => isDevelopment,
+    isEmpty: () => isEmpty,
+    isEmptyObject: () => isEmptyObject,
+    isEqualDeep: () => isEqualDeep,
+    isFunction: () => isFunction,
+    isHtmlElement: () => isHtmlElement,
+    isLocal: () => isLocal,
+    isMethod: () => isMethod,
+    isMobile: () => isMobile,
+    isNode: () => isNode,
+    isNot: () => isNot,
+    isNotProduction: () => isNotProduction,
+    isNull: () => isNull,
+    isNumber: () => isNumber,
+    isObject: () => isObject,
+    isObjectLike: () => isObjectLike,
+    isProduction: () => isProduction,
+    isStaging: () => isStaging,
+    isState: () => isState,
+    isString: () => isString,
+    isStringFunction: () => isStringFunction,
+    isTest: () => isTest,
+    isTesting: () => isTesting,
+    isUndefined: () => isUndefined,
+    isValidHtmlTag: () => isValidHtmlTag,
+    joinArrays: () => joinArrays,
+    jointStacks: () => jointStacks,
+    keys: () => keys,
+    log: () => log,
+    logGroupIf: () => logGroupIf,
+    logIf: () => logIf,
+    lookdown: () => lookdown,
+    lookdownAll: () => lookdownAll,
+    lookup: () => lookup,
+    lowercaseFirstLetter: () => lowercaseFirstLetter,
+    makeObjectWithoutPrototype: () => makeObjectWithoutPrototype,
+    map: () => map,
+    mapStringsWithContextComponents: () => mapStringsWithContextComponents,
+    matchesComponentNaming: () => matchesComponentNaming,
+    memoize: () => memoize,
+    merge: () => merge,
+    nextElement: () => nextElement,
+    objectToString: () => objectToString,
+    objectizeStringProperty: () => objectizeStringProperty,
+    overwrite: () => overwrite,
+    overwriteDeep: () => overwriteDeep,
+    overwriteShallow: () => overwriteShallow,
+    overwriteState: () => overwriteState,
+    parse: () => parse,
+    parseDeep: () => parseDeep,
+    pickupElementFromProps: () => pickupElementFromProps,
+    pickupPropsFromElement: () => pickupPropsFromElement,
+    previousElement: () => previousElement,
+    propExists: () => propExists,
+    propertizeElement: () => propertizeElement,
+    propertizeUpdate: () => propertizeUpdate,
+    remove: () => remove,
+    removeCookie: () => removeCookie,
+    removeDuplicateProps: () => removeDuplicateProps,
+    removeDuplicatesInArray: () => removeDuplicatesInArray,
+    removeFromArray: () => removeFromArray,
+    removeFromObject: () => removeFromObject,
+    removeNestedKeyByPath: () => removeNestedKeyByPath,
+    removeValueFromArray: () => removeValueFromArray,
+    removeValueFromArrayAll: () => removeValueFromArrayAll,
+    reorderArrayByValues: () => reorderArrayByValues,
+    replaceLiteralsWithObjectFields: () => replaceLiteralsWithObjectFields,
+    replaceOctalEscapeSequences: () => replaceOctalEscapeSequences,
+    returnValueAsText: () => returnValueAsText,
+    self: () => self,
+    setCookie: () => setCookie,
+    setHashedExtend: () => setHashedExtend,
+    setInObjectByPath: () => setInObjectByPath,
+    setLocalStorage: () => setLocalStorage,
+    setNodeStyles: () => setNodeStyles,
+    setProps: () => setProps,
+    setPropsPrototype: () => setPropsPrototype,
+    spotByPath: () => spotByPath,
+    stringIncludesAny: () => stringIncludesAny,
+    stringToObject: () => stringToObject,
+    swapItemsInArray: () => swapItemsInArray,
+    syncProps: () => syncProps,
+    triggerEventOn: () => triggerEventOn,
+    triggerEventOnUpdate: () => triggerEventOnUpdate,
+    trimStringFromSymbols: () => trimStringFromSymbols,
+    unstackArrayOfObjects: () => unstackArrayOfObjects,
+    update: () => update,
+    updateProps: () => updateProps,
+    variables: () => variables,
+    verbose: () => verbose,
+    warn: () => warn,
+    window: () => window2
+  });
+
+  // globals.js
+  var global = globalThis;
+  var self = globalThis;
+  var window2 = globalThis;
+  var document2 = window2.document;
+
+  // node.js
+  var isNode = (obj) => {
+    return (typeof Node === "object" ? obj instanceof window2.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+  };
+  var isHtmlElement = (obj) => {
+    return (typeof HTMLElement === "object" ? obj instanceof window2.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+  };
+  var isDOMNode = (obj) => {
+    return typeof window2 !== "undefined" && (obj instanceof window2.Node || obj instanceof window2.Window || obj === window2 || obj === document);
+  };
+
+  // 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));
+  };
+  var isNot = (arg) => {
+    return (...args) => !args.some((val) => TYPES[val](arg));
+  };
+
+  // array.js
+  var arrayContainsOtherArray = (arr1, arr2) => {
+    return arr2.every((val) => arr1.includes(val));
+  };
+  var getFrequencyInArray = (arr, value) => {
+    let count = 0;
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i] === value) count++;
+    }
+    return count;
+  };
+  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 swapItemsInArray = (arr, i, j) => {
+    ;
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  };
+  var joinArrays = (...arrays) => {
+    return [].concat(...arrays);
+  };
+  var unstackArrayOfObjects = (arr, exclude = []) => {
+    return arr.reduce(
+      (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+      {}
+    );
+  };
+  var cutArrayBeforeValue = (arr, value) => {
+    const index = arr.indexOf(value);
+    if (index !== -1) {
+      return arr.slice(0, index);
+    }
+    return arr;
+  };
+  var cutArrayAfterValue = (arr, value) => {
+    if (!isArray(arr)) return;
+    const index = arr.indexOf(value);
+    if (index !== -1) {
+      return arr.slice(index + 1);
+    }
+    return arr;
+  };
+  var removeValueFromArray = (arr, value) => {
+    const index = arr.indexOf(value);
+    if (index > -1) {
+      const newArray = [...arr];
+      newArray.splice(index, 1);
+      return newArray;
+    }
+    return arr;
+  };
+  var removeValueFromArrayAll = (arr, value) => {
+    return arr.filter((item) => item !== value);
+  };
+  var addItemAfterEveryElement = (array, item) => {
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+      result.push(array[i]);
+      if (i < array.length - 1) {
+        result.push(item);
+      }
+    }
+    return result;
+  };
+  var reorderArrayByValues = (array, valueToMove, insertBeforeValue) => {
+    const newArray = [...array];
+    const indexToMove = newArray.indexOf(valueToMove);
+    const indexToInsertBefore = newArray.indexOf(insertBeforeValue);
+    if (indexToMove !== -1 && indexToInsertBefore !== -1) {
+      const removedItem = newArray.splice(indexToMove, 1)[0];
+      const insertIndex = indexToInsertBefore < indexToMove ? indexToInsertBefore : indexToInsertBefore + 1;
+      newArray.splice(insertIndex, 0, removedItem);
+    }
+    return newArray;
+  };
+  var arraysEqual = (arr1, arr2) => {
+    if (arr1.length !== arr2.length) {
+      return false;
+    }
+    for (let i = 0; i < arr1.length; i++) {
+      if (arr1[i] !== arr2[i]) {
+        return false;
+      }
+    }
+    return true;
+  };
+  var filterArrays = (sourceArr, excludeArr) => {
+    return sourceArr.filter((item) => !excludeArr.includes(item));
+  };
+  var filterArraysFast = (sourceArr, excludeArr) => {
+    const excludeSet = new Set(excludeArr);
+    return sourceArr.filter((item) => !excludeSet.has(item));
+  };
+  var checkIfStringIsInArray = (string, arr) => {
+    if (!string) return 0;
+    let count = 0;
+    for (let i = 0; i < arr.length; i++) {
+      if (string.includes(arr[i])) count++;
+    }
+    return count;
+  };
+  var removeDuplicatesInArray = (arr) => {
+    if (!isArray(arr)) return arr;
+    return [...new Set(arr)];
+  };
+  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
+      });
+    }
+  };
+
+  // string.js
+  var stringIncludesAny = (str, characters) => {
+    for (const char of characters) {
+      if (str.includes(char)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  var trimStringFromSymbols = (str, characters) => {
+    const pattern = new RegExp(`[${characters.join("\\")}]`, "g");
+    return str.replace(pattern, "");
+  };
+  var brackRegex = {
+    2: /{{\s*((?:\.\.\/)*)([\w\d.]+)\s*}}/g,
+    3: /{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*}}}/g
+  };
+  var getNestedValue = (obj, path) => {
+    return path.split(".").reduce((acc, part) => {
+      return acc?.[part];
+    }, 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 || this.state || {};
+    return str.replace(reg, (_, parentPath, variable) => {
+      if (parentPath) {
+        const parentLevels = (parentPath.match(/\.\.\//g) || []).length;
+        let parentState = obj;
+        for (let i = 0; i < parentLevels; i++) {
+          if (!parentState || !parentState.parent) return "";
+          parentState = parentState.parent;
+        }
+        const key = variable.trim();
+        if (key === "parent") {
+          return String(parentState.value ?? "");
+        }
+        const value = getNestedValue(parentState, key);
+        return String(value ?? "");
+      } else {
+        const value = getNestedValue(obj, variable.trim());
+        return String(value ?? "");
+      }
+    });
+  }
+  var lowercaseFirstLetter = (inputString) => {
+    return `${inputString.charAt(0).toLowerCase()}${inputString.slice(1)}`;
+  };
+  var findKeyPosition = (str, key) => {
+    const lines = str.split("\n");
+    let startLineNumber = -1;
+    let endLineNumber = -1;
+    let startColumn = -1;
+    let endColumn = -1;
+    const keyPattern = new RegExp(`\\b${key}\\b\\s*:\\s*`);
+    let braceCount = 0;
+    let foundKey = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (keyPattern.test(lines[i]) && !foundKey) {
+        foundKey = true;
+        startLineNumber = i + 1;
+        startColumn = lines[i].indexOf(key) + 1;
+        if (lines[i].includes("{}")) {
+          endLineNumber = startLineNumber;
+          endColumn = lines[i].indexOf("{}") + 3;
+          break;
+        }
+        const line = lines[i].slice(startColumn + key.length);
+        if (line.includes("{") || line.includes("[")) {
+          braceCount = 1;
+        } else {
+          endLineNumber = i + 1;
+          endColumn = lines[i].length + 1;
+          break;
+        }
+      } else if (foundKey) {
+        braceCount += (lines[i].match(/{/g) || []).length;
+        braceCount += (lines[i].match(/\[/g) || []).length;
+        braceCount -= (lines[i].match(/}/g) || []).length;
+        braceCount -= (lines[i].match(/]/g) || []).length;
+        if (braceCount === 0) {
+          endLineNumber = i + 1;
+          endColumn = lines[i].lastIndexOf("}") !== -1 ? lines[i].lastIndexOf("}") + 2 : lines[i].length + 1;
+          break;
+        }
+      }
+    }
+    return {
+      startColumn,
+      endColumn,
+      startLineNumber,
+      endLineNumber
+    };
+  };
+  var RE_OCTAL = /\\([0-7]{1,3})/g;
+  var replaceOctalEscapeSequences = (str) => {
+    return str.replace(RE_OCTAL, (_, p1) => String.fromCharCode(parseInt(p1, 8)));
+  };
+  var encodeNewlines = (str) => {
+    return str.replace(/\n/g, "/////n").replace(/`/g, "/////tilde").replace(/\$/g, "/////dlrsgn");
+  };
+  var decodeNewlines = (encodedStr) => {
+    return encodedStr.replace(/\/\/\/\/\/n/g, "\n").replace(/\/\/\/\/\/tilde/g, "`").replace(/\/\/\/\/\/dlrsgn/g, "$");
+  };
+  var RE_NON_ALNUM = /[^a-zA-Z0-9\s]/g;
+  var customEncodeURIComponent = (str) => {
+    return str.replace(
+      RE_NON_ALNUM,
+      (char) => "%" + char.charCodeAt(0).toString(16).toUpperCase()
+    );
+  };
+  var customDecodeURIComponent = (encodedStr) => {
+    return encodedStr.replace(
+      /%[0-9A-Fa-f]{2}/g,
+      (match) => String.fromCharCode(parseInt(match.slice(1), 16))
+    );
+  };
+
+  // keys.js
+  var DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
+    "attr",
+    "style",
+    "text",
+    "html",
+    "content",
+    "data",
+    "classlist",
+    "state",
+    "scope",
+    "root",
+    "deps",
+    "extend",
+    "extends",
+    "$router",
+    "routes",
+    "children",
+    "childExtend",
+    "childExtends",
+    "childExtendRecursive",
+    "childExtendsRecursive",
+    "props",
+    "if",
+    "define",
+    "__name",
+    "__ref",
+    "__hash",
+    "__text",
+    "key",
+    "tag",
+    "query",
+    "parent",
+    "node",
+    "variables",
+    "on",
+    "component",
+    "context"
+  ]);
+  var PARSED_DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
+    "attr",
+    "style",
+    "text",
+    "html",
+    "content",
+    "data",
+    "class",
+    "state",
+    "scope",
+    "children",
+    "props",
+    "if",
+    "key",
+    "tag",
+    "query",
+    "on",
+    "context"
+  ]);
+  var STATE_PROPERTIES = [
+    "ref",
+    "parent",
+    "__element",
+    "__depends",
+    "__ref",
+    "__children",
+    "root"
+  ];
+  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
+  ]);
+  var DOMQL_EVENTS = /* @__PURE__ */ new Set([
+    "init",
+    "beforeClassAssign",
+    "render",
+    "renderRouter",
+    "attachNode",
+    "stateInit",
+    "stateCreated",
+    "beforeStateUpdate",
+    "stateUpdate",
+    "beforeUpdate",
+    "done",
+    "create",
+    "complete",
+    "frame",
+    "update"
+  ]);
+
+  // object.js
+  var ENV = process.env.NODE_ENV;
+  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 map = (obj, extention, element) => {
+    for (const e in extention) {
+      obj[e] = exec(extention[e], element);
+    }
+  };
+  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 clone = (obj, excludeFrom = []) => {
+    const useSet = excludeFrom instanceof Set;
+    const o = {};
+    for (const prop in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
+      if (_startsWithDunder(prop)) continue;
+      if (useSet ? excludeFrom.has(prop) : excludeFrom.includes(prop)) continue;
+      o[prop] = obj[prop];
+    }
+    return o;
+  };
+  var deepClone = (obj, options = {}) => {
+    const {
+      exclude = [],
+      cleanUndefined = false,
+      cleanNull = false,
+      window: targetWindow,
+      visited = /* @__PURE__ */ new WeakMap(),
+      handleExtends = false
+    } = options;
+    const contentWindow = targetWindow || window2 || 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 deepStringify = (obj, stringified = {}) => {
+    if (obj.node || obj.__ref || obj.parent || obj.__element || obj.parse) {
+      ;
+      (obj.__element || obj.parent?.__element).warn(
+        "Trying to clone element or state at",
+        obj
+      );
+      obj = obj.parse?.();
+    }
+    for (const prop in obj) {
+      const objProp = obj[prop];
+      if (isFunction(objProp)) {
+        stringified[prop] = objProp.toString();
+      } else if (isObject(objProp)) {
+        stringified[prop] = {};
+        deepStringify(objProp, stringified[prop]);
+      } else if (isArray(objProp)) {
+        const arr = stringified[prop] = [];
+        for (let i = 0; i < objProp.length; i++) {
+          const v = objProp[i];
+          if (isObject(v)) {
+            arr[i] = {};
+            deepStringify(v, arr[i]);
+          } else if (isFunction(v)) {
+            arr[i] = v.toString();
+          } else {
+            arr[i] = v;
+          }
+        }
+      } else {
+        stringified[prop] = objProp;
+      }
+    }
+    return stringified;
+  };
+  var OBJ_TO_STR_SPECIAL_CHARS = /* @__PURE__ */ new Set([
+    "&",
+    "*",
+    "-",
+    ":",
+    "%",
+    "{",
+    "}",
+    ">",
+    "<",
+    "@",
+    ".",
+    "/",
+    "!",
+    " "
+  ]);
+  var objectToString = (obj = {}, indent = 0) => {
+    if (obj === null || typeof obj !== "object") {
+      return String(obj);
+    }
+    let hasKeys = false;
+    for (const _k in obj) {
+      hasKeys = true;
+      break;
+    }
+    if (!hasKeys) return "{}";
+    const spaces = "  ".repeat(indent);
+    let str = "{\n";
+    for (const key in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      const value = obj[key];
+      let keyNeedsQuotes = false;
+      for (let i = 0; i < key.length; i++) {
+        if (OBJ_TO_STR_SPECIAL_CHARS.has(key[i])) {
+          keyNeedsQuotes = true;
+          break;
+        }
+      }
+      const stringedKey = keyNeedsQuotes ? `'${key}'` : key;
+      str += `${spaces}  ${stringedKey}: `;
+      if (isArray(value)) {
+        str += "[\n";
+        for (const element of value) {
+          if (isObjectLike(element) && element !== null) {
+            str += `${spaces}    ${objectToString(element, indent + 2)},
+`;
+          } else if (isString(element)) {
+            str += `${spaces}    '${element}',
+`;
+          } else {
+            str += `${spaces}    ${element},
+`;
+          }
+        }
+        str += `${spaces}  ]`;
+      } else if (isObjectLike(value)) {
+        str += objectToString(value, indent + 1);
+      } else if (isString(value)) {
+        str += stringIncludesAny(value, ["\n", "'"]) ? `\`${value}\`` : `'${value}'`;
+      } else {
+        str += value;
+      }
+      str += ",\n";
+    }
+    str += `${spaces}}`;
+    return str;
+  };
+  var FN_PATTERNS = [
+    /^\(\s*\{[^}]*\}\s*\)\s*=>/,
+    /^(\([^)]*\)|[^=]*)\s*=>/,
+    /^function[\s(]/,
+    /^async\s+/,
+    /^\(\s*function/,
+    /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/
+  ];
+  var RE_JSON_LIKE = /^["[{]/;
+  var hasFunction = (str) => {
+    if (!str) return false;
+    const trimmed = str.trim().replace(/\n\s*/g, " ").trim();
+    if (trimmed === "" || trimmed === "{}" || trimmed === "[]") return false;
+    const isFn = FN_PATTERNS.some((pattern) => pattern.test(trimmed));
+    if (!isFn) return false;
+    const firstChar = trimmed.charCodeAt(0);
+    const hasArrow = trimmed.includes("=>");
+    if (firstChar === 123 && !hasArrow) return false;
+    if (firstChar === 91) return false;
+    if (RE_JSON_LIKE.test(trimmed) && !hasArrow) return false;
+    return true;
+  };
+  var deepDestringify = (obj, destringified = {}) => {
+    for (const prop in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
+      const objProp = obj[prop];
+      if (isString(objProp)) {
+        if (hasFunction(objProp)) {
+          try {
+            destringified[prop] = window2.eval(`(${objProp})`);
+          } catch (e) {
+            if (e) destringified[prop] = objProp;
+          }
+        } else {
+          destringified[prop] = objProp;
+        }
+      } else if (isArray(objProp)) {
+        const arr = destringified[prop] = [];
+        for (let i = 0; i < objProp.length; i++) {
+          const arrProp = objProp[i];
+          if (isString(arrProp)) {
+            if (hasFunction(arrProp)) {
+              try {
+                arr.push(window2.eval(`(${arrProp})`));
+              } catch (e) {
+                if (e) arr.push(arrProp);
+              }
+            } else {
+              arr.push(arrProp);
+            }
+          } else if (isObject(arrProp)) {
+            arr.push(deepDestringify(arrProp));
+          } else {
+            arr.push(arrProp);
+          }
+        }
+      } else if (isObject(objProp)) {
+        destringified[prop] = deepDestringify(objProp, destringified[prop]);
+      } else {
+        destringified[prop] = objProp;
+      }
+    }
+    return destringified;
+  };
+  var stringToObject = (str, opts = { verbose: true }) => {
+    try {
+      return str ? window2.eval("(" + str + ")") : {};
+    } catch (e) {
+      if (opts.verbose) console.warn(e);
+    }
+  };
+  var hasOwnProperty = (o, ...args) => Object.prototype.hasOwnProperty.call(o, ...args);
+  var isEmpty = (o) => {
+    for (const _ in o) return false;
+    return true;
+  };
+  var isEmptyObject = (o) => isObject(o) && isEmpty(o);
+  var makeObjectWithoutPrototype = () => /* @__PURE__ */ Object.create(null);
+  var overwrite = (element, params, opts = {}) => {
+    const excl = opts.exclude || [];
+    const allowUnderscore = opts.preventUnderscore;
+    for (const e in params) {
+      if (excl.includes(e) || !allowUnderscore && _startsWithDunder(e)) continue;
+      if (params[e] !== void 0) {
+        element[e] = params[e];
+      }
+    }
+    return element;
+  };
+  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 isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
+    if (typeof param !== "object" || typeof element !== "object" || param === null || element === null) {
+      return param === element;
+    }
+    if (visited.has(param) || visited.has(element)) {
+      return true;
+    }
+    visited.add(param);
+    visited.add(element);
+    const keysParam = Object.keys(param);
+    const keysElement = Object.keys(element);
+    if (keysParam.length !== keysElement.length) {
+      return false;
+    }
+    for (let i = 0; i < keysParam.length; i++) {
+      const key = keysParam[i];
+      if (!Object.prototype.hasOwnProperty.call(element, key)) {
+        return false;
+      }
+      if (!isEqualDeep(param[key], element[key], visited)) {
+        return false;
+      }
+    }
+    return true;
+  };
+  var DEEP_CONTAINS_IGNORED = /* @__PURE__ */ new Set(["node", "__ref"]);
+  var deepContains = (obj1, obj2, ignoredKeys = DEEP_CONTAINS_IGNORED) => {
+    if (obj1 === obj2) return true;
+    if (!isObjectLike(obj1) || !isObjectLike(obj2)) return obj1 === obj2;
+    if (isDOMNode(obj1) || isDOMNode(obj2)) return obj1 === obj2;
+    const ignored = ignoredKeys instanceof Set ? ignoredKeys : new Set(ignoredKeys);
+    const visited = /* @__PURE__ */ new WeakSet();
+    function checkContains(target, source) {
+      if (visited.has(source)) return true;
+      visited.add(source);
+      for (const key in source) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+        if (ignored.has(key)) continue;
+        if (!Object.prototype.hasOwnProperty.call(target, key)) return false;
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (isDOMNode(sourceValue) || isDOMNode(targetValue)) {
+          if (sourceValue !== targetValue) return false;
+        } else if (isObjectLike(sourceValue) && isObjectLike(targetValue)) {
+          if (!checkContains(targetValue, sourceValue)) return false;
+        } else if (sourceValue !== targetValue) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return checkContains(obj1, obj2);
+  };
+  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 createObjectWithoutPrototype = (obj) => {
+    if (obj === null || typeof obj !== "object") {
+      return obj;
+    }
+    const newObj = /* @__PURE__ */ Object.create(null);
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        newObj[key] = createObjectWithoutPrototype(obj[key]);
+      }
+    }
+    return newObj;
+  };
+  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;
+  };
+  var detectInfiniteLoop = (arr) => {
+    const maxRepeats = 10;
+    let pattern = [];
+    let repeatCount = 0;
+    for (let i = 0; i < arr.length; i++) {
+      if (pattern.length < 2) {
+        pattern.push(arr[i]);
+      } else {
+        if (arr[i] === pattern[i % 2]) {
+          repeatCount++;
+        } else {
+          pattern = [arr[i - 1], arr[i]];
+          repeatCount = 1;
+        }
+        if (repeatCount >= maxRepeats * 2) {
+          if (ENV === "test" || ENV === "development") {
+            console.warn(
+              "Warning: Potential infinite loop detected due to repeated sequence:",
+              pattern
+            );
+          }
+          return true;
+        }
+      }
+    }
+  };
+  var isCyclic = (obj) => {
+    const seen = /* @__PURE__ */ new WeakSet();
+    function detect(obj2) {
+      if (obj2 && typeof obj2 === "object") {
+        if (seen.has(obj2)) return true;
+        seen.add(obj2);
+        for (const key in obj2) {
+          if (Object.prototype.hasOwnProperty.call(obj2, key) && detect(obj2[key])) {
+            console.log(obj2, "cycle at " + key);
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    return detect(obj);
+  };
+  var excludeKeysFromObject = (obj, excludedKeys) => {
+    const excluded = excludedKeys instanceof Set ? excludedKeys : new Set(excludedKeys);
+    const result = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key) && !excluded.has(key)) {
+        result[key] = obj[key];
+      }
+    }
+    return result;
+  };
+
+  // key.js
+  var generateKey = /* @__PURE__ */ (function() {
+    let index = 0;
+    function newId() {
+      index++;
+      return index;
+    }
+    return newId;
+  })();
+  var createSnapshotId = generateKey;
+  var createKey = (element, parent, key) => {
+    return (exec(key, element) || key || element.key || generateKey()).toString();
+  };
+
+  // env.js
+  var NODE_ENV = process.env.NODE_ENV;
+  var ENV2 = NODE_ENV;
+  var isProduction = (env = NODE_ENV) => env === "production";
+  var isTest = (env = NODE_ENV) => env === "testing" || env === "test";
+  var isTesting = isTest;
+  var isStaging = (env = NODE_ENV) => env === "staging";
+  var isLocal = (env = NODE_ENV) => env === "local";
+  var isDevelopment = (env = NODE_ENV) => env === "development" || env === "dev" || env === "local";
+  var getNev = (key, env = NODE_ENV) => env[key];
+  var isNotProduction = (env = NODE_ENV) => !isProduction(env);
+
+  // function.js
+  function debounce(func, wait, immediate) {
+    let timeout;
+    return function() {
+      const context = this;
+      const args = arguments;
+      const later = function() {
+        timeout = null;
+        if (!immediate) func.apply(context, args);
+      };
+      const callNow = immediate && !timeout;
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+      if (callNow) func.apply(context, args);
+    };
+  }
+  var debounceOnContext = (element, func, timeout = 300) => {
+    let timer;
+    return (...args) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        func.apply(element, args);
+      }, timeout);
+    };
+  };
+  var memoize = (fn) => {
+    const cache2 = {};
+    return (...args) => {
+      const n = args[0];
+      if (n in cache2) {
+        return cache2[n];
+      } else {
+        const result = fn(n);
+        cache2[n] = result;
+        return result;
+      }
+    };
+  };
+  var RE_STRING_FUNCTION = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/;
+  var isStringFunction = (inputString) => {
+    return RE_STRING_FUNCTION.test(inputString);
+  };
+  function cloneFunction(fn, win = window) {
+    const temp = function() {
+      return fn.apply(win, arguments);
+    };
+    for (const key in fn) {
+      if (Object.prototype.hasOwnProperty.call(fn, key)) {
+        temp[key] = fn[key];
+      }
+    }
+    return temp;
+  }
+
+  // if.js
+  var createIfConditionFlag = (element, parent) => {
+    const { __ref: ref } = element;
+    if (isFunction(element.if) && !element.if(element, element.state, element.context)) {
+      delete ref.__if;
+    } else ref.__if = true;
+  };
+
+  // log.js
+  var logIf = (bool, ...arg) => {
+    if (bool) arg.map((v) => console.log(v));
+  };
+  var logGroupIf = (bool, key, ...arg) => {
+    if (bool) {
+      console.group(key);
+      arg.map((v) => console.log(v));
+      console.groupEnd(key);
+    }
+  };
+
+  // cookie.js
+  var isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+  var setCookie = (cname, cvalue, exdays = 365) => {
+    if (isUndefined(document2) || isUndefined(document2.cookie)) return;
+    const d = /* @__PURE__ */ new Date();
+    d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1e3);
+    const expires = `expires=${d.toUTCString()}`;
+    document2.cookie = `${cname}=${cvalue};${expires};path=/`;
+  };
+  var getCookie = (cname) => {
+    if (isUndefined(document2) || isUndefined(document2.cookie)) return;
+    const name = `${cname}=`;
+    const decodedCookie = decodeURIComponent(document2.cookie);
+    const ca = decodedCookie.split(";");
+    for (let i = 0; i < ca.length; i++) {
+      let c = ca[i];
+      while (c.charAt(0) === " ") c = c.substring(1);
+      if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
+    }
+    return "";
+  };
+  var removeCookie = (cname) => {
+    if (isUndefined(document2) || isUndefined(document2.cookie)) return;
+    document2.cookie = cname + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
+  };
+  function getLocalStorage(key) {
+    if (!window.localStorage) {
+      return void 0;
+    }
+    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 (!window.localStorage || data === void 0 || data === null) {
+      return;
+    }
+    const value = typeof data === "object" ? JSON.stringify(data) : data;
+    window.localStorage.setItem(key, value);
+  }
+
+  // tags.js
+  var HTML_TAGS = {
+    root: ["body", "html"],
+    head: ["title", "base", "meta", "style", "noscript", "script"],
+    body: /* @__PURE__ */ new Set([
+      "string",
+      "style",
+      "fragment",
+      "a",
+      "abbr",
+      "acronym",
+      "address",
+      "applet",
+      "area",
+      "article",
+      "aside",
+      "audio",
+      "b",
+      "basefont",
+      "bdi",
+      "bdo",
+      "big",
+      "blockquote",
+      "br",
+      "button",
+      "canvas",
+      "caption",
+      "center",
+      "cite",
+      "code",
+      "search",
+      "col",
+      "colgroup",
+      "data",
+      "datalist",
+      "dd",
+      "del",
+      "details",
+      "dfn",
+      "dialog",
+      "dir",
+      "div",
+      "dl",
+      "dt",
+      "em",
+      "embed",
+      "fieldset",
+      "figcaption",
+      "figure",
+      "font",
+      "footer",
+      "form",
+      "frame",
+      "frameset",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "head",
+      "header",
+      "hr",
+      "i",
+      "iframe",
+      "img",
+      "input",
+      "ins",
+      "kbd",
+      "label",
+      "legend",
+      "li",
+      "link",
+      "main",
+      "map",
+      "mark",
+      "meter",
+      "nav",
+      "noframes",
+      "noscript",
+      "object",
+      "ol",
+      "optgroup",
+      "option",
+      "output",
+      "p",
+      "param",
+      "picture",
+      "pre",
+      "progress",
+      "hgroup",
+      "q",
+      "rp",
+      "rt",
+      "ruby",
+      "s",
+      "samp",
+      "script",
+      "section",
+      "select",
+      "small",
+      "source",
+      "span",
+      "strike",
+      "strong",
+      "sub",
+      "summary",
+      "sup",
+      "table",
+      "tbody",
+      "td",
+      "template",
+      "hgroup",
+      "textarea",
+      "tfoot",
+      "th",
+      "thead",
+      "time",
+      "tr",
+      "track",
+      "tt",
+      "u",
+      "ul",
+      "var",
+      "video",
+      "wbr",
+      // SVG
+      "svg",
+      "path",
+      "circle",
+      "ellipse",
+      "line",
+      "polygon",
+      "polyline",
+      "rect",
+      "g",
+      "defs",
+      "symbol",
+      "use",
+      "text",
+      "tspan",
+      "image",
+      "clipPath",
+      "mask",
+      "pattern",
+      "marker",
+      "linearGradient",
+      "radialGradient",
+      "stop",
+      "filter",
+      "feGaussianBlur",
+      "feOffset",
+      "feMerge",
+      "feMergeNode",
+      "feBlend",
+      "feColorMatrix",
+      "feFlood",
+      "feComposite",
+      "foreignObject"
+    ])
+  };
+  var SVG_TAGS = /* @__PURE__ */ new Set([
+    "svg",
+    "path",
+    "circle",
+    "ellipse",
+    "line",
+    "polygon",
+    "polyline",
+    "rect",
+    "g",
+    "defs",
+    "symbol",
+    "use",
+    "text",
+    "tspan",
+    "image",
+    "clipPath",
+    "mask",
+    "pattern",
+    "marker",
+    "linearGradient",
+    "radialGradient",
+    "stop",
+    "filter",
+    "feGaussianBlur",
+    "feOffset",
+    "feMerge",
+    "feMergeNode",
+    "feBlend",
+    "feColorMatrix",
+    "feFlood",
+    "feComposite",
+    "foreignObject"
+  ]);
+  var isValidHtmlTag = (arg) => HTML_TAGS.body.has(arg);
+
+  // extends.js
+  var ENV3 = process.env.NODE_ENV;
+  var createExtendsFromKeys = (key) => {
+    if (key.includes("+")) {
+      return key.split("+").filter(matchesComponentNaming);
+    }
+    if (key.includes("_")) {
+      const [first] = key.split("_");
+      return [first];
+    }
+    if (key.includes(".") && !matchesComponentNaming(key.split(".")[1])) {
+      const [first] = key.split(".");
+      return [first];
+    }
+    return [key];
+  };
+  var createExtends = (element, parent, key) => {
+    let __extends = [];
+    const keyExtends = createExtendsFromKeys(key);
+    if (keyExtends) __extends = [...keyExtends];
+    const elementExtends = element.extends;
+    if (elementExtends) {
+      __extends = isArray(elementExtends) ? [...__extends, ...elementExtends] : [...__extends, elementExtends];
+    }
+    return __extends;
+  };
+  var addExtends = (newExtends, element) => {
+    const { __ref: ref } = element;
+    let { __extends } = ref;
+    if (!newExtends) return __extends;
+    const variant = element.props?.variant;
+    const context = element.context;
+    if (variant && context?.components && !Array.isArray(newExtends) && typeof newExtends === "string") {
+      const variantKey = `${newExtends}.${variant}`;
+      if (context.components[variantKey]) {
+        newExtends = variantKey;
+      }
+    }
+    if (!__extends.includes(newExtends)) {
+      __extends = Array.isArray(newExtends) ? [...__extends, ...newExtends] : [...__extends, newExtends];
+      ref.__extends = __extends;
+    }
+    return __extends;
+  };
+  var concatAddExtends = (newExtend, element) => {
+    if (!newExtend) return element;
+    const { extends: elementExtend } = element;
+    const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
+    const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
+    return {
+      ...element,
+      extends: joinArrays(receivedArray, originalArray)
+    };
+  };
+  var generateHash = () => Math.random().toString(36).substring(2);
+  var extendStackRegistry = {};
+  var extendCachedRegistry = {};
+  var getHashedExtend = (extend) => {
+    return extendStackRegistry[extend.__hash];
+  };
+  var setHashedExtend = (extend, stack) => {
+    const hash = generateHash();
+    if (!isString(extend)) {
+      extend.__hash = hash;
+    }
+    if (hash !== "__proto__" && hash !== "constructor" && hash !== "prototype") {
+      extendStackRegistry[hash] = stack;
+    }
+    return stack;
+  };
+  var getExtendsStackRegistry = (extend, stack) => {
+    if (extend.__hash) {
+      return stack.concat(getHashedExtend(extend));
+    }
+    return setHashedExtend(extend, stack);
+  };
+  var extractArrayExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+    for (const each of extend) {
+      if (isArray(each)) {
+        extractArrayExtend(each, stack, context, processed);
+      } else {
+        flattenExtend(each, stack, context, processed);
+      }
+    }
+    return stack;
+  };
+  var deepExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+    const extendOflattenExtend = extend.extends || extend.extend;
+    const cleanExtend = { ...extend };
+    delete cleanExtend.extends;
+    delete cleanExtend.extend;
+    let hasKeys = false;
+    for (const _k in cleanExtend) {
+      hasKeys = true;
+      break;
+    }
+    if (hasKeys) {
+      stack.push(cleanExtend);
+    }
+    if (extendOflattenExtend) {
+      flattenExtend(extendOflattenExtend, stack, context, processed);
+    }
+    return stack;
+  };
+  var flattenExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+    if (!extend) return stack;
+    if (processed.has(extend)) return stack;
+    if (isArray(extend)) {
+      return extractArrayExtend(extend, stack, context, processed);
+    }
+    if (isString(extend)) {
+      extend = mapStringsWithContextComponents(extend, context);
+    }
+    processed.add(extend);
+    if (extend?.extends || extend?.extend) {
+      deepExtend(extend, stack, context, processed);
+    } else if (extend) {
+      stack.push(extend);
+    }
+    return stack;
+  };
+  var MERGE_EXTENDS_SKIP = /* @__PURE__ */ new Set([
+    "parent",
+    "node",
+    "__ref",
+    "__proto__",
+    "extend",
+    "childExtend",
+    "childExtendRecursive"
+  ]);
+  var deepMergeExtends = (element, extend) => {
+    extend = deepClone(extend);
+    for (const e in extend) {
+      if (MERGE_EXTENDS_SKIP.has(e)) continue;
+      const elementProp = element[e];
+      const extendProp = extend[e];
+      if (extendProp === void 0) continue;
+      if (Object.prototype.hasOwnProperty.call(extend, e) && e !== "__proto__" && e !== "constructor" && e !== "prototype") {
+        if (elementProp === void 0) {
+          element[e] = extendProp;
+        } else if (isObject(elementProp) && isObject(extendProp)) {
+          if (matchesComponentNaming(e)) {
+            element[e] = deepMergeExtends(elementProp, extendProp);
+          } else {
+            deepMergeExtends(elementProp, extendProp);
+          }
+        }
+        if (e === "extends" || e === "childExtends" || e === "childExtendsRecursive") {
+          if (isArray(elementProp) && isArray(extendProp)) {
+            element[e] = elementProp.concat(extendProp);
+          } else if (isArray(elementProp) && isObject(extendProp)) {
+            const obj = deepMergeExtends({}, elementProp);
+            element[e] = deepMergeExtends(obj, extendProp);
+          }
+        }
+      }
+    }
+    return element;
+  };
+  var cloneAndMergeArrayExtend = (stack) => {
+    return stack.reduce((acc, current) => {
+      const cloned = deepClone(current);
+      return deepMergeExtends(acc, cloned);
+    }, {});
+  };
+  var mapStringsWithContextComponents = (extend, context, options = {}, variant) => {
+    const COMPONENTS = context?.components || options.components;
+    const PAGES = context?.pages || options.pages;
+    if (isString(extend)) {
+      const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
+      const pageExists = PAGES && extend.charCodeAt(0) === 47 && PAGES[extend];
+      if (componentExists) return componentExists;
+      else if (pageExists) return pageExists;
+      else {
+        if (options.verbose && (ENV3 === "test" || ENV3 === "development")) {
+          console.warn("Extend is string but component was not found:", extend);
+        }
+        return;
+      }
+    }
+    return extend;
+  };
+  var jointStacks = (extendStack, childExtendsStack) => {
+    return [].concat(extendStack.slice(0, 1)).concat(childExtendsStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendsStack.slice(1));
+  };
+  var getExtendsStack = (extend, context) => {
+    if (!extend) return [];
+    if (extend.__hash) return getHashedExtend(extend) || [];
+    const processed = /* @__PURE__ */ new Set();
+    const stack = flattenExtend(extend, [], context, processed);
+    return getExtendsStackRegistry(extend, stack);
+  };
+  var addExtend = (newExtends, elementExtends) => {
+    if (!newExtends) return elementExtends;
+    const receivedArray = isArray(newExtends) ? newExtends : [newExtends];
+    return joinArrays(receivedArray, elementExtends);
+  };
+  var getExtendsInElement = (obj) => {
+    let result = [];
+    function traverse(o) {
+      for (const key in o) {
+        if (Object.prototype.hasOwnProperty.call(o, key)) {
+          if (matchesComponentNaming(key)) {
+            result.push(key);
+          }
+          if (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;
+  };
+  var createElementExtends = (element, parent, options = {}) => {
+    const { __ref: ref } = element;
+    const context = element.context || parent.context;
+    const variant = element.props?.variant;
+    if (element.extend && !element.extends) element.extends = element.extend;
+    delete element.extend;
+    if (!element.extends && element.props?.extends) element.extends = element.props.extends;
+    if (element.extends) {
+      if (Array.isArray(element.extends) && element.extends.length > 0) {
+        const [firstExtend, ...restExtends] = element.extends;
+        if (typeof firstExtend === "string" && variant && context?.components) {
+          const variantKey = `${firstExtend}.${variant}`;
+          if (context.components[variantKey]) {
+            addExtends([variantKey, ...restExtends], element);
+          } else {
+            addExtends(element.extends, element);
+          }
+        } else {
+          addExtends(element.extends, element);
+        }
+      } else if (typeof element.extends === "string" && variant && context?.components) {
+        const variantKey = `${element.extends}.${variant}`;
+        if (context.components[variantKey]) {
+          addExtends(variantKey, element);
+        } else {
+          addExtends(element.extends, element);
+        }
+      } else {
+        addExtends(element.extends, element);
+      }
+    }
+    inheritChildPropsExtends(element, parent, options);
+    inheritChildExtends(element, parent, options);
+    inheritRecursiveChildExtends(element, parent, options);
+    if (element.component) {
+      addExtends(exec(element.component, element), element);
+    }
+    if (context.defaultExtends) {
+      addExtends(context.defaultExtends, element);
+    }
+    return removeDuplicatesInArray(ref.__extends);
+  };
+  var inheritChildPropsExtends = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const ignoreChildExtends = options.ignoreChildExtends || props?.ignoreChildExtends;
+    if (!ignoreChildExtends) {
+      if (parent.props?.childProps?.extends) {
+        addExtends(parent.props?.childProps.extends, element);
+      }
+    }
+    return ref.__extends;
+  };
+  var inheritChildExtends = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const ignoreChildExtends = options.ignoreChildExtends || props?.ignoreChildExtends;
+    const childExtends = parent.childExtends || parent.childExtend;
+    if (!ignoreChildExtends && childExtends) {
+      addExtends(childExtends, element);
+    }
+    return ref.__extends;
+  };
+  var inheritRecursiveChildExtends = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const childExtendsRecursive = parent.childExtendsRecursive || parent.childExtendRecursive;
+    const ignoreChildExtendsRecursive = options.ignoreChildExtendsRecursive || props?.ignoreChildExtendsRecursive;
+    const isText = element.key === "__text";
+    if (childExtendsRecursive && !isText && !ignoreChildExtendsRecursive) {
+      addExtends(childExtendsRecursive, element);
+    }
+    return ref.__extends;
+  };
+  var createExtendsStack = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const context = element.context || parent.context;
+    const variant = element.variant || props?.variant;
+    const __extends = removeDuplicatesInArray(
+      ref.__extends.map((val, i) => {
+        return mapStringsWithContextComponents(
+          val,
+          context,
+          options,
+          i === 0 && variant
+        );
+      })
+    );
+    const stack = getExtendsStack(__extends, context);
+    ref.__extendsStack = stack;
+    return ref.__extendsStack;
+  };
+  var finalizeExtends = (element, parent, options = {}) => {
+    const { __ref: ref } = element;
+    const { __extendsStack } = ref;
+    const flattenExtends = cloneAndMergeArrayExtend(__extendsStack);
+    return deepMergeExtends(element, flattenExtends);
+  };
+  var applyExtends = (element, parent, options = {}) => {
+    createElementExtends(element, parent, options);
+    createExtendsStack(element, parent, options);
+    finalizeExtends(element, parent, options);
+    return element;
+  };
+
+  // component.js
+  var matchesComponentNaming = (key) => {
+    if (!isString(key) || !key.length) return false;
+    const code = key.charCodeAt(0);
+    return code >= 65 && code <= 90;
+  };
+  function getCapitalCaseKeys(obj) {
+    return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
+  }
+  function getSpreadChildren(obj) {
+    return Object.keys(obj).filter((key) => /^\d+$/.test(key));
+  }
+  function isContextComponent(element, parent, passedKey) {
+    const { context } = parent || {};
+    const [extendsKey] = createExtendsFromKeys(passedKey);
+    const key = passedKey || extendsKey;
+    return context?.components?.[key] || context?.pages?.[key];
+  }
+
+  // events.js
+  function addEventFromProps(key, obj) {
+    const { props, on } = obj;
+    const eventName = lowercaseFirstLetter(key.split("on")[1]);
+    const origEvent = on[eventName];
+    const funcFromProps = props[key];
+    if (isFunction(origEvent)) {
+      on[eventName] = (...args) => {
+        const originalEventRetunrs = origEvent(...args);
+        if (originalEventRetunrs !== false) funcFromProps(...args);
+      };
+    } else on[eventName] = funcFromProps;
+  }
+
+  // props.js
+  var RE_UPPER = /^[A-Z]/;
+  var RE_DIGITS = /^\d+$/;
+  var createProps = (element, parent, key) => {
+    const { props, __ref: ref } = element;
+    ref.__propsStack = [];
+    if (props) ref.__initialProps = props;
+    else return {};
+    if (!isObjectLike(props)) {
+      ref.__propsStack.push(props);
+      return {};
+    }
+    return { ...props };
+  };
+  function pickupPropsFromElement(obj, opts = {}) {
+    const cachedKeys = opts.cachedKeys || [];
+    for (const key in obj) {
+      const value = obj[key];
+      const isEventHandler = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key[2] === key[2].toUpperCase() && isFunction(value);
+      if (isEventHandler) {
+        const eventName = lowercaseFirstLetter(key.slice(2));
+        if (obj.on) obj.on[eventName] = value;
+        delete obj[key];
+        continue;
+      }
+      const hasDefine = isObject(this.define?.[key]);
+      const hasGlobalDefine = isObject(this.context?.define?.[key]);
+      const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+      const isBuiltin = DOMQ_PROPERTIES.has(key);
+      if (!isElement && !isBuiltin && !hasDefine && !hasGlobalDefine) {
+        obj.props[key] = value;
+        delete obj[key];
+        cachedKeys.push(key);
+      }
+    }
+    return obj;
+  }
+  function pickupElementFromProps(obj = this, opts) {
+    const cachedKeys = opts.cachedKeys || [];
+    for (const key in obj.props) {
+      const value = obj.props[key];
+      const isEvent = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110;
+      const isFn = isFunction(value);
+      if (isEvent && isFn) {
+        addEventFromProps(key, obj);
+        delete obj.props[key];
+        continue;
+      }
+      if (cachedKeys.includes(key)) continue;
+      const hasDefine = isObject(this.define?.[key]);
+      const hasGlobalDefine = isObject(this.context?.define?.[key]);
+      const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+      const isBuiltin = DOMQ_PROPERTIES.has(key);
+      if (isElement || isBuiltin || hasDefine || hasGlobalDefine) {
+        if (obj[key] === void 0 || value === null) {
+          obj[key] = value;
+          if (obj.props) delete obj.props[key];
+        }
+      }
+    }
+    return obj;
+  }
+  function propertizeElement(element = this) {
+    const cachedKeys = [];
+    pickupPropsFromElement.call(this, element, { cachedKeys });
+    pickupElementFromProps.call(this, element, { cachedKeys });
+    return element;
+  }
+  function propertizeUpdate(params = {}) {
+    if (!params.on) params.on = {};
+    if (!params.props) params.props = {};
+    return propertizeElement.call(this, params);
+  }
+  var objectizeStringProperty = (propValue) => {
+    if (is(propValue)("string", "number")) {
+      return { inheritedString: propValue };
+    }
+    return propValue;
+  };
+  var propExists = (prop, stack) => {
+    if (!prop || !stack.length) return false;
+    return stack.includes(prop);
+  };
+  var inheritParentProps = (element, parent) => {
+    const { __ref: ref } = element;
+    const propsStack = ref.__propsStack || [];
+    const parentProps = parent.props;
+    if (!parentProps) return propsStack;
+    const matchParentKeyProps = parentProps[element.key];
+    const matchParentChildProps = parentProps.childProps;
+    const ignoreChildProps = element.props?.ignoreChildProps;
+    if (matchParentChildProps && !ignoreChildProps) {
+      const childProps = objectizeStringProperty(matchParentChildProps);
+      propsStack.unshift(childProps);
+    }
+    if (matchParentKeyProps) {
+      const keyProps = objectizeStringProperty(matchParentKeyProps);
+      propsStack.unshift(keyProps);
+    }
+    return propsStack;
+  };
+  function update(props, options) {
+    const element = this.__element;
+    element.update({ props }, options);
+  }
+  function setPropsPrototype(element) {
+    const methods = { update: update.bind(element.props), __element: element };
+    Object.setPrototypeOf(element.props, methods);
+  }
+  var removeDuplicateProps = (propsStack) => {
+    const seen = /* @__PURE__ */ new Set();
+    return propsStack.filter((prop) => {
+      if (!prop || PROPS_METHODS.has(prop)) return false;
+      if (seen.has(prop)) return false;
+      seen.add(prop);
+      return true;
+    });
+  };
+  var syncProps = (propsStack, element, opts) => {
+    element.props = propsStack.reduce((mergedProps, v) => {
+      if (PROPS_METHODS.has(v)) return mergedProps;
+      while (isFunction(v)) v = exec(v, element);
+      return deepMerge(mergedProps, deepClone(v, { exclude: PROPS_METHODS }));
+    }, {});
+    setPropsPrototype(element);
+    return element.props;
+  };
+  var createPropsStack = (element, parent) => {
+    const { props, __ref: ref } = element;
+    let propsStack = ref.__propsStack || [];
+    if (parent?.props) {
+      const parentStack = inheritParentProps(element, parent);
+      propsStack = [...parentStack];
+    }
+    if (isObject(props)) propsStack.push(props);
+    else if (props === "inherit" && parent?.props) propsStack.push(parent.props);
+    else if (props) propsStack.push(props);
+    if (isArray(ref.__extendsStack)) {
+      for (let i = 0; i < ref.__extendsStack.length; i++) {
+        const _extends = ref.__extendsStack[i];
+        if (_extends.props && _extends.props !== props) {
+          propsStack.push(_extends.props);
+        }
+      }
+    }
+    ref.__propsStack = removeDuplicateProps(propsStack);
+    return ref.__propsStack;
+  };
+  var applyProps = (element, parent) => {
+    const { __ref: ref } = element;
+    const propsStack = createPropsStack(element, parent);
+    if (propsStack.length) {
+      syncProps(propsStack, element);
+    } else {
+      ref.__propsStack = [];
+      element.props = {};
+    }
+  };
+  var initProps = function(element, parent, options) {
+    const { __ref: ref } = element;
+    if (ref.__if) applyProps(element, parent);
+    else {
+      try {
+        applyProps(element, parent);
+      } catch (e) {
+        if (element.context?.designSystem?.verbose) {
+          console.warn("initProps error at", ref.path?.join("."), e);
+        }
+        element.props = {};
+        ref.__propsStack = [];
+      }
+    }
+    setPropsPrototype(element);
+    return element;
+  };
+  var updateProps = (newProps, element, parent) => {
+    const { __ref: ref } = element;
+    const propsStack = ref.__propsStack || [];
+    let newStack = [...propsStack];
+    const parentProps = inheritParentProps(element, parent);
+    if (parentProps.length) {
+      newStack = [...parentProps, ...newStack];
+    }
+    if (newProps) {
+      newStack = [newProps, ...newStack];
+    }
+    ref.__propsStack = removeDuplicateProps(newStack);
+    if (ref.__propsStack.length) {
+      syncProps(ref.__propsStack, element);
+    }
+    return element;
+  };
+
+  // element.js
+  var ENV4 = process.env.NODE_ENV;
+  var returnValueAsText = (element, parent, key) => {
+    const childExtendsTag = parent.childExtends && parent.childExtends.tag;
+    const childPropsTag = parent.props.childProps && parent.props.childProps.tag;
+    const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key;
+    return {
+      text: element,
+      tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || "string"
+    };
+  };
+  var createBasedOnType = (element, parent, key) => {
+    if (element === void 0) {
+      if (ENV4 === "test" || ENV4 === "development") {
+        console.warn(
+          key,
+          "element is undefined in",
+          parent?.__ref?.path
+        );
+      }
+      return {};
+    }
+    if (element === null) return;
+    if (element === true) return {};
+    if (is(element)("string", "number")) {
+      return returnValueAsText(element, parent, key);
+    }
+    if (isFunction(element)) {
+      return { props: element };
+    }
+    return element;
+  };
+  var addRef = (element, parent) => {
+    const ref = {};
+    ref.origin = element;
+    ref.parent = parent;
+    return ref;
+  };
+  var createParent = (element, parent, key, options, root) => {
+    if (!parent) return root;
+    if (isNode(parent)) {
+      const parentNodeWrapper = { key: ":root", node: parent };
+      root[`${key}_parent`] = parentNodeWrapper;
+      return parentNodeWrapper;
+    }
+    return parent;
+  };
+  var createRoot = (element, parent) => {
+    const { __ref: ref } = element;
+    const { __ref: parentRef } = parent;
+    const hasRoot = parent && parent.key === ":root";
+    if (!ref?.root) {
+      ref.root = hasRoot ? element : parentRef?.root;
+    }
+  };
+  var createPath = (element, parent, key) => {
+    let { __ref: parentRef } = parent;
+    if (!parentRef) parentRef = parent.ref = {};
+    if (!parentRef.path) parentRef.path = [];
+    return parentRef.path.concat(key);
+  };
+  var addContext = (element, parent, key, options, root) => {
+    const forcedOptionsContext = options.context && !root.context && !element.context;
+    if (forcedOptionsContext) root.context = options.context;
+    return options.context || parent.context || root.context || element.context;
+  };
+  var addCaching = (element, parent, key) => {
+    const ref = addRef(element, parent);
+    element.__ref = ref;
+    if (!ref.__defineCache) ref.__defineCache = {};
+    if (!ref.__exec) ref.__exec = {};
+    if (!ref.__execProps) ref.__execProps = {};
+    if (!ref.__class) ref.__class = {};
+    if (!ref.__classNames) ref.__classNames = {};
+    if (!ref.__attr) ref.__attr = {};
+    if (!ref.__changes) ref.__changes = [];
+    if (!ref.__children) ref.__children = [];
+    ref.__extends = createExtends(element, parent, key);
+    ref.path = createPath(element, parent, key);
+    return ref;
+  };
+  var createElement = (passedProps, parentEl, passedKey, opts, root) => {
+    const hashed = passedProps?.__hash;
+    const element = hashed ? { extends: [passedProps] } : createBasedOnType(passedProps, parentEl, passedKey);
+    if (!element) return;
+    const parent = createParent(element, parentEl, passedKey, opts, root);
+    const key = createKey(element, parent, passedKey);
+    addCaching(element, parent, key);
+    const props = createProps(element, parent, key);
+    const context = addContext(element, parent, key, opts, root);
+    const on = element.on || {};
+    return {
+      ...element,
+      key,
+      props,
+      parent,
+      context,
+      on
+    };
+  };
+
+  // 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 isState = function(state) {
+    if (!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
+    );
+  };
+  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: overwrite2 } = options;
+    if (!overwrite2) return;
+    const shallow = overwrite2 === "shallow";
+    const merge2 = overwrite2 === "merge";
+    if (merge2) {
+      deepMerge(state, obj, STATE_METHODS);
+      return;
+    }
+    const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+    overwriteFunc(state, obj, STATE_METHODS);
+  };
+
+  // scope.js
+  var createScope = (element, parent) => {
+    const { __ref: ref } = element;
+    if (!element.scope) element.scope = parent.scope || ref.root?.scope || {};
+  };
+
+  // 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
+      );
+    }
+  };
+
+  // methods.js
+  var ENV5 = process.env.NODE_ENV;
+  function spotByPath(path) {
+    const element = this;
+    const { __ref: ref } = element;
+    const arr = [].concat(path);
+    let foundelement = ref.root[arr[0]];
+    if (!arr || !arr.length) {
+      return console.log(arr, "on", element.key, "is undefined");
+    }
+    while (foundelement.key === arr[0]) {
+      arr.shift();
+      if (!arr.length) break;
+      foundelement = foundelement[arr[0]];
+      if (!foundelement) return;
+    }
+    return foundelement;
+  }
+  function lookup(param) {
+    const el = this;
+    let { parent } = el;
+    if (isFunction(param)) {
+      if (parent.state && param(parent, parent.state, parent.context)) {
+        return parent;
+      } else if (parent.parent) return parent.lookup(param);
+      else return;
+    }
+    if (el[param]) return el[param];
+    while (parent.param !== param) {
+      if (parent[param]) return parent[param];
+      parent = parent.parent;
+      if (!parent) return;
+    }
+    return parent;
+  }
+  function lookdown(param) {
+    const el = this;
+    const { __ref: ref } = el;
+    const children = ref?.__children;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const v = children[i];
+      const childElem = el[v];
+      if (v === param) return childElem;
+      else if (isFunction(param)) {
+        const exec2 = param(childElem, childElem.state, childElem.context);
+        if (childElem.state && exec2) {
+          return childElem;
+        }
+      }
+      const lookdown2 = childElem?.lookdown?.(param);
+      if (lookdown2) return lookdown2;
+    }
+  }
+  function lookdownAll(param, results = []) {
+    const el = this;
+    const { __ref: ref } = el;
+    const children = ref?.__children;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const v = children[i];
+      const childElem = el[v];
+      if (v === param) results.push(childElem);
+      else if (isFunction(param)) {
+        const exec2 = param(childElem, childElem.state, childElem.context);
+        if (childElem.state && exec2) results.push(childElem);
+      }
+      childElem?.lookdownAll?.(param, results);
+    }
+    return results.length ? results : void 0;
+  }
+  function setNodeStyles(params = {}) {
+    const el = this;
+    if (!el.node?.style) return;
+    for (const param in params) {
+      const value = params[param];
+      const childElem = el[param];
+      if (isObject(value) && childElem) setNodeStyles.call(childElem, value);
+      else el.node.style[param] = value;
+    }
+    return el;
+  }
+  function remove(opts) {
+    const element = this;
+    const beforeRemoveReturns = triggerEventOn("beforeRemove", element, opts);
+    if (beforeRemoveReturns === false) return element;
+    if (isFunction(element.node.remove)) element.node.remove();
+    else if (!isProduction()) {
+      console.warn("This item cant be removed");
+      element.log();
+    }
+    delete element.parent[element.key];
+    if (element.parent.__ref) {
+      element.parent.__ref.__children = removeValueFromArray(
+        element.parent.__ref.__children,
+        element.key
+      );
+    }
+    triggerEventOn("remove", element, opts);
+  }
+  function get(param) {
+    const element = this;
+    return element[param];
+  }
+  function setProps(param, options) {
+    const element = this;
+    if (!param || !element.props) return;
+    element.update({ props: param }, options);
+    return element;
+  }
+  function getRef(key) {
+    if (key) return this.__ref && this.__ref[key];
+    return this.__ref;
+  }
+  function getChildren() {
+    const __children = this.getRef("__children");
+    return __children.map((k) => this[k]);
+  }
+  function getPath() {
+    return this.getRef().path;
+  }
+  function getRootState(param) {
+    let state = null;
+    const hasRootState = (obj) => obj.__element && obj.root?.isRootState;
+    if (!this) {
+      state = window.platformState || window.smblsApp?.state;
+    } else if (hasRootState(this)) {
+      state = this.root;
+    } else if (this.__ref && this.__ref.path) {
+      const hasPlatformState = this.state && hasRootState(this.state);
+      const hasPlatformStateOnParent = isFunction(this.state) && this.parent.state && hasRootState(this.parent.state);
+      if (hasPlatformState || hasPlatformStateOnParent) {
+        state = this.state.root || this.parent.state.root;
+      }
+    }
+    if (!state) {
+      state = window.platformState || window.smblsApp?.state;
+    }
+    return param ? state?.[param] : state;
+  }
+  function getRoot(key) {
+    const rootElem = this.getRootState()?.__element;
+    return rootElem && Object.keys(rootElem).length > 0 && key ? rootElem[key] : rootElem;
+  }
+  function getRootData(key) {
+    return this.getRoot("data") && Object.keys(this.getRoot("data")).length > 0 && key ? this.getRoot("data")[key] : this.getRoot("data");
+  }
+  function getRootContext(key) {
+    const ctx = this.getRoot()?.context;
+    return key ? ctx[key] : ctx;
+  }
+  function getContext(key) {
+    const ctx = this.context;
+    return key ? ctx[key] : ctx;
+  }
+  var defineSetter = (element, key, get2, set) => Object.defineProperty(element, key, { get: get2, set });
+  function keys() {
+    const element = this;
+    const keys2 = [];
+    for (const param in element) {
+      if (
+        // (REGISTRY[param] && !DOMQ_PROPERTIES.has(param)) ||
+        !Object.prototype.hasOwnProperty.call(element, param) || DOMQ_PROPERTIES.has(param) && !PARSED_DOMQ_PROPERTIES.has(param)
+      ) {
+        continue;
+      }
+      keys2.push(param);
+    }
+    return keys2;
+  }
+  function parse(excl = []) {
+    const element = this;
+    const obj = {};
+    const keyList = keys.call(element);
+    const hasChildren = keyList.includes("children");
+    const exclSet = excl.length ? new Set(excl) : null;
+    for (let i = 0; i < keyList.length; i++) {
+      const v = keyList[i];
+      if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
+      if (hasChildren && v === "content") continue;
+      const val = element[v];
+      if (v === "state") {
+        if (element.__ref && !element.__ref.__hasRootState) continue;
+        const parsedVal = isFunction(val && val.parse) ? val.parse() : val;
+        obj[v] = isFunction(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
+      } else if (v === "scope") {
+        if (element.__ref && !element.__ref.__hasRootScope) continue;
+        obj[v] = JSON.parse(JSON.stringify(val || {}));
+      } else if (v === "props") {
+        const { __element, update: update2, ...props } = element[v];
+        obj[v] = props;
+      } else if (isDefined(val) && Object.prototype.hasOwnProperty.call(element, v)) {
+        obj[v] = val;
+      }
+    }
+    return obj;
+  }
+  function parseDeep(excl = [], visited = /* @__PURE__ */ new WeakSet()) {
+    const element = this;
+    if (visited.has(element)) return void 0;
+    visited.add(element);
+    const obj = parse.call(element, excl);
+    const exclSet = excl.length ? new Set(excl) : null;
+    for (const v in obj) {
+      if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
+      const val = obj[v];
+      if (Array.isArray(val)) {
+        obj[v] = val.map(
+          (item) => isObjectLike(item) ? parseDeep.call(item, excl, visited) : item
+        );
+      } else if (isObjectLike(val)) {
+        obj[v] = parseDeep.call(val, excl, visited);
+      }
+    }
+    return obj;
+  }
+  function verbose(...args) {
+    if (ENV5 !== "test" && ENV5 !== "development") return;
+    const element = this;
+    const { __ref: ref } = element;
+    console.groupCollapsed(element.key);
+    if (args.length) {
+      args.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+    } else {
+      console.log(ref.path);
+      const keys2 = element.keys();
+      keys2.forEach((v) => console.log(`%c${v}:`, "font-weight: bold", element[v]));
+    }
+    console.log(element);
+    console.groupEnd(element.key);
+    return element;
+  }
+  function log(...params) {
+    if (ENV5 === "test" || ENV5 === "development") {
+      console.log(...params);
+    }
+  }
+  function warn(...params) {
+    if (ENV5 === "test" || ENV5 === "development") {
+      console.warn(...params);
+    }
+  }
+  function error(...params) {
+    if (ENV5 === "test" || ENV5 === "development") {
+      if (params[params.length - 1]?.debugger) debugger;
+      if (params[params.length - 1]?.verbose) verbose.call(this);
+      throw new Error(...params);
+    }
+  }
+  function nextElement() {
+    const element = this;
+    const { key, parent } = element;
+    const { __children } = parent.__ref;
+    const currentIndex = __children.indexOf(key);
+    const nextChild = __children[currentIndex + 1];
+    return parent[nextChild];
+  }
+  function previousElement(el) {
+    const element = el || this;
+    const { key, parent } = element;
+    const { __children } = parent.__ref;
+    if (!__children) return;
+    const currentIndex = __children.indexOf(key);
+    return parent[__children[currentIndex - 1]];
+  }
+  function variables(obj = {}) {
+    const element = this;
+    if (!element.data) element.data = {};
+    if (!element.data.varCaches) element.data.varCaches = {};
+    const varCaches = element.data.varCaches;
+    const changes = {};
+    let changed;
+    for (const key in obj) {
+      if (obj[key] !== varCaches[key]) {
+        changed = true;
+        changes[key] = obj[key];
+      }
+    }
+    return {
+      changed: (cb) => {
+        if (!changed) return;
+        const returns = cb(changes, deepClone(varCaches));
+        for (const key in changes) {
+          varCaches[key] = changes[key];
+        }
+        return returns;
+      },
+      timeout: (cb, timeout) => {
+        if (!changed) return;
+        const t = setTimeout(() => {
+          cb(changes);
+          clearTimeout(t);
+        }, timeout);
+      }
+    };
+  }
+  function call(fnKey, ...args) {
+    const context = this.context;
+    return (context.utils?.[fnKey] || context.functions?.[fnKey] || context.methods?.[fnKey] || context.snippets?.[fnKey])?.call(this, ...args);
+  }
+  function isMethod(param, element) {
+    return Boolean(METHODS.has(param) || element?.context?.methods?.[param]);
+  }
+
+  // cache.js
+  var cache = {};
+  var OPTIONS = {};
+
+  // update.js
+  var snapshot = {
+    snapshotId: createSnapshotId
+  };
+  var 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];
+  };
+  return __toCommonJS(index_exports);
+})();
+// @preserve-env