ddan-js 2.9.4 → 2.9.6

package/bin/lib/modules/rule/async-validator/index.js

@@ -1,306 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("./util");
-const index_1 = require("./validator/index");
-const messages_1 = require("./messages");
-__exportStar(require("./interface"), exports);
-/**
- *  Encapsulates a validation schema.
- *
- *  @param descriptor An object declaring validation rules
- *  for this schema.
- */
-class Schema {
-    // ========================= Static =========================
-    static register = function register(type, validator) {
-        if (typeof validator !== 'function') {
-            throw new Error('Cannot register a validator by type, validator is not a function');
-        }
-        index_1.default[type] = validator;
-    };
-    static warning = util_1.warning;
-    static messages = messages_1.messages;
-    static validators = index_1.default;
-    // ======================== Instance ========================
-    rules = {};
-    _messages = messages_1.messages;
-    constructor(descriptor) {
-        this.define(descriptor);
-    }
-    define(rules) {
-        if (!rules) {
-            throw new Error('Cannot configure a schema with no rules');
-        }
-        if (typeof rules !== 'object' || Array.isArray(rules)) {
-            throw new Error('Rules must be an object');
-        }
-        this.rules = {};
-        Object.keys(rules).forEach(name => {
-            const item = rules[name];
-            this.rules[name] = Array.isArray(item) ? item : [item];
-        });
-    }
-    messages(messages) {
-        if (messages) {
-            this._messages = (0, util_1.deepMerge)((0, messages_1.newMessages)(), messages);
-        }
-        return this._messages;
-    }
-    validate(source_, o = {}, oc = () => { }) {
-        let source = source_;
-        let options = o;
-        let callback = oc;
-        if (typeof options === 'function') {
-            callback = options;
-            options = {};
-        }
-        if (!this.rules || Object.keys(this.rules).length === 0) {
-            if (callback) {
-                callback(null, source);
-            }
-            return Promise.resolve(source);
-        }
-        function complete(results) {
-            let errors = [];
-            let fields = {};
-            function add(e) {
-                if (Array.isArray(e)) {
-                    errors = errors.concat(...e);
-                }
-                else {
-                    errors.push(e);
-                }
-            }
-            for (let i = 0; i < results.length; i++) {
-                add(results[i]);
-            }
-            if (!errors.length) {
-                callback(null, source);
-            }
-            else {
-                fields = (0, util_1.convertFieldsError)(errors);
-                callback(errors, fields);
-            }
-        }
-        if (options.messages) {
-            let messages = this.messages();
-            if (messages === messages_1.messages) {
-                messages = (0, messages_1.newMessages)();
-            }
-            (0, util_1.deepMerge)(messages, options.messages);
-            options.messages = messages;
-        }
-        else {
-            options.messages = this.messages();
-        }
-        const series = {};
-        const keys = options.keys || Object.keys(this.rules);
-        keys.forEach(z => {
-            const arr = this.rules[z];
-            let value = source[z];
-            arr.forEach(r => {
-                let rule = r;
-                if (typeof rule.transform === 'function') {
-                    if (source === source_) {
-                        source = { ...source };
-                    }
-                    value = source[z] = rule.transform(value);
-                }
-                if (typeof rule === 'function') {
-                    rule = {
-                        validator: rule,
-                    };
-                }
-                else {
-                    rule = { ...rule };
-                }
-                // Fill validator. Skip if nothing need to validate
-                rule.validator = this.getValidationMethod(rule);
-                if (!rule.validator) {
-                    return;
-                }
-                rule.field = z;
-                rule.fullField = rule.fullField || z;
-                rule.type = this.getType(rule);
-                series[z] = series[z] || [];
-                series[z].push({
-                    rule,
-                    value,
-                    source,
-                    field: z,
-                });
-            });
-        });
-        const errorFields = {};
-        return (0, util_1.asyncMap)(series, options, (data, doIt) => {
-            const rule = data.rule;
-            let deep = (rule.type === 'object' || rule.type === 'array') &&
-                (typeof rule.fields === 'object' ||
-                    typeof rule.defaultField === 'object');
-            deep = deep && (rule.required || (!rule.required && data.value));
-            rule.field = data.field;
-            function addFullField(key, schema) {
-                return {
-                    ...schema,
-                    fullField: `${rule.fullField}.${key}`,
-                    fullFields: rule.fullFields ? [...rule.fullFields, key] : [key],
-                };
-            }
-            function cb(e = []) {
-                let errorList = Array.isArray(e) ? e : [e];
-                if (options.suppressWarning === true && errorList.length) {
-                    Schema.warning('async-validator:', errorList);
-                }
-                if (errorList.length && rule.message !== undefined) {
-                    //@ts-ignore
-                    errorList = [].concat(rule.message);
-                }
-                // Fill error info
-                let filledErrors = errorList.map((0, util_1.complementError)(rule, source));
-                if (options.first && filledErrors.length) {
-                    errorFields[rule.field] = 1;
-                    return doIt(filledErrors);
-                }
-                if (!deep) {
-                    doIt(filledErrors);
-                }
-                else {
-                    // if rule is required but the target object
-                    // does not exist fail at the rule level and don't
-                    // go deeper
-                    if (rule.required && !data.value) {
-                        if (rule.message !== undefined) {
-                            filledErrors = []
-                                //@ts-ignore
-                                .concat(rule.message)
-                                .map((0, util_1.complementError)(rule, source));
-                        }
-                        else if (options.error) {
-                            filledErrors = [
-                                options.error(rule, (0, util_1.format)(options.messages.required, rule.field)),
-                            ];
-                        }
-                        return doIt(filledErrors);
-                    }
-                    let fieldsSchema = {};
-                    if (rule.defaultField) {
-                        Object.keys(data.value).map(key => {
-                            //@ts-ignore
-                            fieldsSchema[key] = rule.defaultField;
-                        });
-                    }
-                    fieldsSchema = {
-                        ...fieldsSchema,
-                        ...data.rule.fields,
-                    };
-                    const paredFieldsSchema = {};
-                    Object.keys(fieldsSchema).forEach(field => {
-                        const fieldSchema = fieldsSchema[field];
-                        const fieldSchemaList = Array.isArray(fieldSchema)
-                            ? fieldSchema
-                            : [fieldSchema];
-                        paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
-                    });
-                    const schema = new Schema(paredFieldsSchema);
-                    schema.messages(options.messages);
-                    if (data.rule.options) {
-                        data.rule.options.messages = options.messages;
-                        data.rule.options.error = options.error;
-                    }
-                    schema.validate(data.value, data.rule.options || options, errs => {
-                        const finalErrors = [];
-                        if (filledErrors && filledErrors.length) {
-                            //@ts-ignore
-                            finalErrors.push(...filledErrors);
-                        }
-                        if (errs && errs.length) {
-                            //@ts-ignore
-                            finalErrors.push(...errs);
-                        }
-                        //@ts-ignore
-                        doIt(finalErrors.length ? finalErrors : null);
-                    });
-                }
-            }
-            let res = undefined;
-            if (rule.asyncValidator) {
-                res = rule.asyncValidator(rule, data.value, cb, data.source, options);
-            }
-            else if (rule.validator) {
-                try {
-                    res = rule.validator(rule, data.value, cb, data.source, options);
-                }
-                catch (error) {
-                    console.error?.(error);
-                    // rethrow to report error
-                    if (!options.suppressValidatorError) {
-                        setTimeout(() => {
-                            throw error;
-                        }, 0);
-                    }
-                    //@ts-ignore
-                    cb(error.message);
-                }
-                if (res === true) {
-                    cb();
-                }
-                else if (res === false) {
-                    cb(typeof rule.message === 'function'
-                        ? rule.message(rule.fullField || rule.field)
-                        : rule.message || `${rule.fullField || rule.field} fails`);
-                }
-                else if (res instanceof Array) {
-                    cb(res);
-                }
-                else if (res instanceof Error) {
-                    cb(res.message);
-                }
-            }
-            if (res && res.then) {
-                res.then(() => cb(), e => cb(e));
-            }
-        }, results => {
-            complete(results);
-        }, source);
-    }
-    getType(rule) {
-        if (rule.type === undefined && rule.pattern instanceof RegExp) {
-            rule.type = 'pattern';
-        }
-        if (typeof rule.validator !== 'function' &&
-            rule.type &&
-            !index_1.default.hasOwnProperty(rule.type)) {
-            throw new Error((0, util_1.format)('Unknown rule type %s', rule.type));
-        }
-        return rule.type || 'string';
-    }
-    getValidationMethod(rule) {
-        if (typeof rule.validator === 'function') {
-            return rule.validator;
-        }
-        const keys = Object.keys(rule);
-        const messageIndex = keys.indexOf('message');
-        if (messageIndex !== -1) {
-            keys.splice(messageIndex, 1);
-        }
-        if (keys.length === 1 && keys[0] === 'required') {
-            return index_1.default.required;
-        }
-        return index_1.default[this.getType(rule)] || undefined;
-    }
-}
-exports.default = Schema;

package/bin/lib/modules/rule/async-validator/interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/bin/lib/modules/rule/async-validator/messages.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.messages = exports.newMessages = void 0;
-function newMessages() {
-    return {
-        default: 'Validation error on field %s',
-        required: '%s is required',
-        enum: '%s must be one of %s',
-        whitespace: '%s cannot be empty',
-        date: {
-            format: '%s date %s is invalid for format %s',
-            parse: '%s date could not be parsed, %s is invalid ',
-            invalid: '%s date %s is invalid',
-        },
-        types: {
-            string: '%s is not a %s',
-            method: '%s is not a %s (function)',
-            array: '%s is not an %s',
-            object: '%s is not an %s',
-            number: '%s is not a %s',
-            date: '%s is not a %s',
-            boolean: '%s is not a %s',
-            integer: '%s is not an %s',
-            float: '%s is not a %s',
-            regexp: '%s is not a valid %s',
-            email: '%s is not a valid %s',
-            url: '%s is not a valid %s',
-            hex: '%s is not a valid %s',
-        },
-        string: {
-            len: '%s must be exactly %s characters',
-            min: '%s must be at least %s characters',
-            max: '%s cannot be longer than %s characters',
-            range: '%s must be between %s and %s characters',
-        },
-        number: {
-            len: '%s must equal %s',
-            min: '%s cannot be less than %s',
-            max: '%s cannot be greater than %s',
-            range: '%s must be between %s and %s',
-        },
-        array: {
-            len: '%s must be exactly %s in length',
-            min: '%s cannot be less than %s in length',
-            max: '%s cannot be greater than %s in length',
-            range: '%s must be between %s and %s in length',
-        },
-        pattern: {
-            mismatch: '%s value %s does not match pattern %s',
-        },
-        clone() {
-            const cloned = JSON.parse(JSON.stringify(this));
-            cloned.clone = this.clone;
-            return cloned;
-        },
-    };
-}
-exports.newMessages = newMessages;
-exports.messages = newMessages();

package/bin/lib/modules/rule/async-validator/rule/enum.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../util");
-const ENUM = 'enum';
-const enumerable = (rule, value, source, errors, options) => {
-    rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];
-    if (rule[ENUM].indexOf(value) === -1) {
-        errors.push(
-        //@ts-ignore
-        (0, util_1.format)(options.messages[ENUM], rule.fullField, rule[ENUM].join(', ')));
-    }
-};
-exports.default = enumerable;

package/bin/lib/modules/rule/async-validator/rule/index.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const required_1 = require("./required");
-const whitespace_1 = require("./whitespace");
-const type_1 = require("./type");
-const range_1 = require("./range");
-const enum_1 = require("./enum");
-const pattern_1 = require("./pattern");
-exports.default = {
-    required: required_1.default,
-    whitespace: whitespace_1.default,
-    type: type_1.default,
-    range: range_1.default,
-    enum: enum_1.default,
-    pattern: pattern_1.default,
-};

package/bin/lib/modules/rule/async-validator/rule/pattern.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../util");
-const pattern = (rule, value, source, errors, options) => {
-    if (rule.pattern) {
-        if (rule.pattern instanceof RegExp) {
-            // if a RegExp instance is passed, reset `lastIndex` in case its `global`
-            // flag is accidentally set to `true`, which in a validation scenario
-            // is not necessary and the result might be misleading
-            rule.pattern.lastIndex = 0;
-            if (!rule.pattern.test(value)) {
-                errors.push((0, util_1.format)(
-                //@ts-ignore
-                options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
-            }
-        }
-        else if (typeof rule.pattern === 'string') {
-            const _pattern = new RegExp(rule.pattern);
-            if (!_pattern.test(value)) {
-                errors.push((0, util_1.format)(
-                //@ts-ignore
-                options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
-            }
-        }
-    }
-};
-exports.default = pattern;

package/bin/lib/modules/rule/async-validator/rule/range.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../util");
-const range = (rule, value, source, errors, options) => {
-    const len = typeof rule.len === 'number';
-    const min = typeof rule.min === 'number';
-    const max = typeof rule.max === 'number';
-    // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
-    const spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-    let val = value;
-    let key = "";
-    const num = typeof value === 'number';
-    const str = typeof value === 'string';
-    const arr = Array.isArray(value);
-    if (num) {
-        key = 'number';
-    }
-    else if (str) {
-        key = 'string';
-    }
-    else if (arr) {
-        key = 'array';
-    }
-    // if the value is not of a supported type for range validation
-    // the validation rule rule should use the
-    // type property to also test for a particular type
-    if (!key) {
-        return false;
-    }
-    if (arr) {
-        val = value.length;
-    }
-    if (str) {
-        // 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".length !== 3
-        val = value.replace(spRegexp, '_').length;
-    }
-    if (len) {
-        if (val !== rule.len) {
-            //@ts-ignore
-            errors.push((0, util_1.format)(options.messages[key].len, rule.fullField, rule.len));
-        }
-        //@ts-ignore
-    }
-    else if (min && !max && val < rule.min) {
-        errors.push((0, util_1.format)(options.messages[key].min, rule.fullField, rule.min));
-    }
-    else if (max && !min && val > rule.max) {
-        errors.push((0, util_1.format)(options.messages[key].max, rule.fullField, rule.max));
-    }
-    else if (min && max && (val < rule.min || val > rule.max)) {
-        errors.push((0, util_1.format)(options.messages[key].range, rule.fullField, rule.min, rule.max));
-    }
-};
-exports.default = range;

package/bin/lib/modules/rule/async-validator/rule/required.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../util");
-const required = (rule, value, source, errors, options, type) => {
-    if (rule.required &&
-        (!source.hasOwnProperty(rule.field || "") ||
-            (0, util_1.isEmptyValue)(value, type || rule.type))) {
-        //@ts-ignore
-        errors.push((0, util_1.format)(options.messages.required, rule.fullField));
-    }
-};
-exports.default = required;

package/bin/lib/modules/rule/async-validator/rule/type.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../util");
-const required_1 = require("./required");
-const url_1 = require("./url");
-/* eslint max-len:0 */
-const pattern = {
-    // http://emailregex.com/
-    email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
-    // url: new RegExp(
-    //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
-    //   'i',
-    // ),
-    hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
-};
-const types = {
-    integer(value) {
-        return types.number(value) && parseInt(value, 10) === value;
-    },
-    float(value) {
-        return types.number(value) && !types.integer(value);
-    },
-    array(value) {
-        return Array.isArray(value);
-    },
-    regexp(value) {
-        if (value instanceof RegExp) {
-            return true;
-        }
-        try {
-            return !!new RegExp(value);
-        }
-        catch (e) {
-            return false;
-        }
-    },
-    date(value) {
-        return (typeof value.getTime === 'function' &&
-            typeof value.getMonth === 'function' &&
-            typeof value.getYear === 'function' &&
-            !isNaN(value.getTime()));
-    },
-    number(value) {
-        if (isNaN(value)) {
-            return false;
-        }
-        return typeof value === 'number';
-    },
-    object(value) {
-        return typeof value === 'object' && !types.array(value);
-    },
-    method(value) {
-        return typeof value === 'function';
-    },
-    email(value) {
-        return (typeof value === 'string' &&
-            value.length <= 320 &&
-            !!value.match(pattern.email));
-    },
-    url(value) {
-        return (typeof value === 'string' &&
-            value.length <= 2048 &&
-            !!value.match((0, url_1.default)()));
-    },
-    hex(value) {
-        return typeof value === 'string' && !!value.match(pattern.hex);
-    },
-};
-const type = (rule, value, source, errors, options) => {
-    if (rule.required && value === undefined) {
-        (0, required_1.default)(rule, value, source, errors, options);
-        return;
-    }
-    const custom = [
-        'integer',
-        'float',
-        'array',
-        'regexp',
-        'object',
-        'method',
-        'email',
-        'number',
-        'date',
-        'url',
-        'hex',
-    ];
-    const ruleType = rule.type;
-    if (custom.indexOf(ruleType) > -1) {
-        if (!types[ruleType](value)) {
-            errors.push((0, util_1.format)(options.messages.types[ruleType], rule.fullField, rule.type));
-        }
-        // straight typeof check
-    }
-    else if (ruleType && typeof value !== rule.type) {
-        errors.push((0, util_1.format)(options.messages.types[ruleType], rule.fullField, rule.type));
-    }
-};
-exports.default = type;

package/bin/lib/modules/rule/async-validator/rule/url.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// https://github.com/kevva/url-regex/blob/master/index.js
-let urlReg;
-exports.default = () => {
-    if (urlReg) {
-        return urlReg;
-    }
-    const word = '[a-fA-F\\d:]';
-    const b = options => options && options.includeBoundaries
-        ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))`
-        : '';
-    const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
-    const v6seg = '[a-fA-F\\d]{1,4}';
-    const v6 = `
-(?:
-(?:${v6seg}:){7}(?:${v6seg}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
-(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
-(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
-(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
-(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
-(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
-(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
-(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
-)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
-`
-        .replace(/\s*\/\/.*$/gm, '')
-        .replace(/\n/g, '')
-        .trim();
-    // Pre-compile only the exact regexes because adding a global flag make regexes stateful
-    const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
-    const v4exact = new RegExp(`^${v4}$`);
-    const v6exact = new RegExp(`^${v6}$`);
-    const ip = options => options && options.exact
-        ? v46Exact
-        : new RegExp(`(?:${b(options)}${v4}${b(options)})|(?:${b(options)}${v6}${b(options)})`, 'g');
-    ip.v4 = (options) => options && options.exact
-        ? v4exact
-        : new RegExp(`${b(options)}${v4}${b(options)}`, 'g');
-    ip.v6 = (options) => options && options.exact
-        ? v6exact
-        : new RegExp(`${b(options)}${v6}${b(options)}`, 'g');
-    const protocol = `(?:(?:[a-z]+:)?//)`;
-    const auth = '(?:\\S+(?::\\S*)?@)?';
-    const ipv4 = ip.v4().source;
-    const ipv6 = ip.v6().source;
-    const host = '(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)';
-    const domain = '(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*';
-    const tld = `(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))`;
-    const port = '(?::\\d{2,5})?';
-    const path = '(?:[/?#][^\\s"]*)?';
-    const regex = `(?:${protocol}|www\\.)${auth}(?:localhost|${ipv4}|${ipv6}|${host}${domain}${tld})${port}${path}`;
-    urlReg = new RegExp(`(?:^${regex}$)`, 'i');
-    return urlReg;
-};

package/bin/lib/modules/rule/async-validator/rule/whitespace.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("../util");
-/**
- *  Rule for validating whitespace.
- *
- *  @param rule The validation rule.
- *  @param value The value of the field on the source object.
- *  @param source The source object being validated.
- *  @param errors An array of errors that this rule may add
- *  validation errors to.
- *  @param options The validation options.
- *  @param options.messages The validation messages.
- */
-const whitespace = (rule, value, source, errors, options) => {
-    if (/^\s+$/.test(value) || value === '') {
-        errors.push((0, util_1.format)(options.messages.whitespace, rule.fullField));
-    }
-};
-exports.default = whitespace;