@hina114514/chaite 1.9.3

package/dist/chunks/content-disposition/index.mjs-DqMQ6Fbz.mjs

@@ -0,0 +1,307 @@
+import { i as __require, t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+import { a as require_safe_buffer } from "../@google/genai/index.mjs-CJMm4uh0.mjs";
+
+//#region node_modules/.pnpm/content-disposition@0.5.4/node_modules/content-disposition/index.js
+/*!
+* content-disposition
+* Copyright(c) 2014-2017 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_content_disposition = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/content-disposition@0.5.4/node_modules/content-disposition/index.js": ((exports, module) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	module.exports = contentDisposition;
+	module.exports.parse = parse;
+	/**
+	* Module dependencies.
+	* @private
+	*/
+	var basename = __require("path").basename;
+	var Buffer = require_safe_buffer().Buffer;
+	/**
+	* RegExp to match non attr-char, *after* encodeURIComponent (i.e. not including "%")
+	* @private
+	*/
+	var ENCODE_URL_ATTR_CHAR_REGEXP = /[\x00-\x20"'()*,/:;<=>?@[\\\]{}\x7f]/g;
+	/**
+	* RegExp to match percent encoding escape.
+	* @private
+	*/
+	var HEX_ESCAPE_REGEXP = /%[0-9A-Fa-f]{2}/;
+	var HEX_ESCAPE_REPLACE_REGEXP = /%([0-9A-Fa-f]{2})/g;
+	/**
+	* RegExp to match non-latin1 characters.
+	* @private
+	*/
+	var NON_LATIN1_REGEXP = /[^\x20-\x7e\xa0-\xff]/g;
+	/**
+	* RegExp to match quoted-pair in RFC 2616
+	*
+	* quoted-pair = "\" CHAR
+	* CHAR        = <any US-ASCII character (octets 0 - 127)>
+	* @private
+	*/
+	var QESC_REGEXP = /\\([\u0000-\u007f])/g;
+	/**
+	* RegExp to match chars that must be quoted-pair in RFC 2616
+	* @private
+	*/
+	var QUOTE_REGEXP = /([\\"])/g;
+	/**
+	* RegExp for various RFC 2616 grammar
+	*
+	* parameter     = token "=" ( token | quoted-string )
+	* token         = 1*<any CHAR except CTLs or separators>
+	* separators    = "(" | ")" | "<" | ">" | "@"
+	*               | "," | ";" | ":" | "\" | <">
+	*               | "/" | "[" | "]" | "?" | "="
+	*               | "{" | "}" | SP | HT
+	* quoted-string = ( <"> *(qdtext | quoted-pair ) <"> )
+	* qdtext        = <any TEXT except <">>
+	* quoted-pair   = "\" CHAR
+	* CHAR          = <any US-ASCII character (octets 0 - 127)>
+	* TEXT          = <any OCTET except CTLs, but including LWS>
+	* LWS           = [CRLF] 1*( SP | HT )
+	* CRLF          = CR LF
+	* CR            = <US-ASCII CR, carriage return (13)>
+	* LF            = <US-ASCII LF, linefeed (10)>
+	* SP            = <US-ASCII SP, space (32)>
+	* HT            = <US-ASCII HT, horizontal-tab (9)>
+	* CTL           = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
+	* OCTET         = <any 8-bit sequence of data>
+	* @private
+	*/
+	var PARAM_REGEXP = /;[\x09\x20]*([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*=[\x09\x20]*("(?:[\x20!\x23-\x5b\x5d-\x7e\x80-\xff]|\\[\x20-\x7e])*"|[!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*/g;
+	var TEXT_REGEXP = /^[\x20-\x7e\x80-\xff]+$/;
+	var TOKEN_REGEXP = /^[!#$%&'*+.0-9A-Z^_`a-z|~-]+$/;
+	/**
+	* RegExp for various RFC 5987 grammar
+	*
+	* ext-value     = charset  "'" [ language ] "'" value-chars
+	* charset       = "UTF-8" / "ISO-8859-1" / mime-charset
+	* mime-charset  = 1*mime-charsetc
+	* mime-charsetc = ALPHA / DIGIT
+	*               / "!" / "#" / "$" / "%" / "&"
+	*               / "+" / "-" / "^" / "_" / "`"
+	*               / "{" / "}" / "~"
+	* language      = ( 2*3ALPHA [ extlang ] )
+	*               / 4ALPHA
+	*               / 5*8ALPHA
+	* extlang       = *3( "-" 3ALPHA )
+	* value-chars   = *( pct-encoded / attr-char )
+	* pct-encoded   = "%" HEXDIG HEXDIG
+	* attr-char     = ALPHA / DIGIT
+	*               / "!" / "#" / "$" / "&" / "+" / "-" / "."
+	*               / "^" / "_" / "`" / "|" / "~"
+	* @private
+	*/
+	var EXT_VALUE_REGEXP = /^([A-Za-z0-9!#$%&+\-^_`{}~]+)'(?:[A-Za-z]{2,3}(?:-[A-Za-z]{3}){0,3}|[A-Za-z]{4,8}|)'((?:%[0-9A-Fa-f]{2}|[A-Za-z0-9!#$&+.^_`|~-])+)$/;
+	/**
+	* RegExp for various RFC 6266 grammar
+	*
+	* disposition-type = "inline" | "attachment" | disp-ext-type
+	* disp-ext-type    = token
+	* disposition-parm = filename-parm | disp-ext-parm
+	* filename-parm    = "filename" "=" value
+	*                  | "filename*" "=" ext-value
+	* disp-ext-parm    = token "=" value
+	*                  | ext-token "=" ext-value
+	* ext-token        = <the characters in token, followed by "*">
+	* @private
+	*/
+	var DISPOSITION_TYPE_REGEXP = /^([!#$%&'*+.0-9A-Z^_`a-z|~-]+)[\x09\x20]*(?:$|;)/;
+	/**
+	* Create an attachment Content-Disposition header.
+	*
+	* @param {string} [filename]
+	* @param {object} [options]
+	* @param {string} [options.type=attachment]
+	* @param {string|boolean} [options.fallback=true]
+	* @return {string}
+	* @public
+	*/
+	function contentDisposition(filename, options) {
+		var opts = options || {};
+		return format(new ContentDisposition(opts.type || "attachment", createparams(filename, opts.fallback)));
+	}
+	/**
+	* Create parameters object from filename and fallback.
+	*
+	* @param {string} [filename]
+	* @param {string|boolean} [fallback=true]
+	* @return {object}
+	* @private
+	*/
+	function createparams(filename, fallback) {
+		if (filename === void 0) return;
+		var params = {};
+		if (typeof filename !== "string") throw new TypeError("filename must be a string");
+		if (fallback === void 0) fallback = true;
+		if (typeof fallback !== "string" && typeof fallback !== "boolean") throw new TypeError("fallback must be a string or boolean");
+		if (typeof fallback === "string" && NON_LATIN1_REGEXP.test(fallback)) throw new TypeError("fallback must be ISO-8859-1 string");
+		var name = basename(filename);
+		var isQuotedString = TEXT_REGEXP.test(name);
+		var fallbackName = typeof fallback !== "string" ? fallback && getlatin1(name) : basename(fallback);
+		var hasFallback = typeof fallbackName === "string" && fallbackName !== name;
+		if (hasFallback || !isQuotedString || HEX_ESCAPE_REGEXP.test(name)) params["filename*"] = name;
+		if (isQuotedString || hasFallback) params.filename = hasFallback ? fallbackName : name;
+		return params;
+	}
+	/**
+	* Format object to Content-Disposition header.
+	*
+	* @param {object} obj
+	* @param {string} obj.type
+	* @param {object} [obj.parameters]
+	* @return {string}
+	* @private
+	*/
+	function format(obj) {
+		var parameters = obj.parameters;
+		var type = obj.type;
+		if (!type || typeof type !== "string" || !TOKEN_REGEXP.test(type)) throw new TypeError("invalid type");
+		var string = String(type).toLowerCase();
+		if (parameters && typeof parameters === "object") {
+			var param;
+			var params = Object.keys(parameters).sort();
+			for (var i = 0; i < params.length; i++) {
+				param = params[i];
+				var val = param.substr(-1) === "*" ? ustring(parameters[param]) : qstring(parameters[param]);
+				string += "; " + param + "=" + val;
+			}
+		}
+		return string;
+	}
+	/**
+	* Decode a RFC 5987 field value (gracefully).
+	*
+	* @param {string} str
+	* @return {string}
+	* @private
+	*/
+	function decodefield(str) {
+		var match = EXT_VALUE_REGEXP.exec(str);
+		if (!match) throw new TypeError("invalid extended field value");
+		var charset = match[1].toLowerCase();
+		var encoded = match[2];
+		var value;
+		var binary = encoded.replace(HEX_ESCAPE_REPLACE_REGEXP, pdecode);
+		switch (charset) {
+			case "iso-8859-1":
+				value = getlatin1(binary);
+				break;
+			case "utf-8":
+				value = Buffer.from(binary, "binary").toString("utf8");
+				break;
+			default: throw new TypeError("unsupported charset in extended field");
+		}
+		return value;
+	}
+	/**
+	* Get ISO-8859-1 version of string.
+	*
+	* @param {string} val
+	* @return {string}
+	* @private
+	*/
+	function getlatin1(val) {
+		return String(val).replace(NON_LATIN1_REGEXP, "?");
+	}
+	/**
+	* Parse Content-Disposition header string.
+	*
+	* @param {string} string
+	* @return {object}
+	* @public
+	*/
+	function parse(string) {
+		if (!string || typeof string !== "string") throw new TypeError("argument string is required");
+		var match = DISPOSITION_TYPE_REGEXP.exec(string);
+		if (!match) throw new TypeError("invalid type format");
+		var index = match[0].length;
+		var type = match[1].toLowerCase();
+		var key;
+		var names = [];
+		var params = {};
+		var value;
+		index = PARAM_REGEXP.lastIndex = match[0].substr(-1) === ";" ? index - 1 : index;
+		while (match = PARAM_REGEXP.exec(string)) {
+			if (match.index !== index) throw new TypeError("invalid parameter format");
+			index += match[0].length;
+			key = match[1].toLowerCase();
+			value = match[2];
+			if (names.indexOf(key) !== -1) throw new TypeError("invalid duplicate parameter");
+			names.push(key);
+			if (key.indexOf("*") + 1 === key.length) {
+				key = key.slice(0, -1);
+				value = decodefield(value);
+				params[key] = value;
+				continue;
+			}
+			if (typeof params[key] === "string") continue;
+			if (value[0] === "\"") value = value.substr(1, value.length - 2).replace(QESC_REGEXP, "$1");
+			params[key] = value;
+		}
+		if (index !== -1 && index !== string.length) throw new TypeError("invalid parameter format");
+		return new ContentDisposition(type, params);
+	}
+	/**
+	* Percent decode a single character.
+	*
+	* @param {string} str
+	* @param {string} hex
+	* @return {string}
+	* @private
+	*/
+	function pdecode(str, hex) {
+		return String.fromCharCode(parseInt(hex, 16));
+	}
+	/**
+	* Percent encode a single character.
+	*
+	* @param {string} char
+	* @return {string}
+	* @private
+	*/
+	function pencode(char) {
+		return "%" + String(char).charCodeAt(0).toString(16).toUpperCase();
+	}
+	/**
+	* Quote a string for HTTP.
+	*
+	* @param {string} val
+	* @return {string}
+	* @private
+	*/
+	function qstring(val) {
+		return "\"" + String(val).replace(QUOTE_REGEXP, "\\$1") + "\"";
+	}
+	/**
+	* Encode a Unicode string for HTTP (RFC 5987).
+	*
+	* @param {string} val
+	* @return {string}
+	* @private
+	*/
+	function ustring(val) {
+		var str = String(val);
+		return "UTF-8''" + encodeURIComponent(str).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode);
+	}
+	/**
+	* Class for parsed Content-Disposition header for v8 optimization
+	*
+	* @public
+	* @param {string} type
+	* @param {object} parameters
+	* @constructor
+	*/
+	function ContentDisposition(type, parameters) {
+		this.type = type;
+		this.parameters = parameters;
+	}
+}) });
+
+//#endregion
+export { require_content_disposition as t };

package/dist/chunks/cookie/index.mjs-CTmQWCqd.mjs

@@ -0,0 +1,243 @@
+import { t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+
+//#region node_modules/.pnpm/cookie@0.7.1/node_modules/cookie/index.js
+/*!
+* cookie
+* Copyright(c) 2012-2014 Roman Shtylman
+* Copyright(c) 2015 Douglas Christopher Wilson
+* MIT Licensed
+*/
+var require_cookie = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/cookie@0.7.1/node_modules/cookie/index.js": ((exports) => {
+	/**
+	* Module exports.
+	* @public
+	*/
+	exports.parse = parse;
+	exports.serialize = serialize;
+	/**
+	* Module variables.
+	* @private
+	*/
+	var __toString = Object.prototype.toString;
+	/**
+	* RegExp to match cookie-name in RFC 6265 sec 4.1.1
+	* This refers out to the obsoleted definition of token in RFC 2616 sec 2.2
+	* which has been replaced by the token definition in RFC 7230 appendix B.
+	*
+	* cookie-name       = token
+	* token             = 1*tchar
+	* tchar             = "!" / "#" / "$" / "%" / "&" / "'" /
+	*                     "*" / "+" / "-" / "." / "^" / "_" /
+	*                     "`" / "|" / "~" / DIGIT / ALPHA
+	*/
+	var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+	/**
+	* RegExp to match cookie-value in RFC 6265 sec 4.1.1
+	*
+	* cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
+	* cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
+	*                     ; US-ASCII characters excluding CTLs,
+	*                     ; whitespace DQUOTE, comma, semicolon,
+	*                     ; and backslash
+	*/
+	var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/;
+	/**
+	* RegExp to match domain-value in RFC 6265 sec 4.1.1
+	*
+	* domain-value      = <subdomain>
+	*                     ; defined in [RFC1034], Section 3.5, as
+	*                     ; enhanced by [RFC1123], Section 2.1
+	* <subdomain>       = <label> | <subdomain> "." <label>
+	* <label>           = <let-dig> [ [ <ldh-str> ] <let-dig> ]
+	*                     Labels must be 63 characters or less.
+	*                     'let-dig' not 'letter' in the first char, per RFC1123
+	* <ldh-str>         = <let-dig-hyp> | <let-dig-hyp> <ldh-str>
+	* <let-dig-hyp>     = <let-dig> | "-"
+	* <let-dig>         = <letter> | <digit>
+	* <letter>          = any one of the 52 alphabetic characters A through Z in
+	*                     upper case and a through z in lower case
+	* <digit>           = any one of the ten digits 0 through 9
+	*
+	* Keep support for leading dot: https://github.com/jshttp/cookie/issues/173
+	*
+	* > (Note that a leading %x2E ("."), if present, is ignored even though that
+	* character is not permitted, but a trailing %x2E ("."), if present, will
+	* cause the user agent to ignore the attribute.)
+	*/
+	var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+	/**
+	* RegExp to match path-value in RFC 6265 sec 4.1.1
+	*
+	* path-value        = <any CHAR except CTLs or ";">
+	* CHAR              = %x01-7F
+	*                     ; defined in RFC 5234 appendix B.1
+	*/
+	var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
+	/**
+	* Parse a cookie header.
+	*
+	* Parse the given cookie header string into an object
+	* The object has the various cookies as keys(names) => values
+	*
+	* @param {string} str
+	* @param {object} [opt]
+	* @return {object}
+	* @public
+	*/
+	function parse(str, opt) {
+		if (typeof str !== "string") throw new TypeError("argument str must be a string");
+		var obj = {};
+		var len = str.length;
+		if (len < 2) return obj;
+		var dec = opt && opt.decode || decode;
+		var index = 0;
+		var eqIdx = 0;
+		var endIdx = 0;
+		do {
+			eqIdx = str.indexOf("=", index);
+			if (eqIdx === -1) break;
+			endIdx = str.indexOf(";", index);
+			if (endIdx === -1) endIdx = len;
+			else if (eqIdx > endIdx) {
+				index = str.lastIndexOf(";", eqIdx - 1) + 1;
+				continue;
+			}
+			var keyStartIdx = startIndex(str, index, eqIdx);
+			var keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
+			var key = str.slice(keyStartIdx, keyEndIdx);
+			if (!obj.hasOwnProperty(key)) {
+				var valStartIdx = startIndex(str, eqIdx + 1, endIdx);
+				var valEndIdx = endIndex(str, endIdx, valStartIdx);
+				if (str.charCodeAt(valStartIdx) === 34 && str.charCodeAt(valEndIdx - 1) === 34) {
+					valStartIdx++;
+					valEndIdx--;
+				}
+				obj[key] = tryDecode(str.slice(valStartIdx, valEndIdx), dec);
+			}
+			index = endIdx + 1;
+		} while (index < len);
+		return obj;
+	}
+	function startIndex(str, index, max) {
+		do {
+			var code = str.charCodeAt(index);
+			if (code !== 32 && code !== 9) return index;
+		} while (++index < max);
+		return max;
+	}
+	function endIndex(str, index, min) {
+		while (index > min) {
+			var code = str.charCodeAt(--index);
+			if (code !== 32 && code !== 9) return index + 1;
+		}
+		return min;
+	}
+	/**
+	* Serialize data into a cookie header.
+	*
+	* Serialize a name value pair into a cookie string suitable for
+	* http headers. An optional options object specifies cookie parameters.
+	*
+	* serialize('foo', 'bar', { httpOnly: true })
+	*   => "foo=bar; httpOnly"
+	*
+	* @param {string} name
+	* @param {string} val
+	* @param {object} [opt]
+	* @return {string}
+	* @public
+	*/
+	function serialize(name, val, opt) {
+		var enc = opt && opt.encode || encodeURIComponent;
+		if (typeof enc !== "function") throw new TypeError("option encode is invalid");
+		if (!cookieNameRegExp.test(name)) throw new TypeError("argument name is invalid");
+		var value = enc(val);
+		if (!cookieValueRegExp.test(value)) throw new TypeError("argument val is invalid");
+		var str = name + "=" + value;
+		if (!opt) return str;
+		if (null != opt.maxAge) {
+			var maxAge = Math.floor(opt.maxAge);
+			if (!isFinite(maxAge)) throw new TypeError("option maxAge is invalid");
+			str += "; Max-Age=" + maxAge;
+		}
+		if (opt.domain) {
+			if (!domainValueRegExp.test(opt.domain)) throw new TypeError("option domain is invalid");
+			str += "; Domain=" + opt.domain;
+		}
+		if (opt.path) {
+			if (!pathValueRegExp.test(opt.path)) throw new TypeError("option path is invalid");
+			str += "; Path=" + opt.path;
+		}
+		if (opt.expires) {
+			var expires = opt.expires;
+			if (!isDate(expires) || isNaN(expires.valueOf())) throw new TypeError("option expires is invalid");
+			str += "; Expires=" + expires.toUTCString();
+		}
+		if (opt.httpOnly) str += "; HttpOnly";
+		if (opt.secure) str += "; Secure";
+		if (opt.partitioned) str += "; Partitioned";
+		if (opt.priority) switch (typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority) {
+			case "low":
+				str += "; Priority=Low";
+				break;
+			case "medium":
+				str += "; Priority=Medium";
+				break;
+			case "high":
+				str += "; Priority=High";
+				break;
+			default: throw new TypeError("option priority is invalid");
+		}
+		if (opt.sameSite) switch (typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite) {
+			case true:
+				str += "; SameSite=Strict";
+				break;
+			case "lax":
+				str += "; SameSite=Lax";
+				break;
+			case "strict":
+				str += "; SameSite=Strict";
+				break;
+			case "none":
+				str += "; SameSite=None";
+				break;
+			default: throw new TypeError("option sameSite is invalid");
+		}
+		return str;
+	}
+	/**
+	* URL-decode string value. Optimized to skip native call when no %.
+	*
+	* @param {string} str
+	* @returns {string}
+	*/
+	function decode(str) {
+		return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+	}
+	/**
+	* Determine if value is a Date.
+	*
+	* @param {*} val
+	* @private
+	*/
+	function isDate(val) {
+		return __toString.call(val) === "[object Date]";
+	}
+	/**
+	* Try decoding a string using a decoding function.
+	*
+	* @param {string} str
+	* @param {function} decode
+	* @private
+	*/
+	function tryDecode(str, decode$1) {
+		try {
+			return decode$1(str);
+		} catch (e) {
+			return str;
+		}
+	}
+}) });
+
+//#endregion
+export { require_cookie as t };

package/dist/chunks/cookie-signature/index.mjs-CIA1F6JJ.mjs

@@ -0,0 +1,46 @@
+import { i as __require, t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+
+//#region node_modules/.pnpm/cookie-signature@1.0.6/node_modules/cookie-signature/index.js
+var require_cookie_signature = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/cookie-signature@1.0.6/node_modules/cookie-signature/index.js": ((exports) => {
+	/**
+	* Module dependencies.
+	*/
+	var crypto = __require("crypto");
+	/**
+	* Sign the given `val` with `secret`.
+	*
+	* @param {String} val
+	* @param {String} secret
+	* @return {String}
+	* @api private
+	*/
+	exports.sign = function(val, secret) {
+		if ("string" != typeof val) throw new TypeError("Cookie value must be provided as a string.");
+		if ("string" != typeof secret) throw new TypeError("Secret string must be provided.");
+		return val + "." + crypto.createHmac("sha256", secret).update(val).digest("base64").replace(/\=+$/, "");
+	};
+	/**
+	* Unsign and decode the given `val` with `secret`,
+	* returning `false` if the signature is invalid.
+	*
+	* @param {String} val
+	* @param {String} secret
+	* @return {String|Boolean}
+	* @api private
+	*/
+	exports.unsign = function(val, secret) {
+		if ("string" != typeof val) throw new TypeError("Signed cookie string must be provided.");
+		if ("string" != typeof secret) throw new TypeError("Secret string must be provided.");
+		var str = val.slice(0, val.lastIndexOf("."));
+		return sha1(exports.sign(str, secret)) == sha1(val) ? str : false;
+	};
+	/**
+	* Private
+	*/
+	function sha1(str) {
+		return crypto.createHash("sha1").update(str).digest("hex");
+	}
+}) });
+
+//#endregion
+export { require_cookie_signature as t };

package/dist/chunks/core-util-is/index.mjs-C0h_2dGX.mjs

@@ -0,0 +1,69 @@
+import { i as __require, t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+
+//#region node_modules/.pnpm/core-util-is@1.0.3/node_modules/core-util-is/lib/util.js
+var require_util = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/core-util-is@1.0.3/node_modules/core-util-is/lib/util.js": ((exports) => {
+	function isArray(arg) {
+		if (Array.isArray) return Array.isArray(arg);
+		return objectToString(arg) === "[object Array]";
+	}
+	exports.isArray = isArray;
+	function isBoolean(arg) {
+		return typeof arg === "boolean";
+	}
+	exports.isBoolean = isBoolean;
+	function isNull(arg) {
+		return arg === null;
+	}
+	exports.isNull = isNull;
+	function isNullOrUndefined(arg) {
+		return arg == null;
+	}
+	exports.isNullOrUndefined = isNullOrUndefined;
+	function isNumber(arg) {
+		return typeof arg === "number";
+	}
+	exports.isNumber = isNumber;
+	function isString(arg) {
+		return typeof arg === "string";
+	}
+	exports.isString = isString;
+	function isSymbol(arg) {
+		return typeof arg === "symbol";
+	}
+	exports.isSymbol = isSymbol;
+	function isUndefined(arg) {
+		return arg === void 0;
+	}
+	exports.isUndefined = isUndefined;
+	function isRegExp(re) {
+		return objectToString(re) === "[object RegExp]";
+	}
+	exports.isRegExp = isRegExp;
+	function isObject(arg) {
+		return typeof arg === "object" && arg !== null;
+	}
+	exports.isObject = isObject;
+	function isDate(d) {
+		return objectToString(d) === "[object Date]";
+	}
+	exports.isDate = isDate;
+	function isError(e) {
+		return objectToString(e) === "[object Error]" || e instanceof Error;
+	}
+	exports.isError = isError;
+	function isFunction(arg) {
+		return typeof arg === "function";
+	}
+	exports.isFunction = isFunction;
+	function isPrimitive(arg) {
+		return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || typeof arg === "undefined";
+	}
+	exports.isPrimitive = isPrimitive;
+	exports.isBuffer = __require("buffer").Buffer.isBuffer;
+	function objectToString(o) {
+		return Object.prototype.toString.call(o);
+	}
+}) });
+
+//#endregion
+export { require_util as t };