@buession/prototype/dist/prototype.esm.js

/*!
 * Buession prototype v2.2.0
 *
 * @link https://prototype.buession.com/
 * @source https://github.com/buession/buession-prototype
 * @copyright @ 2020-2023 Buession.com Inc.
 * @license MIT
 * @Build Time Wed, 01 Feb 2023 06:44:53 GMT
 */

/**
 * Prototype 对象
 */
var Prototype = {
    /**
     * 版本
     */
    version: "v2.2.0",
    /**
     * 空方法
     *
     * @return void
     */
    emptyFunction: function () {
    },
    /**
     *
     * @param x 任意参数
     * @return 任意值
     */
    K: function (x) {
        return x;
    }
};
window.Prototype = Prototype;

/**
 * Try 对象
 */
var Try = {
    /**
     * 接收任意数目的函数作为参数，返回第一个执行成功的函数（未抛出异常的函数）的结果
     *
     * @return 任意函数参数执行结果
     */
    these: function () {
        var result;
        for (var i = 0; i < arguments.length; i++) {
            var lambda = arguments[i];
            if (Object.isFunction(lambda)) {
                try {
                    result = lambda();
                    break;
                }
                catch (e) {
                    console.error(e);
                }
            }
        }
        return result;
    }
};
window.Try = Try;

/**
 * Optional 对象
 */
var Optional = /** @class */ (function () {
    /**
     * 构造函数
     *
     * @param value T 类型的值
     */
    function Optional(value) {
        this.value = value;
    }
    /**
     * 返回一个指定 T 类型的值的 Optional 实例
     *
     * @param value T 类型的值
     * @return T 类型的值的 Optional 实例
     */
    Optional.of = function (value) {
        return new Optional(value);
    };
    /**
     * 如果为非 null 或 undefined，返回 Optional 描述的指定值的实例，否则返回空的 Optional 实例
     *
     * @param value T 类型的值
     * @return T 类型的值的 Optional 实例，或空的 Optional 实例
     */
    Optional.ofNullable = function (value) {
        return Object.isUndefinedOrNull(value) ? Optional.empty() : new Optional(value);
    };
    /**
     * 返回空的 Optional 实例
     *
     * @return 空的 Optional 实例
     */
    Optional.empty = function () {
        return new Optional(null);
    };
    /**
     * 如果 value 不为 null 或 undefined，则返回 value 的值；否则抛出异常
     *
     * @return Optional 中包含这个值
     */
    Optional.prototype.get = function () {
        if (this.value === null || typeof this.value === 'undefined') {
            throw "No value present";
        }
        return this.value;
    };
    /**
     * 如果 value 不为 null 或 undefined，则返回 value 的值；否则返回 other
     *
     * @param other 其它值
     * @return value 不为 null 或 undefined，则返回 value 的值；否则返回 other
     */
    Optional.prototype.orElse = function (other) {
        return Object.isUndefinedOrNull(this.value) ? other : this.value;
    };
    /**
     * 如果 value 不为 null 或 undefined，则返回 true；否则返回 false
     *
     * @return value 不为 null 或 undefined，则返回 true；否则返回 false
     */
    Optional.prototype.isPresent = function () {
        return Object.isUndefinedOrNull(this.value) === false;
    };
    return Optional;
}());
window.Optional = Optional;

/**
 * Object 对象扩展
 */
/**
 * 获取对象数据类型
 *
 * @param obj 对象变量
 * @return 对象数据类型
 */
Object.type = function (obj) {
    return typeof obj;
};
/**
 * 获取对象数据类型
 *
 * @param obj 对象变量
 * @return 对象数据类型
 */
Object.rawType = function (obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
};
/**
 * 判断对象是否为 object 类型
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isObject = function (obj) {
    return obj !== null && typeof obj === "object";
};
/**
 * 判断对象是否为 object 类型
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isPlainObject = function (obj) {
    return Object.prototype.toString.call(obj) === "[object Object]";
};
/**
 * 判断对象是否为 Map 类型
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isMap = function (obj) {
    return Object.prototype.toString.call(obj) === "[object Map]";
};
/**
 * 判断对象是否为 Set 类型
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isSet = function (obj) {
    return Object.prototype.toString.call(obj) === "[object Set]";
};
/**
 * 判断对象是否为函数
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isFunction = function (obj) {
    return Object.type(obj) === "function";
};
/**
 * 判断对象是否为 Symbol
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isSymbol = function (obj) {
    if (typeof obj === "symbol") {
        return true;
    }
    try {
        var toString_1 = Symbol.prototype.toString;
        if (typeof obj.valueOf() !== "symbol") {
            return false;
        }
        return /^Symbol\(.*\)$/.test(toString_1.call(obj));
    }
    catch (e) {
        return false;
    }
};
/**
 * 判断对象是否为 Promise
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isPromise = function (obj) {
    return Object.isUndefinedOrNull(obj) === false && Object.isFunction(obj.then) && Object.isFunction(obj.catch);
};
/**
 * 判断对象是否为原始类型
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isPrimitive = function (obj) {
    return Object.isBoolean(obj) || Object.isString(obj) || Object.isNumber(obj);
};
/**
 * 判断对象是否为数组
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isArray = function (obj) {
    return Array.isArray(obj);
};
/**
 * 判断对象是否为字符串对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isString = function (obj) {
    return Object.type(obj) === "string";
};
/**
 * 判断对象是否为数字对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isNumber = function (obj) {
    return Object.type(obj) === "number";
};
/**
 * 判断对象是否为布尔对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isBoolean = function (obj) {
    return Object.type(obj) === "boolean";
};
/**
 * 判断对象是否为正则对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isRegExp = function (obj) {
    return Object.rawType(obj) === 'RegExp';
};
/**
 * 判断对象是否为文件对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isFile = function (obj) {
    return obj instanceof File;
};
/**
 * 判断对象是否为 windows 对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isWindow = function (obj) {
    return Object.isUndefinedOrNull(obj) && obj == obj.window;
};
/**
 * 判断对象是否为 Element
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isElement = function (obj) {
    if (Object.isUndefinedOrNull(obj)) {
        return false;
    }
    return !!(obj.nodeType == 1);
};
/**
 * 判断对象是否为事件对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isEvent = function (obj) {
    return obj instanceof Event;
};
/**
 * 判断对象是否为 null 对象
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isNull = function (obj) {
    return obj === null;
};
/**
 * 判断对象是否为未定义
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isUndefined = function (obj) {
    return obj === undefined;
};
/**
 * 判断对象是否为未定义或 null
 *
 * @param obj 任意对象
 * @return boolean
 */
Object.isUndefinedOrNull = function (obj) {
    return Object.isUndefined(obj) || Object.isNull(obj);
};
/**
 * 克隆对象
 *
 * @param obj 任意对象
 * @return 新对象实例
 */
Object.clone = function (obj) {
    if (Object.isString(obj)) {
        return String(obj);
    }
    else if (Object.isArray(obj)) {
        return Array.prototype.slice.apply(obj);
    }
    else if (Object.isPlainObject(obj)) {
        var result_1 = {};
        Object.keys(obj).forEach(function (name) {
            result_1[name] = Object.clone(obj[name]);
        });
        return result_1;
    }
    return obj;
};
/**
 * 判断两个对象是否相等
 *
 * @param obj1 一个对象
 * @param obj2 用于和 obj1 比较的对象
 * @return 当两个对象相等时，返回 true；否则，返回 false
 */
Object.equals = function (obj1, obj2) {
    if (obj1 === obj2) {
        return true;
    }
    else if (!(obj1 instanceof Object) || !(obj2 instanceof Object)) {
        return false;
    }
    else if (obj1.constructor !== obj2.constructor) {
        return false;
    }
    else if (Object.isArray(obj1) && Object.isArray(obj2) && obj1.length === obj2.length) {
        for (var i = 0; i < obj1.length; i++) {
            if (Object.equals(obj1[i], obj2[i]) === false) {
                return false;
            }
        }
    }
    else if (Object.isObject(obj1) && Object.isObject(obj2) && Object.keys(obj1).length === Object.keys(obj2).length) {
        for (var key in obj1) {
            if (obj1.hasOwnProperty.call(key)) {
                if (Object.equals(obj1[key], obj2[key]) === false) {
                    return false;
                }
            }
        }
    }
    else {
        return false;
    }
    return true;
};
/**
 * 克隆对象，但需要删除指定属性
 *
 * @param obj 任意对象
 * @param fields 需要删除的属性
 * @return 新对象实例
 */
Object.omit = function (obj) {
    var fields = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        fields[_i - 1] = arguments[_i];
    }
    var result = Object.assign({}, obj);
    for (var i = 0; i < fields.length; i++) {
        var key = fields[i];
        delete result[key];
    }
    return result;
};

/**
 * Array 对象扩展
 */
/**
 * 判断数组是否为空数组
 *
 * @return boolean
 */
Array.prototype.isEmpty = function () {
    return this.length === 0;
};
/**
 * 判断元素是否在数组中
 *
 * @param item 查找对象
 * @return boolean
 */
Array.prototype.exists = function (item) {
    return this.indexOf(item) !== -1;
};
/**
 * 获取一个元素
 *
 * @return 第一个元素
 */
Array.prototype.first = function () {
    if (this.length === 0) {
        throw "Array index out of range: 0";
    }
    return this[0];
};
/**
 * 获取一个元素
 *
 * @return 第一个元素
 */
Array.prototype.last = function () {
    if (this.length === 0) {
        throw "Array index out of range: 0";
    }
    return this[this.length - 1];
};
/**
 * 数组迭代
 *
 * @param callback 回调函数
 * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
 */
Array.prototype.each = Array.prototype.forEach;
/**
 * 获取数组大小
 *
 * @return 数组大小
 */
Array.prototype.size = function () {
    return this.length;
};
/**
 * 克隆数组
 *
 * @return 克隆结果
 */
Array.prototype.merge = Array.prototype.concat;
/**
 * 返回一个不包含 null/undefined 值元素的数组的新版本
 *
 * @return 不包含 null/undefined 值元素的数组的新版本
 */
Array.prototype.compact = function () {
    return this.filter(function (value) { return Object.isUndefinedOrNull(value); });
};
/**
 * 对数组的元素进行去重
 *
 * @return 数组元素进行去重后的新版本
 */
Array.prototype.unique = function () {
    var temp = new Array();
    return this.filter(function (v) {
        var ret = temp.includes(v) === false;
        temp.push(v);
        return ret;
    });
};
/**
 * 返回不包括参数中任意一个指定值的数组
 *
 * @param values 排除值数组
 * @return 不包括参数中任意一个指定值的数组
 */
Array.prototype.without = function () {
    var values = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        values[_i] = arguments[_i];
    }
    return this.filter(function (v) {
        return values.includes(v) === false;
    });
};
/**
 * 克隆数组
 *
 * @return 克隆结果
 */
Array.prototype.clone = function () {
    return this.slice(0);
};
/**
 * 清空数组
 *
 * @return 空数组
 */
Array.prototype.clear = function () {
    this.length = 0;
    return this;
};

/**
 * Date 对象扩展
 */
/**
 * 判断是否为闰年
 *
 * @return boolean
 */
Date.prototype.isLeapYear = function () {
    var year = this.getFullYear();
    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
};
/**
 * 获取季节
 *
 * @return 季节
 */
Date.prototype.getSeason = function () {
    var month = this.getMonth();
    if (month >= 3 && month <= 5) {
        return 0;
    }
    else if (month >= 6 && month <= 8) {
        return 1;
    }
    else if (month >= 9 && month <= 11) {
        return 2;
    }
    else if (month >= 12 || month <= 2) {
        return 3;
    }
    else {
        return 0;
    }
};
/**
 * 获取年份中的第几天
 *
 * @return 年份中的第几天
 */
Date.prototype.getDayOfYear = function () {
    var month_days = this.isLeapYear() == true ? [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] : [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    var days = this.getDate();
    for (var m = 0; m < this.getMonth(); m++) {
        days += month_days[m];
    }
    return days;
};
/**
 * 获取年份总天数
 *
 * @return 年份总天数
 */
Date.prototype.getDaysOfYear = function () {
    return this.isLeapYear() ? 366 : 365;
};
/**
 * Format a date object into a string value.
 * @param  format string - the desired format of the date
 *
 * The format can be combinations of the following:
 *
 * y - 年
 * n - 季度（1 到 4）
 * N - 季度名称
 * A - 季度中文名称
 * M - 月
 * f - 月（Jan 到 Dec）
 * F - 月（January 到 December）
 * C - 月，中文名称
 * d - 日
 * Y - 年份中的第几天（0 到 365）
 * T - 月份有几天（28 到 30）
 * j - 每月天数后面的英文后缀（st，nd，rd 或者 th）
 * e - 星期几，数字表示，0（表示星期天）到 6（表示星期六）
 * E - 星期几，数字表示，1（表示星期一）到 7（表示星期天）
 * l - 星期几，文本表示，3 个字母（Mon 到 Sun）
 * L - 星期几，完整的文本格式（Sunday 到 Saturday）
 * w - 星期几，中文名称
 * W - 一月中第几个星期几
 * i - 月份中的第几周
 * o - 年份中的第几周
 * h - 小时(1~12)
 * H - 小时(0~23)
 * m - 分
 * s - 秒
 * S - 毫秒
 * a - 上午/下午标记
 * O - 与格林威治时间相差的小时数
 * P - 与格林威治时间相差的小时数，小时和分钟之间有冒号分隔
 * Z - 时区
 *
 * @return 格式化后的日期时间
 */
Date.prototype.format = function (format) {
    if (Object.isString(format) === false) {
        throw "Invalid argument format";
    }
    var $this = this;
    var _season_map = {
        "N": ["Spring", "Summer", "Autumn", "Winter"],
        "A": ["\u6625", "\u590f", "\u79cb", "\u51ac"]
    };
    var _month_map = {
        "f": ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
        "F": ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
        "C": ["\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D", "\u4E03", "\u516B", "\u4E5D", "\u5341", "\u5341\u4E00", "\u5341\u4E8C"]
    };
    var _weekday_map = {
        "W": ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
        "WW": ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"],
        "WC": ["\u65E5", "\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D"]
    };
    var seasonFn = function () { return Math.floor(($this.getMonth() + 3) / 3); };
    var $funcs = {
        // 年
        "y": function (pattern) {
            console.debug("y => pattern: " + pattern);
            return ($this.getFullYear() + "").substring(4 - pattern.length);
        },
        // 季度（1 到 4）
        "n": function (pattern) {
            console.debug("n => pattern: " + pattern);
            return seasonFn();
        },
        // 季度名称
        "N": function (pattern) {
            console.debug("N => pattern: " + pattern);
            var n = seasonFn() - 1;
            return _season_map["N"][n];
        },
        // 季度中文名称
        "A": function (pattern) {
            console.debug("A => pattern: " + pattern);
            var n = seasonFn() - 1;
            return _season_map["A"][n];
        },
        // 月
        "M": function (pattern) {
            console.debug("M => pattern: " + pattern);
            var $month = $this.getMonth() + 1;
            var result = $month < 10 ? "0" + $month : "" + $month;
            return result.substring(2 - pattern.length);
        },
        // 月（Jan 到 Dec）
        "f": function (pattern) {
            console.debug("f => pattern: " + pattern);
            var $month = $this.getMonth();
            return _month_map["f"][$month];
        },
        // 月（January 到 December）
        "F": function (pattern) {
            console.debug("F => pattern: " + pattern);
            var $month = $this.getMonth();
            return _month_map["F"][$month];
        },
        // 月，中文名称
        "C": function (pattern) {
            console.debug("C => pattern: " + pattern);
            var $month = $this.getMonth();
            return _month_map["C"][$month];
        },
        // 星期数字，0 到 6 表示
        "e": function (pattern) {
            console.debug("e => pattern: " + pattern);
            return $this.getDay();
        },
        // 星期数字，1 到 7 表示
        "E": function (pattern) {
            console.debug("E => pattern: " + pattern);
            return $this.getDay() + 1;
        },
        // 星期英文缩写
        "l": function (pattern) {
            console.debug("l => pattern: " + pattern);
            var $weekday = $this.getDay();
            return _weekday_map["W"][$weekday];
        },
        // 星期英文全称
        "L": function (pattern) {
            console.debug("L => pattern: " + pattern);
            var $weekday = $this.getDay();
            return _weekday_map["WC"][$weekday];
        },
        // 星期中文名称
        "w": function (pattern) {
            console.debug("w => pattern: " + pattern);
            var $weekday = $this.getDay();
            return _weekday_map["WC"][$weekday];
        },
        // 日
        "d": function (pattern) {
            console.debug("d => pattern: " + pattern);
            var $date = $this.getDate();
            var result = $date < 10 ? "0" + $date : "" + $date;
            return result.substring(2 - pattern.length);
        },
        // 小时
        "h": function (pattern) {
            console.debug("h => pattern: " + pattern);
            var $hour = $this.getHours();
            var result = $hour % 12 === 0 ? "12" : $hour % 12;
            result = $hour < 10 ? "0" + $hour : "" + $hour;
            return result.substring(2 - pattern.length);
        },
        // 小时
        "H": function (pattern) {
            console.debug("H => pattern: " + pattern);
            var $hour = $this.getHours();
            var result = $hour < 10 ? "0" + $hour : "" + $hour;
            return result.substring(2 - pattern.length);
        },
        // 分钟
        "m": function (pattern) {
            console.debug("m => pattern: " + pattern);
            var $minutes = $this.getMinutes();
            var result = $minutes < 10 ? "0" + $minutes : "" + $minutes;
            return result.substring(2 - pattern.length);
        },
        // 秒钟
        "s": function (pattern) {
            console.debug("s => pattern: " + pattern);
            var $seconds = $this.getSeconds();
            var result = $seconds < 10 ? "0" + $seconds : "" + $seconds;
            return result.substring(2 - pattern.length);
        },
        // 毫秒
        "S": function (pattern) {
            console.debug("S => pattern: " + pattern);
            var $mise = $this.getMilliseconds();
            var result = $mise < 10 ? "0" + $mise : "" + $mise;
            return result.substring(2 - pattern.length);
        }
    };
    return format.replace(/([ynNAMfFCdYTjeElLwWiohHmsSaOPZ])+/g, function (all, t) {
        var fn = $funcs[t];
        if (Object.isFunction(fn) === true) {
            return fn(all);
        }
        return all;
    });
};

/**
 * Document 对象扩展
 */
var SameSite;
(function (SameSite) {
    SameSite["NONE"] = "None";
    SameSite["LAX"] = "Lax";
    SameSite["STRICT"] = "Strict";
})(SameSite || (SameSite = {}));
var CookieInstance = /** @class */ (function () {
    function CookieInstance() {
    }
    CookieInstance.prototype.set = function (name, value, options) {
        var $name = name = encodeURIComponent(name)
            .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent);
        var $value = value ? encodeURIComponent(value)
            .replace(/%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g, decodeURIComponent) : '';
        var stringifiedAttributes = '';
        if (options) {
            stringifiedAttributes += options.domain ? '; domain=' + options.domain : '';
            stringifiedAttributes += options.path ? '; path=' + options.path : '';
            if (options.expires) {
                var $expiresDate = options.expires instanceof Date ? options.expires : new Date(Date.now() + options.expires * 864e5);
                stringifiedAttributes += options.expires ? '; expires=' + $expiresDate.toUTCString() : '';
            }
            stringifiedAttributes += options.sameSite ? '; sameSite=' + options.sameSite : '';
            if (Object.isBoolean(options.secure) && options.secure) {
                stringifiedAttributes += options.expires ? '; secure' : '';
            }
            if (Object.isBoolean(options.httpOnly) && options.httpOnly) {
                stringifiedAttributes += options.httpOnly ? '; httpOnly' : '';
            }
        }
        return document.cookie = $name + '=' + $value + stringifiedAttributes;
    };
    CookieInstance.prototype.get = function (name) {
        var cookies = document.cookie ? document.cookie.split('; ') : [];
        for (var i = 0; i < cookies.length; i++) {
            var parts = cookies[i].split('=');
            var $name = decodeURIComponent(parts[0]);
            var $value = parts.slice(1).join('=');
            if ($name === name) {
                if ($value[0] === '"') {
                    $value = $value.slice(1, -1);
                }
                return $value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
            }
        }
        return null;
    };
    CookieInstance.prototype.delete = function (name, options) {
        var $options = options ? options : {};
        $options.expires = -1;
        this.set(name, '', $options);
    };
    return CookieInstance;
}());
/**
 * 检测当前浏览器是否为全屏
 *
 * @return 当前浏览器是否为全屏
 */
Object.defineProperty(document, "fullScreen", {
    value: Object.isUndefined(document.fullscreen) === false ? document.fullscreen : (Object.isUndefined(document.mozFullScreen) === false ? document.mozFullScreen : (Object.isUndefined(document.webkitIsFullScreen) === false ? document.webkitIsFullScreen : (Object.isUndefined(document.msFullScreen) === false ? document.msFullScreen : (Object.isUndefined(document.fullscreenElement) === false ? document.fullscreenElement !== null : (Object.isUndefined(document.mozFullScreenElement) === false ? document.mozFullScreenElement !== null : (Object.isUndefined(document.webkitFullscreenElement) === false ? document.webkitFullscreenElement !== null : (Object.isUndefined(document.msFullscreenElement) === false ? document.msFullscreenElement !== null : false))))))),
    configurable: true,
    writable: false
});
/**
 * 检测当前浏览器是否支持全屏模式
 *
 * @return 当前浏览器是否支持全屏模式
 */
Object.defineProperty(document, "fullScreenEnabled", {
    value: Object.isUndefined(document.mozFullScreenEnabled) === false ? document.mozFullScreenEnabled : (Object.isUndefined(document.webkitFullscreenEnabled) === false ? document.webkitFullscreenEnabled : (Object.isUndefined(document.msFullscreenEnabled) === false ? document.msFullscreenEnabled : (Object.isUndefined(document.fullscreenEnabled) === false ? document.fullscreenEnabled : false))),
    configurable: true,
    writable: false
});
/**
 * 返回当前文档中正在以全屏模式显示的 Element 节点
 *
 * @return 当前文档中正在以全屏模式显示的 Element 节点
 */
Object.defineProperty(document, "fullScreenElement", {
    value: Object.isUndefined(document.mozFullScreenElement) === false ? document.mozFullScreenElement : (Object.isUndefined(document.webkitFullscreenElement) === false ? document.webkitFullscreenElement : (Object.isUndefined(document.msFullscreenElement) === false ? document.msFullscreenElement : (Object.isUndefined(document.fullscreenElement) === false ? document.fullscreenElement : null))),
    configurable: true,
    writable: false
});
/**
 * 返回 Cookie 对象
 *
 * @return Cookie 对象
 */
Object.defineProperty(document, "httpCookie", {
    value: new CookieInstance(),
    configurable: true,
    writable: false
});
/**
 * 请求进入全屏模式
 *
 * @return Promise
 */
Document.prototype.requestFullscreen = function () {
    var doc = document.documentElement;
    if (Object.isFunction(doc.mozRequestFullScreen)) {
        return doc.mozRequestFullScreen();
    }
    else if (Object.isFunction(doc.webkitRequestFullscreen)) {
        return doc.webkitRequestFullscreen();
    }
    else if (Object.isFunction(doc.msRequestFullscreen)) {
        return doc.msRequestFullscreen();
    }
    else {
        return doc.requestFullscreen();
    }
};
/**
 * 退出全屏模式
 *
 * @return Promise
 */
Document.prototype.exitFullscreen = function () {
    if (Object.isFunction(document.mozCancelFullScreen)) {
        return document.mozCancelFullScreen();
    }
    else if (Object.isFunction(document.mozExitFullScreen)) {
        return document.mozExitFullScreen();
    }
    else if (Object.isFunction(document.webkitCancelFullScreen)) {
        return document.webkitCancelFullScreen();
    }
    else if (Object.isFunction(document.webkitExitFullscreen)) {
        return document.webkitExitFullscreen();
    }
    else if (Object.isFunction(document.msExitFullscreen)) {
        return document.msExitFullscreen();
    }
    else {
        return document.exitFullscreen();
    }
};

/**
 * Function 对象扩展
 */
/**
 * 获取函数参数名称
 *
 * @return 函数参数名称列表
 */
Function.prototype.argumentNames = function () {
    var method = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/);
    if (method === null) {
        return null;
    }
    var names = method[1].replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, "").replace(/\s+/g, "").split(", ");
    return names.length === 1 && !names[0] ? [] : names;
};
/**
 * 延时执行函数
 *
 * @param timeout 延时时间（单位：秒）
 * @return mixed
 */
Function.prototype.delay = function (timeout) {
    var __method = this;
    var args = Array.prototype.slice.call(arguments, 1);
    return window.setTimeout(__method.apply(__method, args), timeout * 1000);
};

/**
 * Math 对象扩展
 */
/**
 * 产生一个指定范围内的随机数
 *
 * @param min 返回的最低值(默认 0)
 * @param max 返回的最高值
 * @return 随机数
 */
Math.rand = function (min, max) {
    min = min || 0;
    max = max || Number.MAX_SAFE_INTEGER;
    var result = Math.random() * (max - min + 1) + min;
    result = Math.round(result);
    if (result < min) {
        result = min;
    }
    else if (result > max) {
        result = max;
    }
    return result;
};

/**
 * Number 对象扩展
 */
/**
 * 数字填充
 *
 * @param length 长度
 * @param radix 进制
 * @return 填充后的字符串数字
 */
Number.prototype.toPaddedString = function (length, radix) {
    var str = this.toString(radix || 10);
    return "0".repeat(length - str.length) + str;
};
/**
 * 判断数字是否为奇数
 *
 * @param num 需要判断的数字
 * @return boolean 数字是为奇数返回 true；否则返回 false
 */
Number.isOdd = function (num) {
    return num % 2 === 1;
};
/**
 * 判断数字是否为偶数
 *
 * @param num 需要判断的数字
 * @return boolean 数字是为偶数返回 true；否则返回 false
 */
Number.isEven = function (num) {
    return num % 2 === 0;
};
/**
 * 判断一个数字是否在另两个数字之间
 *
 * @param num 需要判断的数
 * @param min 最小值
 * @param max 最大值
 * @param match 是否包含最小值或最大值
 * @return boolean 数字是否在另两个数字之间，返回 true；否则返回 false
 */
Number.isBetween = function (num, min, max, match) {
    if (match === void 0) { match = false; }
    min = min || 0;
    max = max || 0;
    if (min > max) {
        min ^= max;
        max ^= min;
        min ^= max;
    }
    return match == true ? num >= min && num <= max : num > min && num < max;
};

/**
 * String 对象扩展
 */
/**
 * 判断字符串是否存在
 *
 * @param str 子字符串
 * @return boolean
 */
String.prototype.exists = function (str) {
    return this.indexOf(str) >= 0;
};
/**
 * 判断字符串是否相等
 *
 * @param str 与此 String 进行比较的对象
 * @return boolean
 */
String.prototype.equals = function (str) {
    return Object.isUndefinedOrNull(str) == false && this === str;
};
/**
 * 判断字符串是否相等，不考虑大小写
 *
 * @param str 与此 String 进行比较的对象
 * @return boolean
 */
String.prototype.equalsIgnoreCase = function (str) {
    return str !== undefined && str !== null && this.toLowerCase() === str.toLowerCase();
};
/**
 * 判断是否为空字符串
 *
 * @return boolean
 */
String.prototype.isEmpty = function () {
    return this.length === 0;
};
/**
 * 判断是否不为空字符串
 *
 * @return boolean
 */
String.prototype.isNotEmpty = function () {
    return this.length > 0;
};
/**
 * 判断是否为空白字符串
 *
 * @return boolean
 */
String.prototype.isBlank = function () {
    return /^\s*$/.test(this.toString());
};
/**
 * 重复一个字符串
 *
 * @papram count 重复次数
 * @return 重复后的字符串
 */
String.prototype.repeat = function (count) {
    if (count < 1) {
        return "";
    }
    else {
        var result = this.toString();
        for (var i = 0; i < count; i++) {
            result += this.toString();
        }
        return result;
    }
};
/**
 * 截取字符串左边边指定数目的字符串
 *
 * @param length 截取长度
 * @return 子字符串
 */
String.prototype.left = function (length) {
    return this.substring(0, length);
};
/**
 * 截取字符串右边指定数目的字符串
 *
 * @param length 截取长度
 * @return 子字符串
 */
String.prototype.right = function (length) {
    return this.substring(this.length - length, this.length);
};
/**
 * 截取字符串，超出部分用 truncation 替代
 *
 * @param length 截取长度
 * @param truncation 替换字符串
 * @return 截取后的字符串
 *		   实际截取长度：当 length 小于等于 truncation 的长度时为，length；当 length 大于 truncation 的长度时为，length - truncation.length
 */
String.prototype.truncation = function (length, truncation) {
    if (truncation === void 0) { truncation = '...'; }
    truncation = truncation || "...";
    return this.length > length ? this.slice(0, length <= truncation.length ? length : length - truncation.length) + truncation : String(this);
};
/**
 * 删除字符串开头的空白字符
 *
 * @return 删除了字符串最左边的空白字符的字符串
 */
String.prototype.ltrim = function () {
    return Object.isFunction(this.trimStart) ? this.trimStart() : this.replace(/^\s*/g, "");
};
/**
 * 删除字符串结尾的空白字符
 *
 * @return 删除了字符串最右边的空白字符的字符串
 */
String.prototype.rtrim = function () {
    return Object.isFunction(this.trimEnd) ? this.trimEnd() : this.replace(/\s*$/g, "");
};
/**
 * 判断字符串是否以给定的字符串开头
 *
 * @param str 搜索的字符串
 * @return boolean
 */
String.prototype.startsWith = function (str) {
    return this.indexOf(str) === 0;
};
/**
 * 判断字符串是否以给定的字符串结尾
 *
 * @param str 搜索的字符串
 * @return boolean
 */
String.prototype.endsWith = function (str) {
    var d = this.length - str.length;
    return d >= 0 && this.lastIndexOf(str) === d;
};
/**
 * 首字母小写
 *
 * @return 结果字符串
 */
String.prototype.lcfirst = function () {
    return this.charAt(0).toLowerCase() + this.substring(1);
};
/**
 * 首字母大写
 *
 * @return 结果字符串
 */
String.prototype.ucfirst = function () {
    return this.charAt(0).toUpperCase() + this.substring(1);
};
/**
 * 将 HTML 编码
 *
 * @return 编码后的字符串
 */
String.prototype.escapeHTML = function () {
    return this.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
};
/**
 * 将 HTML 实体字符解码
 *
 * @return 解码后的字符串
 */
String.prototype.unescapeHTML = function () {
    return this.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
};
/**
 * 删除 HTML 标签
 *
 * @param tag HTML 标签
 * @returns 删除标签后的字符串
 */
String.prototype.stripTag = function (tag) {
    return this.replace(new RegExp("<" + tag + "(\\s+(\"[^\"]*\"|'[^']*'|[^>])+)?(\/)?>|<\/" + tag + ">", "gi"), "");
};
/**
 * 批量删除 HTML 标签
 *
 * @param tags 删除指定的标签
 * @return 删除标签后的字符串
 */
String.prototype.stripTags = function (tags) {
    if (typeof tags === "string") {
        return this.stripTag(tags);
    }
    else if (Array.isArray(tags)) {
        var result = this.toString();
        for (var i = 0; i < tags.length; i++) {
            result = result.stripTag(tags[i]);
        }
        return result;
    }
    else {
        return this.toString();
    }
};
/**
 * 删除 script 标签
 *
 * @return 删除 script 标签后的字符串
 */
String.prototype.stripScripts = function () {
    return this.replace(/<script[^>]*>([\S\s]*?)<\/script>/img, "");
};
/**
 * 将字符串转换为数组
 *
 * @param delimiter 分隔字符
 * @return 数组
 */
String.prototype.toArray = function (delimiter) {
    return this.split(delimiter || "");
};
/**
 * 返回一个数组的字符串表示形式
 *
 * @param useDoubleQuotes 是否使用双引号引住
 * @return 后的字符串
 */
String.prototype.inspect = function (useDoubleQuotes) {
    var specialChar = { '\b': '\\b', '\t': '\\t', '\r': '\\r', '\n': '\\n', '\f': '\\f', '\\': '\\\\' };
    var escapedString = this.replace(/[\x00-\x1f\\]/g, function (character) {
        if (character in specialChar) {
            return specialChar[character];
        }
        return '\\u00' + character.charCodeAt(0).toPaddedString(2, 16);
    });
    if (useDoubleQuotes) {
        return '"' + escapedString.replace(/"/g, '\\"') + '"';
    }
    else {
        return "'" + escapedString.replace(/'/g, '\\\'') + "'";
    }
};
/**
 * 获取字符串 hash code
 *
 * @return 字符串 hash code
 */
String.prototype.hashCode = function () {
    var result = 0;
    if (result === 0 && this.length > 0) {
        for (var i = 0; i < this.length; i++) {
            result = 31 * result + this.charCodeAt(i);
        }
    }
    return result;
};
/**
 * 生成随机字符串
 *
 * @param length 生成字符串的长度
 * @param type 生成类型
 *        NUMERIC 		 - 数字随机字符串
 *		  LETTER  		 - 英文随机字符串
 *		  LETTER_NUMERIC - 英文数字混合随机字符串
 *		  CHINESE 		 - 中文随机字符串
 *
 * @return 生成结果
 */
String.random = function (length, type) {
    if (type === void 0) { type = "LETTER_NUMERIC"; }
    var result = "";
    if (type === "CHINESE") {
        for (var i = 0; i < length; i++) {
            result += String.fromCharCode(Math.rand(19968, 40891));
        }
        return result;
    }
    var numeric = "0123456789";
    var letter = "abcdefghijklmnopqrstuvwxyz";
    var map = {
        "NUMERIC": numeric,
        "LETTER": letter + letter.toUpperCase(),
        "LETTER_NUMERIC": numeric + letter + letter.toUpperCase()
    };
    if (!map[type]) {
        throw "Invalid argument type value, must be: NUMERIC, LETTER, LETTER_NUMERIC or CHINESE";
    }
    for (var j = 0; j < length; j++) {
        result += map[type].charAt(Math.rand(0, map[type].length - 1));
    }
    return result;
};

/**
 * Window 对象扩展
 */
Object.defineProperty(window, "browser", {
    value: {
        userAgent: navigator.userAgent,
        name: navigator.appName,
        version: navigator.appVersion,
        isMobile: ["Android", "iPhone", "iPod", "Windows Phone", "Mobile", "Coolpad", "mmp", "SmartPhone", "midp", "wap", "xoom", "Symbian", "J2ME", "Blackberry", "Wince"].some(function (value) { return navigator.userAgent.exists(value); }),
        isChrome: /\(KHTML, like Gecko\) Chrome\//.test(navigator.userAgent),
        isFirefox: navigator.userAgent.exists("Firefox"),
        isMozilla: navigator.userAgent.exists("Mozilla"),
        isEdge: navigator.userAgent.exists("Edge"),
        isMSIE: navigator.userAgent.exists("MSIE") && navigator.userAgent.exists("compatible"),
        isOpera: navigator.userAgent.exists("Opera"),
        isSafari: navigator.userAgent.exists("Safari"),
        isNetscape: /Netscape([\d]*)\/([^\s]+)/i.test(navigator.userAgent)
    },
    configurable: true,
    writable: false
});
/**
 * 将字符串复制到剪贴板
 *
 * @param str 字符串
 */
Window.prototype.copy = function (str) {
    try {
        if (Object.isObject(this.clipboardData)) {
            this.clipboardData.setData("text", str);
        }
        else {
            var fakeElement = document.createElement("textarea");
            fakeElement.style.border = "none";
            fakeElement.style.margin = "0";
            fakeElement.style.padding = "0";
            fakeElement.style.position = "absolute";
            fakeElement.style.top = "-9999px";
            fakeElement.style.left = "-9999px";
            fakeElement.value = str;
            fakeElement.setAttribute("readonly", "");
            document.body.appendChild(fakeElement);
            fakeElement.setSelectionRange(0, str.length);
            fakeElement.select();
            document.execCommand("copy");
            fakeElement.remove();
        }
    }
    catch (e) {
        console.error(e);
    }
};
/**
 * 获取所有的请求参数及值
 *
 * @return 所有的请求参数及值
 */
Location.prototype.getParameters = function () {
    var queryString = this.search;
    var parameters = new Object();
    if (queryString.indexOf("?") != -1) {
        queryString = queryString.substring(1);
        var parts = queryString.split("&");
        for (var i = 0; i < parts.length; i++) {
            var temp = parts[i].split("=");
            var val = temp.length == 2 ? encodeURIComponent(temp[1]) : "";
            if (Object.isUndefined(parameters[temp[0]])) {
                parameters[temp[0]] = val;
            }
            else {
                if (Object.isArray(parameters[temp[0]]) == false) {
                    var oldVal = parameters[temp[0]];
                    delete parameters[temp[0]];
                    parameters[temp[0]] = [oldVal];
                }
                parameters[temp[0]].push(val);
            }
        }
    }
    return parameters;
};
/**
 * 获取指定请求参数的值
 *
 * @param name 参数名
 * @return 指定请求参数的值
 */
Location.prototype.getParameter = function (name) {
    var parameters = this.getParameters();
    return parameters[name];
};
//# sourceMappingURL=prototype.esm.js.map