@symbo.ls/scratch 2.10.224 → 2.10.230

package/dist/cjs/utils/index.js

@@ -1,8 +1,17 @@
 "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))
@@ -11,13 +20,1522 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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/globals/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "../../node_modules/@domql/globals/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 __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: () => document3,
+      global: () => global,
+      self: () => self,
+      window: () => window3
+    });
+    module2.exports = __toCommonJS2(globals_exports);
+    var global = globalThis;
+    var self = globalThis;
+    var window3 = globalThis;
+    var document3 = window3.document;
+  }
+});
+
+// ../../node_modules/@domql/tags/dist/cjs/htmlTags.js
+var require_htmlTags = __commonJS({
+  "../../node_modules/@domql/tags/dist/cjs/htmlTags.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 htmlTags_exports = {};
+    __export2(htmlTags_exports, {
+      HTML_TAGS: () => HTML_TAGS
+    });
+    module2.exports = __toCommonJS2(htmlTags_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",
+        "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",
+        "q",
+        "rp",
+        "rt",
+        "ruby",
+        "s",
+        "samp",
+        "script",
+        "section",
+        "select",
+        "small",
+        "source",
+        "span",
+        "strike",
+        "strong",
+        "sub",
+        "summary",
+        "sup",
+        "table",
+        "tbody",
+        "td",
+        "template",
+        "textarea",
+        "tfoot",
+        "th",
+        "thead",
+        "time",
+        "tr",
+        "track",
+        "tt",
+        "u",
+        "ul",
+        "var",
+        "video",
+        "wbr",
+        // SVG
+        "svg",
+        "path"
+      ]
+    };
+  }
+});
+
+// ../../node_modules/@domql/tags/dist/cjs/index.js
+var require_cjs2 = __commonJS({
+  "../../node_modules/@domql/tags/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 tags_exports = {};
+    module2.exports = __toCommonJS2(tags_exports);
+    __reExport(tags_exports, require_htmlTags(), module2.exports);
+  }
+});
+
+// ../../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,
+      isDefined: () => isDefined2,
+      isFunction: () => isFunction,
+      isHtmlElement: () => isHtmlElement,
+      isNode: () => isNode,
+      isNot: () => isNot,
+      isNull: () => isNull,
+      isNumber: () => isNumber,
+      isObject: () => isObject3,
+      isObjectLike: () => isObjectLike2,
+      isString: () => isString4,
+      isUndefined: () => isUndefined,
+      isValidHtmlTag: () => isValidHtmlTag
+    });
+    module2.exports = __toCommonJS2(types_exports);
+    var import_globals2 = require_cjs();
+    var import_tags = require_cjs2();
+    var isValidHtmlTag = (arg) => import_tags.HTML_TAGS.body.indexOf(arg);
+    var isObject3 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object" && arg.constructor === Object;
+    };
+    var isString4 = (arg) => typeof arg === "string";
+    var isNumber = (arg) => typeof arg === "number";
+    var isFunction = (arg) => typeof arg === "function";
+    var isBoolean = (arg) => arg === true || arg === false;
+    var isNull = (arg) => arg === null;
+    var isArray3 = (arg) => Array.isArray(arg);
+    var isObjectLike2 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object";
+    };
+    var isNode = (obj) => {
+      return typeof import_globals2.window.Node === "object" ? obj instanceof import_globals2.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+    };
+    var isHtmlElement = (obj) => {
+      return typeof import_globals2.window.HTMLElement === "object" ? obj instanceof import_globals2.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+    };
+    var isDefined2 = (arg) => {
+      return isObject3(arg) || isObjectLike2(arg) || isString4(arg) || isNumber(arg) || isFunction(arg) || isArray3(arg) || isObjectLike2(arg) || isBoolean(arg) || isNull(arg);
+    };
+    var isUndefined = (arg) => {
+      return arg === void 0;
+    };
+    var TYPES = {
+      boolean: isBoolean,
+      array: isArray3,
+      object: isObject3,
+      string: isString4,
+      number: isNumber,
+      null: isNull,
+      function: isFunction,
+      objectLike: isObjectLike2,
+      node: isNode,
+      htmlElement: 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;
+      };
+    };
+  }
+});
+
+// ../../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: () => deepClone2,
+      deepCloneExclude: () => deepCloneExclude,
+      deepDestringify: () => deepDestringify,
+      deepMerge: () => deepMerge,
+      deepStringify: () => deepStringify,
+      detachFunctionsFromObject: () => detachFunctionsFromObject,
+      diff: () => diff,
+      exec: () => exec,
+      flattenRecursive: () => flattenRecursive,
+      isEqualDeep: () => isEqualDeep,
+      map: () => map,
+      merge: () => merge,
+      mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+      mergeArray: () => mergeArray,
+      mergeArrayExclude: () => mergeArrayExclude,
+      mergeIfExisted: () => mergeIfExisted,
+      overwrite: () => overwrite,
+      overwriteDeep: () => overwriteDeep,
+      overwriteObj: () => overwriteObj
+    });
+    module2.exports = __toCommonJS2(object_exports);
+    var import_globals2 = require_cjs();
+    var import_types = require_types();
+    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) => {
+      for (const e in obj) {
+        const elementProp = element[e];
+        const objProp = obj[e];
+        if (elementProp === void 0) {
+          element[e] = objProp;
+        }
+      }
+      return element;
+    };
+    var deepMerge = (element, extend) => {
+      for (const e in extend) {
+        const extendProp = extend[e];
+        if (e === "parent" || e === "props")
+          continue;
+        if (element[e] === void 0) {
+          element[e] = extendProp;
+        } else if ((0, import_types.isObjectLike)(element[e]) && (0, import_types.isObjectLike)(extendProp)) {
+          deepMerge(element[e], extendProp);
+        } else {
+          element[e] = extendProp;
+        }
+      }
+      return element;
+    };
+    var clone = (obj) => {
+      const o = {};
+      for (const prop in obj) {
+        if (prop === "node")
+          continue;
+        o[prop] = obj[prop];
+      }
+      return o;
+    };
+    var deepCloneExclude = (obj, exclude = []) => {
+      if ((0, import_types.isArray)(obj)) {
+        return obj.map((x) => deepCloneExclude(x, exclude));
+      }
+      const o = {};
+      for (const k in obj) {
+        if (exclude.indexOf(k) > -1)
+          continue;
+        let v = obj[k];
+        if (k === "extend" && (0, import_types.isArray)(v)) {
+          v = mergeArrayExclude(v, exclude);
+        }
+        if ((0, import_types.isArray)(v)) {
+          o[k] = v.map((x) => deepCloneExclude(x, exclude));
+        } else if ((0, import_types.isObject)(v)) {
+          o[k] = deepCloneExclude(v, exclude);
+        } else
+          o[k] = v;
+      }
+      return o;
+    };
+    var mergeArrayExclude = (arr, excl = []) => {
+      return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
+    };
+    var deepClone2 = (obj) => {
+      if ((0, import_types.isArray)(obj)) {
+        return obj.map(deepClone2);
+      }
+      const o = {};
+      for (const prop in obj) {
+        let objProp = obj[prop];
+        if (prop === "extend" && (0, import_types.isArray)(objProp)) {
+          objProp = mergeArray(objProp);
+        }
+        if ((0, import_types.isArray)(objProp)) {
+          o[prop] = objProp.map((v) => (0, import_types.isObject)(v) ? deepClone2(v) : v);
+        } else if ((0, import_types.isObject)(objProp)) {
+          o[prop] = deepClone2(objProp);
+        } 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 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[prop], detached[prop]);
+        } else if ((0, import_types.isArray)(objProp)) {
+          detached[prop] = [];
+          objProp.map((v, i) => deepStringify(v, detached[prop][i]));
+        } else
+          detached[prop] = objProp;
+      }
+      return detached;
+    };
+    var deepDestringify = (obj, stringified = {}) => {
+      for (const prop in obj) {
+        const objProp = obj[prop];
+        if ((0, import_types.isString)(objProp)) {
+          if (objProp.includes("=>") || objProp.includes("function") || objProp.startsWith("(")) {
+            try {
+              const evalProp = import_globals2.window.eval(`(${objProp})`);
+              stringified[prop] = evalProp;
+            } catch (e) {
+              if (e)
+                stringified[prop] = objProp;
+            }
+          } else {
+            stringified[prop] = objProp;
+          }
+        } else if ((0, import_types.isArray)(objProp)) {
+          stringified[prop] = [];
+          objProp.forEach((arrProp) => {
+            if ((0, import_types.isString)(arrProp)) {
+              if (arrProp.includes("=>") || arrProp.includes("function") || arrProp.startsWith("(")) {
+                try {
+                  const evalProp = import_globals2.window.eval(`(${arrProp})`);
+                  stringified[prop].push(evalProp);
+                } catch (e) {
+                  if (e)
+                    stringified[prop].push(arrProp);
+                }
+              } else {
+                stringified[prop].push(arrProp);
+              }
+            } else if ((0, import_types.isObject)(arrProp)) {
+              stringified[prop].push(deepDestringify(arrProp));
+            } else {
+              stringified[prop].push(arrProp);
+            }
+          });
+        } else if ((0, import_types.isObject)(objProp)) {
+          stringified[prop] = deepDestringify(objProp, stringified[prop]);
+        } else {
+          stringified[prop] = objProp;
+        }
+      }
+      return stringified;
+    };
+    var overwrite = (element, params, options) => {
+      const { ref } = element;
+      const changes = {};
+      for (const e in params) {
+        if (e === "props")
+          continue;
+        const elementProp = element[e];
+        const paramsProp = params[e];
+        if (paramsProp) {
+          ref.__cache[e] = changes[e] = elementProp;
+          ref[e] = paramsProp;
+        }
+      }
+      return changes;
+    };
+    var diff = (obj, original, cache) => {
+      const changes = cache || {};
+      for (const e in obj) {
+        if (e === "ref")
+          continue;
+        const originalProp = original[e];
+        const objProp = obj[e];
+        if ((0, import_types.isObjectLike)(originalProp) && (0, import_types.isObjectLike)(objProp)) {
+          changes[e] = {};
+          diff(originalProp, objProp, changes[e]);
+        } else if (objProp !== void 0) {
+          changes[e] = objProp;
+        }
+      }
+      return changes;
+    };
+    var overwriteObj = (params, obj) => {
+      const changes = {};
+      for (const e in params) {
+        const objProp = obj[e];
+        const paramsProp = params[e];
+        if (paramsProp) {
+          obj[e] = changes[e] = objProp;
+        }
+      }
+      return changes;
+    };
+    var overwriteDeep = (params, obj) => {
+      for (const e in params) {
+        const objProp = obj[e];
+        const paramsProp = params[e];
+        if ((0, import_types.isObjectLike)(objProp) && (0, import_types.isObjectLike)(paramsProp)) {
+          overwriteDeep(paramsProp, objProp);
+        } 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 mergeArray = (arr) => {
+      return arr.reduce((a, c) => deepMerge(a, deepClone2(c)), {});
+    };
+    var mergeAndCloneIfArray = (obj) => {
+      return (0, import_types.isArray)(obj) ? mergeArray(obj) : deepClone2(obj);
+    };
+    var flattenRecursive = (param, prop, stack = []) => {
+      const objectized = mergeAndCloneIfArray(param);
+      stack.push(objectized);
+      const extendOfExtend = objectized[prop];
+      if (extendOfExtend)
+        flattenRecursive(extendOfExtend, prop, stack);
+      delete objectized[prop];
+      return stack;
+    };
+    var isEqualDeep = (param, element) => {
+      if (param === element)
+        return true;
+      if (!param || !element)
+        return false;
+      for (const prop in param) {
+        const paramProp = param[prop];
+        const elementProp = element[prop];
+        if ((0, import_types.isObjectLike)(paramProp)) {
+          const isEqual = isEqualDeep(paramProp, elementProp);
+          if (!isEqual)
+            return false;
+        } else {
+          const isEqual = paramProp === elementProp;
+          if (!isEqual)
+            return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// ../../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,
+      memoize: () => memoize
+    });
+    module2.exports = __toCommonJS2(function_exports);
+    var debounce = (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;
+        }
+      };
+    };
+  }
+});
+
+// ../../node_modules/@domql/utils/dist/cjs/array.js
+var require_array = __commonJS({
+  "../../node_modules/@domql/utils/dist/cjs/array.js"() {
+    "use strict";
+  }
+});
+
+// ../../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, {
+      cleanWithNode: () => cleanWithNode,
+      createID: () => createID,
+      createSnapshotId: () => createSnapshotId
+    });
+    module2.exports = __toCommonJS2(node_exports);
+    var cleanWithNode = (extend) => delete extend.node && extend;
+    var createID = function() {
+      let index = 0;
+      function newId() {
+        index++;
+        return index;
+      }
+      return newId;
+    }();
+    var createSnapshotId = createID;
+  }
+});
+
+// ../../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/index.js
+var require_cjs3 = __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_exports2 = {};
+    module2.exports = __toCommonJS2(utils_exports2);
+    __reExport(utils_exports2, require_types(), module2.exports);
+    __reExport(utils_exports2, require_object(), module2.exports);
+    __reExport(utils_exports2, require_function(), module2.exports);
+    __reExport(utils_exports2, require_array(), module2.exports);
+    __reExport(utils_exports2, require_node(), module2.exports);
+    __reExport(utils_exports2, require_log(), module2.exports);
+  }
+});
+
+// src/utils/index.js
 var utils_exports = {};
+__export(utils_exports, {
+  applySequenceVars: () => applySequenceVars,
+  changeLightness: () => changeLightness,
+  colorStringToRgbaArray: () => colorStringToRgbaArray,
+  convertSvgToSymbol: () => convertSvgToSymbol,
+  findHeadingLetter: () => findHeadingLetter,
+  findHeadings: () => findHeadings,
+  generateSequence: () => generateSequence,
+  generateSprite: () => generateSprite,
+  generateSubSequence: () => generateSubSequence,
+  getColorShade: () => getColorShade,
+  getDefaultOrFirstKey: () => getDefaultOrFirstKey,
+  getFontFace: () => getFontFace,
+  getFontFaceEach: () => getFontFaceEach,
+  getFontFaceEachString: () => getFontFaceEachString,
+  getFontFaceString: () => getFontFaceString,
+  getFontFormat: () => getFontFormat,
+  getSequenceValue: () => getSequenceValue,
+  getSequenceValuePropertyPair: () => getSequenceValuePropertyPair,
+  hexToRgb: () => hexToRgb,
+  hexToRgbArray: () => hexToRgbArray,
+  hexToRgba: () => hexToRgba,
+  hslToRgb: () => hslToRgb,
+  mixTwoColors: () => mixTwoColors,
+  mixTwoRgb: () => mixTwoRgb,
+  mixTwoRgba: () => mixTwoRgba,
+  numToLetterMap: () => numToLetterMap,
+  opacify: () => opacify,
+  returnSubThemeOrDefault: () => returnSubThemeOrDefault,
+  rgbArrayToHex: () => rgbArrayToHex,
+  rgbToHSL: () => rgbToHSL,
+  rgbToHex: () => rgbToHex,
+  setCustomFont: () => setCustomFont,
+  setCustomFontMedia: () => setCustomFontMedia,
+  setInCustomFontMedia: () => setInCustomFontMedia,
+  setVariables: () => setVariables
+});
 module.exports = __toCommonJS(utils_exports);
-__reExport(utils_exports, require("./color.js"), module.exports);
-__reExport(utils_exports, require("./theme.js"), module.exports);
-__reExport(utils_exports, require("./font.js"), module.exports);
-__reExport(utils_exports, require("./sequence.js"), module.exports);
-__reExport(utils_exports, require("./var.js"), module.exports);
-__reExport(utils_exports, require("./sprite.js"), module.exports);
+
+// src/utils/color.js
+var import_globals = __toESM(require_cjs(), 1);
+var ENV = "development";
+var colorStringToRgbaArray = (color) => {
+  if (color === "")
+    return;
+  if (color.toLowerCase() === "transparent")
+    return [0, 0, 0, 0];
+  if (color[0] === "#") {
+    if (color.length < 7) {
+      color = "#" + color[1] + color[1] + color[2] + color[2] + color[3] + color[3] + (color.length > 4 ? color[4] + color[4] : "");
+    }
+    return [
+      parseInt(color.substr(1, 2), 16),
+      parseInt(color.substr(3, 2), 16),
+      parseInt(color.substr(5, 2), 16),
+      color.length > 7 ? parseInt(color.substr(7, 2), 16) / 255 : 1
+    ];
+  }
+  if (color.indexOf("rgb") === -1) {
+    if (import_globals.document && import_globals.window) {
+      const elem = import_globals.document.body.appendChild(import_globals.document.createElement("fictum"));
+      const flag = "rgb(1, 2, 3)";
+      elem.style.color = flag;
+      if (elem.style.color !== flag)
+        return;
+      elem.style.color = color;
+      if (elem.style.color === flag || elem.style.color === "")
+        return;
+      color = import_globals.window.getComputedStyle(elem).color;
+      import_globals.document.body.removeChild(elem);
+    } else
+      console.warn("Color conversion failed, no document or window object found");
+  }
+  if (color.indexOf("rgb") === 0) {
+    if (color.indexOf("rgba") === -1)
+      color = `${color}, 1`;
+    return color.match(/[\.\d]+/g).map((a) => +a);
+  }
+  return [];
+};
+var mixTwoColors = (colorA, colorB, range = 0.5) => {
+  colorA = colorStringToRgbaArray(colorA);
+  colorB = colorStringToRgbaArray(colorB);
+  return mixTwoRgba(colorA, colorB, range);
+};
+var hexToRgb = (hex, alpha = 1) => {
+  const [r, g, b] = hex.match(/\w\w/g).map((x) => parseInt(x, 16));
+  return `rgb(${r},${g},${b})`;
+};
+var hexToRgbArray = (hex, alpha = 1) => {
+  const [r, g, b] = hex.match(/\w\w/g).map((x) => parseInt(x, 16));
+  return [r, g, b];
+};
+var rgbToHex = (r, g, b) => {
+  return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+};
+var rgbArrayToHex = ([r, g, b]) => {
+  return ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+};
+var hexToRgba = (hex, alpha = 1) => {
+  const [r, g, b] = hex.match(/\w\w/g).map((x) => parseInt(x, 16));
+  return `rgba(${r},${g},${b},${alpha})`;
+};
+var mixTwoRgb = (colorA, colorB, range = 0.5) => {
+  const arr = [];
+  for (let i = 0; i < 3; i++) {
+    arr[i] = ~~(colorA[i] + (colorB[i] - colorA[i]) * range);
+  }
+  return `rgb(${arr})`;
+};
+var changeLightness = (delta, hsl) => {
+  const [hue, saturation, lightness] = hsl;
+  const newLightness = Math.max(
+    0,
+    Math.min(100, lightness + parseFloat(delta))
+  );
+  return [hue, saturation, newLightness];
+};
+var rgbToHSL = (r, g, b) => {
+  const a = Math.max(r, g, b);
+  const n = a - Math.min(r, g, b);
+  const f = 1 - Math.abs(a + a - n - 1);
+  const h = n && (a == r ? (g - b) / n : a == g ? 2 + (b - r) / n : 4 + (r - g) / n);
+  return [60 * (h < 0 ? h + 6 : h), f ? n / f : 0, (a + a - n) / 2];
+};
+var hslToRgb = (h, s, l, a = s * Math.min(l, 1 - l), f = (n, k = (n + h / 30) % 12) => l - a * Math.max(
+  Math.min(k - 3, 9 - k, 1),
+  -1
+)) => [f(0), f(8), f(4)];
+var getColorShade = (col, amt) => {
+  const num = parseInt(col, 16);
+  let r = (num >> 16) + amt;
+  if (r > 255)
+    r = 255;
+  else if (r < 0)
+    r = 0;
+  let b = (num >> 8 & 255) + amt;
+  if (b > 255)
+    b = 255;
+  else if (b < 0)
+    b = 0;
+  let g = (num & 255) + amt;
+  if (g > 255)
+    g = 255;
+  else if (g < 0)
+    g = 0;
+  return (g | b << 8 | r << 16).toString(16);
+};
+var mixTwoRgba = (colorA, colorB, range = 0.5) => {
+  const arr = [];
+  for (let i = 0; i < 4; i++) {
+    const round = i === 3 ? (x) => x : Math.round;
+    arr[i] = round(
+      colorA[i] + (colorB[i] - colorA[i]) * range
+    );
+  }
+  return `rgba(${arr})`;
+};
+var opacify = (color, opacity) => {
+  const arr = colorStringToRgbaArray(color);
+  if (!arr) {
+    if (ENV === "test" || ENV === "development")
+      console.warn(color + "color is not rgba");
+    return;
+  }
+  arr[3] = opacity;
+  return `rgba(${arr})`;
+};
+
+// src/utils/theme.js
+var returnSubThemeOrDefault = (orig, theme) => {
+  if (!orig)
+    return;
+  if (orig.themes && orig.themes[theme])
+    return orig.themes[theme];
+  if (orig[theme])
+    return [orig, orig[theme]];
+  return orig;
+};
+
+// src/utils/font.js
+var getDefaultOrFirstKey = (LIBRARY, key) => {
+  if (LIBRARY[key])
+    return LIBRARY[key].value;
+  if (LIBRARY.default)
+    return LIBRARY[LIBRARY.default].value;
+  const hasValue = Object.keys(LIBRARY)[0];
+  return hasValue && LIBRARY[hasValue] && LIBRARY[hasValue].value;
+};
+var getFontFormat = (url) => url.split(/[#?]/)[0].split(".").pop().trim();
+var setInCustomFontMedia = (str) => `@font-face { ${str} }`;
+var setCustomFont = (name, url, weight) => `
+  font-family: '${name}';
+  font-style: normal;
+  ${weight && `font-weight: ${weight};`}
+  src: url('${url}') format('${getFontFormat(url)}');`;
+var setCustomFontMedia = (name, url, weight) => `@font-face {
+  ${setCustomFont(name, url, weight)}
+}`;
+var getFontFaceEach = (name, weights) => {
+  const keys = Object.keys(weights);
+  return keys.map((key) => {
+    const { url, fontWeight } = weights[key];
+    return setCustomFont(name, url, fontWeight);
+  });
+};
+var getFontFace = (LIBRARY) => {
+  const keys = Object.keys(LIBRARY);
+  return keys.map((key) => getFontFaceEach(key, LIBRARY[key].value));
+};
+var getFontFaceEachString = (name, weights) => {
+  const isArr = weights[0];
+  if (isArr)
+    return getFontFaceEach(name, weights).map(setInCustomFontMedia);
+  return setCustomFontMedia(name, weights.url);
+};
+var getFontFaceString = (LIBRARY) => {
+  const keys = Object.keys(LIBRARY);
+  return keys.map((key) => getFontFaceEachString(key, LIBRARY[key].value));
+};
+
+// src/utils/sequence.js
+var import_utils4 = __toESM(require_cjs3(), 1);
+
+// ../utils/src/index.js
+var import_utils2 = __toESM(require_cjs3());
+
+// ../utils/src/scaling.js
+var import_utils = __toESM(require_cjs3());
+
+// ../utils/src/index.js
+var toDashCase = (val) => val.replace(/[A-Z]/g, (match, offset) => (offset > 0 ? "-" : "") + match.toLowerCase()).replace(".", "-");
+
+// src/factory.js
+var import_utils3 = __toESM(require_cjs3(), 1);
+
+// src/defaultConfig/index.js
+var defaultConfig_exports = {};
+__export(defaultConfig_exports, {
+  ANIMATION: () => ANIMATION,
+  BREAKPOINTS: () => BREAKPOINTS,
+  CASES: () => CASES,
+  COLOR: () => COLOR,
+  DEVICES: () => DEVICES,
+  DOCUMENT: () => DOCUMENT,
+  FONT: () => FONT,
+  FONT_FACE: () => FONT_FACE,
+  FONT_FAMILY: () => FONT_FAMILY,
+  FONT_FAMILY_TYPES: () => FONT_FAMILY_TYPES,
+  GRADIENT: () => GRADIENT,
+  ICONS: () => ICONS,
+  MEDIA: () => MEDIA,
+  RESET: () => RESET,
+  SEQUENCE: () => SEQUENCE,
+  SPACING: () => SPACING,
+  SVG: () => SVG,
+  SVG_DATA: () => SVG_DATA,
+  THEME: () => THEME,
+  TIMING: () => TIMING,
+  TYPOGRAPHY: () => TYPOGRAPHY,
+  UNIT: () => UNIT
+});
+
+// src/defaultConfig/sequence.js
+var SEQUENCE = {
+  "minor-second": 1.067,
+  "major-second": 1.125,
+  "minor-third": 1.2,
+  "major-third": 1.25,
+  "perfect-fourth": 1.333,
+  "augmented-fourth": 1.414,
+  "perfect-fifth": 1.5,
+  "minor-sixth": 1.6,
+  phi: 1.618,
+  // golden-ratio
+  "major-sixth": 1.667,
+  "square-root-3": 1.732,
+  // theodorus
+  "minor-seventh": 1.778,
+  "major-seventh": 1.875,
+  octave: 2,
+  "square-root-5": 2.23,
+  // pythagoras
+  "major-tenth": 2.5,
+  "major-eleventh": 2.667,
+  "major-twelfth": 3,
+  pi: 3.14,
+  // archimedes
+  "double-octave": 4
+};
+
+// src/defaultConfig/unit.js
+var UNIT = {
+  default: "em"
+};
+
+// src/defaultConfig/typography.js
+var defaultProps = {
+  browserDefault: 16,
+  base: 16,
+  type: "font-size",
+  ratio: SEQUENCE["minor-third"],
+  range: [-3, 12],
+  h1Matches: 6,
+  lineHeight: 1.5,
+  unit: "em",
+  templates: {},
+  sequence: {},
+  scales: {},
+  vars: {}
+};
+var TYPOGRAPHY = defaultProps;
+
+// src/defaultConfig/font.js
+var FONT = {};
+
+// src/defaultConfig/font-family.js
+var FONT_FAMILY = {};
+var FONT_FAMILY_TYPES = {
+  "sans-serif": "Helvetica, Arial, sans-serif, --system-default",
+  serif: "Times New Roman, Georgia, serif, --system-default",
+  monospace: "Courier New, monospace, --system-default"
+};
+var FONT_FACE = {};
+
+// src/defaultConfig/media.js
+var MEDIA = {
+  tv: "(min-width: 2780px)",
+  screenL: "(max-width: 1920px)",
+  screenM: "(max-width: 1680px)",
+  screenS: "(max-width: 1440px)",
+  tabletL: "(max-width: 1366px)",
+  tabletM: "(max-width: 1280px)",
+  tabletS: "(max-width: 1024px)",
+  mobileL: "(max-width: 768px)",
+  mobileM: "(max-width: 560px)",
+  mobileS: "(max-width: 480px)",
+  mobileXS: "(max-width: 375px)",
+  light: "(prefers-color-scheme: light)",
+  dark: "(prefers-color-scheme: dark)",
+  print: "print"
+};
+
+// src/defaultConfig/spacing.js
+var defaultProps2 = {
+  base: TYPOGRAPHY.base,
+  type: "spacing",
+  ratio: SEQUENCE.phi,
+  range: [-5, 15],
+  subSequence: true,
+  unit: "em",
+  sequence: {},
+  scales: {},
+  vars: {}
+};
+var SPACING = defaultProps2;
+
+// src/defaultConfig/color.js
+var COLOR = {};
+var GRADIENT = {};
+
+// src/defaultConfig/theme.js
+var THEME = {};
+
+// src/defaultConfig/icons.js
+var ICONS = {};
+
+// src/defaultConfig/timing.js
+var defaultProps3 = {
+  default: 150,
+  base: 150,
+  type: "timing",
+  ratio: SEQUENCE["perfect-fourth"],
+  range: [-3, 12],
+  unit: "ms",
+  sequence: {},
+  scales: {},
+  vars: {}
+};
+var TIMING = defaultProps3;
+
+// src/defaultConfig/document.js
+var DOCUMENT = {};
+
+// src/defaultConfig/responsive.js
+var BREAKPOINTS = {
+  screenL: 1920,
+  screenM: 1680,
+  screenS: 1440,
+  tabletL: 1366,
+  tabletM: 1280,
+  tabletS: 1024,
+  mobileL: 768,
+  mobileM: 560,
+  mobileS: 480,
+  mobileXS: 375
+};
+var DEVICES = {
+  screenL: [1920, 1024],
+  screenM: [1680, 1024],
+  screenS: [1440, 978],
+  tabletL: [1366, 926],
+  tabletM: [1280, 768],
+  tabletS: [1024, 768],
+  mobileL: [768, 375],
+  mobileM: [560, 768],
+  mobileS: [480, 768],
+  mobileXS: [375, 768]
+};
+
+// src/defaultConfig/cases.js
+var CASES = {};
+
+// src/defaultConfig/animation.js
+var ANIMATION = {};
+
+// src/defaultConfig/svg.js
+var SVG = {};
+var SVG_DATA = {};
+
+// src/defaultConfig/index.js
+var RESET = {};
+
+// src/factory.js
+var CSS_VARS = {};
+var CONFIG = {
+  verbose: false,
+  useVariable: true,
+  useReset: true,
+  CSS_VARS,
+  ...defaultConfig_exports
+};
+var cachedConfig = (0, import_utils3.deepClone)(CONFIG);
+var FACTORY = {
+  active: "0",
+  0: CONFIG
+};
+var getActiveConfig = (def) => {
+  if ((0, import_utils3.isDefined)(def) && !FACTORY[def]) {
+    FACTORY[def] = (0, import_utils3.deepClone)(cachedConfig);
+    return FACTORY[def];
+  }
+  return FACTORY[def || FACTORY.active];
+};
+
+// src/utils/sequence.js
+var numToLetterMap = {
+  "-6": "U",
+  "-5": "V",
+  "-4": "W",
+  "-3": "X",
+  "-2": "Y",
+  "-1": "Z",
+  0: "A",
+  1: "B",
+  2: "C",
+  3: "D",
+  4: "E",
+  5: "F",
+  6: "G",
+  7: "H",
+  8: "I",
+  9: "J",
+  10: "K",
+  11: "L",
+  12: "M",
+  13: "N",
+  14: "O",
+  15: "P",
+  16: "Q",
+  17: "R",
+  18: "S",
+  19: "T"
+};
+var setSequenceValue = (props, sequenceProps) => {
+  const { key, variable, value, scaling, index } = props;
+  sequenceProps.sequence[key] = {
+    key,
+    decimal: ~~(value * 100) / 100,
+    val: ~~value,
+    scaling,
+    index,
+    variable
+  };
+  sequenceProps.scales[key] = scaling;
+  sequenceProps.vars[variable] = scaling + sequenceProps.unit;
+};
+var generateSubSequence = (props, sequenceProps) => {
+  const { key, base, value, ratio, variable, index } = props;
+  const next = value * ratio;
+  const diff = next - value;
+  const smallscale = diff / 1.618;
+  const valueRounded = ~~value;
+  const nextRounded = ~~next;
+  const diffRounded = nextRounded - valueRounded;
+  let arr = [];
+  const first = next - smallscale;
+  const second = value + smallscale;
+  const middle = (first + second) / 2;
+  if (diffRounded > 16)
+    arr = [first, middle, second];
+  else
+    arr = [first, second];
+  arr.map((v, k) => {
+    const scaling = ~~(v / base * 1e3) / 1e3;
+    const newVar = variable + (k + 1);
+    const props2 = {
+      key: key + (k + 1),
+      variable: newVar,
+      value: v,
+      scaling,
+      index: index + (k + 1) / 10
+    };
+    return setSequenceValue(props2, sequenceProps);
+  });
+};
+var switchSequenceOnNegative = (key, base, ratio) => {
+  return base * Math.pow(ratio, key);
+};
+var generateSequence = (sequenceProps) => {
+  const { type, base, ratio, range, subSequence } = sequenceProps;
+  const n = Math.abs(range[0]) + Math.abs(range[1]);
+  const prefix = "--" + (type && type.replace(".", "-")) + "-";
+  for (let i = 0; i <= n; i++) {
+    const key = range[1] - i;
+    const letterKey = numToLetterMap[key];
+    const value = switchSequenceOnNegative(key, base, ratio);
+    const scaling = ~~(value / base * 100) / 100;
+    const variable = prefix + letterKey;
+    const props = {
+      key: letterKey,
+      variable,
+      value,
+      base,
+      scaling,
+      ratio,
+      index: key
+    };
+    setSequenceValue(props, sequenceProps);
+    if (subSequence)
+      generateSubSequence(props, sequenceProps);
+  }
+  return sequenceProps;
+};
+var getSequenceValue = (value = "A", sequenceProps) => {
+  const CONFIG2 = getActiveConfig();
+  const { UNIT: UNIT2 } = CONFIG2;
+  const {
+    sequence,
+    unit = UNIT2.default,
+    useVariable
+  } = sequenceProps;
+  if ((0, import_utils4.isString)(value) && value.slice(0, 2) === "--")
+    return `var(${value})`;
+  const prefix = `--${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") || !startsWithDashOrLetter)
+    return value;
+  const letterVal = value.toUpperCase();
+  const isNegative = letterVal.slice(0, 1) === "-" ? "-" : "";
+  let absValue = isNegative ? letterVal.slice(1) : letterVal;
+  let mediaName = "";
+  if (absValue.includes("-")) {
+    mediaName = "-" + absValue.split("-")[1].toLowerCase();
+    absValue = absValue.split("-")[0];
+  }
+  const varValue = (v) => `var(${prefix}${v}${mediaName})`;
+  if (absValue.includes("+")) {
+    const args = absValue.split("+");
+    const [first, second] = args;
+    const joint = `${varValue(first)} + ${varValue(second)}`;
+    return isNegative ? `calc((${joint}) * -1)` : `calc(${joint})`;
+  } else if (absValue.includes("-")) {
+    const args = absValue.split("-");
+    const [first, second] = args;
+    const joint = `${varValue(first)} - ${varValue(second)}`;
+    return isNegative ? `calc((${joint}) * -1)` : `calc(${joint})`;
+  }
+  if (!sequence[absValue] && absValue.length === 2) {
+    if (CONFIG2.verbose)
+      console.warn(absValue, "- value is not found because `subSequence` is set to false");
+    absValue = absValue.slice(0, 1);
+  }
+  if (useVariable || CONFIG2.useVariable) {
+    const varValue2 = `var(${prefix}${absValue}${mediaName})`;
+    return isNegative ? `calc(${varValue2} * -1)` : varValue2;
+  }
+  const sequenceItem = sequence ? sequence[absValue] : null;
+  if (!sequenceItem)
+    return console.warn("can't find", sequence, absValue);
+  if (unit === "ms" || unit === "s") {
+    return isNegative + sequenceItem.val + unit;
+  }
+  return isNegative + sequenceItem.scaling + unit;
+};
+var getSequenceValuePropertyPair = (value, propertyName, sequenceProps) => {
+  if (typeof value !== "string") {
+    console.warn(propertyName, value, "is not a string");
+    return {};
+  }
+  if (value === "-" || value === "")
+    return {};
+  return { [propertyName]: getSequenceValue(value, sequenceProps) };
+};
+var findHeadingLetter = (h1Matches, index) => numToLetterMap[h1Matches - index];
+var findHeadings = (propertyNames) => {
+  const { h1Matches, sequence } = propertyNames;
+  return new Array(6).fill(null).map((_, i) => {
+    const findLetter = findHeadingLetter(h1Matches, i);
+    return sequence[findLetter];
+  });
+};
+
+// src/utils/var.js
+var import_utils6 = __toESM(require_cjs3(), 1);
+var setVariables = (result, key) => {
+  const CONFIG2 = getActiveConfig();
+  const { CSS_VARS: CSS_VARS2 } = CONFIG2;
+  if ((0, import_utils6.isObjectLike)(result.value)) {
+  } else {
+    CSS_VARS2[result.var] = result.value;
+  }
+};
+var applySequenceVars = (props, mediaName, options = {}) => {
+  const CONFIG2 = getActiveConfig();
+  const { UNIT: UNIT2, MEDIA: MEDIA2, TIMING: TIMING2, CSS_VARS: CSS_VARS2 } = CONFIG2;
+  const unit = props.unit || UNIT2.default;
+  const { sequence, scales } = props;
+  for (const key in sequence) {
+    const item = sequence[key];
+    const value = (props.type === TIMING2.type ? sequence[key].val : scales[key]) + unit;
+    if (mediaName) {
+      const query = MEDIA2[mediaName];
+      if (!query) {
+        if (CONFIG2.verbose)
+          console.warn("Can't find query ", query);
+      }
+      let underMediaQuery = CSS_VARS2[`@media ${query}`];
+      if (!underMediaQuery)
+        underMediaQuery = CSS_VARS2[`@media ${query}`] = {};
+      underMediaQuery[item.variable] = `var(${item.variable + "-" + mediaName})`;
+      CSS_VARS2[item.variable + "-" + mediaName] = value;
+    } else {
+      if (options.useDefault === false) {
+        CSS_VARS2[item.variable] = value;
+      } else {
+        CSS_VARS2[item.variable + "-default"] = value;
+        CSS_VARS2[item.variable] = `var(${item.variable + "-default"})`;
+      }
+    }
+  }
+};
+
+// src/utils/sprite.js
+var import_utils7 = __toESM(require_cjs3(), 1);
+var generateSprite = (icons) => {
+  let sprite = '<svg aria-hidden="true" width="0" height="0" style="position:absolute">';
+  for (let key in icons) {
+    sprite += icons[key];
+  }
+  sprite += "</svg>";
+  return sprite;
+};
+var parseRootAttributes = (htmlString) => {
+  if (!(0, import_utils7.isString)(htmlString)) {
+    return console.warn(`parseRootAttributes: ${htmlString} is not a string`);
+  }
+  let match = htmlString.match(/<svg\s+(.*?)>/);
+  if (!match || !match[1]) {
+    return {};
+  }
+  let attrString = match[1];
+  let attrs = attrString.match(/(\S+)=["']?((?:.(?!["']?\s+(?:\S+)=|\s*\/?[>"']))+.)["']?/gm);
+  return attrs.reduce((acc, attr) => {
+    let [key, value] = attr.split("=");
+    acc[key] = value.replace(/['"]/g, "");
+    return acc;
+  }, {});
+};
+var convertSvgToSymbol = (key, code) => {
+  const extractAttrs = parseRootAttributes(code);
+  const { width, height } = extractAttrs;
+  const viewBox = extractAttrs.viewBox || `0 0 ${width || 24} ${height || 24}`;
+  const xmlns = "http://www.w3.org/2000/svg";
+  let symbol = code.replace(
+    "<svg",
+    `<symbol id="${key}" xmlns="${xmlns}" viewBox="${viewBox}"`
+  );
+  symbol = symbol.replace(/width="[^\"]*/, "");
+  symbol = symbol.replace(/height="[^\"]*/, "");
+  symbol = symbol.replace("</svg", "</symbol");
+  return symbol;
+};