@bleedingdev/modern-js-utils 3.2.0-ultramodern.9 → 3.2.0-ultramodern.90

package/dist/compiled/address/index.js

@@ -0,0 +1,171 @@
+(()=>{
+    "use strict";
+    var e = {
+        198: (e, r, a)=>{
+            var n = a(37);
+            var i = a(147);
+            var t = a(81);
+            var f = "/etc/resolv.conf";
+            function getInterfaceName() {
+                var e = "eth";
+                var r = n.platform();
+                if ("darwin" === r) e = "en";
+                else if ("win32" === r) e = null;
+                return e;
+            }
+            function getIfconfigCMD() {
+                if ("win32" === n.platform()) return "ipconfig/all";
+                return "/sbin/ifconfig";
+            }
+            function address(e, r) {
+                if ("function" == typeof e) {
+                    r = e;
+                    e = null;
+                }
+                var a = {
+                    ip: address.ip(e),
+                    ipv6: address.ipv6(e),
+                    mac: null
+                };
+                address.mac(e, function(e, n) {
+                    if (n) a.mac = n;
+                    r(e, a);
+                });
+            }
+            address.interface = function(e, r) {
+                var a = n.networkInterfaces();
+                var i = !r;
+                r = r || getInterfaceName();
+                e = e || "IPv4";
+                for(var t = -1; t < 8; t++){
+                    var f = r + (t >= 0 ? t : "");
+                    var s = a[f];
+                    if (s) for(var d = 0; d < s.length; d++){
+                        var c = s[d];
+                        if (c.family === e) return c;
+                    }
+                }
+                if (i) for(var u in a){
+                    var s = a[u];
+                    for(var t = 0; t < s.length; t++){
+                        var c = s[t];
+                        if (c.family === e && "127.0.0.1" !== c.address) return c;
+                    }
+                }
+            };
+            address.ip = function(e) {
+                var r = address.interface("IPv4", e);
+                return r && r.address;
+            };
+            address.ipv6 = function(e) {
+                var r = address.interface("IPv6", e);
+                return r && r.address;
+            };
+            var s = /^(\w+)\:\s+flags=/;
+            var d = /^(\w+)\s{2,}link encap:\w+/i;
+            var c = address.MAC_RE = /(?:ether|HWaddr)\s+((?:[a-z0-9]{2}\:){5}[a-z0-9]{2})/i;
+            var u = address.MAC_IP_RE = /inet\s(?:addr\:)?(\d+\.\d+\.\d+\.\d+)/;
+            function getMAC(e, r, a) {
+                var n = e.split("\n");
+                for(var i = 0; i < n.length; i++){
+                    var t = n[i].trimRight();
+                    var f = s.exec(t) || d.exec(t);
+                    if (f) {
+                        var v = f[1];
+                        if (0 === v.indexOf(r)) {
+                            var o = null;
+                            var l = null;
+                            var p = c.exec(t);
+                            if (p) l = p[1];
+                            i++;
+                            while(true){
+                                t = n[i];
+                                if (!t || s.exec(t) || d.exec(t)) {
+                                    i--;
+                                    break;
+                                }
+                                if (!l) {
+                                    p = c.exec(t);
+                                    if (p) l = p[1];
+                                }
+                                if (!o) {
+                                    p = u.exec(t);
+                                    if (p) o = p[1];
+                                }
+                                i++;
+                            }
+                            if (o === a) return l;
+                        }
+                    }
+                }
+            }
+            address.mac = function(e, r) {
+                if ("function" == typeof e) {
+                    r = e;
+                    e = null;
+                }
+                e = e || getInterfaceName();
+                var a = address.interface("IPv4", e);
+                if (!a) return r();
+                if (!process.env.CI && ("ff:00:00:00:00:00" === a.mac || "00:00:00:00:00:00" === a.mac)) a.mac = "";
+                if (a.mac) return r(null, a.mac);
+                t.exec(getIfconfigCMD(), {
+                    timeout: 5e3
+                }, function(n, i, t) {
+                    if (n || !i) return r(n);
+                    var f = getMAC(i || "", e, a.address);
+                    r(null, f);
+                });
+            };
+            var v = /^nameserver\s+(\d+\.\d+\.\d+\.\d+)$/i;
+            address.dns = function(e, r) {
+                if ("function" == typeof e) {
+                    r = e;
+                    e = null;
+                }
+                e = e || f;
+                i.readFile(e, "utf8", function(e, a) {
+                    if (e) return r(e);
+                    var n = [];
+                    a = a || "";
+                    var i = a.split("\n");
+                    for(var t = 0; t < i.length; t++){
+                        var f = i[t].trim();
+                        var s = v.exec(f);
+                        if (s) n.push(s[1]);
+                    }
+                    r(null, n);
+                });
+            };
+            e.exports = address;
+        },
+        81: (e)=>{
+            e.exports = require("child_process");
+        },
+        147: (e)=>{
+            e.exports = require("fs");
+        },
+        37: (e)=>{
+            e.exports = require("os");
+        }
+    };
+    var r = {};
+    function __nccwpck_require__(a) {
+        var n = r[a];
+        if (void 0 !== n) return n.exports;
+        var i = r[a] = {
+            exports: {}
+        };
+        var t = true;
+        try {
+            e[a](i, i.exports, __nccwpck_require__);
+            t = false;
+        } finally{
+            if (t) delete r[a];
+        }
+        return i.exports;
+    }
+    if (void 0 !== __nccwpck_require__) __nccwpck_require__.ab = __dirname + "/";
+    var a = __nccwpck_require__(198);
+    module.exports = a;
+})();

package/dist/compiled/address/lib/address.d.ts

@@ -0,0 +1,28 @@
+export = address;
+
+declare interface Address {
+  ip: string;
+  ipv6: string;
+  mac: string;
+}
+
+declare type AddressCallback = (err: Error, addr: Address) => void;
+declare type MacCallback = (err: Error, addr: string) => void;
+declare type DnsCallback = (err: Error, servers: string[]) => void;
+
+declare function address(interfaceName: string, callback: AddressCallback): void;
+declare function address(callback: AddressCallback): void;
+
+declare namespace address {
+  const MAC_IP_RE: RegExp;
+  const MAC_RE: RegExp;
+
+  function dns(filepath: string, callback: DnsCallback): void;
+  function dns(callback: DnsCallback): void;
+
+  function ip(interfaceName?: string): any;
+  function ipv6(interfaceName?: string): any;
+
+  function mac(interfaceName: string, callback: MacCallback): void;
+  function mac(callback: MacCallback): void;
+}

package/dist/compiled/address/package.json

@@ -0,0 +1 @@
+{"name":"address","author":"fengmk2 <fengmk2@gmail.com>","version":"1.1.2","license":"MIT","types":"lib/address.d.ts"}

package/dist/compiled/browserslist/index.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Return array of browsers by selection queries.
+ *
+ * ```js
+ * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
+ * ```
+ *
+ * @param queries Browser queries.
+ * @returns Array with browser names in Can I Use.
+ */
+declare function browserslist(
+  queries?: string | readonly string[] | null,
+  opts?: browserslist.Options
+): string[]
+
+declare namespace browserslist {
+  interface Options {
+    /**
+     * Path to processed file. It will be used to find config files.
+     */
+    path?: string | false
+    /**
+     * Processing environment. It will be used to take right queries
+     * from config file.
+     */
+    env?: string
+    /**
+     * Custom browser usage statistics for "> 1% in my stats" query.
+     */
+    stats?: Stats | string
+    /**
+     * Path to config file with queries.
+     */
+    config?: string
+    /**
+     * Do not throw on unknown version in direct query.
+     */
+    ignoreUnknownVersions?: boolean
+    /**
+     * Throw a error if env is not found.
+     */
+    throwOnMissing?: boolean
+    /**
+     * Disable security checks for extend query.
+     */
+    dangerousExtend?: boolean
+    /**
+     * Alias mobile browsers to the desktop version when Can I Use
+     * doesn’t have data about the specified version.
+     */
+    mobileToDesktop?: boolean
+  }
+
+  type Config = {
+    defaults: string[]
+    [section: string]: string[] | undefined
+  }
+
+  interface Stats {
+    [browser: string]: {
+      [version: string]: number
+    }
+  }
+
+  /**
+   * Browser names aliases.
+   */
+  let aliases: {
+    [alias: string]: string | undefined
+  }
+
+  /**
+   * Aliases to work with joined versions like `ios_saf 7.0-7.1`.
+   */
+  let versionAliases: {
+    [browser: string]:
+      | {
+          [version: string]: string | undefined
+        }
+      | undefined
+  }
+
+  /**
+   * Can I Use only provides a few versions for some browsers (e.g. `and_chr`).
+   *
+   * Fallback to a similar browser for unknown versions.
+   */
+  let desktopNames: {
+    [browser: string]: string | undefined
+  }
+
+  let data: {
+    [browser: string]:
+      | {
+          name: string
+          versions: string[]
+          released: string[]
+          releaseDate: {
+            [version: string]: number | undefined | null
+          }
+        }
+      | undefined
+  }
+
+  let nodeVersions: string[]
+
+  interface Usage {
+    [version: string]: number
+  }
+
+  let usage: {
+    global?: Usage
+    custom?: Usage | null
+    [country: string]: Usage | undefined | null
+  }
+
+  let cache: {
+    [feature: string]: {
+      [name: string]: 'y' | 'n'
+    }
+  }
+
+  /**
+   * Default browsers query
+   */
+  let defaults: readonly string[]
+
+  /**
+   * Which statistics should be used. Country code or custom statistics.
+   * Pass `"my stats"` to load statistics from `Browserslist` files.
+   */
+  type StatsOptions = string | 'my stats' | Stats | { dataByBrowser: Stats }
+
+  /**
+   * Return browsers market coverage.
+   *
+   * ```js
+   * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
+   * ```
+   *
+   * @param browsers Browsers names in Can I Use.
+   * @param stats Which statistics should be used.
+   * @returns Total market coverage for all selected browsers.
+   */
+  function coverage(browsers: readonly string[], stats?: StatsOptions): number
+
+  function clearCaches(): void
+
+  function parseConfig(string: string): Config
+
+  function readConfig(file: string): Config
+
+  function findConfig(...pathSegments: string[]): Config | undefined
+
+  interface LoadConfigOptions {
+    config?: string
+    path?: string
+    env?: string
+  }
+
+  function loadConfig(options: LoadConfigOptions): string[] | undefined
+}
+
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      BROWSERSLIST?: string
+      BROWSERSLIST_CONFIG?: string
+      BROWSERSLIST_DANGEROUS_EXTEND?: string
+      BROWSERSLIST_DISABLE_CACHE?: string
+      BROWSERSLIST_ENV?: string
+      BROWSERSLIST_IGNORE_OLD_DATA?: string
+      BROWSERSLIST_STATS?: string
+    }
+  }
+}
+
+export = browserslist