@symbo.ls/scratch 2.11.352 → 2.11.365

package/dist/cjs/index.js

@@ -241,32 +241,32 @@ var require_types = __commonJS({
     __export2(types_exports, {
       TYPES: () => TYPES,
       is: () => is,
-      isArray: () => isArray9,
+      isArray: () => isArray7,
       isBoolean: () => isBoolean,
       isDate: () => isDate,
       isDefined: () => isDefined2,
       isFunction: () => isFunction2,
       isNot: () => isNot,
       isNull: () => isNull2,
-      isNumber: () => isNumber3,
-      isObject: () => isObject8,
+      isNumber: () => isNumber2,
+      isObject: () => isObject6,
       isObjectLike: () => isObjectLike3,
-      isString: () => isString10,
+      isString: () => isString9,
       isUndefined: () => isUndefined2
     });
     module2.exports = __toCommonJS2(types_exports);
     var import_node = require_node();
-    var isObject8 = (arg) => {
+    var isObject6 = (arg) => {
       if (arg === null)
         return false;
       return typeof arg === "object" && arg.constructor === Object;
     };
-    var isString10 = (arg) => typeof arg === "string";
-    var isNumber3 = (arg) => typeof arg === "number";
+    var isString9 = (arg) => typeof arg === "string";
+    var isNumber2 = (arg) => typeof arg === "number";
     var isFunction2 = (arg) => typeof arg === "function";
     var isBoolean = (arg) => arg === true || arg === false;
     var isNull2 = (arg) => arg === null;
-    var isArray9 = (arg) => Array.isArray(arg);
+    var isArray7 = (arg) => Array.isArray(arg);
     var isDate = (d) => d instanceof Date;
     var isObjectLike3 = (arg) => {
       if (arg === null)
@@ -274,18 +274,18 @@ var require_types = __commonJS({
       return typeof arg === "object";
     };
     var isDefined2 = (arg) => {
-      return isObject8(arg) || isObjectLike3(arg) || isString10(arg) || isNumber3(arg) || isFunction2(arg) || isArray9(arg) || isObjectLike3(arg) || isBoolean(arg) || isDate(arg) || isNull2(arg);
+      return isObject6(arg) || isObjectLike3(arg) || isString9(arg) || isNumber2(arg) || isFunction2(arg) || isArray7(arg) || isObjectLike3(arg) || isBoolean(arg) || isDate(arg) || isNull2(arg);
     };
     var isUndefined2 = (arg) => {
       return arg === void 0;
     };
     var TYPES = {
       boolean: isBoolean,
-      array: isArray9,
-      object: isObject8,
-      string: isString10,
+      array: isArray7,
+      object: isObject6,
+      string: isString9,
       date: isDate,
-      number: isNumber3,
+      number: isNumber2,
       null: isNull2,
       function: isFunction2,
       objectLike: isObjectLike3,
@@ -1379,6 +1379,1448 @@ var require_cjs2 = __commonJS({
   }
 });
 
+// ../utils/dist/cjs/index.js
+var require_cjs3 = __commonJS({
+  "../utils/dist/cjs/index.js"(exports, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __commonJS2 = (cb, mod) => function __require() {
+      return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var require_key2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/key.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var key_exports = {};
+        __export22(key_exports, {
+          createSnapshotId: () => createSnapshotId,
+          generateKey: () => generateKey
+        });
+        module22.exports = __toCommonJS22(key_exports);
+        var generateKey = /* @__PURE__ */ function() {
+          let index = 0;
+          function newId() {
+            index++;
+            return index;
+          }
+          return newId;
+        }();
+        var createSnapshotId = generateKey;
+      }
+    });
+    var require_env2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/env.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var env_exports = {};
+        __export22(env_exports, {
+          NODE_ENV: () => NODE_ENV,
+          getNev: () => getNev,
+          isDevelopment: () => isDevelopment,
+          isProduction: () => isProduction,
+          isTest: () => isTest
+        });
+        module22.exports = __toCommonJS22(env_exports);
+        var NODE_ENV = "development";
+        var isProduction = (env = NODE_ENV) => env === "production" || env === "prod" || env !== "development" && env !== "dev" && env !== "test";
+        var isTest = (env = NODE_ENV) => env === "test";
+        var isDevelopment = (env = NODE_ENV) => env === "development" || env === "dev";
+        var getNev = (key, env = NODE_ENV) => env[key];
+      }
+    });
+    var require_globals2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/globals.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var globals_exports = {};
+        __export22(globals_exports, {
+          document: () => document22,
+          global: () => global,
+          self: () => self,
+          window: () => window2
+        });
+        module22.exports = __toCommonJS22(globals_exports);
+        var global = globalThis;
+        var self = globalThis;
+        var window2 = globalThis;
+        var document22 = window2.document;
+      }
+    });
+    var require_node2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/node.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var node_exports = {};
+        __export22(node_exports, {
+          isHtmlElement: () => isHtmlElement,
+          isNode: () => isNode
+        });
+        module22.exports = __toCommonJS22(node_exports);
+        var import_globals3 = require_globals2();
+        var isNode = (obj) => {
+          return (typeof Node === "object" ? obj instanceof import_globals3.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+        };
+        var isHtmlElement = (obj) => {
+          return (typeof HTMLElement === "object" ? obj instanceof import_globals3.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+        };
+      }
+    });
+    var require_types2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/types.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var types_exports = {};
+        __export22(types_exports, {
+          TYPES: () => TYPES,
+          is: () => is,
+          isArray: () => isArray32,
+          isBoolean: () => isBoolean,
+          isDate: () => isDate,
+          isDefined: () => isDefined2,
+          isFunction: () => isFunction2,
+          isNot: () => isNot,
+          isNull: () => isNull2,
+          isNumber: () => isNumber2,
+          isObject: () => isObject32,
+          isObjectLike: () => isObjectLike3,
+          isString: () => isString22,
+          isUndefined: () => isUndefined2
+        });
+        module22.exports = __toCommonJS22(types_exports);
+        var import_node = require_node2();
+        var isObject32 = (arg) => {
+          if (arg === null)
+            return false;
+          return typeof arg === "object" && arg.constructor === Object;
+        };
+        var isString22 = (arg) => typeof arg === "string";
+        var isNumber2 = (arg) => typeof arg === "number";
+        var isFunction2 = (arg) => typeof arg === "function";
+        var isBoolean = (arg) => arg === true || arg === false;
+        var isNull2 = (arg) => arg === null;
+        var isArray32 = (arg) => Array.isArray(arg);
+        var isDate = (d) => d instanceof Date;
+        var isObjectLike3 = (arg) => {
+          if (arg === null)
+            return false;
+          return typeof arg === "object";
+        };
+        var isDefined2 = (arg) => {
+          return isObject32(arg) || isObjectLike3(arg) || isString22(arg) || isNumber2(arg) || isFunction2(arg) || isArray32(arg) || isObjectLike3(arg) || isBoolean(arg) || isDate(arg) || isNull2(arg);
+        };
+        var isUndefined2 = (arg) => {
+          return arg === void 0;
+        };
+        var TYPES = {
+          boolean: isBoolean,
+          array: isArray32,
+          object: isObject32,
+          string: isString22,
+          date: isDate,
+          number: isNumber2,
+          null: isNull2,
+          function: isFunction2,
+          objectLike: isObjectLike3,
+          node: import_node.isNode,
+          htmlElement: import_node.isHtmlElement,
+          defined: isDefined2
+        };
+        var is = (arg) => {
+          return (...args) => {
+            return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+          };
+        };
+        var isNot = (arg) => {
+          return (...args) => {
+            return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+          };
+        };
+      }
+    });
+    var require_array2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/array.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var array_exports = {};
+        __export22(array_exports, {
+          arrayContainsOtherArray: () => arrayContainsOtherArray,
+          createNestedObject: () => createNestedObject,
+          cutArrayAfterValue: () => cutArrayAfterValue,
+          cutArrayBeforeValue: () => cutArrayBeforeValue,
+          joinArrays: () => joinArrays,
+          mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+          mergeArray: () => mergeArray,
+          removeFromArray: () => removeFromArray,
+          removeValueFromArray: () => removeValueFromArray,
+          removeValueFromArrayAll: () => removeValueFromArrayAll,
+          swapItemsInArray: () => swapItemsInArray
+        });
+        module22.exports = __toCommonJS22(array_exports);
+        var import_object = require_object2();
+        var import_types = require_types2();
+        var arrayContainsOtherArray = (arr1, arr2) => {
+          return arr2.every((val) => arr1.includes(val));
+        };
+        var removeFromArray = (arr, index) => {
+          if ((0, import_types.isString)(index))
+            index = parseInt(index);
+          if ((0, import_types.isNumber)(index)) {
+            if (index < 0 || index >= arr.length || isNaN(index)) {
+              throw new Error("Invalid index");
+            }
+            arr.splice(index, 1);
+          } else if ((0, import_types.isArray)(index)) {
+            index.forEach((idx) => removeFromArray(arr, idx));
+          } 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 mergeArray = (arr, excludeFrom = []) => {
+          return arr.reduce((a, c) => (0, import_object.deepMerge)(a, (0, import_object.deepClone)(c, excludeFrom), excludeFrom), {});
+        };
+        var mergeAndCloneIfArray = (obj) => {
+          return (0, import_types.isArray)(obj) ? mergeArray(obj) : (0, import_object.deepClone)(obj);
+        };
+        var cutArrayBeforeValue = (arr, value) => {
+          const index = arr.indexOf(value);
+          if (index !== -1) {
+            return arr.slice(0, index);
+          }
+          return arr;
+        };
+        var cutArrayAfterValue = (arr, value) => {
+          if (!(0, import_types.isArray)(arr))
+            return;
+          const index = arr.indexOf(value);
+          if (index !== -1) {
+            return arr.slice(index + 1);
+          }
+          return arr;
+        };
+        var createNestedObject = (arr, lastValue) => {
+          const nestedObject = {};
+          if (arr.length === 0) {
+            return lastValue;
+          }
+          arr.reduce((obj, value, index) => {
+            if (!obj[value]) {
+              obj[value] = {};
+            }
+            if (index === arr.length - 1 && lastValue) {
+              obj[value] = lastValue;
+            }
+            return obj[value];
+          }, nestedObject);
+          return nestedObject;
+        };
+        var removeValueFromArray = (arr, value) => {
+          const index = arr.indexOf(value);
+          if (index > -1) {
+            const newArray = [...arr];
+            newArray.splice(index, 1);
+            return newArray;
+          }
+          return arr.slice();
+        };
+        var removeValueFromArrayAll = (arr, value) => {
+          return arr.filter((item) => item !== value);
+        };
+      }
+    });
+    var require_string2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/string.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var string_exports = {};
+        __export22(string_exports, {
+          lowercaseFirstLetter: () => lowercaseFirstLetter,
+          replaceLiteralsWithObjectFields: () => replaceLiteralsWithObjectFields,
+          stringIncludesAny: () => stringIncludesAny,
+          trimStringFromSymbols: () => trimStringFromSymbols
+        });
+        module22.exports = __toCommonJS22(string_exports);
+        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*((?:\.\.\/)+)?([^}\s]+)\s*\}\}/g,
+          3: /\{\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}\}/g
+        };
+        var replaceLiteralsWithObjectFields = (str, state, options = {}) => {
+          if (!str.includes(options.bracketsLength === 3 ? "{{{" : "{{"))
+            return str;
+          const reg = brackRegex[options.bracketsLength || 2];
+          return str.replace(reg, (_, parentPath, variable) => {
+            if (parentPath) {
+              const parentLevels = parentPath.match(options.bracketsLength === 3 ? /\.\.\.\//g : /\.\.\//g).length;
+              let parentState = state;
+              for (let i = 0; i < parentLevels; i++) {
+                parentState = parentState.parent;
+                if (!parentState) {
+                  return "";
+                }
+              }
+              const value = parentState[variable.trim()];
+              return value !== void 0 ? `${value}` : "";
+            } else {
+              const value = state[variable.trim()];
+              return value !== void 0 ? `${value}` : "";
+            }
+          });
+        };
+        var lowercaseFirstLetter = (inputString) => {
+          return `${inputString.charAt(0).toLowerCase()}${inputString.slice(1)}`;
+        };
+      }
+    });
+    var require_object2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/object.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var object_exports = {};
+        __export22(object_exports, {
+          clone: () => clone,
+          deepClone: () => deepClone2,
+          deepCloneExclude: () => deepCloneExclude,
+          deepCloneWithExtend: () => deepCloneWithExtend,
+          deepContains: () => deepContains,
+          deepDestringify: () => deepDestringify,
+          deepDiff: () => deepDiff,
+          deepMerge: () => deepMerge3,
+          deepStringify: () => deepStringify,
+          detachFunctionsFromObject: () => detachFunctionsFromObject,
+          diff: () => diff,
+          diffArrays: () => diffArrays,
+          diffObjects: () => diffObjects,
+          exec: () => exec,
+          flattenRecursive: () => flattenRecursive,
+          hasOwnProperty: () => hasOwnProperty,
+          isEmpty: () => isEmpty,
+          isEmptyObject: () => isEmptyObject,
+          isEqualDeep: () => isEqualDeep,
+          makeObjectWithoutPrototype: () => makeObjectWithoutPrototype,
+          map: () => map,
+          merge: () => merge5,
+          mergeArrayExclude: () => mergeArrayExclude,
+          mergeIfExisted: () => mergeIfExisted,
+          objectToString: () => objectToString,
+          overwrite: () => overwrite,
+          overwriteDeep: () => overwriteDeep2,
+          overwriteShallow: () => overwriteShallow,
+          removeFromObject: () => removeFromObject,
+          stringToObject: () => stringToObject
+        });
+        module22.exports = __toCommonJS22(object_exports);
+        var import_globals3 = require_globals2();
+        var import_types = require_types2();
+        var import_array = require_array2();
+        var import_string = require_string2();
+        var exec = (param, element, state, context) => {
+          if ((0, import_types.isFunction)(param)) {
+            return param(
+              element,
+              state || element.state,
+              context || element.context
+            );
+          }
+          return param;
+        };
+        var map = (obj, extention, element) => {
+          for (const e in extention) {
+            obj[e] = exec(extention[e], element);
+          }
+        };
+        var merge5 = (element, obj, excludeFrom = []) => {
+          for (const e in obj) {
+            const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, e);
+            if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__"))
+              continue;
+            const elementProp = element[e];
+            const objProp = obj[e];
+            if (elementProp === void 0) {
+              element[e] = objProp;
+            }
+          }
+          return element;
+        };
+        var deepMerge3 = (element, extend, excludeFrom = []) => {
+          for (const e in extend) {
+            const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(extend, e);
+            if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__"))
+              continue;
+            const elementProp = element[e];
+            const extendProp = extend[e];
+            if ((0, import_types.isObjectLike)(elementProp) && (0, import_types.isObjectLike)(extendProp)) {
+              deepMerge3(elementProp, extendProp, excludeFrom);
+            } else if (elementProp === void 0) {
+              element[e] = extendProp;
+            }
+          }
+          return element;
+        };
+        var clone = (obj, excludeFrom = []) => {
+          const o = {};
+          for (const prop in obj) {
+            const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
+            if (!hasOwnProperty2 || excludeFrom.includes(prop) || prop.startsWith("__"))
+              continue;
+            o[prop] = obj[prop];
+          }
+          return o;
+        };
+        var deepCloneExclude = (obj, excludeFrom = []) => {
+          if ((0, import_types.isArray)(obj)) {
+            return obj.map((x) => deepCloneExclude(x, excludeFrom));
+          }
+          const o = {};
+          for (const k in obj) {
+            const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, k);
+            if (!hasOwnProperty2 || excludeFrom.includes(k) || k.startsWith("__"))
+              continue;
+            let v = obj[k];
+            if (k === "extend" && (0, import_types.isArray)(v)) {
+              v = mergeArrayExclude(v, excludeFrom);
+            }
+            if ((0, import_types.isArray)(v)) {
+              o[k] = v.map((x) => deepCloneExclude(x, excludeFrom));
+            } else if ((0, import_types.isObject)(v)) {
+              o[k] = deepCloneExclude(v, excludeFrom);
+            } else
+              o[k] = v;
+          }
+          return o;
+        };
+        var mergeArrayExclude = (arr, excl = []) => {
+          return arr.reduce((acc, curr) => deepMerge3(acc, deepCloneExclude(curr, excl)), {});
+        };
+        var deepClone2 = (obj, excludeFrom = [], cleanUndefined = false) => {
+          const o = (0, import_types.isArray)(obj) ? [] : {};
+          for (const prop in obj) {
+            if (!Object.prototype.hasOwnProperty.call(obj, prop))
+              continue;
+            if (prop === "__proto__")
+              continue;
+            if (excludeFrom.includes(prop) || prop.startsWith("__"))
+              continue;
+            let objProp = obj[prop];
+            if (cleanUndefined && (0, import_types.isUndefined)(objProp))
+              continue;
+            if (prop === "extend" && (0, import_types.isArray)(objProp)) {
+              objProp = (0, import_array.mergeArray)(objProp);
+            }
+            if ((0, import_types.isObjectLike)(objProp)) {
+              o[prop] = deepClone2(objProp, excludeFrom, cleanUndefined);
+            } else
+              o[prop] = objProp;
+          }
+          return o;
+        };
+        var deepCloneWithExtend = (obj, excludeFrom = ["node"], options = {}) => {
+          const o = (0, import_types.isArray)(obj) ? [] : {};
+          for (const prop in obj) {
+            if (!Object.prototype.hasOwnProperty.call(obj, prop))
+              continue;
+            const objProp = obj[prop];
+            if (excludeFrom.includes(prop) || prop.startsWith("__") || options.cleanUndefined && (0, import_types.isUndefined)(objProp) || options.cleanNull && (0, import_types.isNull)(objProp))
+              continue;
+            if ((0, import_types.isObjectLike)(objProp)) {
+              o[prop] = deepCloneWithExtend(objProp, excludeFrom, options);
+            } else
+              o[prop] = objProp;
+          }
+          return o;
+        };
+        var deepStringify = (obj, stringified = {}) => {
+          for (const prop in obj) {
+            const objProp = obj[prop];
+            if ((0, import_types.isFunction)(objProp)) {
+              stringified[prop] = objProp.toString();
+            } else if ((0, import_types.isObject)(objProp)) {
+              stringified[prop] = {};
+              deepStringify(objProp, stringified[prop]);
+            } else if ((0, import_types.isArray)(objProp)) {
+              stringified[prop] = [];
+              objProp.forEach((v, i) => {
+                if ((0, import_types.isObject)(v)) {
+                  stringified[prop][i] = {};
+                  deepStringify(v, stringified[prop][i]);
+                } else if ((0, import_types.isFunction)(v)) {
+                  stringified[prop][i] = v.toString();
+                } else {
+                  stringified[prop][i] = v;
+                }
+              });
+            } else {
+              stringified[prop] = objProp;
+            }
+          }
+          return stringified;
+        };
+        var objectToString = (obj, indent = 0) => {
+          const spaces = "  ".repeat(indent);
+          let str = "{\n";
+          for (const [key, value] of Object.entries(obj)) {
+            const keyNotAllowdChars = (0, import_string.stringIncludesAny)(key, ["&", "*", "-", ":", "%", "{", "}", ">", "<", "@", ".", "/", "!", " "]);
+            const stringedKey = keyNotAllowdChars ? `'${key}'` : key;
+            str += `${spaces}  ${stringedKey}: `;
+            if ((0, import_types.isArray)(value)) {
+              str += "[\n";
+              for (const element of value) {
+                if ((0, import_types.isObject)(element) && element !== null) {
+                  str += `${spaces}    ${objectToString(element, indent + 2)},
+`;
+                } else if ((0, import_types.isString)(element)) {
+                  str += `${spaces}    '${element}',
+`;
+                } else {
+                  str += `${spaces}    ${element},
+`;
+                }
+              }
+              str += `${spaces}  ]`;
+            } else if ((0, import_types.isObjectLike)(value)) {
+              str += objectToString(value, indent + 1);
+            } else if ((0, import_types.isString)(value)) {
+              str += (0, import_string.stringIncludesAny)(value, ["\n", "'"]) ? `\`${value}\`` : `'${value}'`;
+            } else {
+              str += value;
+            }
+            str += ",\n";
+          }
+          str += `${spaces}}`;
+          return str;
+        };
+        var detachFunctionsFromObject = (obj, detached = {}) => {
+          for (const prop in obj) {
+            const objProp = obj[prop];
+            if ((0, import_types.isFunction)(objProp))
+              continue;
+            else if ((0, import_types.isObject)(objProp)) {
+              detached[prop] = {};
+              deepStringify(objProp, detached[prop]);
+            } else if ((0, import_types.isArray)(objProp)) {
+              detached[prop] = [];
+              objProp.forEach((v, i) => {
+                if ((0, import_types.isFunction)(v))
+                  return;
+                if ((0, import_types.isObject)(v)) {
+                  detached[prop][i] = {};
+                  detachFunctionsFromObject(v, detached[prop][i]);
+                } else {
+                  detached[prop][i] = v;
+                }
+              });
+            } else {
+              detached[prop] = objProp;
+            }
+          }
+          return detached;
+        };
+        var deepDestringify = (obj, destringified = {}) => {
+          for (const prop in obj) {
+            const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
+            if (!hasOwnProperty2)
+              continue;
+            const objProp = obj[prop];
+            if ((0, import_types.isString)(objProp)) {
+              if (objProp.includes("=>") || objProp.includes("function") || objProp.startsWith("(")) {
+                try {
+                  const evalProp = import_globals3.window.eval(`(${objProp})`);
+                  destringified[prop] = evalProp;
+                } catch (e) {
+                  if (e)
+                    destringified[prop] = objProp;
+                }
+              } else {
+                destringified[prop] = objProp;
+              }
+            } else if ((0, import_types.isArray)(objProp)) {
+              destringified[prop] = [];
+              objProp.forEach((arrProp) => {
+                if ((0, import_types.isString)(arrProp)) {
+                  if (arrProp.includes("=>") || arrProp.includes("function") || arrProp.startsWith("(")) {
+                    try {
+                      const evalProp = import_globals3.window.eval(`(${arrProp})`);
+                      destringified[prop].push(evalProp);
+                    } catch (e) {
+                      if (e)
+                        destringified[prop].push(arrProp);
+                    }
+                  } else {
+                    destringified[prop].push(arrProp);
+                  }
+                } else if ((0, import_types.isObject)(arrProp)) {
+                  destringified[prop].push(deepDestringify(arrProp));
+                } else {
+                  destringified[prop].push(arrProp);
+                }
+              });
+            } else if ((0, import_types.isObject)(objProp)) {
+              destringified[prop] = deepDestringify(objProp, destringified[prop]);
+            } else {
+              destringified[prop] = objProp;
+            }
+          }
+          return destringified;
+        };
+        var stringToObject = (str, verbose) => {
+          try {
+            return import_globals3.window.eval("(" + str + ")");
+          } catch (e) {
+            if (verbose)
+              console.warn(e);
+          }
+        };
+        var diffObjects = (original, objToDiff, cache) => {
+          for (const e in objToDiff) {
+            if (e === "ref")
+              continue;
+            const originalProp = original[e];
+            const objToDiffProp = objToDiff[e];
+            if ((0, import_types.isObject)(originalProp) && (0, import_types.isObject)(objToDiffProp)) {
+              cache[e] = {};
+              diff(originalProp, objToDiffProp, cache[e]);
+            } else if (objToDiffProp !== void 0) {
+              cache[e] = objToDiffProp;
+            }
+          }
+          return cache;
+        };
+        var diffArrays = (original, objToDiff, cache) => {
+          if (original.length !== objToDiff.length) {
+            cache = objToDiff;
+          } else {
+            const diffArr = [];
+            for (let i = 0; i < original.length; i++) {
+              const diffObj = diff(original[i], objToDiff[i]);
+              if (Object.keys(diffObj).length > 0) {
+                diffArr.push(diffObj);
+              }
+            }
+            if (diffArr.length > 0) {
+              cache = diffArr;
+            }
+          }
+          return cache;
+        };
+        var diff = (original, objToDiff, cache = {}) => {
+          if ((0, import_types.isArray)(original) && (0, import_types.isArray)(objToDiff)) {
+            cache = [];
+            diffArrays(original, objToDiff, cache);
+          } else {
+            diffObjects(original, objToDiff, cache);
+          }
+          return cache;
+        };
+        var hasOwnProperty = (o, ...args) => Object.prototype.hasOwnProperty.call(o, ...args);
+        var isEmpty = (o) => Object.keys(o).length === 0;
+        var isEmptyObject = (o) => (0, import_types.isObject)(o) && isEmpty(o);
+        var makeObjectWithoutPrototype = () => /* @__PURE__ */ Object.create(null);
+        var deepDiff = (lhs, rhs) => {
+          if (lhs === rhs)
+            return {};
+          if (!(0, import_types.isObjectLike)(lhs) || !(0, import_types.isObjectLike)(rhs))
+            return rhs;
+          const deletedValues = Object.keys(lhs).reduce((acc, key) => {
+            if (!hasOwnProperty(rhs, key)) {
+              acc[key] = void 0;
+            }
+            return acc;
+          }, makeObjectWithoutPrototype());
+          if ((0, import_types.isDate)(lhs) || (0, import_types.isDate)(rhs)) {
+            if (lhs.valueOf() === rhs.valueOf())
+              return {};
+            return rhs;
+          }
+          return Object.keys(rhs).reduce((acc, key) => {
+            if (!hasOwnProperty(lhs, key)) {
+              acc[key] = rhs[key];
+              return acc;
+            }
+            const difference = diff(lhs[key], rhs[key]);
+            if (isEmptyObject(difference) && !(0, import_types.isDate)(difference) && (isEmptyObject(lhs[key]) || !isEmptyObject(rhs[key]))) {
+              return acc;
+            }
+            acc[key] = difference;
+            return acc;
+          }, deletedValues);
+        };
+        var overwrite = (element, params, excludeFrom = []) => {
+          const { ref } = element;
+          const changes = {};
+          for (const e in params) {
+            if (excludeFrom.includes(e) || e.startsWith("__"))
+              continue;
+            const elementProp = element[e];
+            const paramsProp = params[e];
+            if (paramsProp) {
+              ref.__cache[e] = changes[e] = elementProp;
+              ref[e] = paramsProp;
+            }
+          }
+          return changes;
+        };
+        var overwriteShallow = (obj, params, excludeFrom = []) => {
+          for (const e in params) {
+            if (excludeFrom.includes(e) || e.startsWith("__"))
+              continue;
+            obj[e] = params[e];
+          }
+          return obj;
+        };
+        var overwriteDeep2 = (obj, params, excludeFrom = []) => {
+          for (const e in params) {
+            if (e === "__proto__")
+              continue;
+            if (excludeFrom.includes(e) || e.startsWith("__"))
+              continue;
+            const objProp = obj[e];
+            const paramsProp = params[e];
+            if ((0, import_types.isObjectLike)(objProp) && (0, import_types.isObjectLike)(paramsProp)) {
+              overwriteDeep2(objProp, paramsProp);
+            } else if (paramsProp !== void 0) {
+              obj[e] = paramsProp;
+            }
+          }
+          return obj;
+        };
+        var mergeIfExisted = (a, b) => {
+          if ((0, import_types.isObjectLike)(a) && (0, import_types.isObjectLike)(b))
+            return deepMerge3(a, b);
+          return a || b;
+        };
+        var flattenRecursive = (param, prop, stack = []) => {
+          const objectized = (0, import_array.mergeAndCloneIfArray)(param);
+          stack.push(objectized);
+          const extendOfExtend = objectized[prop];
+          if (extendOfExtend)
+            flattenRecursive(extendOfExtend, prop, stack);
+          delete objectized[prop];
+          return stack;
+        };
+        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 (const key of keysParam) {
+            if (!keysElement.includes(key)) {
+              return false;
+            }
+            const paramProp = param[key];
+            const elementProp = element[key];
+            if (!isEqualDeep(paramProp, elementProp, visited)) {
+              return false;
+            }
+          }
+          return true;
+        };
+        var deepContains = (obj1, obj2) => {
+          if (typeof obj1 !== typeof obj2) {
+            return false;
+          }
+          if ((0, import_types.isObjectLike)(obj1)) {
+            if (Array.isArray(obj1) && Array.isArray(obj2)) {
+              if (obj1.length !== obj2.length) {
+                return false;
+              }
+              for (let i = 0; i < obj1.length; i++) {
+                if (!deepContains(obj1[i], obj2[i])) {
+                  return false;
+                }
+              }
+            } else if ((0, import_types.isObjectLike)(obj1) && obj2 !== null) {
+              for (const key in obj1) {
+                const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj2, key);
+                if (!hasOwnProperty2 || !deepContains(obj1[key], obj2[key])) {
+                  return false;
+                }
+              }
+            }
+          } else {
+            return obj2 === obj1;
+          }
+          return true;
+        };
+        var removeFromObject = (obj, props) => {
+          if (props === void 0 || props === null)
+            return obj;
+          if ((0, import_types.is)(props)("string", "number")) {
+            delete obj[props];
+          } else if ((0, import_types.isArray)(props)) {
+            props.forEach((prop) => delete obj[prop]);
+          } else {
+            throw new Error("Invalid input: props must be a string or an array of strings");
+          }
+          return obj;
+        };
+      }
+    });
+    var require_function2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/function.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var function_exports = {};
+        __export22(function_exports, {
+          debounce: () => debounce,
+          debounceOnContext: () => debounceOnContext,
+          isStringFunction: () => isStringFunction,
+          memoize: () => memoize
+        });
+        module22.exports = __toCommonJS22(function_exports);
+        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 cache = {};
+          return (...args) => {
+            const n = args[0];
+            if (n in cache) {
+              return cache[n];
+            } else {
+              const result = fn(n);
+              cache[n] = result;
+              return result;
+            }
+          };
+        };
+        var isStringFunction = (inputString) => {
+          const functionRegex = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/;
+          return functionRegex.test(inputString);
+        };
+      }
+    });
+    var require_log2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/log.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var log_exports = {};
+        __export22(log_exports, {
+          logGroupIf: () => logGroupIf,
+          logIf: () => logIf
+        });
+        module22.exports = __toCommonJS22(log_exports);
+        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);
+          }
+        };
+      }
+    });
+    var require_cookie2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/cookie.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var cookie_exports = {};
+        __export22(cookie_exports, {
+          getCookie: () => getCookie,
+          isMobile: () => isMobile,
+          setCookie: () => setCookie
+        });
+        module22.exports = __toCommonJS22(cookie_exports);
+        var import_types = require_types2();
+        var isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+        var setCookie = (cname, cvalue, exdays = 365) => {
+          if ((0, import_types.isUndefined)(document) || (0, import_types.isUndefined)(document.cookie))
+            return;
+          const d = /* @__PURE__ */ new Date();
+          d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1e3);
+          const expires = `expires=${d.toUTCString()}`;
+          document.cookie = `${cname}=${cvalue};${expires};path=/`;
+        };
+        var getCookie = (cname) => {
+          if ((0, import_types.isUndefined)(document) || (0, import_types.isUndefined)(document.cookie))
+            return;
+          const name = `${cname}=`;
+          const decodedCookie = decodeURIComponent(document.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 require_tags2 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/tags.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __export22 = (target, all) => {
+          for (var name in all)
+            __defProp22(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var tags_exports = {};
+        __export22(tags_exports, {
+          HTML_TAGS: () => HTML_TAGS,
+          isValidHtmlTag: () => isValidHtmlTag
+        });
+        module22.exports = __toCommonJS22(tags_exports);
+        var HTML_TAGS = {
+          root: [
+            "body",
+            "html"
+          ],
+          head: [
+            "title",
+            "base",
+            "meta",
+            "style"
+          ],
+          body: [
+            "string",
+            "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"
+          ]
+        };
+        var isValidHtmlTag = (arg) => HTML_TAGS.body.includes(arg);
+      }
+    });
+    var require_cjs4 = __commonJS2({
+      "../../node_modules/@domql/utils/dist/cjs/index.js"(exports2, module22) {
+        "use strict";
+        var __defProp22 = Object.defineProperty;
+        var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames22 = Object.getOwnPropertyNames;
+        var __hasOwnProp22 = Object.prototype.hasOwnProperty;
+        var __copyProps22 = (to, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key of __getOwnPropNames22(from))
+              if (!__hasOwnProp22.call(to, key) && key !== except)
+                __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
+          }
+          return to;
+        };
+        var __reExport = (target, mod, secondTarget) => (__copyProps22(target, mod, "default"), secondTarget && __copyProps22(secondTarget, mod, "default"));
+        var __toCommonJS22 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
+        var utils_exports2 = {};
+        module22.exports = __toCommonJS22(utils_exports2);
+        __reExport(utils_exports2, require_key2(), module22.exports);
+        __reExport(utils_exports2, require_env2(), module22.exports);
+        __reExport(utils_exports2, require_types2(), module22.exports);
+        __reExport(utils_exports2, require_object2(), module22.exports);
+        __reExport(utils_exports2, require_function2(), module22.exports);
+        __reExport(utils_exports2, require_array2(), module22.exports);
+        __reExport(utils_exports2, require_node2(), module22.exports);
+        __reExport(utils_exports2, require_log2(), module22.exports);
+        __reExport(utils_exports2, require_string2(), module22.exports);
+        __reExport(utils_exports2, require_globals2(), module22.exports);
+        __reExport(utils_exports2, require_cookie2(), module22.exports);
+        __reExport(utils_exports2, require_tags2(), module22.exports);
+      }
+    });
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      arrayzeValue: () => arrayzeValue3,
+      copyStringToClipboard: () => copyStringToClipboard,
+      fibonacciNumberByIndex: () => fibonacciNumberByIndex,
+      findClosestNumber: () => findClosestNumber,
+      findClosestNumberInFactory: () => findClosestNumberInFactory,
+      formatDate: () => formatDate,
+      loadJavascriptFile: () => loadJavascriptFile,
+      removeChars: () => removeChars,
+      toCamelCase: () => toCamelCase2,
+      toDashCase: () => toDashCase2,
+      toDescriptionCase: () => toDescriptionCase,
+      toTitleCase: () => toTitleCase,
+      toggleFullscreen: () => toggleFullscreen
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_utils27 = __toESM2(require_cjs4(), 1);
+    var toggleFullscreen = (el) => {
+      if (!document.fullscreenElement) {
+        el.node.requestFullscreen().catch((err) => {
+          console.warn(`Error attempting to enable fullscreen mode: ${err.message} (${err.name})`);
+        });
+      } else {
+        document.exitFullscreen();
+      }
+    };
+    var import_utils28 = __toESM2(require_cjs4(), 1);
+    var findClosestNumber = (number, arr) => {
+      return ((0, import_utils28.isArray)(arr) ? arr : Object.values(arr)).reduce((prev, curr) => {
+        return Math.abs(curr - number) < Math.abs(prev - number) ? curr : prev;
+      });
+    };
+    var findClosestNumberInFactory = (val, factory) => {
+      val = parseFloat(val);
+      if ((0, import_utils28.isObject)(factory))
+        factory = Object.values(factory);
+      return findClosestNumber(val, factory);
+    };
+    var formatDate = (timestamp) => {
+      if (!timestamp)
+        return "";
+      const d = new Date(timestamp);
+      const ye = new Intl.DateTimeFormat("en", { year: "numeric" }).format(d);
+      const mo = new Intl.DateTimeFormat("en", { month: "short" }).format(d);
+      const da = new Intl.DateTimeFormat("en", { day: "2-digit" }).format(d);
+      return `${da} ${mo}, ${ye}`;
+    };
+    var fibonacciNumberByIndex = function fibonacciNumberByIndex2(n) {
+      const fib = [0, 1];
+      for (let i = 2; i <= n; i++) {
+        fib[i] = fib[i - 1] + fib[i - 2];
+      }
+      return fib[n];
+    };
+    var loadJavascriptFile = (FILE_URL, async = true, doc = document, type = "text/javascript") => {
+      return new Promise((resolve, reject) => {
+        try {
+          const scriptEle = doc.createElement("script");
+          scriptEle.type = type;
+          scriptEle.async = async;
+          scriptEle.src = FILE_URL;
+          scriptEle.addEventListener("load", (ev) => {
+            resolve({
+              status: true
+            });
+          });
+          scriptEle.addEventListener("error", (ev) => {
+            reject({
+              status: false,
+              message: `Failed to load the script ${FILE_URL}`
+            });
+          });
+          doc.body.appendChild(scriptEle);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    };
+    var copyStringToClipboard = (str) => {
+      const el = document.createElement("textarea");
+      el.value = str;
+      el.setAttribute("readonly", "");
+      el.style = { position: "absolute", left: "-9999px" };
+      document.body.appendChild(el);
+      el.select();
+      document.execCommand("copy");
+      document.body.removeChild(el);
+    };
+    var removeChars = (str) => {
+      return str.replace(/[^a-zA-Z0-9_]/g, "");
+    };
+    var toCamelCase2 = (str) => {
+      return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+        return index === 0 ? word.toLowerCase() : word.toUpperCase();
+      }).replaceAll(/\s+/g, "");
+    };
+    var toTitleCase = (str) => str && str.replace(
+      /\w\S*/g,
+      (txt) => {
+        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+      }
+    );
+    var toDashCase2 = (val) => val.replace(/[^a-zA-Z0-9]/g, " ").trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    var toDescriptionCase = (str = "") => {
+      const result = str.replace(/([A-Z])/g, " $1");
+      return result.charAt(0).toUpperCase() + result.slice(1);
+    };
+    var arrayzeValue3 = (val) => {
+      if ((0, import_utils27.isArray)(val))
+        return val;
+      if ((0, import_utils27.isString)(val))
+        return val.split(" ");
+      if ((0, import_utils27.isObject)(val))
+        return Object.values(val);
+      if ((0, import_utils27.isNumber)(val))
+        return [val];
+    };
+  }
+});
+
 // src/index.js
 var src_exports = {};
 __export(src_exports, {
@@ -1766,34 +3208,11 @@ var getFontFaceString = (LIBRARY) => {
 };
 
 // src/utils/sequence.js
-var import_utils5 = __toESM(require_cjs2(), 1);
-
-// ../../node_modules/@symbo.ls/utils/src/index.js
-var import_utils3 = __toESM(require_cjs2());
-
-// ../../node_modules/@symbo.ls/utils/src/scaling.js
-var import_utils2 = __toESM(require_cjs2());
-
-// ../../node_modules/@symbo.ls/utils/src/index.js
-var toCamelCase = (str) => {
-  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
-    return index === 0 ? word.toLowerCase() : word.toUpperCase();
-  }).replaceAll(/\s+/g, "");
-};
-var toDashCase = (val) => val.replace(/[^a-zA-Z0-9]/g, " ").trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-var arrayzeValue = (val) => {
-  if ((0, import_utils3.isArray)(val))
-    return val;
-  if ((0, import_utils3.isString)(val))
-    return val.split(" ");
-  if ((0, import_utils3.isObject)(val))
-    return Object.values(val);
-  if ((0, import_utils3.isNumber)(val))
-    return [val];
-};
+var import_utils3 = __toESM(require_cjs2(), 1);
+var import_utils4 = __toESM(require_cjs3(), 1);
 
 // src/factory.js
-var import_utils4 = __toESM(require_cjs2(), 1);
+var import_utils2 = __toESM(require_cjs2(), 1);
 
 // src/defaultConfig/index.js
 var defaultConfig_exports = {};
@@ -1998,13 +3417,13 @@ var CONFIG = {
   CSS_VARS,
   ...defaultConfig_exports
 };
-var cachedConfig = (0, import_utils4.deepClone)(CONFIG);
+var cachedConfig = (0, import_utils2.deepClone)(CONFIG);
 var FACTORY = {
   active: "0",
   0: CONFIG
 };
 var activateConfig = (def) => {
-  if ((0, import_utils4.isDefined)(def)) {
+  if ((0, import_utils2.isDefined)(def)) {
     FACTORY.active = def;
   }
   return FACTORY[def || FACTORY.active];
@@ -2013,10 +3432,10 @@ var getActiveConfig = (def) => {
   return FACTORY[def || FACTORY.active];
 };
 var setActiveConfig = (newConfig) => {
-  if (!(0, import_utils4.isObject)(newConfig))
+  if (!(0, import_utils2.isObject)(newConfig))
     return;
   FACTORY.active = "1";
-  FACTORY["1"] = (0, import_utils4.deepMerge)(newConfig, (0, import_utils4.deepClone)(cachedConfig));
+  FACTORY["1"] = (0, import_utils2.deepMerge)(newConfig, (0, import_utils2.deepClone)(cachedConfig));
   return newConfig;
 };
 
@@ -2162,9 +3581,9 @@ var getSequenceValue = (value = "A", sequenceProps) => {
     unit = UNIT2.default,
     useVariable
   } = sequenceProps;
-  if ((0, import_utils5.isString)(value) && value.slice(0, 2) === "--")
+  if ((0, import_utils3.isString)(value) && value.slice(0, 2) === "--")
     return `var(${value})`;
-  const prefix = `--${toDashCase(sequenceProps.type.replace(".", "-"))}-`;
+  const prefix = `--${(0, import_utils4.toDashCase)(sequenceProps.type.replace(".", "-"))}-`;
   const startsWithDashOrLetterRegex = /^-?[a-zA-Z]/i;
   const startsWithDashOrLetter = startsWithDashOrLetterRegex.test(value);
   if (value === "none" || value === "auto" || value === "unset" || value === "inherit" || value === "fit-content" || value === "min-content" || value === "max-content" || value.includes("calc") || value.includes("var") || !startsWithDashOrLetter)
@@ -2227,11 +3646,11 @@ var findHeadings = (propertyNames) => {
 };
 
 // src/utils/var.js
-var import_utils7 = __toESM(require_cjs2(), 1);
+var import_utils5 = __toESM(require_cjs2(), 1);
 var setVariables = (result, key) => {
   const CONFIG2 = getActiveConfig();
   const { CSS_VARS: CSS_VARS2 } = CONFIG2;
-  if ((0, import_utils7.isObjectLike)(result.value)) {
+  if ((0, import_utils5.isObjectLike)(result.value)) {
   } else {
     CSS_VARS2[result.var] = result.value;
   }
@@ -2306,7 +3725,7 @@ var applyMediaSequenceVars = (FACTORY2, media, options = {}) => {
 };
 
 // src/utils/sprite.js
-var import_utils8 = __toESM(require_cjs2(), 1);
+var import_utils6 = __toESM(require_cjs2(), 1);
 var generateSprite = (icons) => {
   const CONFIG2 = getActiveConfig();
   let sprite = "";
@@ -2320,7 +3739,7 @@ var generateSprite = (icons) => {
   return sprite;
 };
 var parseRootAttributes = (htmlString) => {
-  if (!(0, import_utils8.isString)(htmlString)) {
+  if (!(0, import_utils6.isString)(htmlString)) {
     return console.warn(`parseRootAttributes: ${htmlString} is not a string`);
   }
   const match = htmlString.match(/<svg\s+(.*?)>/);
@@ -2340,7 +3759,7 @@ var replaceIdsAndUrls = (code, key) => {
   const urlRegex = /url\(#([^)]*)\)/g;
   const matches = code.match(/id="([^"]*)"/g);
   let replacedCode = code;
-  if ((0, import_utils8.isArray)(matches)) {
+  if ((0, import_utils6.isArray)(matches)) {
     matches.forEach(() => {
       const randomKey = Math.floor(Math.random() * 1e5);
       replacedCode = code.replace(idRegex, `id="${key}-${randomKey}"`).replace(urlRegex, `url(#${key}-${randomKey})`);
@@ -2399,10 +3818,10 @@ __export(system_exports, {
 });
 
 // src/system/color.js
-var import_utils9 = __toESM(require_cjs2(), 1);
+var import_utils7 = __toESM(require_cjs2(), 1);
 var getColor = (value, key, config) => {
   const CONFIG2 = config || getActiveConfig();
-  if (!(0, import_utils9.isString)(value)) {
+  if (!(0, import_utils7.isString)(value)) {
     if (CONFIG2.verbose)
       console.warn(value, "- type for color is not valid");
     return;
@@ -2411,7 +3830,7 @@ var getColor = (value, key, config) => {
     return `var(${value})`;
   if (key && value[key])
     value = value[key];
-  const [name, alpha, tone] = (0, import_utils9.isArray)(value) ? value : value.split(" ");
+  const [name, alpha, tone] = (0, import_utils7.isArray)(value) ? value : value.split(" ");
   const { COLOR: COLOR2, GRADIENT: GRADIENT2 } = CONFIG2;
   let val = COLOR2[name] || GRADIENT2[name];
   if (!val) {
@@ -2443,17 +3862,17 @@ var getMediaColor = (value, globalTheme, config) => {
   const CONFIG2 = config || getActiveConfig();
   if (!globalTheme)
     globalTheme = CONFIG2.globalTheme;
-  if (!(0, import_utils9.isString)(value)) {
+  if (!(0, import_utils7.isString)(value)) {
     if (CONFIG2.verbose)
       console.warn(value, "- type for color is not valid");
     return;
   }
   if (value.slice(0, 2) === "--")
     return `var(${value})`;
-  const [name] = (0, import_utils9.isArray)(value) ? value : value.split(" ");
+  const [name] = (0, import_utils7.isArray)(value) ? value : value.split(" ");
   const { COLOR: COLOR2, GRADIENT: GRADIENT2 } = CONFIG2;
   const val = COLOR2[name] || GRADIENT2[name];
-  const isObj = (0, import_utils9.isObject)(val);
+  const isObj = (0, import_utils7.isObject)(val);
   if (isObj && val.value)
     return getColor(value, `@${globalTheme}`, config);
   else if (isObj) {
@@ -2476,7 +3895,7 @@ var getMediaColor = (value, globalTheme, config) => {
 };
 var setColor = (val, key, suffix) => {
   const CONFIG2 = getActiveConfig();
-  if ((0, import_utils9.isString)(val) && val.slice(0, 2) === "--") {
+  if ((0, import_utils7.isString)(val) && val.slice(0, 2) === "--") {
     val = getColor(val.slice(2));
     if (!(val.includes("rgb") || val.includes("var") || val.includes("#"))) {
       if (CONFIG2.verbose)
@@ -2484,13 +3903,13 @@ var setColor = (val, key, suffix) => {
       val = val.split(" ")[0];
     }
   }
-  if ((0, import_utils9.isArray)(val)) {
+  if ((0, import_utils7.isArray)(val)) {
     return {
       "@light": setColor(val[0], key, "light"),
       "@dark": setColor(val[1], key, "dark")
     };
   }
-  if ((0, import_utils9.isObject)(val)) {
+  if ((0, import_utils7.isObject)(val)) {
     const obj = {};
     for (const variant in val) {
       obj[variant] = setColor(
@@ -2519,15 +3938,15 @@ var setColor = (val, key, suffix) => {
 };
 var setGradient = (val, key, suffix) => {
   const CONFIG2 = getActiveConfig();
-  if ((0, import_utils9.isString)(val) && val.slice(0, 2) === "--")
+  if ((0, import_utils7.isString)(val) && val.slice(0, 2) === "--")
     val = getColor(val.slice(2));
-  if ((0, import_utils9.isArray)(val)) {
+  if ((0, import_utils7.isArray)(val)) {
     return {
       "@light": setGradient(val[0], key, "light"),
       "@dark": setGradient(val[0], key, "dark")
     };
   }
-  if ((0, import_utils9.isObject)(val)) {
+  if ((0, import_utils7.isObject)(val)) {
     const obj = {};
     for (const variant in val)
       obj[variant] = setGradient(val[variant], key, variant.slice(0, 1) === "@" ? variant.slice(1) : variant);
@@ -2544,7 +3963,7 @@ var setGradient = (val, key, suffix) => {
 };
 
 // src/system/theme.js
-var import_utils11 = __toESM(require_cjs2(), 1);
+var import_utils9 = __toESM(require_cjs2(), 1);
 var setThemeValue = (theme) => {
   const value = {};
   const { state, media, helpers, ...rest } = theme;
@@ -2567,7 +3986,7 @@ var getTheme = (value, modifier) => {
   if (CONFIG2.useVariable)
     return getMediaTheme(value, modifier);
   const { THEME: THEME2 } = CONFIG2;
-  if ((0, import_utils11.isString)(value)) {
+  if ((0, import_utils9.isString)(value)) {
     const [theme, subtheme] = value.split(" ");
     const isOurTheme = THEME2[theme];
     if (isOurTheme) {
@@ -2576,7 +3995,7 @@ var getTheme = (value, modifier) => {
       value = [theme, subtheme || modifier];
     }
   }
-  if ((0, import_utils11.isObjectLike)(value) && value[1]) {
+  if ((0, import_utils9.isObjectLike)(value) && value[1]) {
     const themeName = value[0];
     const subThemeName = value[1];
     const { helpers, media, state } = THEME2[themeName];
@@ -2586,11 +4005,11 @@ var getTheme = (value, modifier) => {
       return getThemeValue(helpers[subThemeName]);
     if (state && state[subThemeName])
       return getThemeValue(state[subThemeName]);
-  } else if ((0, import_utils11.isObject)(value))
+  } else if ((0, import_utils9.isObject)(value))
     return setThemeValue(value);
 };
 var setInverseTheme = (theme, variant, value) => {
-  if ((0, import_utils11.isObject)(variant)) {
+  if ((0, import_utils9.isObject)(variant)) {
     theme.variants.inverse.value = setThemeValue(variant);
   } else if (variant === true) {
     const { color, background } = value;
@@ -2605,7 +4024,7 @@ var setInverseTheme = (theme, variant, value) => {
 var setPseudo = (theme, key, variant, themeValue) => {
   const result = getTheme(variant);
   themeValue[`&:${key}`] = result;
-  if ((0, import_utils11.isObject)(variant) && !variant.value)
+  if ((0, import_utils9.isObject)(variant) && !variant.value)
     variant.value = result;
 };
 var setSelectors = (theme, value) => {
@@ -2623,7 +4042,7 @@ var setSelectors = (theme, value) => {
 var setPrefersScheme = (theme, key, variant, themeValue) => {
   const result = getTheme(variant);
   themeValue[`@media (prefers-color-scheme: ${key})`] = result;
-  if ((0, import_utils11.isObject)(variant) && !variant.value)
+  if ((0, import_utils9.isObject)(variant) && !variant.value)
     variant.value = result;
 };
 var setMedia = (theme, value) => {
@@ -2649,7 +4068,7 @@ var setHelpers = (theme, value) => {
   const keys = Object.keys(helpers);
   keys.map((key) => {
     const helper = helpers[key];
-    if ((0, import_utils11.isString)(helper))
+    if ((0, import_utils9.isString)(helper))
       helpers[key] = CONFIG2.THEME[helper];
     else
       getThemeValue(helpers[key]);
@@ -2673,7 +4092,7 @@ var setMediaTheme = (val, key, suffix, prefers) => {
   const CONFIG2 = getActiveConfig();
   const { CSS_VARS: CSS_VARS2 } = CONFIG2;
   const theme = { value: val };
-  if ((0, import_utils11.isObjectLike)(val)) {
+  if ((0, import_utils9.isObjectLike)(val)) {
     for (const param in val) {
       const symb = param.slice(0, 1);
       const value = val[param];
@@ -2701,7 +4120,7 @@ var setMediaTheme = (val, key, suffix, prefers) => {
       };
     }
   }
-  if ((0, import_utils11.isString)(val) && val.slice(0, 2) === "--") {
+  if ((0, import_utils9.isString)(val) && val.slice(0, 2) === "--") {
     const { THEME: THEME2 } = CONFIG2;
     const value = THEME2[val.slice(2)];
     const getReferenced = getMediaTheme(value, prefers);
@@ -2714,7 +4133,7 @@ var recursiveTheme = (val) => {
   const obj = {};
   for (const param in val) {
     const symb = param.slice(0, 1);
-    if ((0, import_utils11.isObjectLike)(val[param])) {
+    if ((0, import_utils9.isObjectLike)(val[param])) {
       if (symb === "@") {
         const query = CONFIG2.MEDIA[param.slice(1)];
         const media = `@media screen and ${query}`;
@@ -2734,25 +4153,25 @@ var findModifierFromArray = (val, modifierArray) => {
   return val;
 };
 var findModifier = (val, modifier) => {
-  if ((0, import_utils11.isArray)(modifier))
+  if ((0, import_utils9.isArray)(modifier))
     return findModifierFromArray(val, modifier);
-  else if ((0, import_utils11.isString)(modifier) && val[modifier])
+  else if ((0, import_utils9.isString)(modifier) && val[modifier])
     return val[modifier];
   else
     return val;
 };
 var getMediaTheme = (value, modifier) => {
   const activeConfig = getActiveConfig();
-  if ((0, import_utils11.isString)(value) && value.slice(0, 2) === "--") {
+  if ((0, import_utils9.isString)(value) && value.slice(0, 2) === "--") {
     value = getMediaTheme(value.slice(2));
   }
-  if (!value || !(0, import_utils11.isString)(value)) {
+  if (!value || !(0, import_utils9.isString)(value)) {
     if (activeConfig.verbose) {
       console.warn(`${value} - Theme is not a string`);
     }
     return;
   }
-  const [themeName, ...themeModifiers] = (0, import_utils11.isArray)(value) ? value : value.split(" ");
+  const [themeName, ...themeModifiers] = (0, import_utils9.isArray)(value) ? value : value.split(" ");
   let themeValue = activeConfig.THEME[themeName];
   if (themeValue && (themeModifiers || modifier)) {
     themeValue = findModifier(themeValue, themeModifiers.length ? themeModifiers : modifier);
@@ -2762,10 +4181,11 @@ var getMediaTheme = (value, modifier) => {
 };
 
 // src/system/font.js
-var import_utils12 = __toESM(require_cjs2(), 1);
+var import_utils10 = __toESM(require_cjs2(), 1);
+var import_utils11 = __toESM(require_cjs3(), 1);
 var setFont = (val, key) => {
   const CSSvar = `--font-${key}`;
-  if (!val || (0, import_utils12.isArray)(val) && !val[0])
+  if (!val || (0, import_utils10.isArray)(val) && !val[0])
     return;
   const fontFace = val[0] ? getFontFaceEach(key, val) : setCustomFontMedia(key, val.url);
   return { var: CSSvar, value: val, fontFace };
@@ -2781,15 +4201,15 @@ var setFontFamily = (val, key) => {
   let { value, type } = val;
   if (val.isDefault)
     FONT_FAMILY2.default = key;
-  if ((0, import_utils12.isObject)(value))
-    value = arrayzeValue(value);
+  if ((0, import_utils10.isObject)(value))
+    value = (0, import_utils11.arrayzeValue)(value);
   const CSSvar = `--font-family-${key}`;
   const str = `${value.join(", ")}, ${FONT_FAMILY_TYPES2[type]}`;
   return { var: CSSvar, value: str, arr: value, type };
 };
 
 // src/system/typography.js
-var import_utils15 = __toESM(require_cjs2(), 1);
+var import_utils13 = __toESM(require_cjs2(), 1);
 var runThroughMedia = (FACTORY2) => {
   const CONFIG2 = getActiveConfig();
   const { TYPOGRAPHY: TYPOGRAPHY2, MEDIA: MEDIA2 } = CONFIG2;
@@ -2809,7 +4229,7 @@ var runThroughMedia = (FACTORY2) => {
       h1Matches,
       unit
     } = FACTORY2;
-    (0, import_utils15.merge)(mediaValue, {
+    (0, import_utils13.merge)(mediaValue, {
       type,
       base,
       ratio,
@@ -2826,7 +4246,7 @@ var runThroughMedia = (FACTORY2) => {
       applyMediaSequenceVars(FACTORY2, prop);
       continue;
     }
-    (0, import_utils15.merge)(mediaValue, {
+    (0, import_utils13.merge)(mediaValue, {
       sequence: {},
       scales: {},
       templates: {},
@@ -2874,7 +4294,8 @@ var getFontSizeByKey = (value) => {
 };
 
 // src/system/spacing.js
-var import_utils18 = __toESM(require_cjs2(), 1);
+var import_utils15 = __toESM(require_cjs3(), 1);
+var import_utils16 = __toESM(require_cjs2(), 1);
 var runThroughMedia2 = (FACTORY2) => {
   for (const prop in FACTORY2) {
     const mediaProps = FACTORY2[prop];
@@ -2890,7 +4311,7 @@ var runThroughMedia2 = (FACTORY2) => {
       h1Matches,
       unit
     } = FACTORY2;
-    (0, import_utils18.merge)(mediaProps, {
+    (0, import_utils16.merge)(mediaProps, {
       type,
       base,
       ratio,
@@ -2924,11 +4345,11 @@ var getSequence = (sequenceProps) => {
 };
 var getSpacingByKey = (value, propertyName = "padding", sequenceProps) => {
   const sequence = getSequence(sequenceProps);
-  if ((0, import_utils18.isString)(value) && (value.includes("calc") || value.includes("var"))) {
+  if ((0, import_utils16.isString)(value) && (value.includes("calc") || value.includes("var"))) {
     return { [propertyName]: value };
   }
-  const stack = arrayzeValue(value);
-  if (!(0, import_utils18.isArray)(stack))
+  const stack = (0, import_utils15.arrayzeValue)(value);
+  if (!(0, import_utils16.isArray)(stack))
     return;
   if (stack.length > 1) {
     let suffix = "";
@@ -2963,7 +4384,7 @@ var getSpacingBasedOnRatio = (props, propertyName, val) => {
     let sequenceProps = SPACING2[spacingRatio];
     if (!sequenceProps) {
       const { type, base, range, subSequence } = SPACING2;
-      sequenceProps = SPACING2[spacingRatio] = (0, import_utils18.merge)({
+      sequenceProps = SPACING2[spacingRatio] = (0, import_utils16.merge)({
         ratio: spacingRatio,
         type: type + "-" + spacingRatio,
         unit,
@@ -2986,16 +4407,16 @@ var getSpacingBasedOnRatio = (props, propertyName, val) => {
 };
 
 // src/system/shadow.js
-var import_utils20 = __toESM(require_cjs2(), 1);
+var import_utils18 = __toESM(require_cjs2(), 1);
 var setShadow = (value, key, suffix, prefers) => {
   const CONFIG2 = getActiveConfig();
-  if ((0, import_utils20.isArray)(value)) {
+  if ((0, import_utils18.isArray)(value)) {
     return {
       "@light": setShadow(value[0], key, "light"),
       "@dark": setShadow(value[1], key, "dark")
     };
   }
-  if ((0, import_utils20.isObject)(value)) {
+  if ((0, import_utils18.isObject)(value)) {
     const obj = {};
     for (const variant in value) {
       obj[variant] = setShadow(
@@ -3006,7 +4427,7 @@ var setShadow = (value, key, suffix, prefers) => {
     }
     return obj;
   }
-  if ((0, import_utils20.isString)(value) && value.includes(",")) {
+  if ((0, import_utils18.isString)(value) && value.includes(",")) {
     value = value.split(",").map((v) => {
       v = v.trim();
       if (v.startsWith("--"))
@@ -3034,17 +4455,17 @@ var getShadow = (value, globalTheme) => {
   const CONFIG2 = getActiveConfig();
   if (!globalTheme)
     globalTheme = CONFIG2.globalTheme;
-  if (!(0, import_utils20.isString)(value)) {
+  if (!(0, import_utils18.isString)(value)) {
     if (CONFIG2.verbose)
       console.warn(value, "- type for color is not valid");
     return;
   }
   if (value.slice(0, 2) === "--")
     return `var(${value})`;
-  const [name] = (0, import_utils20.isArray)(value) ? value : value.split(" ");
+  const [name] = (0, import_utils18.isArray)(value) ? value : value.split(" ");
   const { SHADOW: SHADOW2 } = CONFIG2;
   const val = SHADOW2[name];
-  const isObj = (0, import_utils20.isObject)(val);
+  const isObj = (0, import_utils18.isObject)(val);
   if (!val) {
     if (CONFIG2.verbose)
       console.warn("Can't find color ", name);
@@ -3073,6 +4494,7 @@ var getShadow = (value, globalTheme) => {
 };
 
 // src/system/timing.js
+var import_utils19 = __toESM(require_cjs3(), 1);
 var applyTimingSequence = () => {
   const CONFIG2 = getActiveConfig();
   const { TIMING: TIMING2 } = CONFIG2;
@@ -3082,7 +4504,7 @@ var applyTimingSequence = () => {
 var getTimingFunction = (value) => {
   const CONFIG2 = getActiveConfig();
   const { TIMING: TIMING2 } = CONFIG2;
-  return TIMING2[value] || TIMING2[toCamelCase(value)] || value;
+  return TIMING2[value] || TIMING2[(0, import_utils19.toCamelCase)(value)] || value;
 };
 var getTimingByKey = (value, property = "timing") => {
   const CONFIG2 = getActiveConfig();
@@ -3095,11 +4517,11 @@ var getTimingByKey = (value, property = "timing") => {
 };
 
 // src/system/document.js
-var import_utils23 = __toESM(require_cjs2(), 1);
+var import_utils21 = __toESM(require_cjs2(), 1);
 var applyDocument = () => {
   const CONFIG2 = getActiveConfig();
   const { DOCUMENT: DOCUMENT2, FONT_FAMILY: FONT_FAMILY2, THEME: THEME2, TYPOGRAPHY: TYPOGRAPHY2 } = CONFIG2;
-  return (0, import_utils23.merge)(DOCUMENT2, {
+  return (0, import_utils21.merge)(DOCUMENT2, {
     theme: THEME2.document,
     fontFamily: getDefaultOrFirstKey(FONT_FAMILY2),
     fontSize: TYPOGRAPHY2.base,
@@ -3183,7 +4605,7 @@ var appendSVG = (lib, options = DEF_OPTIONS) => {
 };
 
 // src/system/reset.js
-var import_utils26 = __toESM(require_cjs2(), 1);
+var import_utils24 = __toESM(require_cjs2(), 1);
 var applyReset = (reset = {}) => {
   const CONFIG2 = getActiveConfig();
   const { RESET: RESET2, TYPOGRAPHY: TYPOGRAPHY2, DOCUMENT: DOCUMENT2 } = CONFIG2;
@@ -3205,8 +4627,8 @@ var applyReset = (reset = {}) => {
     const { body, ...templates } = TYPOGRAPHY2.templates;
     const globalTheme = CONFIG2.useDocumentTheme ? getMediaTheme("document", `@${CONFIG2.globalTheme}`) : {};
     if (RESET2.html)
-      (0, import_utils26.overwriteDeep)(RESET2.html, globalTheme);
-    return (0, import_utils26.deepMerge)((0, import_utils26.merge)(RESET2, reset), {
+      (0, import_utils24.overwriteDeep)(RESET2.html, globalTheme);
+    return (0, import_utils24.deepMerge)((0, import_utils24.merge)(RESET2, reset), {
       html: {
         position: "absolute",
         // overflow: 'hidden',
@@ -3245,7 +4667,7 @@ var applyReset = (reset = {}) => {
 };
 
 // src/transforms/index.js
-var import_utils27 = __toESM(require_cjs2(), 1);
+var import_utils25 = __toESM(require_cjs2(), 1);
 var isBorderStyle = (str) => [
   "none",
   "hidden",
@@ -3317,7 +4739,7 @@ var transformBackgroundImage = (backgroundImage, globalTheme) => {
     return v;
   }).join(" ");
 };
-var transfromGap = (gap) => (0, import_utils27.isString)(gap) && gap.split(" ").map((v) => getSpacingByKey(v, "gap").gap).join(" ");
+var transfromGap = (gap) => (0, import_utils25.isString)(gap) && gap.split(" ").map((v) => getSpacingByKey(v, "gap").gap).join(" ");
 var transformTransition = (transition) => {
   const arr = transition.split(" ");
   if (!arr.length)
@@ -3335,7 +4757,7 @@ var transformTransition = (transition) => {
   }).join(" ");
 };
 var transformDuration = (duration, props, propertyName) => {
-  if (!(0, import_utils27.isString)(duration))
+  if (!(0, import_utils25.isString)(duration))
     return;
   return duration.split(",").map((v) => getTimingByKey(v).timing || v).join(",");
 };
@@ -3351,11 +4773,11 @@ var checkIfBoxSize = (propertyName) => {
 };
 var transformSize = (propertyName, val, props = {}, opts = {}) => {
   let value = val || props[propertyName];
-  if ((0, import_utils27.isUndefined)(value) && (0, import_utils27.isNull)(value))
+  if ((0, import_utils25.isUndefined)(value) && (0, import_utils25.isNull)(value))
     return;
   const shouldScaleBoxSize = props.scaleBoxSize;
   const isBoxSize = checkIfBoxSize(propertyName);
-  if (!shouldScaleBoxSize && isBoxSize && (0, import_utils27.isString)(value)) {
+  if (!shouldScaleBoxSize && isBoxSize && (0, import_utils25.isString)(value)) {
     value = value.split(" ").map((v) => {
       const isSingleLetter = v.length < 3 && /[A-Z]/.test(v);
       const hasUnits = ["%", "vw", "vh", "ch"].some((unit) => value.includes(unit));
@@ -3377,9 +4799,9 @@ var transformSizeRatio = (propertyName, props) => {
 };
 
 // src/set.js
-var import_utils28 = __toESM(require_cjs2(), 1);
+var import_utils26 = __toESM(require_cjs2(), 1);
 var setCases = (val, key) => {
-  if ((0, import_utils28.isFunction)(val))
+  if ((0, import_utils26.isFunction)(val))
     return val();
   return val;
 };