@symbo.ls/utils 2.11.363 → 2.11.365

package/dist/cjs/codify.js

@@ -0,0 +1,1390 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // 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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/@domql/utils/dist/cjs/key.js
+var require_key = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/key.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var key_exports = {};
+    __export2(key_exports, {
+      createSnapshotId: () => createSnapshotId,
+      generateKey: () => generateKey
+    });
+    module2.exports = __toCommonJS2(key_exports);
+    var generateKey = /* @__PURE__ */ function() {
+      let index = 0;
+      function newId() {
+        index++;
+        return index;
+      }
+      return newId;
+    }();
+    var createSnapshotId = generateKey;
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/env.js
+var require_env = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/env.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var env_exports = {};
+    __export2(env_exports, {
+      NODE_ENV: () => NODE_ENV,
+      getNev: () => getNev,
+      isDevelopment: () => isDevelopment,
+      isProduction: () => isProduction,
+      isTest: () => isTest
+    });
+    module2.exports = __toCommonJS2(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];
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/globals.js
+var require_globals = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/globals.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var globals_exports = {};
+    __export2(globals_exports, {
+      document: () => document2,
+      global: () => global,
+      self: () => self,
+      window: () => window
+    });
+    module2.exports = __toCommonJS2(globals_exports);
+    var global = globalThis;
+    var self = globalThis;
+    var window = globalThis;
+    var document2 = window.document;
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/node.js
+var require_node = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/node.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var node_exports = {};
+    __export2(node_exports, {
+      isHtmlElement: () => isHtmlElement,
+      isNode: () => isNode
+    });
+    module2.exports = __toCommonJS2(node_exports);
+    var import_globals = require_globals();
+    var isNode = (obj) => {
+      return (typeof Node === "object" ? obj instanceof import_globals.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_globals.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/types.js
+var require_types = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/types.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var types_exports = {};
+    __export2(types_exports, {
+      TYPES: () => TYPES,
+      is: () => is,
+      isArray: () => isArray3,
+      isBoolean: () => isBoolean,
+      isDate: () => isDate,
+      isDefined: () => isDefined,
+      isFunction: () => isFunction,
+      isNot: () => isNot,
+      isNull: () => isNull,
+      isNumber: () => isNumber2,
+      isObject: () => isObject3,
+      isObjectLike: () => isObjectLike,
+      isString: () => isString2,
+      isUndefined: () => isUndefined
+    });
+    module2.exports = __toCommonJS2(types_exports);
+    var import_node = require_node();
+    var isObject3 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object" && arg.constructor === Object;
+    };
+    var isString2 = (arg) => typeof arg === "string";
+    var isNumber2 = (arg) => typeof arg === "number";
+    var isFunction = (arg) => typeof arg === "function";
+    var isBoolean = (arg) => arg === true || arg === false;
+    var isNull = (arg) => arg === null;
+    var isArray3 = (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) => {
+      return isObject3(arg) || isObjectLike(arg) || isString2(arg) || isNumber2(arg) || isFunction(arg) || isArray3(arg) || isObjectLike(arg) || isBoolean(arg) || isDate(arg) || isNull(arg);
+    };
+    var isUndefined = (arg) => {
+      return arg === void 0;
+    };
+    var TYPES = {
+      boolean: isBoolean,
+      array: isArray3,
+      object: isObject3,
+      string: isString2,
+      date: isDate,
+      number: isNumber2,
+      null: isNull,
+      function: isFunction,
+      objectLike: isObjectLike,
+      node: import_node.isNode,
+      htmlElement: import_node.isHtmlElement,
+      defined: isDefined
+    };
+    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;
+      };
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/array.js
+var require_array = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/array.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var array_exports = {};
+    __export2(array_exports, {
+      arrayContainsOtherArray: () => arrayContainsOtherArray,
+      createNestedObject: () => createNestedObject,
+      cutArrayAfterValue: () => cutArrayAfterValue,
+      cutArrayBeforeValue: () => cutArrayBeforeValue,
+      joinArrays: () => joinArrays,
+      mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+      mergeArray: () => mergeArray,
+      removeFromArray: () => removeFromArray,
+      removeValueFromArray: () => removeValueFromArray,
+      removeValueFromArrayAll: () => removeValueFromArrayAll,
+      swapItemsInArray: () => swapItemsInArray
+    });
+    module2.exports = __toCommonJS2(array_exports);
+    var import_object = require_object();
+    var import_types = require_types();
+    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);
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/string.js
+var require_string = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/string.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var string_exports = {};
+    __export2(string_exports, {
+      lowercaseFirstLetter: () => lowercaseFirstLetter,
+      replaceLiteralsWithObjectFields: () => replaceLiteralsWithObjectFields,
+      stringIncludesAny: () => stringIncludesAny,
+      trimStringFromSymbols: () => trimStringFromSymbols
+    });
+    module2.exports = __toCommonJS2(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)}`;
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/object.js
+var require_object = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/object.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var object_exports = {};
+    __export2(object_exports, {
+      clone: () => clone,
+      deepClone: () => deepClone,
+      deepCloneExclude: () => deepCloneExclude,
+      deepCloneWithExtend: () => deepCloneWithExtend,
+      deepContains: () => deepContains,
+      deepDestringify: () => deepDestringify,
+      deepDiff: () => deepDiff,
+      deepMerge: () => deepMerge,
+      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: () => merge,
+      mergeArrayExclude: () => mergeArrayExclude,
+      mergeIfExisted: () => mergeIfExisted,
+      objectToString: () => objectToString,
+      overwrite: () => overwrite,
+      overwriteDeep: () => overwriteDeep,
+      overwriteShallow: () => overwriteShallow,
+      removeFromObject: () => removeFromObject,
+      stringToObject: () => stringToObject
+    });
+    module2.exports = __toCommonJS2(object_exports);
+    var import_globals = require_globals();
+    var import_types = require_types();
+    var import_array = require_array();
+    var import_string = require_string();
+    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 merge = (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 deepMerge = (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)) {
+          deepMerge(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) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
+    };
+    var deepClone = (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] = deepClone(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_globals.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_globals.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_globals.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 overwriteDeep = (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)) {
+          overwriteDeep(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 deepMerge(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;
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/function.js
+var require_function = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/function.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var function_exports = {};
+    __export2(function_exports, {
+      debounce: () => debounce,
+      debounceOnContext: () => debounceOnContext,
+      isStringFunction: () => isStringFunction,
+      memoize: () => memoize
+    });
+    module2.exports = __toCommonJS2(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);
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/log.js
+var require_log = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/log.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var log_exports = {};
+    __export2(log_exports, {
+      logGroupIf: () => logGroupIf,
+      logIf: () => logIf
+    });
+    module2.exports = __toCommonJS2(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);
+      }
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/cookie.js
+var require_cookie = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/cookie.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var cookie_exports = {};
+    __export2(cookie_exports, {
+      getCookie: () => getCookie,
+      isMobile: () => isMobile,
+      setCookie: () => setCookie
+    });
+    module2.exports = __toCommonJS2(cookie_exports);
+    var import_types = require_types();
+    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 "";
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/tags.js
+var require_tags = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/tags.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var tags_exports = {};
+    __export2(tags_exports, {
+      HTML_TAGS: () => HTML_TAGS,
+      isValidHtmlTag: () => isValidHtmlTag
+    });
+    module2.exports = __toCommonJS2(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);
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/index.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var utils_exports = {};
+    module2.exports = __toCommonJS2(utils_exports);
+    __reExport(utils_exports, require_key(), module2.exports);
+    __reExport(utils_exports, require_env(), module2.exports);
+    __reExport(utils_exports, require_types(), module2.exports);
+    __reExport(utils_exports, require_object(), module2.exports);
+    __reExport(utils_exports, require_function(), module2.exports);
+    __reExport(utils_exports, require_array(), module2.exports);
+    __reExport(utils_exports, require_node(), module2.exports);
+    __reExport(utils_exports, require_log(), module2.exports);
+    __reExport(utils_exports, require_string(), module2.exports);
+    __reExport(utils_exports, require_globals(), module2.exports);
+    __reExport(utils_exports, require_cookie(), module2.exports);
+    __reExport(utils_exports, require_tags(), module2.exports);
+  }
+});
+
+// src/codify.js
+var codify_exports = {};
+__export(codify_exports, {
+  codify: () => codify,
+  replaceKeysWithAttr: () => replaceKeysWithAttr,
+  stringifyProps: () => stringifyProps
+});
+module.exports = __toCommonJS(codify_exports);
+
+// src/index.js
+var import_utils2 = __toESM(require_cjs(), 1);
+
+// src/scaling.js
+var import_utils = __toESM(require_cjs(), 1);
+
+// src/index.js
+var toDashCase = (val) => val.replace(/[^a-zA-Z0-9]/g, " ").trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+
+// src/codify.js
+var stringifyProps = (props, indent = 2) => JSON.stringify(props, null, indent);
+var replaceKeysWithAttr = (str) => str.replaceAll('": "', '="').replaceAll('\n  "', " ").replaceAll("{ ", "\n  ").replaceAll("}", "").replaceAll(", ", "\n  ");
+var codify = (key, props) => ({
+  react: `import { ${key} } from '@symbo.ls/react'
+
+const props = ${stringifyProps(props)}
+
+<${key} {...props} />`,
+  domql: `import { ${key} } from 'smbls'
+
+const props = ${stringifyProps(props)}
+
+const component = {
+  extend: ${key},
+  props
+}`,
+  iframe: `<iframe
+  title="${key}"
+  style="border: 0; resize: both; padding: 0 10px 10px 0"
+  src="https://demo.symbols.app/scene/${key}/fullscreen/smbls.symbo.ls" 
+  referrerpolicy="no-referrer-when-downgrade"
+></iframe>`,
+  html: `<script src="smbls.js"><\/script>
+
+<${key && toDashCase(key)} ${replaceKeysWithAttr(stringifyProps(props))}/>`
+});