init commit

shared/utils/node_modules/@amp/runtime-detect/dist/version.js

@@ -0,0 +1,99 @@
+function parseVersion(input) {
+    const data = {
+        version: input.toLowerCase()
+    };
+    const parts = input.toLowerCase().split('.').filter((p)=>!!p);
+    // Only parse single parts that are actual numbers.
+    // This check will prevent `parseInt` from pasing the leading chars if they are
+    // valid numbers.
+    if (parts.length <= 1 && !/^\d+$/.test(parts[0])) {
+        return data;
+    }
+    const major = parseInt(parts[0], 10);
+    const minor = parseInt(parts[1], 10);
+    const patch = parseInt(parts[2], 10);
+    // Only add converted versions if `major` part was valid
+    if (!Number.isNaN(major)) {
+        data.major = major;
+        if (!Number.isNaN(minor)) data.minor = minor;
+        if (!Number.isNaN(patch)) data.patch = patch;
+    }
+    return data;
+}
+/**
+ * Check if the given value is a complete Version struct.
+ */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isVersion(value) {
+    var _value, _value1;
+    return typeof ((_value = value) === null || _value === void 0 ? void 0 : _value.major) === 'number' && typeof ((_value1 = value) === null || _value1 === void 0 ? void 0 : _value1.minor) === 'number';
+}
+/**
+ * Compare two version numbers together.
+ *
+ * NOTE: This only supports the first 3 segments (major, minor, patch) and does not
+ *       do a full SemVer compare.
+ *
+ * @example
+ * ```javascript
+ * compareVersion('1.2.3', '1.2.4');
+ * // => -1
+ * ```
+ */ function compareVersion(base, comp) {
+    let baseList = toNumbers(base);
+    let compList = toNumbers(comp);
+    // Right pad versions with zeros to make them equal length
+    const versionLength = Math.max(baseList.length, compList.length);
+    baseList = baseList.concat(Array(versionLength).fill(0)).slice(0, versionLength);
+    compList = compList.concat(Array(versionLength).fill(0)).slice(0, versionLength);
+    /** Constrain the given value to the output range of this function. */ const constrain = (value)=>{
+        if (value <= -1) return -1;
+        else if (value >= 1) return 1;
+        else return 0;
+    };
+    for(let index = 0; index < versionLength; index++){
+        const aValue = baseList[index];
+        const bValue = compList[index];
+        if (aValue !== bValue) {
+            return constrain(aValue - bValue);
+        }
+    }
+    return 0;
+}
+function eq(base, comp) {
+    return compareVersion(base, comp) === 0;
+}
+function gt(base, comp) {
+    return compareVersion(base, comp) > 0;
+}
+function gte(base, comp) {
+    const result = compareVersion(base, comp);
+    return result > 0 || result === 0;
+}
+function lt(base, comp) {
+    return compareVersion(base, comp) < 0;
+}
+function lte(base, comp) {
+    const result = compareVersion(base, comp);
+    return result < 0 || result === 0;
+}
+function toNumbers(value) {
+    if (Array.isArray(value)) {
+        return value;
+    } else if (typeof value === 'number') {
+        return [
+            value
+        ];
+    } else if (typeof value === 'string') {
+        return toNumbers(parseVersion(value));
+    } else {
+        const values = [
+            value.major,
+            value.minor,
+            value.patch
+        ];
+        const uidx = values.indexOf(undefined);
+        return uidx === -1 ? values : values.slice(0, uidx);
+    }
+}
+
+export { compareVersion, eq, gt, gte, isVersion, lt, lte, parseVersion };