@xiping/react-components 1.0.20 → 1.0.21

package/dist/es/node_modules/.pnpm/bowser@2.11.0/node_modules/bowser/src/parser-os.js

@@ -0,0 +1,159 @@
+import s from "./utils.js";
+import { OS_MAP as n } from "./constants.js";
+const a = [
+  /* Roku */
+  {
+    test: [/Roku\/DVP/],
+    describe(t) {
+      const e = s.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, t);
+      return {
+        name: n.Roku,
+        version: e
+      };
+    }
+  },
+  /* Windows Phone */
+  {
+    test: [/windows phone/i],
+    describe(t) {
+      const e = s.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, t);
+      return {
+        name: n.WindowsPhone,
+        version: e
+      };
+    }
+  },
+  /* Windows */
+  {
+    test: [/windows /i],
+    describe(t) {
+      const e = s.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, t), i = s.getWindowsVersionName(e);
+      return {
+        name: n.Windows,
+        version: e,
+        versionName: i
+      };
+    }
+  },
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe(t) {
+      const e = {
+        name: n.iOS
+      }, i = s.getSecondMatch(/(Version\/)(\d[\d.]+)/, t);
+      return i && (e.version = i), e;
+    }
+  },
+  /* macOS */
+  {
+    test: [/macintosh/i],
+    describe(t) {
+      const e = s.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, t).replace(/[_\s]/g, "."), i = s.getMacOSVersionName(e), r = {
+        name: n.MacOS,
+        version: e
+      };
+      return i && (r.versionName = i), r;
+    }
+  },
+  /* iOS */
+  {
+    test: [/(ipod|iphone|ipad)/i],
+    describe(t) {
+      const e = s.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, t).replace(/[_\s]/g, ".");
+      return {
+        name: n.iOS,
+        version: e
+      };
+    }
+  },
+  /* Android */
+  {
+    test(t) {
+      const e = !t.test(/like android/i), i = t.test(/android/i);
+      return e && i;
+    },
+    describe(t) {
+      const e = s.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, t), i = s.getAndroidVersionName(e), r = {
+        name: n.Android,
+        version: e
+      };
+      return i && (r.versionName = i), r;
+    }
+  },
+  /* WebOS */
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(t) {
+      const e = s.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, t), i = {
+        name: n.WebOS
+      };
+      return e && e.length && (i.version = e), i;
+    }
+  },
+  /* BlackBerry */
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(t) {
+      const e = s.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, t) || s.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, t) || s.getFirstMatch(/\bbb(\d+)/i, t);
+      return {
+        name: n.BlackBerry,
+        version: e
+      };
+    }
+  },
+  /* Bada */
+  {
+    test: [/bada/i],
+    describe(t) {
+      const e = s.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, t);
+      return {
+        name: n.Bada,
+        version: e
+      };
+    }
+  },
+  /* Tizen */
+  {
+    test: [/tizen/i],
+    describe(t) {
+      const e = s.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, t);
+      return {
+        name: n.Tizen,
+        version: e
+      };
+    }
+  },
+  /* Linux */
+  {
+    test: [/linux/i],
+    describe() {
+      return {
+        name: n.Linux
+      };
+    }
+  },
+  /* Chrome OS */
+  {
+    test: [/CrOS/],
+    describe() {
+      return {
+        name: n.ChromeOS
+      };
+    }
+  },
+  /* Playstation 4 */
+  {
+    test: [/PlayStation 4/],
+    describe(t) {
+      const e = s.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, t);
+      return {
+        name: n.PlayStation4,
+        version: e
+      };
+    }
+  }
+];
+export {
+  a as default
+};

package/dist/es/node_modules/.pnpm/bowser@2.11.0/node_modules/bowser/src/parser-platforms.js

@@ -0,0 +1,238 @@
+import s from "./utils.js";
+import { PLATFORMS_MAP as t } from "./constants.js";
+const d = [
+  /* Googlebot */
+  {
+    test: [/googlebot/i],
+    describe() {
+      return {
+        type: "bot",
+        vendor: "Google"
+      };
+    }
+  },
+  /* Huawei */
+  {
+    test: [/huawei/i],
+    describe(e) {
+      const r = s.getFirstMatch(/(can-l01)/i, e) && "Nova", i = {
+        type: t.mobile,
+        vendor: "Huawei"
+      };
+      return r && (i.model = r), i;
+    }
+  },
+  /* Nexus Tablet */
+  {
+    test: [/nexus\s*(?:7|8|9|10).*/i],
+    describe() {
+      return {
+        type: t.tablet,
+        vendor: "Nexus"
+      };
+    }
+  },
+  /* iPad */
+  {
+    test: [/ipad/i],
+    describe() {
+      return {
+        type: t.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe() {
+      return {
+        type: t.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  /* Amazon Kindle Fire */
+  {
+    test: [/kftt build/i],
+    describe() {
+      return {
+        type: t.tablet,
+        vendor: "Amazon",
+        model: "Kindle Fire HD 7"
+      };
+    }
+  },
+  /* Another Amazon Tablet with Silk */
+  {
+    test: [/silk/i],
+    describe() {
+      return {
+        type: t.tablet,
+        vendor: "Amazon"
+      };
+    }
+  },
+  /* Tablet */
+  {
+    test: [/tablet(?! pc)/i],
+    describe() {
+      return {
+        type: t.tablet
+      };
+    }
+  },
+  /* iPod/iPhone */
+  {
+    test(e) {
+      const r = e.test(/ipod|iphone/i), i = e.test(/like (ipod|iphone)/i);
+      return r && !i;
+    },
+    describe(e) {
+      const r = s.getFirstMatch(/(ipod|iphone)/i, e);
+      return {
+        type: t.mobile,
+        vendor: "Apple",
+        model: r
+      };
+    }
+  },
+  /* Nexus Mobile */
+  {
+    test: [/nexus\s*[0-6].*/i, /galaxy nexus/i],
+    describe() {
+      return {
+        type: t.mobile,
+        vendor: "Nexus"
+      };
+    }
+  },
+  /* Mobile */
+  {
+    test: [/[^-]mobi/i],
+    describe() {
+      return {
+        type: t.mobile
+      };
+    }
+  },
+  /* BlackBerry */
+  {
+    test(e) {
+      return e.getBrowserName(!0) === "blackberry";
+    },
+    describe() {
+      return {
+        type: t.mobile,
+        vendor: "BlackBerry"
+      };
+    }
+  },
+  /* Bada */
+  {
+    test(e) {
+      return e.getBrowserName(!0) === "bada";
+    },
+    describe() {
+      return {
+        type: t.mobile
+      };
+    }
+  },
+  /* Windows Phone */
+  {
+    test(e) {
+      return e.getBrowserName() === "windows phone";
+    },
+    describe() {
+      return {
+        type: t.mobile,
+        vendor: "Microsoft"
+      };
+    }
+  },
+  /* Android Tablet */
+  {
+    test(e) {
+      const r = Number(String(e.getOSVersion()).split(".")[0]);
+      return e.getOSName(!0) === "android" && r >= 3;
+    },
+    describe() {
+      return {
+        type: t.tablet
+      };
+    }
+  },
+  /* Android Mobile */
+  {
+    test(e) {
+      return e.getOSName(!0) === "android";
+    },
+    describe() {
+      return {
+        type: t.mobile
+      };
+    }
+  },
+  /* desktop */
+  {
+    test(e) {
+      return e.getOSName(!0) === "macos";
+    },
+    describe() {
+      return {
+        type: t.desktop,
+        vendor: "Apple"
+      };
+    }
+  },
+  /* Windows */
+  {
+    test(e) {
+      return e.getOSName(!0) === "windows";
+    },
+    describe() {
+      return {
+        type: t.desktop
+      };
+    }
+  },
+  /* Linux */
+  {
+    test(e) {
+      return e.getOSName(!0) === "linux";
+    },
+    describe() {
+      return {
+        type: t.desktop
+      };
+    }
+  },
+  /* PlayStation 4 */
+  {
+    test(e) {
+      return e.getOSName(!0) === "playstation 4";
+    },
+    describe() {
+      return {
+        type: t.tv
+      };
+    }
+  },
+  /* Roku */
+  {
+    test(e) {
+      return e.getOSName(!0) === "roku";
+    },
+    describe() {
+      return {
+        type: t.tv
+      };
+    }
+  }
+];
+export {
+  d as default
+};

package/dist/es/node_modules/.pnpm/bowser@2.11.0/node_modules/bowser/src/parser.js

@@ -0,0 +1,303 @@
+import h from "./parser-browsers.js";
+import l from "./parser-os.js";
+import p from "./parser-platforms.js";
+import m from "./parser-engines.js";
+import n from "./utils.js";
+class B {
+  /**
+   * Create instance of Parser
+   *
+   * @param {String} UA User-Agent string
+   * @param {Boolean} [skipParsing=false] parser can skip parsing in purpose of performance
+   * improvements if you need to make a more particular parsing
+   * like {@link Parser#parseBrowser} or {@link Parser#parsePlatform}
+   *
+   * @throw {Error} in case of empty UA String
+   *
+   * @constructor
+   */
+  constructor(t, e = !1) {
+    if (t == null || t === "")
+      throw new Error("UserAgent parameter can't be empty");
+    this._ua = t, this.parsedResult = {}, e !== !0 && this.parse();
+  }
+  /**
+   * Get UserAgent string of current Parser instance
+   * @return {String} User-Agent String of the current <Parser> object
+   *
+   * @public
+   */
+  getUA() {
+    return this._ua;
+  }
+  /**
+   * Test a UA string for a regexp
+   * @param {RegExp} regex
+   * @return {Boolean}
+   */
+  test(t) {
+    return t.test(this._ua);
+  }
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   */
+  parseBrowser() {
+    this.parsedResult.browser = {};
+    const t = n.find(h, (e) => {
+      if (typeof e.test == "function")
+        return e.test(this);
+      if (e.test instanceof Array)
+        return e.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return t && (this.parsedResult.browser = t.describe(this.getUA())), this.parsedResult.browser;
+  }
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   *
+   * @public
+   */
+  getBrowser() {
+    return this.parsedResult.browser ? this.parsedResult.browser : this.parseBrowser();
+  }
+  /**
+   * Get browser's name
+   * @return {String} Browser's name or an empty string
+   *
+   * @public
+   */
+  getBrowserName(t) {
+    return t ? String(this.getBrowser().name).toLowerCase() || "" : this.getBrowser().name || "";
+  }
+  /**
+   * Get browser's version
+   * @return {String} version of browser
+   *
+   * @public
+   */
+  getBrowserVersion() {
+    return this.getBrowser().version;
+  }
+  /**
+   * Get OS
+   * @return {Object}
+   *
+   * @example
+   * this.getOS();
+   * {
+   *   name: 'macOS',
+   *   version: '10.11.12'
+   * }
+   */
+  getOS() {
+    return this.parsedResult.os ? this.parsedResult.os : this.parseOS();
+  }
+  /**
+   * Parse OS and save it to this.parsedResult.os
+   * @return {*|{}}
+   */
+  parseOS() {
+    this.parsedResult.os = {};
+    const t = n.find(l, (e) => {
+      if (typeof e.test == "function")
+        return e.test(this);
+      if (e.test instanceof Array)
+        return e.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return t && (this.parsedResult.os = t.describe(this.getUA())), this.parsedResult.os;
+  }
+  /**
+   * Get OS name
+   * @param {Boolean} [toLowerCase] return lower-cased value
+   * @return {String} name of the OS — macOS, Windows, Linux, etc.
+   */
+  getOSName(t) {
+    const { name: e } = this.getOS();
+    return t ? String(e).toLowerCase() || "" : e || "";
+  }
+  /**
+   * Get OS version
+   * @return {String} full version with dots ('10.11.12', '5.6', etc)
+   */
+  getOSVersion() {
+    return this.getOS().version;
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  getPlatform() {
+    return this.parsedResult.platform ? this.parsedResult.platform : this.parsePlatform();
+  }
+  /**
+   * Get platform name
+   * @param {Boolean} [toLowerCase=false]
+   * @return {*}
+   */
+  getPlatformType(t = !1) {
+    const { type: e } = this.getPlatform();
+    return t ? String(e).toLowerCase() || "" : e || "";
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parsePlatform() {
+    this.parsedResult.platform = {};
+    const t = n.find(p, (e) => {
+      if (typeof e.test == "function")
+        return e.test(this);
+      if (e.test instanceof Array)
+        return e.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return t && (this.parsedResult.platform = t.describe(this.getUA())), this.parsedResult.platform;
+  }
+  /**
+   * Get parsed engine
+   * @return {{}}
+   */
+  getEngine() {
+    return this.parsedResult.engine ? this.parsedResult.engine : this.parseEngine();
+  }
+  /**
+   * Get engines's name
+   * @return {String} Engines's name or an empty string
+   *
+   * @public
+   */
+  getEngineName(t) {
+    return t ? String(this.getEngine().name).toLowerCase() || "" : this.getEngine().name || "";
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parseEngine() {
+    this.parsedResult.engine = {};
+    const t = n.find(m, (e) => {
+      if (typeof e.test == "function")
+        return e.test(this);
+      if (e.test instanceof Array)
+        return e.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return t && (this.parsedResult.engine = t.describe(this.getUA())), this.parsedResult.engine;
+  }
+  /**
+   * Parse full information about the browser
+   * @returns {Parser}
+   */
+  parse() {
+    return this.parseBrowser(), this.parseOS(), this.parsePlatform(), this.parseEngine(), this;
+  }
+  /**
+   * Get parsed result
+   * @return {ParsedResult}
+   */
+  getResult() {
+    return n.assign({}, this.parsedResult);
+  }
+  /**
+   * Check if parsed browser matches certain conditions
+   *
+   * @param {Object} checkTree It's one or two layered object,
+   * which can include a platform or an OS on the first layer
+   * and should have browsers specs on the bottom-laying layer
+   *
+   * @returns {Boolean|undefined} Whether the browser satisfies the set conditions or not.
+   * Returns `undefined` when the browser is no described in the checkTree object.
+   *
+   * @example
+   * const browser = Bowser.getParser(window.navigator.userAgent);
+   * if (browser.satisfies({chrome: '>118.01.1322' }))
+   * // or with os
+   * if (browser.satisfies({windows: { chrome: '>118.01.1322' } }))
+   * // or with platforms
+   * if (browser.satisfies({desktop: { chrome: '>118.01.1322' } }))
+   */
+  satisfies(t) {
+    const e = {};
+    let s = 0;
+    const r = {};
+    let a = 0;
+    if (Object.keys(t).forEach((f) => {
+      const i = t[f];
+      typeof i == "string" ? (r[f] = i, a += 1) : typeof i == "object" && (e[f] = i, s += 1);
+    }), s > 0) {
+      const f = Object.keys(e), i = n.find(f, (o) => this.isOS(o));
+      if (i) {
+        const o = this.satisfies(e[i]);
+        if (o !== void 0)
+          return o;
+      }
+      const u = n.find(
+        f,
+        (o) => this.isPlatform(o)
+      );
+      if (u) {
+        const o = this.satisfies(e[u]);
+        if (o !== void 0)
+          return o;
+      }
+    }
+    if (a > 0) {
+      const f = Object.keys(r), i = n.find(f, (u) => this.isBrowser(u, !0));
+      if (i !== void 0)
+        return this.compareVersion(r[i]);
+    }
+  }
+  /**
+   * Check if the browser name equals the passed string
+   * @param browserName The string to compare with the browser name
+   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
+   * @returns {boolean}
+   */
+  isBrowser(t, e = !1) {
+    const s = this.getBrowserName().toLowerCase();
+    let r = t.toLowerCase();
+    const a = n.getBrowserTypeByAlias(r);
+    return e && a && (r = a.toLowerCase()), r === s;
+  }
+  compareVersion(t) {
+    let e = [0], s = t, r = !1;
+    const a = this.getBrowserVersion();
+    if (typeof a == "string")
+      return t[0] === ">" || t[0] === "<" ? (s = t.substr(1), t[1] === "=" ? (r = !0, s = t.substr(2)) : e = [], t[0] === ">" ? e.push(1) : e.push(-1)) : t[0] === "=" ? s = t.substr(1) : t[0] === "~" && (r = !0, s = t.substr(1)), e.indexOf(
+        n.compareVersions(a, s, r)
+      ) > -1;
+  }
+  isOS(t) {
+    return this.getOSName(!0) === String(t).toLowerCase();
+  }
+  isPlatform(t) {
+    return this.getPlatformType(!0) === String(t).toLowerCase();
+  }
+  isEngine(t) {
+    return this.getEngineName(!0) === String(t).toLowerCase();
+  }
+  /**
+   * Is anything? Check if the browser is called "anything",
+   * the OS called "anything" or the platform called "anything"
+   * @param {String} anything
+   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
+   * @returns {Boolean}
+   */
+  is(t, e = !1) {
+    return this.isBrowser(t, e) || this.isOS(t) || this.isPlatform(t);
+  }
+  /**
+   * Check if any of the given values satisfies this.is(anything)
+   * @param {String[]} anythings
+   * @returns {Boolean}
+   */
+  some(t = []) {
+    return t.some((e) => this.is(e));
+  }
+}
+export {
+  B as default
+};