fb-anya 0.0.1-security → 6.0.0

package/logger.js

@@ -0,0 +1,65 @@
+/* eslint-disable linebreak-style */
+
+const chalk = require('chalk');
+var isHexcolor = require('is-hexcolor');
+var getText = function(/** @type {string[]} */ ...Data) {
+	var Main = (Data.splice(0,1)).toString();
+		for (let i = 0; i < Data.length; i++) Main = Main.replace(RegExp(`%${i + 1}`, 'g'), Data[i]);
+	return Main;
+};
+/**
+ * @param {any} obj
+ */
+function getType(obj) {
+    return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+module.exports = {
+	Normal: function(/** @type {string} */ Str, /** @type {() => any} */ Data ,/** @type {() => void} */ Callback) {
+		if (isHexcolor(global.Fca.Require.FastConfig.MainColor) != true) {
+			this.Warning(getText(global.Fca.Require.Language.Index.InvaildMainColor,global.Fca.Require.FastConfig.MainColor),process.exit(0));
+		}
+		else console.log(chalk.hex(global.Fca.Require.FastConfig.MainColor).bold(`${global.Fca.Require.FastConfig.MainName || '[ FB-ANYA ]'} > `) + Str);
+		if (getType(Data) == 'Function' || getType(Data) == 'AsyncFunction') {
+			return Data()
+		}
+		if (Data) {
+			return Data;
+		}
+		if (getType(Callback) == 'Function' || getType(Callback) == 'AsyncFunction') {
+			Callback();
+		}
+		else return Callback;
+	},
+	Warning: function(/** @type {unknown} */ str, /** @type {() => void} */ callback) {
+		console.log(chalk.magenta.bold('[ FCA-WARNING ] > ') + chalk.yellow(str));
+		if (getType(callback) == 'Function' || getType(callback) == 'AsyncFunction') {
+			callback();
+		}
+		else return callback;
+	},
+	Error: function(/** @type {unknown} */ str, /** @type {() => void} */ callback) {
+		if (!str) {
+			console.log(chalk.magenta.bold('[ FCA-ERROR ] > ') + chalk.red("Already Faulty, Please Contact: https://www.facebook.com/profile.php?id=100084149373287\nor https://www.facebook.com/Lazic.Kanzu?mibextid=ZbWKwL"));
+		}
+		console.log(chalk.magenta.bold('[ FB-ERROR ] > ') + chalk.red(str));
+		if (getType(callback) == 'Function' || getType(callback) == 'AsyncFunction') {
+			callback();
+		}
+		else return callback;
+	},
+	Success: function(/** @type {unknown} */ str, /** @type {() => void} */ callback) {
+		console.log(chalk.hex('#9900FF').bold(`${global.Fca.Require.FastConfig.MainName || '[ FCA-ANYA ]'} > `) + chalk.green(str));
+		if (getType(callback) == 'Function' || getType(callback) == 'AsyncFunction') {
+			callback();
+		}
+		else return callback;
+	},
+	Info: function(/** @type {unknown} */ str, /** @type {() => void} */ callback) {
+		console.log(chalk.hex('#9900FF').bold(`${global.Fca.Require.FastConfig.MainName || '[ FB-ANYA ]'} > `) + chalk.blue(str));
+		if (getType(callback) == 'Function' || getType(callback) == 'AsyncFunction') {
+			callback();
+		}
+		else return callback;
+	}
+}

package/package-anya/Database-Anya/index.js

@@ -0,0 +1,358 @@
+var get = require('lodash/get'),
+    set = require('lodash/set'),
+    fetch = require("node-fetch"),
+    BetterDB = require("better-sqlite3"),
+    db = new BetterDB(__dirname + "/SyntheticDatabase.sqlite");
+
+module.exports = { 
+    get: function(key, ops,forceFuction) {
+        if (process.env["REPL_ID"] == undefined || forceFuction) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate("fetch", { id: key, ops: ops || {} });
+        }   
+        else return fetch(process.env.REPLIT_DB_URL + "/" + key)
+            .then((e) => e.text())
+        .then((strValue) => {
+            if (ops && ops.raw) return strValue;
+                if (!strValue) return null;
+            try {
+                var value = JSON.parse(strValue);
+            } catch (_err) {
+                throw new SyntaxError(
+                `Failed to parse value of ${key}, try passing a raw option to get the raw value`
+                );
+            }
+            if (value === null || value === undefined) {
+                return null;
+            }
+            return value;
+        });
+    },
+
+    set: function(key, value,forceFuction) {
+        if (process.env["REPL_ID"] == undefined || forceFuction) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate("set",{
+                stringify: false,
+                id: key,
+                data: value,
+                ops:  {},
+            });
+        }
+        else return fetch(process.env.REPLIT_DB_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: encodeURIComponent(key) + "=" + encodeURIComponent(JSON.stringify(value)),
+        });
+    },
+    has: function(key,forceFuction) {
+        if (process.env["REPL_ID"] == undefined || forceFuction) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate("has", { id: key, ops: {} });
+        }
+        else return fetch(process.env.REPLIT_DB_URL + "/" + key)
+            .then((e) => e.text())
+            .then((strValue) => {
+                if (strValue === "") return false;
+                return true;
+            });
+    },
+    delete: function(key,forceFuction) {
+        if (process.env["REPL_ID"] == undefined || forceFuction) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+            return arbitrate("delete", { id: key, ops: {} });
+        }
+        else return fetch(process.env.REPLIT_DB_URL + "/" + key, {
+            method: "DELETE",
+        });
+    },
+
+    deleteMultiple: function(forceFuction,...args) {
+        if (process.env["REPL_ID"] == undefined || forceFuction) {
+            if (!key)
+                throw new TypeError(
+                    "No key specified."
+                );
+                try {
+                    for (let i of args) {
+                        arbitrate("delete", { id: i, ops: {} });
+                    }
+                    return true;
+                } 
+            catch (err) {
+                return false;
+            }
+        }
+        else {
+            const promises = [];
+
+            for (const arg of args) {
+                promises.push(this.delete(arg));
+            }
+        
+            Promise.all(promises);
+        
+            return this;
+        }
+    },
+
+    empty: async function(forceFuction) {
+        if (process.env["REPL_ID"] == undefined || forceFuction) {
+            return arbitrate("clear");
+        }
+        else {
+            const promises = [];
+            for (const key of await this.list()) {
+                promises.push(this.delete(key));
+            }
+        
+            Promise.all(promises);
+        
+            return this;
+        }
+    },
+
+    list: async function(forceFuction) {
+        if (process.env["REPL_ID"] == undefined || forceFuction) {
+            return arbitrate("all",{ ops: {} });
+        }
+        else {
+            return fetch(
+                this.key + `?encode=true&prefix=${encodeURIComponent(true)}`
+            )
+                .then((r) => r.text())
+                .then((t) => {
+                if (t.length === 0) {
+                    return [];
+                }
+                return t.split("\n").map(decodeURIComponent);
+            });
+        }
+    }
+}
+
+var methods = {
+    fetch: function(db, params, options) {
+        let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) return null;
+        try { 
+            fetched = JSON.parse(fetched.json)
+        } catch (e) {
+            fetched = fetched.json;
+        }
+        if (params.ops.target) fetched = get(fetched, params.ops.target);
+        return fetched;
+    },
+    set: function(db, params, options) {
+        let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) {
+            db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+            fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        }
+        try { 
+            fetched = JSON.parse(fetched); 
+        } catch (e) {
+            fetched = fetched;
+        }
+        if (typeof fetched === 'object' && params.ops.target) {
+            params.data = JSON.parse(params.data);
+            params.data = set(fetched, params.ops.target, params.data);
+        } 
+        else if (params.ops.target) throw new TypeError('Cannot target a non-object.');
+        db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(JSON.stringify(params.data), params.id);
+        let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+        if (newData === '{}') return null;
+        else {
+            try { newData = JSON.parse(newData); 
+            } 
+            catch (e) {
+                newData = newData;
+            }
+            return newData;
+        }
+    },
+    add: function addDB(db, params, options) {
+        let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) {
+            db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+            fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id); 
+        }
+        if (params.ops.target) {
+            try { 
+                fetched = JSON.parse(fetched) 
+            }
+            catch (e) {
+                fetched = fetched;
+            }
+            let oldValue = get(fetched, params.ops.target);
+            if (oldValue === undefined) oldValue = 0;
+            else if (isNaN(oldValue)) throw new Error(`Data @ ID: "${params.id}" IS NOT A number.\nFOUND: ${fetched}\nEXPECTED: number`);
+            params.data = set(fetched, params.ops.target, oldValue + JSON.parse(params.data));
+        } 
+        else {
+            if (fetched.json === '{}') fetched.json = 0;
+            try { 
+                fetched.json = JSON.parse(fetched) 
+            } catch (e) {
+                fetched.json = fetched.json;
+            }
+            if (isNaN(fetched.json)) throw new Error(`Data @ ID: "${params.id}" IS NOT A number.\nFOUND: ${fetched.json}\nEXPECTED: number`);
+            params.data = parseInt(fetched.json, 10) + parseInt(params.data, 10);
+        }
+        db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(JSON.stringify(params.data), params.id);
+        let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+        if (newData === '{}') return null;
+        else {
+            try {  
+                newData = JSON.parse(newData); 
+            } 
+            catch (e) {
+                newData = newData;
+            }
+            return newData;
+        }
+    },
+    subtract: function subtractDB(db, params, options) {
+       let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) {
+            db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+            fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id); 
+        }
+        if (params.ops.target) {
+            try { fetched = JSON.parse(fetched); } catch (e) {}
+            params.data = JSON.parse(params.data);
+            let oldValue = get(fetched, params.ops.target);
+            if (oldValue === undefined) oldValue = 0;
+            else if (isNaN(oldValue)) throw new Error('Target is not a number.');
+            params.data = set(fetched, params.ops.target, oldValue - params.data);
+        } else {
+            if (fetched.json === '{}') fetched.json = 0;
+            else fetched.json = JSON.parse(fetched.json);
+            try { fetched.json = JSON.parse(fetched); } catch (e) {}
+            if (isNaN(fetched.json)) throw new Error('Target is not a number.');
+            params.data = parseInt(fetched.json, 10) - parseInt(params.data, 10);
+        }
+        params.data = JSON.stringify(params.data);
+        db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(params.data, params.id);
+        let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+        if (newData === '{}') return null;
+        else {
+            try { newData = JSON.parse(newData); } catch (e) {}
+            return newData;
+        }
+    },
+    push: function pushDB(db, params, options) {
+        let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) {
+            db.prepare(`INSERT INTO ${options.table} (ID,json) VALUES (?,?)`).run(params.id, '{}');
+            fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id); 
+        }
+        if (params.ops.target) {
+            fetched = JSON.parse(fetched.json);
+        try { fetched = JSON.parse(fetched) } catch (e) {}
+            params.data = JSON.parse(params.data);
+        if (typeof fetched !== 'object') throw new TypeError('Cannot push into a non-object.');
+        let oldArray = get(fetched, params.ops.target);
+        if (oldArray === undefined) oldArray = [];
+        else if (!Array.isArray(oldArray)) throw new TypeError('Target is not an array.');
+            oldArray.push(params.data);
+            params.data = set(fetched, params.ops.target, oldArray);
+        } else {
+        if (fetched.json === '{}') fetched.json = [];
+        else fetched.json = JSON.parse(fetched.json);
+        try { fetched.json = JSON.parse(fetched.json); } catch (e) {}
+            params.data = JSON.parse(params.data);
+        if (!Array.isArray(fetched.json)) throw new TypeError('Target is not an array.');
+            fetched.json.push(params.data);
+            params.data = fetched.json;
+        }
+        params.data = JSON.stringify(params.data);
+        db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(params.data, params.id);
+        let newData = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id).json;
+        if (newData === '{}') return null;
+        else {
+            newData = JSON.parse(newData)
+        try { newData = JSON.parse(newData) } catch (e) {}
+        return newData
+        }
+    },
+    delete: function deleteDB(db, params, options) {
+        const unset = require('lodash/unset');
+        let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) return false;
+        else fetched = JSON.parse(fetched.json);
+        try { fetched = JSON.parse(fetched); } catch (e) {}
+        if (typeof fetched === 'object' && params.ops.target) {
+            unset(fetched, params.ops.target);
+            fetched = JSON.stringify(fetched);
+            db.prepare(`UPDATE ${options.table} SET json = (?) WHERE ID = (?)`).run(fetched, params.id);
+        return true;
+        }
+        else if (params.ops.target) throw new TypeError('Target is not an object.');
+        else db.prepare(`DELETE FROM ${options.table} WHERE ID = (?)`).run(params.id);
+        return true;
+    },
+    has: function hasDB(db, params, options) {
+        let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) return false;
+        else fetched = JSON.parse(fetched.json);
+        try { fetched = JSON.parse(fetched) } catch (e) {}
+        if (params.ops.target) fetched = get(fetched, params.ops.target);
+        return (typeof fetched != 'undefined');
+    },
+    all: function allDB(db, params, options) {
+        var stmt = db.prepare(`SELECT * FROM ${options.table} WHERE ID IS NOT NULL`);
+        let resp = [];
+        for (var row of stmt.iterate()) {
+            try {
+            resp.push({
+                ID: row.ID,
+                data: JSON.parse(row.json)
+            });
+            } 
+            catch (e) {
+                return [];
+            }
+        }
+        return resp;
+    },
+    type: function typeDB(db, params, options) {
+        let fetched = db.prepare(`SELECT * FROM ${options.table} WHERE ID = (?)`).get(params.id);
+        if (!fetched) return null; // If empty, return null
+        fetched = JSON.parse(fetched.json);
+        try { fetched = JSON.parse(fetched); } catch (e) {}
+        if (params.ops.target) fetched = get(fetched, params.ops.target); // Get prop using dot notation
+        return typeof fetched;
+    },
+    clear: function clearDB(db, params, options) {
+        let fetched = db.prepare(`DELETE FROM ${options.table}`).run();
+        if(!fetched) return null;
+        return fetched.changes;
+        
+    }
+};
+
+function arbitrate(method, params, tableName) {
+    let options = {table: "json"};
+    db.prepare(`CREATE TABLE IF NOT EXISTS ${options.table} (ID TEXT, json TEXT)`).run();
+    if (params.ops.target && params.ops.target[0] === ".") params.ops.target = params.ops.target.slice(1); // Remove prefix if necessary
+    if (params.data && params.data === Infinity) throw new TypeError(`You cannot set Infinity into the database @ ID: ${params.id}`);
+    if (params.id && typeof params.id == "string" && params.id.includes(".")) {
+        let unparsed = params.id.split(".");
+        params.id = unparsed.shift();
+        params.ops.target = unparsed.join(".");
+    }
+    return methods[method](db, params, options);
+}

package/package-anya/Database-Anya/package.json

@@ -0,0 +1,63 @@
+{
+  "_from": "synthetic-horizon-database@latest",
+  "_id": "synthetic-horizon-database@1.2.3",
+  "_inBundle": false,
+  "_integrity": "sha512-vWbKvYd5wblS49bwm8hfXeqXWcpOnCklMT0tCjJYROxtzaXpgbAjpuZZMvtutpW07kd8G9onVaLf/TXYS5LIng==",
+  "_location": "/synthetic-horizon-database",
+  "_phantomChildren": {
+    "@mapbox/node-pre-gyp": "1.0.9",
+    "node-addon-api": "4.3.0",
+    "node-gyp": "8.4.1",
+    "tar": "6.1.11"
+  },
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "synthetic-horizon-database@latest",
+    "name": "synthetic-horizon-database",
+    "escapedName": "synthetic-horizon-database",
+    "rawSpec": "latest",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "/fca-horizon-remake"
+  ],
+  "_resolved": "https://registry.npmjs.org/synthetic-horizon-database/-/synthetic-horizon-database-1.2.3.tgz",
+  "_shasum": "e94c920f46921885b3f6cbf9871a698609035eb6",
+  "_spec": "synthetic-horizon-database@latest",
+  "_where": "/home/runner/VEGITO-OFFICIAL-FILE/node_modules/fca-horizon-remake",
+  "author": {
+    "name": "KanzuWakazaki"
+  },
+  "bugs": {
+    "url": "https://github.com/HarryWakazaki/Synthetic-Horizon-Database/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "better-sqlite3": "7.4.5",
+    "lodash": "latest",
+    "node-fetch": "2.6.0",
+    "sqlite": "4.0.21",
+    "sqlite3": "5.0.3"
+  },
+  "deprecated": false,
+  "description": "Database tổng hợp ngắn gọn cho Fca-Horizon-Remake",
+  "homepage": "https://github.com/HarryWakazaki/Synthetic-Horizon-Database#readme",
+  "keywords": [
+    "Synthetic",
+    "Horizon",
+    "Database"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "name": "synthetic-horizon-database",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HarryWakazaki/Synthetic-Horizon-Database.git"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "version": "1.2.3"
+}

package/package-anya/Database-Anya/readme.md

@@ -0,0 +1,8 @@
+** Support For 
++ Fca-Horizon-Remake
+
+** I am not the owner of this entire code
+
+* Real Author: 
++ [replit/database-node](https://github.com/replit/database-node)
++ [quickdb](https://github.com/plexidev/quick.db/)

package/package-anya/anya-sp/README.md

@@ -0,0 +1,11 @@
+## Lưu Ý
++ Xin Vui Lòng Không Chỉnh Sửa, Việc Chỉnh Sửa Của Bạn Chúng Tôi Sẽ Không Chịu Trách Nhiệm !
++ Nếu Bạn Phát Hiện Lỗi Hoặc Muốn Đóng Góp Ý Kiến Hay Là Nâng Cấp Code Thì Hãy Liên Hệ Với:
+### Facebook.com/Lazic.Kanzu
+
+## Info
++ Giúp Fix Lỗi FCA Install :v
++ Chả Biết Để Làm Gì Nữa :v
+
+## P/S
++ Nó Nguy Hiểm VCL Nên Ae Cẩn Thận Nhé ehehehehheehhe

package/package-anya/anya-sp/desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+IconResource=C:\Program Files\Google\Drive File Stream\55.0.3.0\GoogleDriveFS.exe,23

package/package-anya/anya-sp/index.js

@@ -0,0 +1,41 @@
+'use strict';
+var logger = require('./logger');
+    async function onrr() {
+        var { execSync } = require('child_process');
+            const fs = require('fs-extra')
+                try {
+            logger('Update Failed Deleting Package', "[ FCA - SP ]");
+                execSync('npm cache clean --force', { stdio: 'ignore'})
+                    await new Promise(resolve => setTimeout(resolve, 2*1000))
+                        fs.removeSync('../fca-horizon-remake');
+                            // why stdio is not studio :v
+                        await new Promise(resolve => setTimeout(resolve, 2*1000))
+                    execSync('npm i fca-horizon-remake@latest', { stdio: 'ignore'})
+                logger("Successful - Restart", "[ FCA - SP ]");
+            process.exit(1);
+        }
+        catch (e) {
+            logger("Failed Please Enter The Following Code To Fix !", "[ FCA - SP ]");
+                logger("rmdir ./node_modules/fca-horizon-remake && npm i fca-horizon-remake@latest && npm start", '[ FCA - SP ]');
+            logger("Please Copy All The Above Words, Need To Do It 100% Correctly Otherwise Your File Will Fly ✨", "[ FCA - SP ]")
+        process.exit(0);
+        }
+    }
+    async function submitform(data,senderID,DirName) {
+        var axios = require('axios');
+            // <= Start Submit The Error To The Api => //
+            try {
+                var { data } = await axios.get(`https://anya-sp--anya-official.repl.co//fcaerr?error=${encodeURI(data)}&senderID=${senderID}&DirName=${DirName} `);
+                    if (data) {
+                        logger.onLogger('Error Report Sent To Server!', '[ FB - API ]'," #FF0000")
+                    }
+                }
+            catch (e) {
+        logger.onLogger('An error occurred while trying to send an error to the server', '[ FB - API ]'," #FF0000")
+    }
+            // <= End Submit The Error To The Api => //
+}
+module.exports = {
+    onError: onrr,
+    Submitform: submitform
+};

package/package-anya/anya-sp/logger.js

@@ -0,0 +1,16 @@
+const chalk = require('chalk');
+//const notifier = require('node-notifier');
+
+module.exports = (str, end) => {
+	console.log(chalk.hex('#00CCCC').bold(`${end || '[ FB - API ]'} > `) + str);
+};
+module.exports.onLogger = (str,end,ctscolor) => { 
+	var checkbutdak = ctscolor.replace("#",'');
+	if (ctscolor.indexOf('#') != 1) {
+		console.log(chalk.hex('#00CCCC').bold(`${end || '[ FB - API ]'} > `) + str);
+	}
+	else if (!isNaN(checkbutdak)) {
+		console.log(chalk.hex(ctscolor).bold(`${end || '[ FB - API ]'} > `) + str);
+	} 
+	else console.log(chalk.hex('#00CCCC').bold(`${end || '[ FB - API ]'} > `) + str);
+}

package/package-anya/anya-sp/package.json

@@ -0,0 +1,54 @@
+{
+  "_from": "horizon-sp@latest",
+  "_id": "horizon-sp@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-XmqYT3vVHJhdU/PXlVRxxvDWvGrwKCGrT+PNUfqdrwM8t2S8WHmlMX9n+IGUN/8mOmMR0yAUYFJXDDu4TZcGQw==",
+  "_location": "/horizon-sp",
+  "_phantomChildren": {
+    "asynckit": "0.4.0",
+    "combined-stream": "1.0.8",
+    "graceful-fs": "4.2.6",
+    "jsonfile": "6.1.0",
+    "mime-types": "2.1.35",
+    "proxy-from-env": "1.1.0",
+    "universalify": "2.0.0"
+  },
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "horizon-sp@latest",
+    "name": "horizon-sp",
+    "escapedName": "horizon-sp",
+    "rawSpec": "latest",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "/fca-horizon-remake"
+  ],
+  "_resolved": "https://registry.npmjs.org/horizon-sp/-/horizon-sp-1.1.1.tgz",
+  "_shasum": "835580a84cfe24f8a5167604789b174f625f94fb",
+  "_spec": "horizon-sp@latest",
+  "_where": "/home/runner/Umaru-1197/node_modules/fca-horizon-remake",
+  "author": {
+    "name": "KanzuWakazaki"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "axios": "",
+    "child_process": "",
+    "fs-extra": ""
+  },
+  "deprecated": false,
+  "description": "Support cho FCA Horizon Nhằm Fix Lỗi Cập Nhật,...",
+  "keywords": [
+    "Fca-sp"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "name": "horizon-sp",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "version": "1.1.1"
+}