@5even7/dlc-ui 0.2.20 → 0.2.21

package/dist/icon.cjs

@@ -0,0 +1,1773 @@
+'use strict';
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: true
+          } : {
+            done: false,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = true,
+    u = false;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = true, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+var styleCache = new Map();
+function hashString(value) {
+  var hash = 2166136261;
+  for (var index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function removeKeyframes(css) {
+  var output = '';
+  var cursor = 0;
+  var pattern = /@(?:-webkit-)?keyframes\s+[\w-]+\s*\{/gi;
+  var match;
+  while (match = pattern.exec(css)) {
+    output += css.slice(cursor, match.index);
+    var depth = 1;
+    var index = pattern.lastIndex;
+    while (index < css.length && depth) {
+      if (css[index] === '{') depth += 1;else if (css[index] === '}') depth -= 1;
+      index += 1;
+    }
+    cursor = index;
+    pattern.lastIndex = index;
+  }
+  return output + css.slice(cursor);
+}
+function stripComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, ' ');
+}
+function splitSelectorList(selector) {
+  var result = [];
+  var depth = 0;
+  var start = 0;
+  for (var index = 0; index < selector.length; index += 1) {
+    if (selector[index] === '(' || selector[index] === '[') depth += 1;else if (selector[index] === ')' || selector[index] === ']') depth -= 1;else if (selector[index] === ',' && depth === 0) {
+      result.push(selector.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  result.push(selector.slice(start).trim());
+  return result.filter(Boolean);
+}
+function parseScopeFunction(selector) {
+  var start = /^:(?:where|is)\(/.exec(selector);
+  if (!start) return null;
+  var depth = 1;
+  for (var index = start[0].length; index < selector.length; index += 1) {
+    if (selector[index] === '(') depth += 1;else if (selector[index] === ')') {
+      depth -= 1;
+      if (depth === 0) return {
+        alternatives: selector.slice(start[0].length, index),
+        tail: selector.slice(index + 1)
+      };
+    }
+  }
+  return null;
+}
+function cloneAndFreeze(value) {
+  var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new WeakMap();
+  if (!value || _typeof(value) !== 'object') return value;
+  if (seen.has(value)) return seen.get(value);
+  var clone = Array.isArray(value) ? [] : {};
+  seen.set(value, clone);
+  for (var _i = 0, _Object$entries = Object.entries(value); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      item = _Object$entries$_i[1];
+    clone[key] = cloneAndFreeze(item, seen);
+  }
+  return Object.freeze(clone);
+}
+function normalizeIconMotion(input) {
+  var motion = input && input.default ? input.default : input;
+  if (!motion || motion.kind !== 'css' || typeof motion.id !== 'string' || !motion.id.trim() || typeof motion.css !== 'string') {
+    throw new Error('dlc-icon: invalid CSS MotionDefinition');
+  }
+  var css = motion.css;
+  if (/@import\b/i.test(css) || /url\(\s*['"]?(?!#)/i.test(css)) throw new Error("dlc-icon: motion \"".concat(motion.id, "\" contains an external resource"));
+  if (/(?:^|[;{])\s*(?:width|height|min-width|max-width|min-height|max-height|inline-size|block-size|view-box|color|fill|stroke)\s*:/i.test(css)) {
+    throw new Error("dlc-icon: motion \"".concat(motion.id, "\" cannot override size or paint"));
+  }
+  var activation = String(motion.activation || motion.id).trim();
+  if (!/^[A-Za-z0-9_-]+$/.test(activation)) throw new Error("dlc-icon: invalid activation for motion \"".concat(motion.id, "\""));
+  var rules = stripComments(removeKeyframes(css));
+  var unsupportedAtRule = _toConsumableArray(rules.matchAll(/@([\w-]+)/g)).map(function (match) {
+    return match[1].toLowerCase();
+  }).find(function (name) {
+    return !['media', 'supports', 'container'].includes(name);
+  });
+  if (unsupportedAtRule) throw new Error("dlc-icon: motion \"".concat(motion.id, "\" contains unsupported @").concat(unsupportedAtRule));
+  var selectors = _toConsumableArray(rules.matchAll(/([^{}]+)\{/g)).map(function (match) {
+    return match[1].trim();
+  }).filter(function (selector) {
+    return selector && !selector.startsWith('@');
+  });
+  var expected = ["[data-p2m-motion~=\"".concat(activation, "\"]"), "[data-p2m-motion~='".concat(activation, "']"), '[data-dlc-icon-motion~="MOTION"]', "[data-dlc-icon-motion~=\"".concat(activation, "\"]")];
+  var isGatedSelector = function isGatedSelector(selector) {
+    return expected.some(function (gate) {
+      if (!selector.startsWith(gate)) return false;
+      var rest = selector.slice(gate.length);
+      if (!rest) return true;
+      var trimmed = rest.trimStart();
+      return trimmed.startsWith('>') || trimmed.length < rest.length && !/^[+~]/.test(trimmed);
+    });
+  };
+  var isGatedTarget = function isGatedTarget(selector) {
+    return expected.some(function (gate) {
+      return selector === "svg".concat(gate);
+    });
+  };
+  var isScopedSelector = function isScopedSelector(selector) {
+    if (isGatedSelector(selector) || isGatedTarget(selector)) return true;
+    var scope = parseScopeFunction(selector);
+    if (!scope) return false;
+    var alternatives = splitSelectorList(scope.alternatives);
+    if (!alternatives.length || alternatives.some(function (item) {
+      return !isGatedSelector(item) && !isGatedTarget(item);
+    })) return false;
+    var tail = scope.tail;
+    if (!tail) return true;
+    var trimmed = tail.trimStart();
+    return trimmed.startsWith('>') || trimmed.length < tail.length && !/^[+~]/.test(trimmed);
+  };
+  if (selectors.flatMap(splitSelectorList).some(function (selector) {
+    return !isScopedSelector(selector);
+  })) {
+    throw new Error("dlc-icon: motion \"".concat(motion.id, "\" contains an unscoped selector"));
+  }
+  if (motion.duration == null) throw new Error("dlc-icon: duration is required for motion \"".concat(motion.id, "\""));
+  var duration = Number(motion.duration);
+  if (!Number.isFinite(duration) || duration <= 0) throw new Error("dlc-icon: invalid duration for motion \"".concat(motion.id, "\""));
+  var iterations = motion.iterations == null ? 1 : motion.iterations;
+  if (iterations !== 'infinite' && (!Number.isInteger(Number(iterations)) || Number(iterations) <= 0)) {
+    throw new Error("dlc-icon: invalid iterations for motion \"".concat(motion.id, "\""));
+  }
+  var suggestedEvents = motion.suggestedEvents == null ? undefined : motion.suggestedEvents;
+  if (suggestedEvents !== undefined && (!Array.isArray(suggestedEvents) || suggestedEvents.some(function (event) {
+    return typeof event !== 'string';
+  }))) {
+    throw new Error("dlc-icon: invalid suggestedEvents for motion \"".concat(motion.id, "\""));
+  }
+  if (motion.meta != null && (!motion.meta || _typeof(motion.meta) !== 'object' || Array.isArray(motion.meta))) {
+    throw new Error("dlc-icon: invalid meta for motion \"".concat(motion.id, "\""));
+  }
+  var meta = motion.meta && _typeof(motion.meta) === 'object' ? cloneAndFreeze(motion.meta) : motion.meta;
+  return Object.freeze(_objectSpread2(_objectSpread2(_objectSpread2({}, motion), {}, {
+    id: motion.id.trim(),
+    activation: activation,
+    duration: duration,
+    iterations: iterations
+  }, suggestedEvents === undefined ? {} : {
+    suggestedEvents: Object.freeze(_toConsumableArray(suggestedEvents))
+  }), meta === undefined ? {} : {
+    meta: meta
+  }));
+}
+function defineIconMotion(input) {
+  return normalizeIconMotion(input);
+}
+function scaleTimes(css, speed) {
+  if (speed === 1) return css;
+  return css.replace(/(^|[^\w.-])(\d*\.?\d+)(ms|s)\b/g, function (full, prefix, number, unit) {
+    var scaled = Number(number) / speed;
+    return "".concat(prefix).concat(Number(scaled.toFixed(5))).concat(unit);
+  });
+}
+function findBlockEnd(css, open) {
+  var depth = 1;
+  var quote = '';
+  var comment = false;
+  for (var index = open + 1; index < css.length; index += 1) {
+    var char = css[index];
+    var next = css[index + 1];
+    if (comment) {
+      if (char === '*' && next === '/') {
+        comment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (char === '\\') index += 1;else if (char === quote) quote = '';
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      comment = true;
+      index += 1;
+    } else if (char === '"' || char === "'") quote = char;else if (char === '{') depth += 1;else if (char === '}' && --depth === 0) return index;
+  }
+  return css.length - 1;
+}
+function findBlockStart(css, start) {
+  var quote = '';
+  var comment = false;
+  for (var index = start; index < css.length; index += 1) {
+    var char = css[index];
+    var next = css[index + 1];
+    if (comment) {
+      if (char === '*' && next === '/') {
+        comment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (char === '\\') index += 1;else if (char === quote) quote = '';
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      comment = true;
+      index += 1;
+    } else if (char === '"' || char === "'") quote = char;else if (char === '{') return index;
+  }
+  return -1;
+}
+function rewriteSelectors(css, transform) {
+  var output = '';
+  var cursor = 0;
+  while (cursor < css.length) {
+    var open = findBlockStart(css, cursor);
+    if (open === -1) return output + css.slice(cursor);
+    var close = findBlockEnd(css, open);
+    var prelude = css.slice(cursor, open);
+    var trimmed = prelude.trim();
+    var content = css.slice(open + 1, close);
+    var keyframes = /^@(?:-webkit-)?keyframes\b/i.test(trimmed);
+    var conditional = /^@(?:media|supports|container)\b/i.test(trimmed);
+    output += keyframes || trimmed.startsWith('@') ? prelude : transform(prelude);
+    output += "{".concat(conditional ? rewriteSelectors(content, transform) : content, "}");
+    cursor = close + 1;
+  }
+  return output;
+}
+function renameKeyframes(css, names, token) {
+  var mappings = names.map(function (name) {
+    return [name, "".concat(token, "-").concat(name)];
+  });
+  var output = css.replace(/(@(?:-webkit-)?keyframes\s+)([\w-]+)/gi, function (full, prefix, name) {
+    var mapping = mappings.find(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 1),
+        from = _ref2[0];
+      return from === name;
+    });
+    return mapping ? "".concat(prefix).concat(mapping[1]) : full;
+  });
+  output = output.replace(/((?:^|[;{])\s*(?:-webkit-)?animation(?:-name)?\s*:\s*)([^;}]+)/gi, function (full, prefix, value) {
+    var renamed = value;
+    var _iterator = _createForOfIteratorHelper(mappings),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+          from = _step$value[0],
+          to = _step$value[1];
+        renamed = renamed.replace(new RegExp("\\b".concat(from.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), "\\b"), 'g'), to);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return "".concat(prefix).concat(renamed);
+  });
+  return output;
+}
+function rewriteIdSelectors(selector) {
+  var output = '';
+  var quote = '';
+  var bracketDepth = 0;
+  for (var index = 0; index < selector.length; index += 1) {
+    var char = selector[index];
+    if (quote) {
+      output += char;
+      if (char === '\\') output += selector[++index] || '';else if (char === quote) quote = '';
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      output += char;
+      continue;
+    }
+    if (char === '[') {
+      bracketDepth += 1;
+      output += char;
+      continue;
+    }
+    if (char === ']') {
+      bracketDepth = Math.max(0, bracketDepth - 1);
+      output += char;
+      continue;
+    }
+    if (char === '#' && bracketDepth === 0) {
+      var match = /^[A-Za-z_][\w:.-]*/.exec(selector.slice(index + 1));
+      if (match) {
+        output += "[data-dlc-original-id=\"".concat(match[0], "\"]");
+        index += match[0].length;
+        continue;
+      }
+    }
+    output += char;
+  }
+  return output;
+}
+function compileMotion(motion, speed) {
+  var normalized = normalizeIconMotion(motion);
+  var signature = hashString("".concat(normalized.id, "\n").concat(normalized.css, "\n").concat(speed));
+  var token = "dlc-".concat(signature);
+  var css = normalized.css;
+  var keyframes = _toConsumableArray(css.matchAll(/@(?:-webkit-)?keyframes\s+([\w-]+)/gi)).map(function (match) {
+    return match[1];
+  });
+  css = renameKeyframes(css, keyframes, token);
+  var gates = [/\[data-dlc-icon-motion~=["']MOTION["']\]/g, new RegExp("\\[data-dlc-icon-motion~=[\"']".concat(normalized.activation.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), "[\"']\\]"), 'g'), new RegExp("\\[data-p2m-motion~=[\"']".concat(normalized.activation.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), "[\"']\\]"), 'g')];
+  for (var _i2 = 0, _gates = gates; _i2 < _gates.length; _i2++) {
+    var gate = _gates[_i2];
+    css = css.replace(gate, "[data-dlc-icon-motion~=\"".concat(token, "\"]"));
+  }
+  css = rewriteSelectors(css, rewriteIdSelectors);
+  css = scaleTimes(css, speed);
+  return {
+    css: css,
+    token: token,
+    duration: normalized.duration / speed,
+    motion: normalized
+  };
+}
+function acquireMotionStyle(motion) {
+  var speed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  var compiled = compileMotion(motion, speed);
+  var key = compiled.css;
+  var entry = styleCache.get(key);
+  if (!entry) {
+    var style = document.createElement('style');
+    style.setAttribute('data-dlc-icon-motion-style', compiled.token);
+    style.textContent = compiled.css;
+    document.head.appendChild(style);
+    entry = {
+      count: 0,
+      style: style
+    };
+    styleCache.set(key, entry);
+  }
+  entry.count += 1;
+  return _objectSpread2(_objectSpread2({}, compiled), {}, {
+    release: function release() {
+      entry.count -= 1;
+      if (entry.count <= 0) {
+        if (entry.style.parentNode) entry.style.parentNode.removeChild(entry.style);
+        styleCache.delete(key);
+      }
+    }
+  });
+}
+
+var EVENTS$1 = ['create', 'hover', 'click', 'focus'];
+var VIEW_BOX = /^\s*-?(?:\d*\.)?\d+(?:[\s,]+-?(?:\d*\.)?\d+){3}\s*$/;
+var COLOR_MODES = new Set(['currentColor', 'original', 'multi']);
+function freezeObject(value) {
+  var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new WeakSet();
+  if (!value || _typeof(value) !== 'object' || seen.has(value)) return value;
+  seen.add(value);
+  for (var _i = 0, _Object$values = Object.values(value); _i < _Object$values.length; _i++) {
+    var item = _Object$values[_i];
+    freezeObject(item, seen);
+  }
+  return Object.freeze(value);
+}
+function cloneValue(value) {
+  var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new WeakMap();
+  if (!value || _typeof(value) !== 'object') return value;
+  if (seen.has(value)) return seen.get(value);
+  var clone = Array.isArray(value) ? [] : {};
+  seen.set(value, clone);
+  for (var _i2 = 0, _Object$entries = Object.entries(value); _i2 < _Object$entries.length; _i2++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i2], 2),
+      key = _Object$entries$_i[0],
+      item = _Object$entries$_i[1];
+    clone[key] = cloneValue(item, seen);
+  }
+  return clone;
+}
+function normalizeIconDefinition(icon) {
+  var expected = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (!icon || _typeof(icon) !== 'object') throw new Error('dlc-icon: invalid IconDefinition');
+  var type = typeof icon.type === 'string' ? icon.type.trim().toLowerCase() : '';
+  var name = typeof icon.name === 'string' ? icon.name.trim() : '';
+  if (!type || !name || typeof icon.body !== 'string' || typeof icon.viewBox !== 'string' || !VIEW_BOX.test(icon.viewBox)) {
+    throw new Error('dlc-icon: invalid IconDefinition');
+  }
+  if (expected.type && type !== expected.type) throw new Error("dlc-icon: provider returned type \"".concat(type, "\" for ").concat(expected.type, ":").concat(expected.name));
+  if (expected.name && name !== expected.name) throw new Error("dlc-icon: provider returned name \"".concat(name, "\" for ").concat(expected.type, ":").concat(expected.name));
+  var sourceMotions = icon.motions == null ? {} : icon.motions;
+  if (!sourceMotions || _typeof(sourceMotions) !== 'object' || Array.isArray(sourceMotions)) throw new Error("dlc-icon: invalid motions for ".concat(type, ":").concat(name));
+  var motions = {};
+  for (var _i3 = 0, _Object$entries2 = Object.entries(sourceMotions); _i3 < _Object$entries2.length; _i3++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i3], 2),
+      id = _Object$entries2$_i[0],
+      entry = _Object$entries2$_i[1];
+    if (typeof entry !== 'function') normalizeIconMotion(entry);
+    motions[id] = entry;
+  }
+  var sourceDefaults = icon.defaults == null ? {} : icon.defaults;
+  if (!sourceDefaults || _typeof(sourceDefaults) !== 'object' || Array.isArray(sourceDefaults)) throw new Error("dlc-icon: invalid defaults for ".concat(type, ":").concat(name));
+  var defaults = {};
+  var _iterator = _createForOfIteratorHelper(EVENTS$1),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var event = _step.value;
+      var _id = sourceDefaults[event] == null ? null : sourceDefaults[event];
+      if (_id !== null && (typeof _id !== 'string' || !Object.prototype.hasOwnProperty.call(motions, _id))) {
+        throw new Error("dlc-icon: default ".concat(event, " references unknown motion \"").concat(_id, "\" for ").concat(type, ":").concat(name));
+      }
+      defaults[event] = _id;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var attributes = {};
+  if (icon.attributes != null) {
+    if (!icon.attributes || _typeof(icon.attributes) !== 'object' || Array.isArray(icon.attributes)) throw new Error("dlc-icon: invalid root attributes for ".concat(type, ":").concat(name));
+    for (var _i4 = 0, _Object$entries3 = Object.entries(icon.attributes); _i4 < _Object$entries3.length; _i4++) {
+      var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i4], 2),
+        key = _Object$entries3$_i[0],
+        value = _Object$entries3$_i[1];
+      if (value != null) attributes[key] = String(value);
+    }
+  }
+  var colorMode = icon.colorMode || 'currentColor';
+  if (!COLOR_MODES.has(colorMode)) throw new Error("dlc-icon: invalid colorMode \"".concat(colorMode, "\" for ").concat(type, ":").concat(name));
+  var aliases = icon.aliases == null ? [] : icon.aliases;
+  if (!Array.isArray(aliases) || aliases.some(function (alias) {
+    return typeof alias !== 'string' || !alias.trim();
+  })) {
+    throw new Error("dlc-icon: invalid aliases for ".concat(type, ":").concat(name));
+  }
+  if (icon.meta != null && (!icon.meta || _typeof(icon.meta) !== 'object' || Array.isArray(icon.meta))) {
+    throw new Error("dlc-icon: invalid meta for ".concat(type, ":").concat(name));
+  }
+  var definition = {
+    type: type,
+    name: name,
+    viewBox: icon.viewBox.trim(),
+    body: icon.body,
+    colorMode: colorMode,
+    motions: motions,
+    defaults: defaults,
+    attributes: attributes,
+    aliases: aliases.map(function (alias) {
+      return alias.trim();
+    }),
+    meta: icon.meta && _typeof(icon.meta) === 'object' ? cloneValue(icon.meta) : {}
+  };
+  return freezeObject(definition);
+}
+
+var providers = Object.create(null);
+var providerLoaders = Object.create(null);
+var providerLoads = Object.create(null);
+var iconCache = Object.create(null);
+function normalizeType(type) {
+  return typeof type === 'string' && type.trim() ? type.trim().toLowerCase() : 'linemd';
+}
+function registerIconProvider(type, provider) {
+  var id = normalizeType(type);
+  if (!provider || typeof provider.load !== 'function') throw new Error("Invalid icon provider: ".concat(id));
+  providers[id] = provider;
+  delete providerLoads[id];
+  for (var _i = 0, _Object$keys = Object.keys(iconCache); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    if (key.startsWith("".concat(id, ":"))) delete iconCache[key];
+  }
+  return provider;
+}
+function registerIconProviderLoader(type, loader) {
+  var id = normalizeType(type);
+  if (typeof loader !== 'function') throw new Error("Invalid icon provider loader: ".concat(id));
+  providerLoaders[id] = loader;
+}
+function getIconProvider(type) {
+  return providers[normalizeType(type)];
+}
+function ensureProvider(_x) {
+  return _ensureProvider.apply(this, arguments);
+}
+function _ensureProvider() {
+  _ensureProvider = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(type) {
+    var id, loader;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          id = normalizeType(type);
+          if (!providers[id]) {
+            _context.n = 1;
+            break;
+          }
+          return _context.a(2, providers[id]);
+        case 1:
+          loader = providerLoaders[id];
+          if (loader) {
+            _context.n = 2;
+            break;
+          }
+          throw new Error("Unknown icon provider: ".concat(id));
+        case 2:
+          if (!providerLoads[id]) {
+            providerLoads[id] = Promise.resolve().then(loader).then(function (module) {
+              var provider = module && (module.default || module.provider || module);
+              if (!providers[id] && provider && typeof provider.load === 'function') registerIconProvider(id, provider);
+              if (!providers[id]) throw new Error("Unknown icon provider: ".concat(id));
+              return providers[id];
+            }).catch(function (error) {
+              delete providerLoads[id];
+              throw error;
+            });
+          }
+          return _context.a(2, providerLoads[id]);
+      }
+    }, _callee);
+  }));
+  return _ensureProvider.apply(this, arguments);
+}
+function loadIconDefinition(_x2, _x3) {
+  return _loadIconDefinition.apply(this, arguments);
+}
+function _loadIconDefinition() {
+  _loadIconDefinition = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(type, name) {
+    var id, iconName, key;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          id = normalizeType(type);
+          iconName = typeof name === 'string' ? name.trim() : '';
+          if (iconName) {
+            _context2.n = 1;
+            break;
+          }
+          throw new Error("Icon not found: ".concat(id, ":").concat(iconName));
+        case 1:
+          key = "".concat(id, ":").concat(iconName);
+          if (!iconCache[key]) {
+            iconCache[key] = ensureProvider(id).then(function (provider) {
+              return provider.load(iconName);
+            }).then(function (icon) {
+              if (!icon) throw new Error("Icon not found: ".concat(key));
+              return normalizeIconDefinition(icon, {
+                type: id,
+                name: iconName
+              });
+            }).catch(function (error) {
+              delete iconCache[key];
+              if (/^Icon not found:/.test(error.message)) throw error;
+              throw error;
+            });
+          }
+          return _context2.a(2, iconCache[key]);
+      }
+    }, _callee2);
+  }));
+  return _loadIconDefinition.apply(this, arguments);
+}
+function listIcons() {
+  return _listIcons.apply(this, arguments);
+}
+function _listIcons() {
+  _listIcons = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+    var type,
+      provider,
+      _args3 = arguments;
+    return _regenerator().w(function (_context3) {
+      while (1) switch (_context3.n) {
+        case 0:
+          type = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : 'linemd';
+          _context3.n = 1;
+          return ensureProvider(type);
+        case 1:
+          provider = _context3.v;
+          return _context3.a(2, typeof provider.list === 'function' ? provider.list() : []);
+      }
+    }, _callee3);
+  }));
+  return _listIcons.apply(this, arguments);
+}
+
+/**
+ * Tiny event emitter. Accepts any event name so the API stays open for
+ * future events (hover, click, custom) without breaking changes.
+ */
+function createEmitter() {
+  // Plain object storage (no Map/Set) so the legacy build has no API
+  // dependencies beyond what IE11 provides.
+  var listeners = Object.create(null);
+  return {
+    on: function on(event, fn) {
+      if (!listeners[event]) listeners[event] = [];
+      listeners[event].push(fn);
+      return function () {
+        var current = listeners[event];
+        if (current) {
+          var index = current.indexOf(fn);
+          if (index !== -1) current.splice(index, 1);
+        }
+      };
+    },
+    off: function off(event, fn) {
+      var current = listeners[event];
+      if (!current) return false;
+      var index = current.indexOf(fn);
+      if (index === -1) return false;
+      current.splice(index, 1);
+      return true;
+    },
+    emit: function emit(event) {
+      var current = listeners[event];
+      if (!current) return;
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      var _iterator = _createForOfIteratorHelper(current.slice()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var fn = _step.value;
+          fn.apply(void 0, args);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  };
+}
+
+function createReducedMotionPreference(enabled, onChange) {
+  var query = enabled && typeof matchMedia !== 'undefined' ? matchMedia('(prefers-reduced-motion: reduce)') : null;
+  var notify = function notify() {
+    if (typeof onChange === 'function') onChange(Boolean(query && query.matches));
+  };
+  if (query) {
+    if (typeof query.addEventListener === 'function') query.addEventListener('change', notify);else if (typeof query.addListener === 'function') query.addListener(notify);
+  }
+  return {
+    matches: function matches() {
+      return Boolean(query && query.matches);
+    },
+    dispose: function dispose() {
+      if (!query) return;
+      if (typeof query.removeEventListener === 'function') query.removeEventListener('change', notify);else if (typeof query.removeListener === 'function') query.removeListener(notify);
+    }
+  };
+}
+
+var UNIT_PATTERN = /^[\d.]+(?:px|%|vw|vh|vmin|vmax|em|rem)$/;
+
+/**
+ * Normalize a size option to a CSS length string.
+ * Accepts numbers (treated as px) or strings with px/%, vw/vh/vmin/vmax, em/rem.
+ */
+function parseSize(value) {
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value) || value < 0) throw new Error("Invalid size: ".concat(value));
+    return "".concat(value, "px");
+  }
+  if (typeof value !== 'string') throw new Error("Invalid size: ".concat(String(value)));
+  var trimmed = value.trim();
+  if (!trimmed) throw new Error('Invalid size: empty string');
+  if (/^\d+(?:\.\d+)?$/.test(trimmed)) return "".concat(trimmed, "px");
+  if (!UNIT_PATTERN.test(trimmed)) {
+    throw new Error("Invalid size or unsupported unit: \"".concat(value, "\" (use px, %, vw, vh, vmin, vmax, em, rem)"));
+  }
+  return trimmed;
+}
+
+var BLOCKED_ELEMENTS = new Set(['script', 'style', 'foreignobject', 'iframe', 'object', 'embed', 'audio', 'video', 'animate', 'animatetransform', 'animatemotion', 'animatecolor', 'set', 'mpath']);
+var URL_ATTRIBUTES = new Set(['href', 'xlink:href', 'src']);
+var ROOT_ATTRIBUTES = new Set(['fill', 'fill-opacity', 'fill-rule', 'stroke', 'stroke-width', 'stroke-opacity', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-dasharray', 'stroke-dashoffset', 'clip-rule', 'color', 'opacity', 'preserveAspectRatio', 'shape-rendering', 'text-rendering', 'vector-effect', 'aria-labelledby', 'aria-describedby']);
+var IDREF_ATTRIBUTES = new Set(['aria-labelledby', 'aria-describedby']);
+function containsExternalUrl(value) {
+  var urls = _toConsumableArray(String(value).matchAll(/url\(\s*(['"]?)(.*?)\1\s*\)/gi));
+  return urls.some(function (match) {
+    return !match[2].trim().startsWith('#');
+  });
+}
+function parser() {
+  if (typeof DOMParser === 'undefined') throw new Error('dlc-icon: DOMParser is required to render SVG');
+  return new DOMParser();
+}
+function assertSvgDocument(document) {
+  var error = document.querySelector('parsererror');
+  if (error || !document.documentElement || document.documentElement.localName.toLowerCase() !== 'svg') {
+    throw new Error('dlc-icon: invalid SVG');
+  }
+}
+function sanitizeTree(svg) {
+  for (var _i = 0, _arr = [svg].concat(_toConsumableArray(Array.from(svg.querySelectorAll('*')))); _i < _arr.length; _i++) {
+    var element = _arr[_i];
+    if (BLOCKED_ELEMENTS.has(element.localName.toLowerCase())) {
+      element.remove();
+      continue;
+    }
+    for (var _i2 = 0, _Array$from = Array.from(element.attributes); _i2 < _Array$from.length; _i2++) {
+      var attribute = _Array$from[_i2];
+      var name = attribute.name.toLowerCase();
+      var value = attribute.value.trim();
+      if (name.startsWith('on') || name === 'style') element.removeAttribute(attribute.name);else if (URL_ATTRIBUTES.has(name) && value && !value.startsWith('#')) element.removeAttribute(attribute.name);else if (/javascript\s*:/i.test(value) || containsExternalUrl(value)) element.removeAttribute(attribute.name);
+    }
+  }
+  return svg;
+}
+function parseSvgString(source) {
+  if (typeof source !== 'string' || !source.trim()) throw new Error('dlc-icon: SVG string is required');
+  var document = parser().parseFromString(source, 'image/svg+xml');
+  assertSvgDocument(document);
+  var svg = sanitizeTree(document.documentElement);
+  var dimensions = [svg.getAttribute('width'), svg.getAttribute('height')].map(function (value) {
+    var match = /^\s*(\d*\.?\d+)\s*(?:px)?\s*$/i.exec(value || '');
+    return match && Number(match[1]) > 0 ? Number(match[1]) : null;
+  });
+  var viewBox = svg.getAttribute('viewBox') || (dimensions.every(Number.isFinite) ? "0 0 ".concat(dimensions[0], " ").concat(dimensions[1]) : '0 0 24 24');
+  if (!/^\s*-?(?:\d*\.)?\d+(?:[\s,]+-?(?:\d*\.)?\d+){3}\s*$/.test(viewBox)) throw new Error('dlc-icon: invalid SVG viewBox');
+  var attributes = {};
+  for (var _i3 = 0, _Array$from2 = Array.from(svg.attributes); _i3 < _Array$from2.length; _i3++) {
+    var attribute = _Array$from2[_i3];
+    if (ROOT_ATTRIBUTES.has(attribute.name)) attributes[attribute.name] = attribute.value;
+  }
+  return {
+    viewBox: viewBox,
+    body: svg.innerHTML,
+    attributes: attributes
+  };
+}
+function createSanitizedSvg(definition, instanceId) {
+  var rootAttributes = Object.entries(definition.attributes || {}).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+      name = _ref2[0];
+    return ROOT_ATTRIBUTES.has(name);
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      name = _ref4[0],
+      value = _ref4[1];
+    return " ".concat(name, "=\"").concat(String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;'), "\"");
+  }).join('');
+  var source = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"".concat(String(definition.viewBox || '0 0 24 24').replace(/"/g, '&quot;'), "\"").concat(rootAttributes, ">").concat(definition.body || '', "</svg>");
+  var document = parser().parseFromString(source, 'image/svg+xml');
+  assertSvgDocument(document);
+  var svg = sanitizeTree(document.documentElement);
+  var ids = new Map();
+  for (var _i4 = 0, _Array$from3 = Array.from(svg.querySelectorAll('[id]')); _i4 < _Array$from3.length; _i4++) {
+    var element = _Array$from3[_i4];
+    var original = element.getAttribute('id');
+    var scoped = "".concat(instanceId, "-").concat(original);
+    ids.set(original, scoped);
+    element.setAttribute('data-dlc-original-id', original);
+    element.setAttribute('id', scoped);
+  }
+  if (ids.size) {
+    for (var _i5 = 0, _arr2 = [svg].concat(_toConsumableArray(Array.from(svg.querySelectorAll('*')))); _i5 < _arr2.length; _i5++) {
+      var _element = _arr2[_i5];
+      for (var _i6 = 0, _Array$from4 = Array.from(_element.attributes); _i6 < _Array$from4.length; _i6++) {
+        var attribute = _Array$from4[_i6];
+        var value = attribute.value;
+        var _iterator = _createForOfIteratorHelper(ids),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = _slicedToArray(_step.value, 2),
+              _original = _step$value[0],
+              _scoped = _step$value[1];
+            var escaped = _original.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            value = value.replace(new RegExp("url\\(\\s*(['\"]?)#".concat(escaped, "\\1\\s*\\)"), 'g'), "url(#".concat(_scoped, ")"));
+            if (value === "#".concat(_original)) value = "#".concat(_scoped);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        if (IDREF_ATTRIBUTES.has(attribute.name.toLowerCase())) {
+          value = value.split(/\s+/).map(function (id) {
+            return ids.get(id) || id;
+          }).join(' ');
+        }
+        if (value !== attribute.value) _element.setAttribute(attribute.name, value);
+      }
+    }
+  }
+  svg.removeAttribute('width');
+  svg.removeAttribute('height');
+  svg.setAttribute('class', 'dlc-icon__svg');
+  svg.setAttribute('focusable', 'false');
+  svg.style.setProperty('width', '100%', 'important');
+  svg.style.setProperty('height', '100%', 'important');
+  if (svg.getAttribute('fill') === 'currentColor') svg.style.setProperty('fill', 'currentColor', 'important');
+  if (svg.getAttribute('stroke') === 'currentColor') svg.style.setProperty('stroke', 'currentColor', 'important');
+  for (var _i7 = 0, _Array$from5 = Array.from(svg.querySelectorAll('*')); _i7 < _Array$from5.length; _i7++) {
+    var _element2 = _Array$from5[_i7];
+    var fill = _element2.getAttribute('fill');
+    var stroke = _element2.getAttribute('stroke');
+    if (fill === 'currentColor') _element2.style.setProperty('fill', 'currentColor', 'important');
+    if (stroke === 'currentColor') _element2.style.setProperty('stroke', 'currentColor', 'important');
+  }
+  return svg;
+}
+
+var EVENTS = ['create', 'hover', 'click', 'focus'];
+var EVENT_ALIASES = new Set(EVENTS);
+var instanceSequence = 0;
+function positiveNumber(value, fallback, label) {
+  if (value == null) return fallback;
+  var number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) throw new Error("dlc-icon: ".concat(label, " must be greater than 0"));
+  return number;
+}
+function normalizeCount(value) {
+  if (value == null) return undefined;
+  if (value === 'infinite') return value;
+  var number = Number(value);
+  if (!Number.isInteger(number) || number <= 0) throw new Error('dlc-icon: count must be a positive integer or "infinite"');
+  return number;
+}
+function eventOption(value, fallback) {
+  if (value === undefined) return fallback;
+  return value;
+}
+function payload(state) {
+  var extra = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return _objectSpread2({
+    type: state.definition ? state.definition.type : state.type,
+    name: state.definition ? state.definition.name : state.name,
+    event: extra.event,
+    motionId: extra.motionId,
+    source: extra.source
+  }, extra);
+}
+function customDefinition(svg) {
+  var parsed = parseSvgString(svg);
+  return normalizeIconDefinition(_objectSpread2({
+    type: 'custom',
+    name: 'custom',
+    colorMode: 'original',
+    motions: {},
+    defaults: {}
+  }, parsed));
+}
+function createIcon(container) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (!container || typeof container.appendChild !== 'function') throw new Error('dlc-icon: container element is required');
+  var emitter = createEmitter();
+  var instanceId = "dlc-icon-".concat(++instanceSequence);
+  var element = document.createElement('span');
+  element.className = 'dlc-icon';
+  element.setAttribute('data-dlc-icon-instance', instanceId);
+  container.appendChild(element);
+  var state = {
+    type: options.type || 'linemd',
+    name: options.name,
+    definition: null,
+    size: options.size == null ? 24 : options.size,
+    color: options.color == null ? 'currentColor' : String(options.color),
+    animated: options.animated !== false,
+    speed: positiveNumber(options.speed, 1, 'speed'),
+    count: normalizeCount(options.count),
+    respectReducedMotion: options.respectReducedMotion !== false,
+    eventAnimations: {
+      create: eventOption(options.createAnm, true),
+      hover: eventOption(options.hoverAnm, false),
+      click: eventOption(options.clickAnm, false),
+      focus: eventOption(options.focusAnm, false)
+    }
+  };
+  var motionCache = new Map();
+  var loadSequence = 0;
+  var renderSequence = 0;
+  var motionSequence = 0;
+  var active = null;
+  var lastPlay = null;
+  var disposed = false;
+  var paused = false;
+  var reducedMotion = createReducedMotionPreference(state.respectReducedMotion, function (matches) {
+    if (matches) cancel('reduced-motion');
+  });
+  function applyPresentation() {
+    var size = parseSize(state.size);
+    element.style.width = size;
+    element.style.height = size;
+    element.style.color = state.color;
+    if (options.ariaLabel || options.title) {
+      element.removeAttribute('aria-hidden');
+      element.setAttribute('role', 'img');
+      element.setAttribute('aria-label', options.ariaLabel || options.title);
+    } else if (element.matches('[tabindex],a[href],button,input,select,textarea,[contenteditable="true"]') || element === document.activeElement) {
+      // A focusable element must never be hidden from the accessibility tree.
+      // Consumers should still provide ariaLabel/title when the icon itself is interactive.
+      element.removeAttribute('aria-hidden');
+      element.removeAttribute('role');
+      element.removeAttribute('aria-label');
+    } else {
+      element.setAttribute('aria-hidden', 'true');
+      element.removeAttribute('role');
+      element.removeAttribute('aria-label');
+    }
+  }
+  function renderDefinition(definition, source) {
+    var renderedAt = ++renderSequence;
+    state.definition = normalizeIconDefinition(definition);
+    state.type = state.definition.type;
+    state.name = state.definition.name;
+    var svg = createSanitizedSvg(state.definition, instanceId);
+    if (options.title) {
+      var title = document.createElementNS('http://www.w3.org/2000/svg', 'title');
+      title.textContent = String(options.title);
+      svg.insertBefore(title, svg.firstChild);
+    }
+    element.replaceChildren(svg);
+    applyPresentation();
+    emitter.emit('iconchange', payload(state, {
+      source: source
+    }));
+    queueMicrotask(function () {
+      if (disposed || renderedAt !== renderSequence) return;
+      controller.trigger('create');
+      emitter.emit('ready', payload(state, {
+        source: source
+      }));
+    });
+  }
+  function load(_x, _x2) {
+    return _load.apply(this, arguments);
+  }
+  function _load() {
+    _load = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(type, name) {
+      var sequence, definition, _t3;
+      return _regenerator().w(function (_context3) {
+        while (1) switch (_context3.p = _context3.n) {
+          case 0:
+            sequence = ++loadSequence;
+            _context3.p = 1;
+            _context3.n = 2;
+            return loadIconDefinition(type, name);
+          case 2:
+            definition = _context3.v;
+            if (!(disposed || sequence !== loadSequence)) {
+              _context3.n = 3;
+              break;
+            }
+            return _context3.a(2, null);
+          case 3:
+            renderDefinition(definition, 'provider');
+            return _context3.a(2, definition);
+          case 4:
+            _context3.p = 4;
+            _t3 = _context3.v;
+            if (!disposed && sequence === loadSequence) emitter.emit('error', payload(state, {
+              source: 'provider',
+              error: _t3
+            }));
+            return _context3.a(2, null);
+        }
+      }, _callee3, null, [[1, 4]]);
+    }));
+    return _load.apply(this, arguments);
+  }
+  function loadMotionEntry(_x3) {
+    return _loadMotionEntry.apply(this, arguments);
+  }
+  function _loadMotionEntry() {
+    _loadMotionEntry = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(entry) {
+      var pending;
+      return _regenerator().w(function (_context4) {
+        while (1) switch (_context4.n) {
+          case 0:
+            if (!(typeof entry !== 'function')) {
+              _context4.n = 1;
+              break;
+            }
+            return _context4.a(2, normalizeIconMotion(entry));
+          case 1:
+            if (!motionCache.has(entry)) {
+              pending = Promise.resolve().then(entry).then(function (module) {
+                return normalizeIconMotion(module);
+              }).catch(function (error) {
+                motionCache.delete(entry);
+                throw error;
+              });
+              motionCache.set(entry, pending);
+            }
+            return _context4.a(2, motionCache.get(entry));
+        }
+      }, _callee4);
+    }));
+    return _loadMotionEntry.apply(this, arguments);
+  }
+  function resolveMotion(_x4, _x5) {
+    return _resolveMotion.apply(this, arguments);
+  }
+  function _resolveMotion() {
+    _resolveMotion = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(selection, event) {
+      var config, eventSpeed, eventCount, motion, id, _id, entry;
+      return _regenerator().w(function (_context5) {
+        while (1) switch (_context5.n) {
+          case 0:
+            if (state.definition) {
+              _context5.n = 1;
+              break;
+            }
+            return _context5.a(2, null);
+          case 1:
+            config = selection;
+            if (config && _typeof(config) === 'object' && !('kind' in config) && Object.prototype.hasOwnProperty.call(config, 'anm')) {
+              eventSpeed = config.speed;
+              eventCount = config.count;
+              config = config.anm;
+            }
+            if (!(config === false || config == null)) {
+              _context5.n = 2;
+              break;
+            }
+            return _context5.a(2, null);
+          case 2:
+            if (!(config === true)) {
+              _context5.n = 5;
+              break;
+            }
+            id = state.definition.defaults[event];
+            if (id) {
+              _context5.n = 3;
+              break;
+            }
+            return _context5.a(2, null);
+          case 3:
+            _context5.n = 4;
+            return loadMotionEntry(state.definition.motions[id]);
+          case 4:
+            motion = _context5.v;
+            _context5.n = 10;
+            break;
+          case 5:
+            if (!(typeof config === 'string')) {
+              _context5.n = 9;
+              break;
+            }
+            _id = EVENT_ALIASES.has(config) ? state.definition.defaults[config] : config;
+            if (_id) {
+              _context5.n = 6;
+              break;
+            }
+            return _context5.a(2, null);
+          case 6:
+            entry = state.definition.motions[_id];
+            if (entry) {
+              _context5.n = 7;
+              break;
+            }
+            throw new Error("dlc-icon: unknown motion \"".concat(_id, "\" for ").concat(state.definition.type, ":").concat(state.definition.name));
+          case 7:
+            _context5.n = 8;
+            return loadMotionEntry(entry);
+          case 8:
+            motion = _context5.v;
+            _context5.n = 10;
+            break;
+          case 9:
+            motion = normalizeIconMotion(config);
+          case 10:
+            return _context5.a(2, {
+              motion: motion,
+              speed: positiveNumber(eventSpeed, state.speed, "".concat(event, " speed")),
+              count: eventCount === undefined ? state.count === undefined ? motion.iterations : state.count : normalizeCount(eventCount)
+            });
+        }
+      }, _callee5);
+    }));
+    return _resolveMotion.apply(this, arguments);
+  }
+  function finish(play, cancelled, reason) {
+    if (!active || active !== play) return;
+    element.removeAttribute('data-dlc-icon-motion');
+    element.style.removeProperty('--dlc-icon-iterations');
+    element.style.removeProperty('--p2m-duration');
+    element.style.removeProperty('--p2m-iterations');
+    if (play.timer) clearTimeout(play.timer);
+    play.style.release();
+    active = null;
+    var eventName = cancelled ? 'animationcancel' : 'animationend';
+    emitter.emit(eventName, payload(state, {
+      event: play.event,
+      motionId: play.motion.id,
+      source: play.motion.source,
+      reason: reason
+    }));
+  }
+  function cancelActive() {
+    var reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'cancel';
+    if (active) finish(active, true, reason);
+  }
+  function cancel() {
+    var reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'cancel';
+    motionSequence += 1;
+    cancelActive(reason);
+    return controller;
+  }
+  function startCycle(play) {
+    if (!active || active !== play) return;
+    element.removeAttribute('data-dlc-icon-motion');
+    void element.offsetWidth;
+    element.setAttribute('data-dlc-icon-motion', play.style.token);
+    void element.offsetWidth;
+    play.remaining = Math.max(0, play.style.duration);
+    if (paused) return;
+    play.startedAt = Date.now();
+    play.timer = setTimeout(function () {
+      if (!active || active !== play) return;
+      play.timer = null;
+      play.completed += 1;
+      if (play.count === 'infinite' || play.completed < play.count) startCycle(play);else finish(play, false);
+    }, play.remaining);
+  }
+  function playResolved(_x6) {
+    return _playResolved.apply(this, arguments);
+  }
+  function _playResolved() {
+    _playResolved = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(resolved) {
+      var event,
+        scoped,
+        count,
+        play,
+        _args6 = arguments;
+      return _regenerator().w(function (_context6) {
+        while (1) switch (_context6.n) {
+          case 0:
+            event = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : 'manual';
+            if (!(!resolved || !state.animated || state.respectReducedMotion && reducedMotion.matches() || disposed)) {
+              _context6.n = 1;
+              break;
+            }
+            return _context6.a(2, null);
+          case 1:
+            cancelActive('replay');
+            scoped = acquireMotionStyle(resolved.motion, resolved.speed);
+            count = resolved.count === 'infinite' ? 'infinite' : Number(resolved.count == null ? 1 : resolved.count);
+            play = {
+              event: event,
+              motion: resolved.motion,
+              style: scoped,
+              timer: null,
+              count: count,
+              completed: 0,
+              remaining: null,
+              startedAt: null
+            };
+            active = play;
+            lastPlay = {
+              motion: resolved.motion,
+              options: {
+                speed: resolved.speed,
+                count: resolved.count
+              },
+              event: event
+            };
+            // count controls complete Motion cycles. Each CSS child animation runs once per
+            // cycle so delayed child animations cannot overlap the following cycle.
+            element.style.setProperty('--dlc-icon-iterations', '1');
+            element.style.setProperty('--p2m-iterations', '1');
+            element.style.setProperty('--p2m-duration', "".concat(scoped.duration, "ms"));
+            emitter.emit('animationstart', payload(state, {
+              event: event,
+              motionId: resolved.motion.id,
+              source: resolved.motion.source
+            }));
+            startCycle(play);
+            return _context6.a(2, resolved.motion);
+        }
+      }, _callee6);
+    }));
+    return _playResolved.apply(this, arguments);
+  }
+  function trigger(_x7) {
+    return _trigger.apply(this, arguments);
+  }
+  function _trigger() {
+    _trigger = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(event) {
+      var request, resolved, _t4;
+      return _regenerator().w(function (_context7) {
+        while (1) switch (_context7.p = _context7.n) {
+          case 0:
+            if (EVENT_ALIASES.has(event)) {
+              _context7.n = 1;
+              break;
+            }
+            throw new Error("dlc-icon: unsupported event \"".concat(event, "\""));
+          case 1:
+            request = ++motionSequence;
+            cancelActive('superseded');
+            _context7.p = 2;
+            _context7.n = 3;
+            return resolveMotion(state.eventAnimations[event], event);
+          case 3:
+            resolved = _context7.v;
+            if (!(disposed || request !== motionSequence)) {
+              _context7.n = 4;
+              break;
+            }
+            return _context7.a(2, null);
+          case 4:
+            return _context7.a(2, playResolved(resolved, event));
+          case 5:
+            _context7.p = 5;
+            _t4 = _context7.v;
+            if (!disposed && request === motionSequence) emitter.emit('error', payload(state, {
+              event: event,
+              source: 'motion',
+              error: _t4
+            }));
+            return _context7.a(2, null);
+        }
+      }, _callee7, null, [[2, 5]]);
+    }));
+    return _trigger.apply(this, arguments);
+  }
+  var listeners = {
+    pointerenter: function pointerenter() {
+      return trigger('hover');
+    },
+    click: function click(originalEvent) {
+      emitter.emit('click', payload(state, {
+        event: 'click',
+        source: 'dom',
+        originalEvent: originalEvent
+      }));
+      trigger('click');
+    },
+    focus: function focus() {
+      applyPresentation();
+      trigger('focus');
+    }
+  };
+  for (var _i = 0, _Object$entries = Object.entries(listeners); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      event = _Object$entries$_i[0],
+      listener = _Object$entries$_i[1];
+    element.addEventListener(event, listener);
+  }
+  var controller = {
+    element: element,
+    get state() {
+      return Object.freeze(_objectSpread2(_objectSpread2({}, state), {}, {
+        eventAnimations: Object.freeze(_objectSpread2({}, state.eventAnimations))
+      }));
+    },
+    setIcon: function setIcon(type, name) {
+      cancel('iconchange');
+      return load(type || 'linemd', name);
+    },
+    setDefinition: function setDefinition(icon) {
+      try {
+        var definition = normalizeIconDefinition(icon);
+        ++loadSequence;
+        cancel('iconchange');
+        renderDefinition(definition, 'definition');
+      } catch (error) {
+        queueMicrotask(function () {
+          if (!disposed) emitter.emit('error', payload(state, {
+            source: 'definition',
+            error: error
+          }));
+        });
+      }
+      return this;
+    },
+    setSvg: function setSvg(svg) {
+      try {
+        var definition = customDefinition(svg);
+        ++loadSequence;
+        cancel('iconchange');
+        renderDefinition(definition, 'svg');
+      } catch (error) {
+        queueMicrotask(function () {
+          if (!disposed) emitter.emit('error', payload(state, {
+            source: 'svg',
+            error: error
+          }));
+        });
+      }
+      return this;
+    },
+    setSize: function setSize(size) {
+      parseSize(size);
+      state.size = size;
+      applyPresentation();
+      return this;
+    },
+    setColor: function setColor(color) {
+      state.color = color == null ? 'currentColor' : String(color);
+      applyPresentation();
+      return this;
+    },
+    setAnimated: function setAnimated(value) {
+      state.animated = value !== false;
+      if (!state.animated) cancel('disabled');
+      return this;
+    },
+    setSpeed: function setSpeed(value) {
+      state.speed = positiveNumber(value, state.speed, 'speed');
+      return this;
+    },
+    setCount: function setCount(value) {
+      state.count = normalizeCount(value);
+      return this;
+    },
+    setEventAnimation: function setEventAnimation(event, definition) {
+      if (!EVENT_ALIASES.has(event)) throw new Error("dlc-icon: unsupported event \"".concat(event, "\""));
+      state.eventAnimations[event] = definition;
+      return this;
+    },
+    _syncAccessibility: function _syncAccessibility() {
+      applyPresentation();
+      return this;
+    },
+    trigger: trigger,
+    play: function play(motion) {
+      var _arguments = arguments;
+      return _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var playOptions, request, normalized, _t, _t2;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.p = _context2.n) {
+            case 0:
+              playOptions = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {};
+              request = ++motionSequence;
+              cancelActive('superseded');
+              _context2.p = 1;
+              if (!(typeof motion === 'string')) {
+                _context2.n = 3;
+                break;
+              }
+              _context2.n = 2;
+              return resolveMotion(_objectSpread2({
+                anm: motion
+              }, playOptions), 'manual');
+            case 2:
+              _t = _context2.v;
+              _context2.n = 5;
+              break;
+            case 3:
+              _context2.n = 4;
+              return _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+                var definition;
+                return _regenerator().w(function (_context) {
+                  while (1) switch (_context.n) {
+                    case 0:
+                      _context.n = 1;
+                      return loadMotionEntry(motion);
+                    case 1:
+                      definition = _context.v;
+                      return _context.a(2, {
+                        motion: definition,
+                        speed: positiveNumber(playOptions.speed, state.speed, 'speed'),
+                        count: playOptions.count === undefined ? state.count === undefined ? definition.iterations : state.count : normalizeCount(playOptions.count)
+                      });
+                  }
+                }, _callee);
+              }))();
+            case 4:
+              _t = _context2.v;
+            case 5:
+              normalized = _t;
+              if (!(disposed || request !== motionSequence)) {
+                _context2.n = 6;
+                break;
+              }
+              return _context2.a(2, null);
+            case 6:
+              return _context2.a(2, playResolved(normalized, 'manual'));
+            case 7:
+              _context2.p = 7;
+              _t2 = _context2.v;
+              if (!disposed && request === motionSequence) emitter.emit('error', payload(state, {
+                event: 'manual',
+                source: 'motion',
+                error: _t2
+              }));
+              return _context2.a(2, null);
+          }
+        }, _callee2, null, [[1, 7]]);
+      }))();
+    },
+    replay: function replay() {
+      if (!lastPlay) return null;
+      motionSequence += 1;
+      cancelActive('replay');
+      return disposed ? null : playResolved({
+        motion: lastPlay.motion,
+        speed: lastPlay.options.speed,
+        count: lastPlay.options.count
+      }, lastPlay.event);
+    },
+    pause: function pause() {
+      paused = true;
+      element.classList.add('dlc-icon--paused');
+      if (active && active.timer) {
+        clearTimeout(active.timer);
+        active.timer = null;
+        active.remaining = Math.max(0, active.remaining - (Date.now() - active.startedAt));
+      }
+      return this;
+    },
+    resume: function resume() {
+      paused = false;
+      element.classList.remove('dlc-icon--paused');
+      if (active && active.remaining != null && !active.timer) {
+        var play = active;
+        play.startedAt = Date.now();
+        play.timer = setTimeout(function () {
+          if (!active || active !== play) return;
+          play.timer = null;
+          play.completed += 1;
+          if (play.count === 'infinite' || play.completed < play.count) startCycle(play);else finish(play, false);
+        }, play.remaining);
+      }
+      return this;
+    },
+    cancel: cancel,
+    on: function on(event, listener) {
+      return emitter.on(event, listener);
+    },
+    off: function off(event, listener) {
+      return emitter.off(event, listener);
+    },
+    dispose: function dispose() {
+      if (disposed) return;
+      disposed = true;
+      ++loadSequence;
+      motionSequence += 1;
+      cancelActive('dispose');
+      reducedMotion.dispose();
+      for (var _i2 = 0, _Object$entries2 = Object.entries(listeners); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          _event = _Object$entries2$_i[0],
+          _listener = _Object$entries2$_i[1];
+        element.removeEventListener(_event, _listener);
+      }
+      element.replaceChildren();
+      if (element.parentNode) element.parentNode.removeChild(element);
+    }
+  };
+  applyPresentation();
+  try {
+    if (options.icon) controller.setDefinition(options.icon);else if (options.svg) controller.setSvg(options.svg);else if (state.name) load(state.type, state.name);else throw new Error('dlc-icon: icon, svg, or name is required');
+  } catch (error) {
+    queueMicrotask(function () {
+      if (!disposed) emitter.emit('error', payload(state, {
+        source: 'initialization',
+        error: error
+      }));
+    });
+  }
+  return controller;
+}
+
+registerIconProviderLoader('linemd', function () {
+  if (typeof require !== 'function') return Promise.reject(new Error('dlc-icon: LINE MD CJS provider requires a CommonJS loader'));
+  return Promise.resolve().then(function () {
+    return require('@5even7/dlc-ui/icon/linemd');
+  });
+});
+
+exports.createIcon = createIcon;
+exports.defineIconMotion = defineIconMotion;
+exports.getIconProvider = getIconProvider;
+exports.listIcons = listIcons;
+exports.loadIconDefinition = loadIconDefinition;
+exports.normalizeIconMotion = normalizeIconMotion;
+exports.registerIconProvider = registerIconProvider;
+exports.registerIconProviderLoader = registerIconProviderLoader;