@opendesign-plus/components 0.0.1-rc.10 → 0.0.1-rc.101

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

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+import { require_dom } from "./dom.js.mjs";
+import { require_dom_parser } from "./dom-parser.js.mjs";
+// ../../node_modules/.pnpm/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var dom = require_dom();
+	exports.DOMImplementation = dom.DOMImplementation;
+	exports.XMLSerializer = dom.XMLSerializer;
+	exports.DOMParser = require_dom_parser().DOMParser;
+}));
+export default require_lib();
+export { require_lib };

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

@@ -0,0 +1,489 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+import { require_conventions } from "./conventions.js.mjs";
+// ../../node_modules/.pnpm/@xmldom+xmldom@0.8.12/node_modules/@xmldom/xmldom/lib/sax.js
+var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var NAMESPACE = require_conventions().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;
+	/**
+	* Creates an error that will not be caught by XMLReader aka the SAX parser.
+	*
+	* @param {string} message
+	* @param {any?} locator Optional, can provide details about the location in the source
+	* @constructor
+	*/
+	function ParseError(message, locator) {
+		this.message = message;
+		this.locator = locator;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, ParseError);
+	}
+	ParseError.prototype = /* @__PURE__ */ 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(a) {
+			var k = a.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:" + a);
+				return a;
+			}
+		}
+		function appendText(end) {
+			if (end > start) {
+				var xt = source.substring(start, end).replace(/&#?\w+;/g, entityReplacer);
+				locator && position(start);
+				domBuilder.characters(xt, 0, end - start);
+				start = end;
+			}
+		}
+		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;
+						if (endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase()) {
+							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;
+					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;
+	}
+	/**
+	* @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);
+	* @return end of the elementStartPart(end of elementEndPart for selfClosed el)
+	*/
+	function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
+		/**
+		* @param {string} qname
+		* @param {string} value
+		* @param {number} startIndex
+		*/
+		function addAttribute(qname, value, startIndex) {
+			if (el.attributeNames.hasOwnProperty(qname)) errorHandler.fatalError("Attribute " + qname + " redefined");
+			el.addValue(qname, value.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;
+						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;
+						case S_ATTR_NOQUOT_VALUE:
+						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;
+				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;
+				}
+				else switch (s) {
+					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++;
+		}
+	}
+	/**
+	* @return true if has new namespace define
+	*/
+	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) {
+		switch (source.charAt(start + 2)) {
+			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;
+		}
+	};
+	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;
+		}
+	}
+	exports.XMLReader = XMLReader;
+	exports.ParseError = ParseError;
+}));
+export default require_sax();
+export { require_sax };

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

@@ -0,0 +1,7 @@
+import { __commonJSMin } from "./_rolldown/runtime.mjs";
+// __vite-browser-external
+var require___vite_browser_external = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+}));
+export default require___vite_browser_external();
+export { require___vite_browser_external };

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

@@ -0,0 +1,7 @@
+// \0plugin-vue:export-helper
+var _plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+export { _plugin_vue_export_helper_default as default };

package/dist/treeshaking/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,27 @@
+// \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+export { __commonJSMin, __require, __toESM };