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

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

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

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

@@ -0,0 +1,5 @@
+import { __require as requireLib } from "./index.js2.mjs";
+var libExports = requireLib();
+export {
+  libExports as l
+};

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

@@ -0,0 +1,16 @@
+import { __exports as lib } from "./index.js3.mjs";
+import { __require as requireDom } from "./dom.js.mjs";
+import { __require as requireDomParser } from "./dom-parser.js.mjs";
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  var dom = requireDom();
+  lib.DOMImplementation = dom.DOMImplementation;
+  lib.XMLSerializer = dom.XMLSerializer;
+  lib.DOMParser = requireDomParser().DOMParser;
+  return lib;
+}
+export {
+  requireLib as __require
+};

package/dist/treeshaking/_virtual/@xmldom/xmldom/lib/index.js3.mjs

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

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

@@ -0,0 +1,594 @@
+import { __exports as sax } from "./sax.js2.mjs";
+import { __require as requireConventions } from "./conventions.js.mjs";
+var hasRequiredSax;
+function requireSax() {
+  if (hasRequiredSax) return sax;
+  hasRequiredSax = 1;
+  var NAMESPACE = requireConventions().NAMESPACE;
+  var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
+  var nameChar = new RegExp("[\\-\\.0-9" + nameStartChar.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
+  var tagNamePattern = new RegExp("^" + nameStartChar.source + nameChar.source + "*(?::" + nameStartChar.source + nameChar.source + "*)?$");
+  var S_TAG = 0;
+  var S_ATTR = 1;
+  var S_ATTR_SPACE = 2;
+  var S_EQ = 3;
+  var S_ATTR_NOQUOT_VALUE = 4;
+  var S_ATTR_END = 5;
+  var S_TAG_SPACE = 6;
+  var S_TAG_CLOSE = 7;
+  function ParseError(message, locator) {
+    this.message = message;
+    this.locator = locator;
+    if (Error.captureStackTrace) Error.captureStackTrace(this, ParseError);
+  }
+  ParseError.prototype = new Error();
+  ParseError.prototype.name = ParseError.name;
+  function XMLReader() {
+  }
+  XMLReader.prototype = {
+    parse: function(source, defaultNSMap, entityMap) {
+      var domBuilder = this.domBuilder;
+      domBuilder.startDocument();
+      _copy(defaultNSMap, defaultNSMap = {});
+      parse(
+        source,
+        defaultNSMap,
+        entityMap,
+        domBuilder,
+        this.errorHandler
+      );
+      domBuilder.endDocument();
+    }
+  };
+  function parse(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {
+    function fixedFromCharCode(code) {
+      if (code > 65535) {
+        code -= 65536;
+        var surrogate1 = 55296 + (code >> 10), surrogate2 = 56320 + (code & 1023);
+        return String.fromCharCode(surrogate1, surrogate2);
+      } else {
+        return String.fromCharCode(code);
+      }
+    }
+    function entityReplacer(a2) {
+      var k = a2.slice(1, -1);
+      if (Object.hasOwnProperty.call(entityMap, k)) {
+        return entityMap[k];
+      } else if (k.charAt(0) === "#") {
+        return fixedFromCharCode(parseInt(k.substr(1).replace("x", "0x")));
+      } else {
+        errorHandler.error("entity not found:" + a2);
+        return a2;
+      }
+    }
+    function appendText(end2) {
+      if (end2 > start) {
+        var xt = source.substring(start, end2).replace(/&#?\w+;/g, entityReplacer);
+        locator && position(start);
+        domBuilder.characters(xt, 0, end2 - start);
+        start = end2;
+      }
+    }
+    function position(p, m) {
+      while (p >= lineEnd && (m = linePattern.exec(source))) {
+        lineStart = m.index;
+        lineEnd = lineStart + m[0].length;
+        locator.lineNumber++;
+      }
+      locator.columnNumber = p - lineStart + 1;
+    }
+    var lineStart = 0;
+    var lineEnd = 0;
+    var linePattern = /.*(?:\r\n?|\n)|.*$/g;
+    var locator = domBuilder.locator;
+    var parseStack = [{ currentNSMap: defaultNSMapCopy }];
+    var closeMap = {};
+    var start = 0;
+    while (true) {
+      try {
+        var tagStart = source.indexOf("<", start);
+        if (tagStart < 0) {
+          if (!source.substr(start).match(/^\s*$/)) {
+            var doc = domBuilder.doc;
+            var text = doc.createTextNode(source.substr(start));
+            doc.appendChild(text);
+            domBuilder.currentElement = text;
+          }
+          return;
+        }
+        if (tagStart > start) {
+          appendText(tagStart);
+        }
+        switch (source.charAt(tagStart + 1)) {
+          case "/":
+            var end = source.indexOf(">", tagStart + 3);
+            var tagName = source.substring(tagStart + 2, end).replace(/[ \t\n\r]+$/g, "");
+            var config = parseStack.pop();
+            if (end < 0) {
+              tagName = source.substring(tagStart + 2).replace(/[\s<].*/, "");
+              errorHandler.error("end tag name: " + tagName + " is not complete:" + config.tagName);
+              end = tagStart + 1 + tagName.length;
+            } else if (tagName.match(/\s</)) {
+              tagName = tagName.replace(/[\s<].*/, "");
+              errorHandler.error("end tag name: " + tagName + " maybe not complete");
+              end = tagStart + 1 + tagName.length;
+            }
+            var localNSMap = config.localNSMap;
+            var endMatch = config.tagName == tagName;
+            var endIgnoreCaseMach = endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase();
+            if (endIgnoreCaseMach) {
+              domBuilder.endElement(config.uri, config.localName, tagName);
+              if (localNSMap) {
+                for (var prefix in localNSMap) {
+                  if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
+                    domBuilder.endPrefixMapping(prefix);
+                  }
+                }
+              }
+              if (!endMatch) {
+                errorHandler.fatalError("end tag name: " + tagName + " is not match the current start tagName:" + config.tagName);
+              }
+            } else {
+              parseStack.push(config);
+            }
+            end++;
+            break;
+          // end elment
+          case "?":
+            locator && position(tagStart);
+            end = parseInstruction(source, tagStart, domBuilder);
+            break;
+          case "!":
+            locator && position(tagStart);
+            end = parseDCC(source, tagStart, domBuilder, errorHandler);
+            break;
+          default:
+            locator && position(tagStart);
+            var el = new ElementAttributes();
+            var currentNSMap = parseStack[parseStack.length - 1].currentNSMap;
+            var end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler);
+            var len = el.length;
+            if (!el.closed && fixSelfClosed(source, end, el.tagName, closeMap)) {
+              el.closed = true;
+              if (!entityMap.nbsp) {
+                errorHandler.warning("unclosed xml attribute");
+              }
+            }
+            if (locator && len) {
+              var locator2 = copyLocator(locator, {});
+              for (var i = 0; i < len; i++) {
+                var a = el[i];
+                position(a.offset);
+                a.locator = copyLocator(locator, {});
+              }
+              domBuilder.locator = locator2;
+              if (appendElement(el, domBuilder, currentNSMap)) {
+                parseStack.push(el);
+              }
+              domBuilder.locator = locator;
+            } else {
+              if (appendElement(el, domBuilder, currentNSMap)) {
+                parseStack.push(el);
+              }
+            }
+            if (NAMESPACE.isHTML(el.uri) && !el.closed) {
+              end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);
+            } else {
+              end++;
+            }
+        }
+      } catch (e) {
+        if (e instanceof ParseError) {
+          throw e;
+        }
+        errorHandler.error("element parse error: " + e);
+        end = -1;
+      }
+      if (end > start) {
+        start = end;
+      } else {
+        appendText(Math.max(tagStart, start) + 1);
+      }
+    }
+  }
+  function copyLocator(f, t) {
+    t.lineNumber = f.lineNumber;
+    t.columnNumber = f.columnNumber;
+    return t;
+  }
+  function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
+    function addAttribute(qname, value2, startIndex) {
+      if (el.attributeNames.hasOwnProperty(qname)) {
+        errorHandler.fatalError("Attribute " + qname + " redefined");
+      }
+      el.addValue(
+        qname,
+        // @see https://www.w3.org/TR/xml/#AVNormalize
+        // since the xmldom sax parser does not "interpret" DTD the following is not implemented:
+        // - recursive replacement of (DTD) entity references
+        // - trimming and collapsing multiple spaces into a single one for attributes that are not of type CDATA
+        value2.replace(/[\t\n\r]/g, " ").replace(/&#?\w+;/g, entityReplacer),
+        startIndex
+      );
+    }
+    var attrName;
+    var value;
+    var p = ++start;
+    var s = S_TAG;
+    while (true) {
+      var c = source.charAt(p);
+      switch (c) {
+        case "=":
+          if (s === S_ATTR) {
+            attrName = source.slice(start, p);
+            s = S_EQ;
+          } else if (s === S_ATTR_SPACE) {
+            s = S_EQ;
+          } else {
+            throw new Error("attribute equal must after attrName");
+          }
+          break;
+        case "'":
+        case '"':
+          if (s === S_EQ || s === S_ATTR) {
+            if (s === S_ATTR) {
+              errorHandler.warning('attribute value must after "="');
+              attrName = source.slice(start, p);
+            }
+            start = p + 1;
+            p = source.indexOf(c, start);
+            if (p > 0) {
+              value = source.slice(start, p);
+              addAttribute(attrName, value, start - 1);
+              s = S_ATTR_END;
+            } else {
+              throw new Error("attribute value no end '" + c + "' match");
+            }
+          } else if (s == S_ATTR_NOQUOT_VALUE) {
+            value = source.slice(start, p);
+            addAttribute(attrName, value, start);
+            errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c + ")!!");
+            start = p + 1;
+            s = S_ATTR_END;
+          } else {
+            throw new Error('attribute value must after "="');
+          }
+          break;
+        case "/":
+          switch (s) {
+            case S_TAG:
+              el.setTagName(source.slice(start, p));
+            case S_ATTR_END:
+            case S_TAG_SPACE:
+            case S_TAG_CLOSE:
+              s = S_TAG_CLOSE;
+              el.closed = true;
+            case S_ATTR_NOQUOT_VALUE:
+            case S_ATTR:
+              break;
+            case S_ATTR_SPACE:
+              el.closed = true;
+              break;
+            //case S_EQ:
+            default:
+              throw new Error("attribute invalid close char('/')");
+          }
+          break;
+        case "":
+          errorHandler.error("unexpected end of input");
+          if (s == S_TAG) {
+            el.setTagName(source.slice(start, p));
+          }
+          return p;
+        case ">":
+          switch (s) {
+            case S_TAG:
+              el.setTagName(source.slice(start, p));
+            case S_ATTR_END:
+            case S_TAG_SPACE:
+            case S_TAG_CLOSE:
+              break;
+            //normal
+            case S_ATTR_NOQUOT_VALUE:
+            //Compatible state
+            case S_ATTR:
+              value = source.slice(start, p);
+              if (value.slice(-1) === "/") {
+                el.closed = true;
+                value = value.slice(0, -1);
+              }
+            case S_ATTR_SPACE:
+              if (s === S_ATTR_SPACE) {
+                value = attrName;
+              }
+              if (s == S_ATTR_NOQUOT_VALUE) {
+                errorHandler.warning('attribute "' + value + '" missed quot(")!');
+                addAttribute(attrName, value, start);
+              } else {
+                if (!NAMESPACE.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) {
+                  errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
+                }
+                addAttribute(value, value, start);
+              }
+              break;
+            case S_EQ:
+              throw new Error("attribute value missed!!");
+          }
+          return p;
+        /*xml space '\x20' | #x9 | #xD | #xA; */
+        case "€":
+          c = " ";
+        default:
+          if (c <= " ") {
+            switch (s) {
+              case S_TAG:
+                el.setTagName(source.slice(start, p));
+                s = S_TAG_SPACE;
+                break;
+              case S_ATTR:
+                attrName = source.slice(start, p);
+                s = S_ATTR_SPACE;
+                break;
+              case S_ATTR_NOQUOT_VALUE:
+                var value = source.slice(start, p);
+                errorHandler.warning('attribute "' + value + '" missed quot(")!!');
+                addAttribute(attrName, value, start);
+              case S_ATTR_END:
+                s = S_TAG_SPACE;
+                break;
+            }
+          } else {
+            switch (s) {
+              //case S_TAG:void();break;
+              //case S_ATTR:void();break;
+              //case S_ATTR_NOQUOT_VALUE:void();break;
+              case S_ATTR_SPACE:
+                el.tagName;
+                if (!NAMESPACE.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
+                  errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');
+                }
+                addAttribute(attrName, attrName, start);
+                start = p;
+                s = S_ATTR;
+                break;
+              case S_ATTR_END:
+                errorHandler.warning('attribute space is required"' + attrName + '"!!');
+              case S_TAG_SPACE:
+                s = S_ATTR;
+                start = p;
+                break;
+              case S_EQ:
+                s = S_ATTR_NOQUOT_VALUE;
+                start = p;
+                break;
+              case S_TAG_CLOSE:
+                throw new Error("elements closed character '/' and '>' must be connected to");
+            }
+          }
+      }
+      p++;
+    }
+  }
+  function appendElement(el, domBuilder, currentNSMap) {
+    var tagName = el.tagName;
+    var localNSMap = null;
+    var i = el.length;
+    while (i--) {
+      var a = el[i];
+      var qName = a.qName;
+      var value = a.value;
+      var nsp = qName.indexOf(":");
+      if (nsp > 0) {
+        var prefix = a.prefix = qName.slice(0, nsp);
+        var localName = qName.slice(nsp + 1);
+        var nsPrefix = prefix === "xmlns" && localName;
+      } else {
+        localName = qName;
+        prefix = null;
+        nsPrefix = qName === "xmlns" && "";
+      }
+      a.localName = localName;
+      if (nsPrefix !== false) {
+        if (localNSMap == null) {
+          localNSMap = {};
+          _copy(currentNSMap, currentNSMap = {});
+        }
+        currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
+        a.uri = NAMESPACE.XMLNS;
+        domBuilder.startPrefixMapping(nsPrefix, value);
+      }
+    }
+    var i = el.length;
+    while (i--) {
+      a = el[i];
+      var prefix = a.prefix;
+      if (prefix) {
+        if (prefix === "xml") {
+          a.uri = NAMESPACE.XML;
+        }
+        if (prefix !== "xmlns") {
+          a.uri = currentNSMap[prefix || ""];
+        }
+      }
+    }
+    var nsp = tagName.indexOf(":");
+    if (nsp > 0) {
+      prefix = el.prefix = tagName.slice(0, nsp);
+      localName = el.localName = tagName.slice(nsp + 1);
+    } else {
+      prefix = null;
+      localName = el.localName = tagName;
+    }
+    var ns = el.uri = currentNSMap[prefix || ""];
+    domBuilder.startElement(ns, localName, tagName, el);
+    if (el.closed) {
+      domBuilder.endElement(ns, localName, tagName);
+      if (localNSMap) {
+        for (prefix in localNSMap) {
+          if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
+            domBuilder.endPrefixMapping(prefix);
+          }
+        }
+      }
+    } else {
+      el.currentNSMap = currentNSMap;
+      el.localNSMap = localNSMap;
+      return true;
+    }
+  }
+  function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
+    if (/^(?:script|textarea)$/i.test(tagName)) {
+      var elEndStart = source.indexOf("</" + tagName + ">", elStartEnd);
+      var text = source.substring(elStartEnd + 1, elEndStart);
+      if (/[&<]/.test(text)) {
+        if (/^script$/i.test(tagName)) {
+          domBuilder.characters(text, 0, text.length);
+          return elEndStart;
+        }
+        text = text.replace(/&#?\w+;/g, entityReplacer);
+        domBuilder.characters(text, 0, text.length);
+        return elEndStart;
+      }
+    }
+    return elStartEnd + 1;
+  }
+  function fixSelfClosed(source, elStartEnd, tagName, closeMap) {
+    var pos = closeMap[tagName];
+    if (pos == null) {
+      pos = source.lastIndexOf("</" + tagName + ">");
+      if (pos < elStartEnd) {
+        pos = source.lastIndexOf("</" + tagName);
+      }
+      closeMap[tagName] = pos;
+    }
+    return pos < elStartEnd;
+  }
+  function _copy(source, target) {
+    for (var n in source) {
+      if (Object.prototype.hasOwnProperty.call(source, n)) {
+        target[n] = source[n];
+      }
+    }
+  }
+  function parseDCC(source, start, domBuilder, errorHandler) {
+    var next = source.charAt(start + 2);
+    switch (next) {
+      case "-":
+        if (source.charAt(start + 3) === "-") {
+          var end = source.indexOf("-->", start + 4);
+          if (end > start) {
+            domBuilder.comment(source, start + 4, end - start - 4);
+            return end + 3;
+          } else {
+            errorHandler.error("Unclosed comment");
+            return -1;
+          }
+        } else {
+          return -1;
+        }
+      default:
+        if (source.substr(start + 3, 6) == "CDATA[") {
+          var end = source.indexOf("]]>", start + 9);
+          domBuilder.startCDATA();
+          domBuilder.characters(source, start + 9, end - start - 9);
+          domBuilder.endCDATA();
+          return end + 3;
+        }
+        var matchs = split(source, start);
+        var len = matchs.length;
+        if (len > 1 && /!doctype/i.test(matchs[0][0])) {
+          var name = matchs[1][0];
+          var pubid = false;
+          var sysid = false;
+          if (len > 3) {
+            if (/^public$/i.test(matchs[2][0])) {
+              pubid = matchs[3][0];
+              sysid = len > 4 && matchs[4][0];
+            } else if (/^system$/i.test(matchs[2][0])) {
+              sysid = matchs[3][0];
+            }
+          }
+          var lastMatch = matchs[len - 1];
+          domBuilder.startDTD(name, pubid, sysid);
+          domBuilder.endDTD();
+          return lastMatch.index + lastMatch[0].length;
+        }
+    }
+    return -1;
+  }
+  function parseInstruction(source, start, domBuilder) {
+    var end = source.indexOf("?>", start);
+    if (end) {
+      var match = source.substring(start, end).match(/^<\?(\S*)\s*([\s\S]*?)$/);
+      if (match) {
+        match[0].length;
+        domBuilder.processingInstruction(match[1], match[2]);
+        return end + 2;
+      } else {
+        return -1;
+      }
+    }
+    return -1;
+  }
+  function ElementAttributes() {
+    this.attributeNames = {};
+  }
+  ElementAttributes.prototype = {
+    setTagName: function(tagName) {
+      if (!tagNamePattern.test(tagName)) {
+        throw new Error("invalid tagName:" + tagName);
+      }
+      this.tagName = tagName;
+    },
+    addValue: function(qName, value, offset) {
+      if (!tagNamePattern.test(qName)) {
+        throw new Error("invalid attribute:" + qName);
+      }
+      this.attributeNames[qName] = this.length;
+      this[this.length++] = { qName, value, offset };
+    },
+    length: 0,
+    getLocalName: function(i) {
+      return this[i].localName;
+    },
+    getLocator: function(i) {
+      return this[i].locator;
+    },
+    getQName: function(i) {
+      return this[i].qName;
+    },
+    getURI: function(i) {
+      return this[i].uri;
+    },
+    getValue: function(i) {
+      return this[i].value;
+    }
+    //	,getIndex:function(uri, localName)){
+    //		if(localName){
+    //
+    //		}else{
+    //			var qName = uri
+    //		}
+    //	},
+    //	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
+    //	getType:function(uri,localName){}
+    //	getType:function(i){},
+  };
+  function split(source, start) {
+    var match;
+    var buf = [];
+    var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+    reg.lastIndex = start;
+    reg.exec(source);
+    while (match = reg.exec(source)) {
+      buf.push(match);
+      if (match[1]) return buf;
+    }
+  }
+  sax.XMLReader = XMLReader;
+  sax.ParseError = ParseError;
+  return sax;
+}
+export {
+  requireSax as __require
+};

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

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

package/dist/treeshaking/_virtual/___vite-browser-external.mjs

@@ -0,0 +1,6 @@
+import * as __viteBrowserExternal from "./__vite-browser-external.mjs";
+import { getAugmentedNamespace } from "./_commonjsHelpers.mjs";
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal);
+export {
+  require$$0 as default
+};

package/dist/treeshaking/_virtual/__vite-browser-external.mjs

@@ -0,0 +1,4 @@
+const __viteBrowserExternal = {};
+export {
+  __viteBrowserExternal as default
+};

package/dist/treeshaking/_virtual/_commonjsHelpers.mjs

@@ -0,0 +1,33 @@
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      if (this instanceof a2) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+export {
+  commonjsGlobal,
+  getAugmentedNamespace,
+  getDefaultExportFromCjs
+};

package/dist/treeshaking/_virtual/_plugin-vue_export-helper.mjs

@@ -0,0 +1,10 @@
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+export {
+  _export_sfc as default
+};