@opendesign-plus/components 0.0.1-rc.34 → 0.0.1-rc.36

package/dist/treeshaking/_virtual/@videojs/xhr/lib/interceptors.js.mjs

@@ -0,0 +1,109 @@
+var interceptors;
+var hasRequiredInterceptors;
+function requireInterceptors() {
+  if (hasRequiredInterceptors) return interceptors;
+  hasRequiredInterceptors = 1;
+  function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (it) return (it = it.call(o)).next.bind(it);
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
+      if (it) o = it;
+      var i = 0;
+      return function() {
+        if (i >= o.length) return { done: true };
+        return { done: false, value: o[i++] };
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) {
+      arr2[i] = arr[i];
+    }
+    return arr2;
+  }
+  var InterceptorsStorage = /* @__PURE__ */ (function() {
+    function InterceptorsStorage2() {
+      this.typeToInterceptorsMap_ = /* @__PURE__ */ new Map();
+      this.enabled_ = false;
+    }
+    var _proto = InterceptorsStorage2.prototype;
+    _proto.getIsEnabled = function getIsEnabled() {
+      return this.enabled_;
+    };
+    _proto.enable = function enable() {
+      this.enabled_ = true;
+    };
+    _proto.disable = function disable() {
+      this.enabled_ = false;
+    };
+    _proto.reset = function reset() {
+      this.typeToInterceptorsMap_ = /* @__PURE__ */ new Map();
+      this.enabled_ = false;
+    };
+    _proto.addInterceptor = function addInterceptor(type, interceptor) {
+      if (!this.typeToInterceptorsMap_.has(type)) {
+        this.typeToInterceptorsMap_.set(type, /* @__PURE__ */ new Set());
+      }
+      var interceptorsSet = this.typeToInterceptorsMap_.get(type);
+      if (interceptorsSet.has(interceptor)) {
+        return false;
+      }
+      interceptorsSet.add(interceptor);
+      return true;
+    };
+    _proto.removeInterceptor = function removeInterceptor(type, interceptor) {
+      var interceptorsSet = this.typeToInterceptorsMap_.get(type);
+      if (interceptorsSet && interceptorsSet.has(interceptor)) {
+        interceptorsSet.delete(interceptor);
+        return true;
+      }
+      return false;
+    };
+    _proto.clearInterceptorsByType = function clearInterceptorsByType(type) {
+      var interceptorsSet = this.typeToInterceptorsMap_.get(type);
+      if (!interceptorsSet) {
+        return false;
+      }
+      this.typeToInterceptorsMap_.delete(type);
+      this.typeToInterceptorsMap_.set(type, /* @__PURE__ */ new Set());
+      return true;
+    };
+    _proto.clear = function clear() {
+      if (!this.typeToInterceptorsMap_.size) {
+        return false;
+      }
+      this.typeToInterceptorsMap_ = /* @__PURE__ */ new Map();
+      return true;
+    };
+    _proto.getForType = function getForType(type) {
+      return this.typeToInterceptorsMap_.get(type) || /* @__PURE__ */ new Set();
+    };
+    _proto.execute = function execute(type, payload) {
+      var interceptors2 = this.getForType(type);
+      for (var _iterator = _createForOfIteratorHelperLoose(interceptors2), _step; !(_step = _iterator()).done; ) {
+        var interceptor = _step.value;
+        try {
+          payload = interceptor(payload);
+        } catch (e) {
+        }
+      }
+      return payload;
+    };
+    return InterceptorsStorage2;
+  })();
+  interceptors = InterceptorsStorage;
+  return interceptors;
+}
+export {
+  requireInterceptors as __require
+};

package/dist/treeshaking/_virtual/@videojs/xhr/lib/retry.js.mjs

@@ -0,0 +1,104 @@
+var retry;
+var hasRequiredRetry;
+function requireRetry() {
+  if (hasRequiredRetry) return retry;
+  hasRequiredRetry = 1;
+  var RetryManager = /* @__PURE__ */ (function() {
+    function RetryManager2() {
+      this.maxAttempts_ = 1;
+      this.delayFactor_ = 0.1;
+      this.fuzzFactor_ = 0.1;
+      this.initialDelay_ = 1e3;
+      this.enabled_ = false;
+    }
+    var _proto = RetryManager2.prototype;
+    _proto.getIsEnabled = function getIsEnabled() {
+      return this.enabled_;
+    };
+    _proto.enable = function enable() {
+      this.enabled_ = true;
+    };
+    _proto.disable = function disable() {
+      this.enabled_ = false;
+    };
+    _proto.reset = function reset() {
+      this.maxAttempts_ = 1;
+      this.delayFactor_ = 0.1;
+      this.fuzzFactor_ = 0.1;
+      this.initialDelay_ = 1e3;
+      this.enabled_ = false;
+    };
+    _proto.getMaxAttempts = function getMaxAttempts() {
+      return this.maxAttempts_;
+    };
+    _proto.setMaxAttempts = function setMaxAttempts(maxAttempts) {
+      this.maxAttempts_ = maxAttempts;
+    };
+    _proto.getDelayFactor = function getDelayFactor() {
+      return this.delayFactor_;
+    };
+    _proto.setDelayFactor = function setDelayFactor(delayFactor) {
+      this.delayFactor_ = delayFactor;
+    };
+    _proto.getFuzzFactor = function getFuzzFactor() {
+      return this.fuzzFactor_;
+    };
+    _proto.setFuzzFactor = function setFuzzFactor(fuzzFactor) {
+      this.fuzzFactor_ = fuzzFactor;
+    };
+    _proto.getInitialDelay = function getInitialDelay() {
+      return this.initialDelay_;
+    };
+    _proto.setInitialDelay = function setInitialDelay(initialDelay) {
+      this.initialDelay_ = initialDelay;
+    };
+    _proto.createRetry = function createRetry(_temp) {
+      var _ref = _temp === void 0 ? {} : _temp, maxAttempts = _ref.maxAttempts, delayFactor = _ref.delayFactor, fuzzFactor = _ref.fuzzFactor, initialDelay = _ref.initialDelay;
+      return new Retry({
+        maxAttempts: maxAttempts || this.maxAttempts_,
+        delayFactor: delayFactor || this.delayFactor_,
+        fuzzFactor: fuzzFactor || this.fuzzFactor_,
+        initialDelay: initialDelay || this.initialDelay_
+      });
+    };
+    return RetryManager2;
+  })();
+  var Retry = /* @__PURE__ */ (function() {
+    function Retry2(options) {
+      this.maxAttempts_ = options.maxAttempts;
+      this.delayFactor_ = options.delayFactor;
+      this.fuzzFactor_ = options.fuzzFactor;
+      this.currentDelay_ = options.initialDelay;
+      this.currentAttempt_ = 1;
+    }
+    var _proto2 = Retry2.prototype;
+    _proto2.moveToNextAttempt = function moveToNextAttempt() {
+      this.currentAttempt_++;
+      var delayDelta = this.currentDelay_ * this.delayFactor_;
+      this.currentDelay_ = this.currentDelay_ + delayDelta;
+    };
+    _proto2.shouldRetry = function shouldRetry() {
+      return this.currentAttempt_ < this.maxAttempts_;
+    };
+    _proto2.getCurrentDelay = function getCurrentDelay() {
+      return this.currentDelay_;
+    };
+    _proto2.getCurrentMinPossibleDelay = function getCurrentMinPossibleDelay() {
+      return (1 - this.fuzzFactor_) * this.currentDelay_;
+    };
+    _proto2.getCurrentMaxPossibleDelay = function getCurrentMaxPossibleDelay() {
+      return (1 + this.fuzzFactor_) * this.currentDelay_;
+    };
+    _proto2.getCurrentFuzzedDelay = function getCurrentFuzzedDelay() {
+      var lowValue = this.getCurrentMinPossibleDelay();
+      var highValue = this.getCurrentMaxPossibleDelay();
+      return lowValue + Math.random() * (highValue - lowValue);
+    };
+    return Retry2;
+  })();
+  retry = RetryManager;
+  return retry;
+}
+export {
+  requireRetry as __require
+};

package/dist/treeshaking/_virtual/@xmldom/xmldom/lib/conventions.js.mjs

@@ -0,0 +1,142 @@
+import { __exports as conventions } from "./conventions.js2.mjs";
+var hasRequiredConventions;
+function requireConventions() {
+  if (hasRequiredConventions) return conventions;
+  hasRequiredConventions = 1;
+  function find(list, predicate, ac) {
+    if (ac === void 0) {
+      ac = Array.prototype;
+    }
+    if (list && typeof ac.find === "function") {
+      return ac.find.call(list, predicate);
+    }
+    for (var i = 0; i < list.length; i++) {
+      if (Object.prototype.hasOwnProperty.call(list, i)) {
+        var item = list[i];
+        if (predicate.call(void 0, item, i, list)) {
+          return item;
+        }
+      }
+    }
+  }
+  function freeze(object, oc) {
+    if (oc === void 0) {
+      oc = Object;
+    }
+    return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;
+  }
+  function assign(target, source) {
+    if (target === null || typeof target !== "object") {
+      throw new TypeError("target is not an object");
+    }
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+    return target;
+  }
+  var MIME_TYPE = freeze({
+    /**
+     * `text/html`, the only mime type that triggers treating an XML document as HTML.
+     *
+     * @see DOMParser.SupportedType.isHTML
+     * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+     * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+     */
+    HTML: "text/html",
+    /**
+     * Helper method to check a mime type if it indicates an HTML document
+     *
+     * @param {string} [value]
+     * @returns {boolean}
+     *
+     * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+     * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring 	 */
+    isHTML: function(value) {
+      return value === MIME_TYPE.HTML;
+    },
+    /**
+     * `application/xml`, the standard mime type for XML documents.
+     *
+     * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+     * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+     * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+     */
+    XML_APPLICATION: "application/xml",
+    /**
+     * `text/html`, an alias for `application/xml`.
+     *
+     * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+     * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+     */
+    XML_TEXT: "text/xml",
+    /**
+     * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+     * but is parsed as an XML document.
+     *
+     * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+     * @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+     */
+    XML_XHTML_APPLICATION: "application/xhtml+xml",
+    /**
+     * `image/svg+xml`,
+     *
+     * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+     * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+     * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+     */
+    XML_SVG_IMAGE: "image/svg+xml"
+  });
+  var NAMESPACE = freeze({
+    /**
+     * The XHTML namespace.
+     *
+     * @see http://www.w3.org/1999/xhtml
+     */
+    HTML: "http://www.w3.org/1999/xhtml",
+    /**
+     * Checks if `uri` equals `NAMESPACE.HTML`.
+     *
+     * @param {string} [uri]
+     *
+     * @see NAMESPACE.HTML
+     */
+    isHTML: function(uri) {
+      return uri === NAMESPACE.HTML;
+    },
+    /**
+     * The SVG namespace.
+     *
+     * @see http://www.w3.org/2000/svg
+     */
+    SVG: "http://www.w3.org/2000/svg",
+    /**
+     * The `xml:` namespace.
+     *
+     * @see http://www.w3.org/XML/1998/namespace
+     */
+    XML: "http://www.w3.org/XML/1998/namespace",
+    /**
+     * The `xmlns:` namespace
+     *
+     * @see https://www.w3.org/2000/xmlns/
+     */
+    XMLNS: "http://www.w3.org/2000/xmlns/"
+  });
+  conventions.assign = assign;
+  conventions.find = find;
+  conventions.freeze = freeze;
+  conventions.MIME_TYPE = MIME_TYPE;
+  conventions.NAMESPACE = NAMESPACE;
+  return conventions;
+}
+export {
+  requireConventions as __require
+};

package/dist/treeshaking/_virtual/@xmldom/xmldom/lib/conventions.js2.mjs

@@ -0,0 +1,4 @@
+var conventions = {};
+export {
+  conventions as __exports
+};

package/dist/treeshaking/_virtual/@xmldom/xmldom/lib/dom-parser.js.mjs

@@ -0,0 +1,224 @@
+import { __exports as domParser } from "./dom-parser.js2.mjs";
+import { __require as requireConventions } from "./conventions.js.mjs";
+import { __require as requireDom } from "./dom.js.mjs";
+import { __require as requireEntities } from "./entities.js.mjs";
+import { __require as requireSax } from "./sax.js.mjs";
+var hasRequiredDomParser;
+function requireDomParser() {
+  if (hasRequiredDomParser) return domParser;
+  hasRequiredDomParser = 1;
+  var conventions = requireConventions();
+  var dom = requireDom();
+  var entities = requireEntities();
+  var sax = requireSax();
+  var DOMImplementation = dom.DOMImplementation;
+  var NAMESPACE = conventions.NAMESPACE;
+  var ParseError = sax.ParseError;
+  var XMLReader = sax.XMLReader;
+  function normalizeLineEndings(input) {
+    return input.replace(/\r[\n\u0085]/g, "\n").replace(/[\r\u0085\u2028]/g, "\n");
+  }
+  function DOMParser(options) {
+    this.options = options || { locator: {} };
+  }
+  DOMParser.prototype.parseFromString = function(source, mimeType) {
+    var options = this.options;
+    var sax2 = new XMLReader();
+    var domBuilder = options.domBuilder || new DOMHandler();
+    var errorHandler = options.errorHandler;
+    var locator = options.locator;
+    var defaultNSMap = options.xmlns || {};
+    var isHTML = /\/x?html?$/.test(mimeType);
+    var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
+    if (locator) {
+      domBuilder.setDocumentLocator(locator);
+    }
+    sax2.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
+    sax2.domBuilder = options.domBuilder || domBuilder;
+    if (isHTML) {
+      defaultNSMap[""] = NAMESPACE.HTML;
+    }
+    defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
+    var normalize = options.normalizeLineEndings || normalizeLineEndings;
+    if (source && typeof source === "string") {
+      sax2.parse(
+        normalize(source),
+        defaultNSMap,
+        entityMap
+      );
+    } else {
+      sax2.errorHandler.error("invalid doc source");
+    }
+    return domBuilder.doc;
+  };
+  function buildErrorHandler(errorImpl, domBuilder, locator) {
+    if (!errorImpl) {
+      if (domBuilder instanceof DOMHandler) {
+        return domBuilder;
+      }
+      errorImpl = domBuilder;
+    }
+    var errorHandler = {};
+    var isCallback = errorImpl instanceof Function;
+    locator = locator || {};
+    function build(key) {
+      var fn = errorImpl[key];
+      if (!fn && isCallback) {
+        fn = errorImpl.length == 2 ? function(msg) {
+          errorImpl(key, msg);
+        } : errorImpl;
+      }
+      errorHandler[key] = fn && function(msg) {
+        fn("[xmldom " + key + "]	" + msg + _locator(locator));
+      } || function() {
+      };
+    }
+    build("warning");
+    build("error");
+    build("fatalError");
+    return errorHandler;
+  }
+  function DOMHandler() {
+    this.cdata = false;
+  }
+  function position(locator, node) {
+    node.lineNumber = locator.lineNumber;
+    node.columnNumber = locator.columnNumber;
+  }
+  DOMHandler.prototype = {
+    startDocument: function() {
+      this.doc = new DOMImplementation().createDocument(null, null, null);
+      if (this.locator) {
+        this.doc.documentURI = this.locator.systemId;
+      }
+    },
+    startElement: function(namespaceURI, localName, qName, attrs) {
+      var doc = this.doc;
+      var el = doc.createElementNS(namespaceURI, qName || localName);
+      var len = attrs.length;
+      appendElement(this, el);
+      this.currentElement = el;
+      this.locator && position(this.locator, el);
+      for (var i = 0; i < len; i++) {
+        var namespaceURI = attrs.getURI(i);
+        var value = attrs.getValue(i);
+        var qName = attrs.getQName(i);
+        var attr = doc.createAttributeNS(namespaceURI, qName);
+        this.locator && position(attrs.getLocator(i), attr);
+        attr.value = attr.nodeValue = value;
+        el.setAttributeNode(attr);
+      }
+    },
+    endElement: function(namespaceURI, localName, qName) {
+      var current = this.currentElement;
+      current.tagName;
+      this.currentElement = current.parentNode;
+    },
+    startPrefixMapping: function(prefix, uri) {
+    },
+    endPrefixMapping: function(prefix) {
+    },
+    processingInstruction: function(target, data) {
+      var ins = this.doc.createProcessingInstruction(target, data);
+      this.locator && position(this.locator, ins);
+      appendElement(this, ins);
+    },
+    ignorableWhitespace: function(ch, start, length) {
+    },
+    characters: function(chars, start, length) {
+      chars = _toString.apply(this, arguments);
+      if (chars) {
+        if (this.cdata) {
+          var charNode = this.doc.createCDATASection(chars);
+        } else {
+          var charNode = this.doc.createTextNode(chars);
+        }
+        if (this.currentElement) {
+          this.currentElement.appendChild(charNode);
+        } else if (/^\s*$/.test(chars)) {
+          this.doc.appendChild(charNode);
+        }
+        this.locator && position(this.locator, charNode);
+      }
+    },
+    skippedEntity: function(name) {
+    },
+    endDocument: function() {
+      this.doc.normalize();
+    },
+    setDocumentLocator: function(locator) {
+      if (this.locator = locator) {
+        locator.lineNumber = 0;
+      }
+    },
+    //LexicalHandler
+    comment: function(chars, start, length) {
+      chars = _toString.apply(this, arguments);
+      var comm = this.doc.createComment(chars);
+      this.locator && position(this.locator, comm);
+      appendElement(this, comm);
+    },
+    startCDATA: function() {
+      this.cdata = true;
+    },
+    endCDATA: function() {
+      this.cdata = false;
+    },
+    startDTD: function(name, publicId, systemId) {
+      var impl = this.doc.implementation;
+      if (impl && impl.createDocumentType) {
+        var dt = impl.createDocumentType(name, publicId, systemId);
+        this.locator && position(this.locator, dt);
+        appendElement(this, dt);
+        this.doc.doctype = dt;
+      }
+    },
+    /**
+     * @see org.xml.sax.ErrorHandler
+     * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+     */
+    warning: function(error) {
+      console.warn("[xmldom warning]	" + error, _locator(this.locator));
+    },
+    error: function(error) {
+      console.error("[xmldom error]	" + error, _locator(this.locator));
+    },
+    fatalError: function(error) {
+      throw new ParseError(error, this.locator);
+    }
+  };
+  function _locator(l) {
+    if (l) {
+      return "\n@" + (l.systemId || "") + "#[line:" + l.lineNumber + ",col:" + l.columnNumber + "]";
+    }
+  }
+  function _toString(chars, start, length) {
+    if (typeof chars == "string") {
+      return chars.substr(start, length);
+    } else {
+      if (chars.length >= start + length || start) {
+        return new java.lang.String(chars, start, length) + "";
+      }
+      return chars;
+    }
+  }
+  "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(key) {
+    DOMHandler.prototype[key] = function() {
+      return null;
+    };
+  });
+  function appendElement(hander, node) {
+    if (!hander.currentElement) {
+      hander.doc.appendChild(node);
+    } else {
+      hander.currentElement.appendChild(node);
+    }
+  }
+  domParser.__DOMHandler = DOMHandler;
+  domParser.normalizeLineEndings = normalizeLineEndings;
+  domParser.DOMParser = DOMParser;
+  return domParser;
+}
+export {
+  requireDomParser as __require
+};

package/dist/treeshaking/_virtual/@xmldom/xmldom/lib/dom-parser.js2.mjs

@@ -0,0 +1,4 @@
+var domParser = {};
+export {
+  domParser as __exports
+};