@hina114514/chaite 1.9.3

package/dist/chunks/cors/index.mjs-DGt6p49t.mjs

@@ -0,0 +1,311 @@
+import { t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+
+//#region node_modules/.pnpm/vary@1.1.2/node_modules/vary/index.js
+/*!
+* vary
+* Copyright(c) 2014-2017 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_vary = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/vary@1.1.2/node_modules/vary/index.js": ((exports, module) => {
+	/**
+	* Module exports.
+	*/
+	module.exports = vary;
+	module.exports.append = append;
+	/**
+	* RegExp to match field-name in RFC 7230 sec 3.2
+	*
+	* field-name    = token
+	* token         = 1*tchar
+	* tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+	*               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+	*               / DIGIT / ALPHA
+	*               ; any VCHAR, except delimiters
+	*/
+	var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+	/**
+	* Append a field to a vary header.
+	*
+	* @param {String} header
+	* @param {String|Array} field
+	* @return {String}
+	* @public
+	*/
+	function append(header, field) {
+		if (typeof header !== "string") throw new TypeError("header argument is required");
+		if (!field) throw new TypeError("field argument is required");
+		var fields = !Array.isArray(field) ? parse(String(field)) : field;
+		for (var j = 0; j < fields.length; j++) if (!FIELD_NAME_REGEXP.test(fields[j])) throw new TypeError("field argument contains an invalid header name");
+		if (header === "*") return header;
+		var val = header;
+		var vals = parse(header.toLowerCase());
+		if (fields.indexOf("*") !== -1 || vals.indexOf("*") !== -1) return "*";
+		for (var i = 0; i < fields.length; i++) {
+			var fld = fields[i].toLowerCase();
+			if (vals.indexOf(fld) === -1) {
+				vals.push(fld);
+				val = val ? val + ", " + fields[i] : fields[i];
+			}
+		}
+		return val;
+	}
+	/**
+	* Parse a vary header into an array.
+	*
+	* @param {String} header
+	* @return {Array}
+	* @private
+	*/
+	function parse(header) {
+		var end = 0;
+		var list = [];
+		var start = 0;
+		for (var i = 0, len = header.length; i < len; i++) switch (header.charCodeAt(i)) {
+			case 32:
+				if (start === end) start = end = i + 1;
+				break;
+			case 44:
+				list.push(header.substring(start, end));
+				start = end = i + 1;
+				break;
+			default:
+				end = i + 1;
+				break;
+		}
+		list.push(header.substring(start, end));
+		return list;
+	}
+	/**
+	* Mark that a request is varied on a header field.
+	*
+	* @param {Object} res
+	* @param {String|Array} field
+	* @public
+	*/
+	function vary(res, field) {
+		if (!res || !res.getHeader || !res.setHeader) throw new TypeError("res argument is required");
+		var val = res.getHeader("Vary") || "";
+		if (val = append(Array.isArray(val) ? val.join(", ") : String(val), field)) res.setHeader("Vary", val);
+	}
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var require_object_assign = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js": ((exports, module) => {
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+	function toObject(val) {
+		if (val === null || val === void 0) throw new TypeError("Object.assign cannot be called with null or undefined");
+		return Object(val);
+	}
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) return false;
+			var test1 = /* @__PURE__ */ new String("abc");
+			test1[5] = "de";
+			if (Object.getOwnPropertyNames(test1)[0] === "5") return false;
+			var test2 = {};
+			for (var i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i;
+			if (Object.getOwnPropertyNames(test2).map(function(n) {
+				return test2[n];
+			}).join("") !== "0123456789") return false;
+			var test3 = {};
+			"abcdefghijklmnopqrst".split("").forEach(function(letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") return false;
+			return true;
+		} catch (err) {
+			return false;
+		}
+	}
+	module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+			for (var key in from) if (hasOwnProperty.call(from, key)) to[key] = from[key];
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) if (propIsEnumerable.call(from, symbols[i])) to[symbols[i]] = from[symbols[i]];
+			}
+		}
+		return to;
+	};
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/cors@2.8.5/node_modules/cors/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/cors@2.8.5/node_modules/cors/lib/index.js": ((exports, module) => {
+	(function() {
+		var assign = require_object_assign();
+		var vary$1 = require_vary();
+		var defaults = {
+			origin: "*",
+			methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+			preflightContinue: false,
+			optionsSuccessStatus: 204
+		};
+		function isString(s) {
+			return typeof s === "string" || s instanceof String;
+		}
+		function isOriginAllowed(origin, allowedOrigin) {
+			if (Array.isArray(allowedOrigin)) {
+				for (var i = 0; i < allowedOrigin.length; ++i) if (isOriginAllowed(origin, allowedOrigin[i])) return true;
+				return false;
+			} else if (isString(allowedOrigin)) return origin === allowedOrigin;
+			else if (allowedOrigin instanceof RegExp) return allowedOrigin.test(origin);
+			else return !!allowedOrigin;
+		}
+		function configureOrigin(options, req) {
+			var requestOrigin = req.headers.origin, headers = [], isAllowed;
+			if (!options.origin || options.origin === "*") headers.push([{
+				key: "Access-Control-Allow-Origin",
+				value: "*"
+			}]);
+			else if (isString(options.origin)) {
+				headers.push([{
+					key: "Access-Control-Allow-Origin",
+					value: options.origin
+				}]);
+				headers.push([{
+					key: "Vary",
+					value: "Origin"
+				}]);
+			} else {
+				isAllowed = isOriginAllowed(requestOrigin, options.origin);
+				headers.push([{
+					key: "Access-Control-Allow-Origin",
+					value: isAllowed ? requestOrigin : false
+				}]);
+				headers.push([{
+					key: "Vary",
+					value: "Origin"
+				}]);
+			}
+			return headers;
+		}
+		function configureMethods(options) {
+			var methods = options.methods;
+			if (methods.join) methods = options.methods.join(",");
+			return {
+				key: "Access-Control-Allow-Methods",
+				value: methods
+			};
+		}
+		function configureCredentials(options) {
+			if (options.credentials === true) return {
+				key: "Access-Control-Allow-Credentials",
+				value: "true"
+			};
+			return null;
+		}
+		function configureAllowedHeaders(options, req) {
+			var allowedHeaders = options.allowedHeaders || options.headers;
+			var headers = [];
+			if (!allowedHeaders) {
+				allowedHeaders = req.headers["access-control-request-headers"];
+				headers.push([{
+					key: "Vary",
+					value: "Access-Control-Request-Headers"
+				}]);
+			} else if (allowedHeaders.join) allowedHeaders = allowedHeaders.join(",");
+			if (allowedHeaders && allowedHeaders.length) headers.push([{
+				key: "Access-Control-Allow-Headers",
+				value: allowedHeaders
+			}]);
+			return headers;
+		}
+		function configureExposedHeaders(options) {
+			var headers = options.exposedHeaders;
+			if (!headers) return null;
+			else if (headers.join) headers = headers.join(",");
+			if (headers && headers.length) return {
+				key: "Access-Control-Expose-Headers",
+				value: headers
+			};
+			return null;
+		}
+		function configureMaxAge(options) {
+			var maxAge = (typeof options.maxAge === "number" || options.maxAge) && options.maxAge.toString();
+			if (maxAge && maxAge.length) return {
+				key: "Access-Control-Max-Age",
+				value: maxAge
+			};
+			return null;
+		}
+		function applyHeaders(headers, res) {
+			for (var i = 0, n = headers.length; i < n; i++) {
+				var header = headers[i];
+				if (header) {
+					if (Array.isArray(header)) applyHeaders(header, res);
+					else if (header.key === "Vary" && header.value) vary$1(res, header.value);
+					else if (header.value) res.setHeader(header.key, header.value);
+				}
+			}
+		}
+		function cors(options, req, res, next) {
+			var headers = [];
+			if ((req.method && req.method.toUpperCase && req.method.toUpperCase()) === "OPTIONS") {
+				headers.push(configureOrigin(options, req));
+				headers.push(configureCredentials(options, req));
+				headers.push(configureMethods(options, req));
+				headers.push(configureAllowedHeaders(options, req));
+				headers.push(configureMaxAge(options, req));
+				headers.push(configureExposedHeaders(options, req));
+				applyHeaders(headers, res);
+				if (options.preflightContinue) next();
+				else {
+					res.statusCode = options.optionsSuccessStatus;
+					res.setHeader("Content-Length", "0");
+					res.end();
+				}
+			} else {
+				headers.push(configureOrigin(options, req));
+				headers.push(configureCredentials(options, req));
+				headers.push(configureExposedHeaders(options, req));
+				applyHeaders(headers, res);
+				next();
+			}
+		}
+		function middlewareWrapper(o) {
+			var optionsCallback = null;
+			if (typeof o === "function") optionsCallback = o;
+			else optionsCallback = function(req, cb) {
+				cb(null, o);
+			};
+			return function corsMiddleware(req, res, next) {
+				optionsCallback(req, function(err, options) {
+					if (err) next(err);
+					else {
+						var corsOptions = assign({}, defaults, options);
+						var originCallback = null;
+						if (corsOptions.origin && typeof corsOptions.origin === "function") originCallback = corsOptions.origin;
+						else if (corsOptions.origin) originCallback = function(origin, cb) {
+							cb(null, corsOptions.origin);
+						};
+						if (originCallback) originCallback(req.headers.origin, function(err2, origin) {
+							if (err2 || !origin) next(err2);
+							else {
+								corsOptions.origin = origin;
+								cors(corsOptions, req, res, next);
+							}
+						});
+						else next();
+					}
+				});
+			};
+		}
+		module.exports = middlewareWrapper;
+	})();
+}) });
+
+//#endregion
+export { require_vary as n, require_lib as t };

package/dist/chunks/data-uri-to-buffer/index.mjs-CLj4bast.mjs

@@ -0,0 +1,44 @@
+import { n as __esm } from "../../rolldown-runtime-DVriDoez.mjs";
+
+//#region node_modules/.pnpm/data-uri-to-buffer@4.0.1/node_modules/data-uri-to-buffer/dist/index.js
+/**
+* Returns a `Buffer` instance from the given data URI `uri`.
+*
+* @param {String} uri Data URI to turn into a Buffer instance
+* @returns {Buffer} Buffer instance from Data URI
+* @api public
+*/
+function dataUriToBuffer(uri) {
+	if (!/^data:/i.test(uri)) throw new TypeError("`uri` does not appear to be a Data URI (must begin with \"data:\")");
+	uri = uri.replace(/\r?\n/g, "");
+	const firstComma = uri.indexOf(",");
+	if (firstComma === -1 || firstComma <= 4) throw new TypeError("malformed data: URI");
+	const meta = uri.substring(5, firstComma).split(";");
+	let charset = "";
+	let base64 = false;
+	const type = meta[0] || "text/plain";
+	let typeFull = type;
+	for (let i = 1; i < meta.length; i++) if (meta[i] === "base64") base64 = true;
+	else if (meta[i]) {
+		typeFull += `;${meta[i]}`;
+		if (meta[i].indexOf("charset=") === 0) charset = meta[i].substring(8);
+	}
+	if (!meta[0] && !charset.length) {
+		typeFull += ";charset=US-ASCII";
+		charset = "US-ASCII";
+	}
+	const encoding = base64 ? "base64" : "ascii";
+	const data = unescape(uri.substring(firstComma + 1));
+	const buffer = Buffer.from(data, encoding);
+	buffer.type = type;
+	buffer.typeFull = typeFull;
+	buffer.charset = charset;
+	return buffer;
+}
+var dist_default;
+var init_dist = __esm({ "node_modules/.pnpm/data-uri-to-buffer@4.0.1/node_modules/data-uri-to-buffer/dist/index.js": (() => {
+	dist_default = dataUriToBuffer;
+}) });
+
+//#endregion
+export { init_dist as n, dist_default as t };