初始化fy

uni_modules/UniDevTools/node_modules/os-locale-s-fix/cjs/index.js

@@ -0,0 +1,136 @@
+"use strict";
+/*!
+ // Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+ // Released under the MIT license
+ // https://opensource.org/licenses/mit-license.php
+ */
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2020 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+
+const lcid = require("lcid");
+const child_process_1 = require("child_process");
+const defaultLocale = "en_US";
+const getStdOut = async (command, args) => await new Promise((resolve) => {
+    child_process_1.execFile(command, args, (err, stdout) => {
+        resolve(err || stdout);
+    });
+});
+const getStdOutSync = (command, args) => {
+    try {
+        return child_process_1.execFileSync(command, args);
+    }
+    catch (e) {
+        return e;
+    }
+};
+const normalise = (input) => input.replace(/_/, "-");
+function validate(result, processor) {
+    if (typeof result === "string" || result.length) {
+        return processor ? processor(result.toString()) : result.toString().trim();
+    }
+    return defaultLocale;
+}
+const getEnvLocale = (env = process.env) => env.LC_ALL || env.LC_MESSAGES || env.LANG || env.LANGUAGE || "";
+function parseLocale(str) {
+    const env = str.split("\n").reduce((env, definition) => {
+        const [key, value] = definition.split("=");
+        if (key && value) {
+            env[key] = value.replace(/^"|"$/g, "");
+        }
+        return env;
+    }, {});
+    return getEnvLocale(env);
+}
+const purgeExtraToken = (str) => (str && str.replace(/[.:].*/, "")) || defaultLocale;
+const getSupportedLocale = (locale, locales) => locales.includes(locale) ? locale : defaultLocale;
+const [getAppleLocale, getAppleLocaleSync] = ((cmd0, args0, cmd1, args1) => {
+    return [
+        async () => {
+            const results = await Promise.all([
+                getStdOut(cmd0, args0).then(ret => validate(ret)),
+                getStdOut(cmd1, args1).then(ret => validate(ret))
+            ]);
+            return getSupportedLocale(results[0], results[1]);
+        },
+        () => getSupportedLocale(validate(getStdOutSync(cmd0, args0)), validate(getStdOutSync(cmd1, args1)))
+    ];
+})("defaults", ["read", "-globalDomain", "AppleLocale"], "locale", ["-a"]);
+const getUnixLocale = async () => purgeExtraToken(parseLocale(await getStdOut("locale").then(ret => validate(ret))));
+const getUnixLocaleSync = () => purgeExtraToken(parseLocale(validate(getStdOutSync("locale"))));
+const parseLCID = (result) => {
+    const lcidCode = parseInt(result.replace("Locale", ""), 16);
+    return lcid.from(lcidCode);
+};
+const [getWinLocale, getWinLocaleSync] = ((cmd0, args0) => {
+    return [
+        async () => validate(await getStdOut(cmd0, args0), parseLCID),
+        () => validate(getStdOutSync(cmd0, args0), parseLCID)
+    ];
+})("wmic", ["os", "get", "locale"]);
+let detector;
+{
+    const gettersSlot = [
+        {
+            win32: getWinLocaleSync,
+            darwin: getAppleLocaleSync,
+            linux: getUnixLocaleSync,
+        }, {
+            win32: getWinLocale,
+            darwin: getAppleLocale,
+            linux: getUnixLocale,
+        }
+    ];
+    const typeString = {}.toString;
+    const isPromise = (o) => typeString.call(o) === "[object Promise]";
+    let cacheLocal;
+    const base = (async) => (options = {}) => {
+        options = { spawn: true, cache: true, ...options };
+        const cache = options.cache;
+        if (cache && (cacheLocal === null || cacheLocal === void 0 ? void 0 : cacheLocal.length)) {
+            return (async ? Promise.resolve(cacheLocal) : cacheLocal);
+        }
+        const functions = gettersSlot[+(!!async)];
+        let locale;
+        const withCache = (l, mustPromise) => {
+            l = normalise(l);
+            cacheLocal = cache ? l : void 0;
+            return (mustPromise ? Promise.resolve(l) : l);
+        };
+        const envLocale = getEnvLocale();
+        if (envLocale || !options.spawn) {
+            locale = purgeExtraToken(envLocale);
+        }
+        else {
+            let { platform } = process;
+            if (platform !== "win32" && platform !== "darwin") {
+                platform = "linux";
+            }
+            locale = functions[platform]();
+        }
+        if (isPromise(locale)) {
+            return locale.then(result => withCache(result));
+        }
+        else {
+            return withCache(locale, async === true || void 0);
+        }
+    };
+    detector = (base(true));
+    detector.sync = base();
+    Object.defineProperties(detector, {
+        purge: {
+            value: () => cacheLocal = void 0,
+            enumerable: false,
+        },
+        version: {
+            value: "v1.0.8",
+            enumerable: true,
+        },
+    });
+}
+exports.osLocale = Object.freeze(detector);