basant307/AI_Governance_Project

1(function (global, factory) {2    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :3    typeof define === 'function' && define.amd ? define(['exports'], factory) :4    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.compareVersions = {}));5})(this, (function (exports) { 'use strict';6 7    const semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;8    const validateAndParse = (version) => {9        if (typeof version !== 'string') {10            throw new TypeError('Invalid argument expected string');11        }12        const match = version.match(semver);13        if (!match) {14            throw new Error(`Invalid argument not valid semver ('${version}' received)`);15        }16        match.shift();17        return match;18    };19    const isWildcard = (s) => s === '*' || s === 'x' || s === 'X';20    const tryParse = (v) => {21        const n = parseInt(v, 10);22        return isNaN(n) ? v : n;23    };24    const forceType = (a, b) => typeof a !== typeof b ? [String(a), String(b)] : [a, b];25    const compareStrings = (a, b) => {26        if (isWildcard(a) || isWildcard(b))27            return 0;28        const [ap, bp] = forceType(tryParse(a), tryParse(b));29        if (ap > bp)30            return 1;31        if (ap < bp)32            return -1;33        return 0;34    };35    const compareSegments = (a, b) => {36        for (let i = 0; i < Math.max(a.length, b.length); i++) {37            const r = compareStrings(a[i] || '0', b[i] || '0');38            if (r !== 0)39                return r;40        }41        return 0;42    };43 44    /**45     * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.46     * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.47     * @param v1 - First version to compare48     * @param v2 - Second version to compare49     * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).50     */51    const compareVersions = (v1, v2) => {52        // validate input and split into segments53        const n1 = validateAndParse(v1);54        const n2 = validateAndParse(v2);55        // pop off the patch56        const p1 = n1.pop();57        const p2 = n2.pop();58        // validate numbers59        const r = compareSegments(n1, n2);60        if (r !== 0)61            return r;62        // validate pre-release63        if (p1 && p2) {64            return compareSegments(p1.split('.'), p2.split('.'));65        }66        else if (p1 || p2) {67            return p1 ? -1 : 1;68        }69        return 0;70    };71 72    /**73     * Compare [semver](https://semver.org/) version strings using the specified operator.74     *75     * @param v1 First version to compare76     * @param v2 Second version to compare77     * @param operator Allowed arithmetic operator to use78     * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.79     *80     * @example81     * ```82     * compare('10.1.8', '10.0.4', '>'); // return true83     * compare('10.0.1', '10.0.1', '='); // return true84     * compare('10.1.1', '10.2.2', '<'); // return true85     * compare('10.1.1', '10.2.2', '<='); // return true86     * compare('10.1.1', '10.2.2', '>='); // return false87     * ```88     */89    const compare = (v1, v2, operator) => {90        // validate input operator91        assertValidOperator(operator);92        // since result of compareVersions can only be -1 or 0 or 193        // a simple map can be used to replace switch94        const res = compareVersions(v1, v2);95        return operatorResMap[operator].includes(res);96    };97    const operatorResMap = {98        '>': [1],99        '>=': [0, 1],100        '=': [0],101        '<=': [-1, 0],102        '<': [-1],103        '!=': [-1, 1],104    };105    const allowedOperators = Object.keys(operatorResMap);106    const assertValidOperator = (op) => {107        if (typeof op !== 'string') {108            throw new TypeError(`Invalid operator type, expected string but got ${typeof op}`);109        }110        if (allowedOperators.indexOf(op) === -1) {111            throw new Error(`Invalid operator, expected one of ${allowedOperators.join('|')}`);112        }113    };114 115    /**116     * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.117     *118     * @param version Version number to match119     * @param range Range pattern for version120     * @returns `true` if the version number is within the range, `false` otherwise.121     *122     * @example123     * ```124     * satisfies('1.1.0', '^1.0.0'); // return true125     * satisfies('1.1.0', '~1.0.0'); // return false126     * ```127     */128    const satisfies = (version, range) => {129        // clean input130        range = range.replace(/([><=]+)\s+/g, '$1');131        // handle multiple comparators132        if (range.includes('||')) {133            return range.split('||').some((r) => satisfies(version, r));134        }135        else if (range.includes(' - ')) {136            const [a, b] = range.split(' - ', 2);137            return satisfies(version, `>=${a} <=${b}`);138        }139        else if (range.includes(' ')) {140            return range141                .trim()142                .replace(/\s{2,}/g, ' ')143                .split(' ')144                .every((r) => satisfies(version, r));145        }146        // if no range operator then "="147        const m = range.match(/^([<>=~^]+)/);148        const op = m ? m[1] : '=';149        // if gt/lt/eq then operator compare150        if (op !== '^' && op !== '~')151            return compare(version, range, op);152        // else range of either "~" or "^" is assumed153        const [v1, v2, v3, , vp] = validateAndParse(version);154        const [r1, r2, r3, , rp] = validateAndParse(range);155        const v = [v1, v2, v3];156        const r = [r1, r2 !== null && r2 !== void 0 ? r2 : 'x', r3 !== null && r3 !== void 0 ? r3 : 'x'];157        // validate pre-release158        if (rp) {159            if (!vp)160                return false;161            if (compareSegments(v, r) !== 0)162                return false;163            if (compareSegments(vp.split('.'), rp.split('.')) === -1)164                return false;165        }166        // first non-zero number167        const nonZero = r.findIndex((v) => v !== '0') + 1;168        // pointer to where segments can be >=169        const i = op === '~' ? 2 : nonZero > 1 ? nonZero : 1;170        // before pointer must be equal171        if (compareSegments(v.slice(0, i), r.slice(0, i)) !== 0)172            return false;173        // after pointer must be >=174        if (compareSegments(v.slice(i), r.slice(i)) === -1)175            return false;176        return true;177    };178 179    /**180     * Validate [semver](https://semver.org/) version strings.181     *182     * @param version Version number to validate183     * @returns `true` if the version number is a valid semver version number, `false` otherwise.184     *185     * @example186     * ```187     * validate('1.0.0-rc.1'); // return true188     * validate('1.0-rc.1'); // return false189     * validate('foo'); // return false190     * ```191     */192    const validate = (version) => typeof version === 'string' && /^[v\d]/.test(version) && semver.test(version);193    /**194     * Validate [semver](https://semver.org/) version strings strictly. Will not accept wildcards and version ranges.195     *196     * @param version Version number to validate197     * @returns `true` if the version number is a valid semver version number `false` otherwise198     *199     * @example200     * ```201     * validate('1.0.0-rc.1'); // return true202     * validate('1.0-rc.1'); // return false203     * validate('foo'); // return false204     * ```205     */206    const validateStrict = (version) => typeof version === 'string' &&207        /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(version);208 209    exports.compare = compare;210    exports.compareVersions = compareVersions;211    exports.satisfies = satisfies;212    exports.validate = validate;213    exports.validateStrict = validateStrict;214 215}));216//# sourceMappingURL=index.js.map217