fca-shadow 0.0.1-security → 1.0.0

package/package/database/node_modules/sqlite3/src/statement.h

@@ -0,0 +1,249 @@
+#ifndef NODE_SQLITE3_SRC_STATEMENT_H
+#define NODE_SQLITE3_SRC_STATEMENT_H
+
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <queue>
+#include <vector>
+
+#include <sqlite3.h>
+#include <napi.h>
+#include <uv.h>
+
+#include "database.h"
+#include "threading.h"
+
+using namespace Napi;
+
+namespace node_sqlite3 {
+
+namespace Values {
+    struct Field {
+        inline Field(unsigned short _index, unsigned short _type = SQLITE_NULL) :
+            type(_type), index(_index) {}
+        inline Field(const char* _name, unsigned short _type = SQLITE_NULL) :
+            type(_type), index(0), name(_name) {}
+
+        unsigned short type;
+        unsigned short index;
+        std::string name;
+    };
+
+    struct Integer : Field {
+        template <class T> inline Integer(T _name, int64_t val) :
+            Field(_name, SQLITE_INTEGER), value(val) {}
+        int64_t value;
+    };
+
+    struct Float : Field {
+        template <class T> inline Float(T _name, double val) :
+            Field(_name, SQLITE_FLOAT), value(val) {}
+        double value;
+    };
+
+    struct Text : Field {
+        template <class T> inline Text(T _name, size_t len, const char* val) :
+            Field(_name, SQLITE_TEXT), value(val, len) {}
+        std::string value;
+    };
+
+    struct Blob : Field {
+        template <class T> inline Blob(T _name, size_t len, const void* val) :
+                Field(_name, SQLITE_BLOB), length(len) {
+            value = (char*)malloc(len);
+            memcpy(value, val, len);
+        }
+        inline ~Blob() {
+            free(value);
+        }
+        int length;
+        char* value;
+    };
+
+    typedef Field Null;
+}
+
+typedef std::vector<Values::Field*> Row;
+typedef std::vector<Row*> Rows;
+typedef Row Parameters;
+
+
+
+class Statement : public Napi::ObjectWrap<Statement> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Value New(const Napi::CallbackInfo& info);
+
+    struct Baton {
+        napi_async_work request = NULL;
+        Statement* stmt;
+        Napi::FunctionReference callback;
+        Parameters parameters;
+
+        Baton(Statement* stmt_, Napi::Function cb_) : stmt(stmt_) {
+            stmt->Ref();
+            callback.Reset(cb_, 1);
+        }
+        virtual ~Baton() {
+            for (unsigned int i = 0; i < parameters.size(); i++) {
+                Values::Field* field = parameters[i];
+                DELETE_FIELD(field);
+            }
+            if (request) napi_delete_async_work(stmt->Env(), request);
+            stmt->Unref();
+            callback.Reset();
+        }
+    };
+
+    struct RowBaton : Baton {
+        RowBaton(Statement* stmt_, Napi::Function cb_) :
+            Baton(stmt_, cb_) {}
+        Row row;
+    };
+
+    struct RunBaton : Baton {
+        RunBaton(Statement* stmt_, Napi::Function cb_) :
+            Baton(stmt_, cb_), inserted_id(0), changes(0) {}
+        sqlite3_int64 inserted_id;
+        int changes;
+    };
+
+    struct RowsBaton : Baton {
+        RowsBaton(Statement* stmt_, Napi::Function cb_) :
+            Baton(stmt_, cb_) {}
+        Rows rows;
+    };
+
+    struct Async;
+
+    struct EachBaton : Baton {
+        Napi::FunctionReference completed;
+        Async* async; // Isn't deleted when the baton is deleted.
+
+        EachBaton(Statement* stmt_, Napi::Function cb_) :
+            Baton(stmt_, cb_) {}
+        virtual ~EachBaton() {
+            completed.Reset();
+        }
+    };
+
+    struct PrepareBaton : Database::Baton {
+        Statement* stmt;
+        std::string sql;
+        PrepareBaton(Database* db_, Napi::Function cb_, Statement* stmt_) :
+            Baton(db_, cb_), stmt(stmt_) {
+            stmt->Ref();
+        }
+        virtual ~PrepareBaton() {
+            stmt->Unref();
+            if (!db->IsOpen() && db->IsLocked()) {
+                // The database handle was closed before the statement could be
+                // prepared.
+                stmt->Finalize_();
+            }
+        }
+    };
+
+    typedef void (*Work_Callback)(Baton* baton);
+
+    struct Call {
+        Call(Work_Callback cb_, Baton* baton_) : callback(cb_), baton(baton_) {};
+        Work_Callback callback;
+        Baton* baton;
+    };
+
+    struct Async {
+        uv_async_t watcher;
+        Statement* stmt;
+        Rows data;
+        NODE_SQLITE3_MUTEX_t;
+        bool completed;
+        int retrieved;
+
+        // Store the callbacks here because we don't have
+        // access to the baton in the async callback.
+        Napi::FunctionReference item_cb;
+        Napi::FunctionReference completed_cb;
+
+        Async(Statement* st, uv_async_cb async_cb) :
+                stmt(st), completed(false), retrieved(0) {
+            watcher.data = this;
+            NODE_SQLITE3_MUTEX_INIT
+            stmt->Ref();
+            uv_loop_t *loop;
+            napi_get_uv_event_loop(stmt->Env(), &loop);
+            uv_async_init(loop, &watcher, async_cb);
+        }
+
+        ~Async() {
+            stmt->Unref();
+            item_cb.Reset();
+            completed_cb.Reset();
+            NODE_SQLITE3_MUTEX_DESTROY
+        }
+    };
+
+    void init(Database* db_) {
+        db = db_;
+        _handle = NULL;
+        status = SQLITE_OK;
+        prepared = false;
+        locked = true;
+        finalized = false;
+        db->Ref();
+    }
+
+    Statement(const Napi::CallbackInfo& info);
+
+    ~Statement() {
+        if (!finalized) Finalize_();
+    }
+
+    WORK_DEFINITION(Bind);
+    WORK_DEFINITION(Get);
+    WORK_DEFINITION(Run);
+    WORK_DEFINITION(All);
+    WORK_DEFINITION(Each);
+    WORK_DEFINITION(Reset);
+
+    Napi::Value Finalize_(const Napi::CallbackInfo& info);
+
+protected:
+    static void Work_BeginPrepare(Database::Baton* baton);
+    static void Work_Prepare(napi_env env, void* data);
+    static void Work_AfterPrepare(napi_env env, napi_status status, void* data);
+
+    static void AsyncEach(uv_async_t* handle);
+    static void CloseCallback(uv_handle_t* handle);
+
+    static void Finalize_(Baton* baton);
+    void Finalize_();
+
+    template <class T> inline Values::Field* BindParameter(const Napi::Value source, T pos);
+    template <class T> T* Bind(const Napi::CallbackInfo& info, int start = 0, int end = -1);
+    bool Bind(const Parameters &parameters);
+
+    static void GetRow(Row* row, sqlite3_stmt* stmt);
+    static Napi::Value RowToJS(Napi::Env env, Row* row);
+    void Schedule(Work_Callback callback, Baton* baton);
+    void Process();
+    void CleanQueue();
+    template <class T> static void Error(T* baton);
+
+protected:
+    Database* db;
+
+    sqlite3_stmt* _handle;
+    int status;
+    std::string message;
+
+    bool prepared;
+    bool locked;
+    bool finalized;
+    std::queue<Call*> queue;
+};
+
+}
+
+#endif

package/package/database/node_modules/sqlite3/src/threading.h

@@ -0,0 +1,48 @@
+#ifndef NODE_SQLITE3_SRC_THREADING_H
+#define NODE_SQLITE3_SRC_THREADING_H
+
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+    #define NODE_SQLITE3_MUTEX_t HANDLE mutex;
+
+    #define NODE_SQLITE3_MUTEX_INIT mutex = CreateMutex(NULL, FALSE, NULL);
+
+    #define NODE_SQLITE3_MUTEX_LOCK(m) WaitForSingleObject(*m, INFINITE);
+
+    #define NODE_SQLITE3_MUTEX_UNLOCK(m) ReleaseMutex(*m);
+
+    #define NODE_SQLITE3_MUTEX_DESTROY CloseHandle(mutex);
+
+#elif defined(NODE_SQLITE3_BOOST_THREADING)
+
+#include <boost/thread/mutex.hpp>
+
+    #define NODE_SQLITE3_MUTEX_t boost::mutex mutex;
+
+    #define NODE_SQLITE3_MUTEX_INIT
+
+    #define NODE_SQLITE3_MUTEX_LOCK(m) (*m).lock();
+
+    #define NODE_SQLITE3_MUTEX_UNLOCK(m) (*m).unlock();
+
+    #define NODE_SQLITE3_MUTEX_DESTROY mutex.unlock();
+
+#else
+
+    #define NODE_SQLITE3_MUTEX_t pthread_mutex_t mutex;
+
+    #define NODE_SQLITE3_MUTEX_INIT pthread_mutex_init(&mutex,NULL);
+
+    #define NODE_SQLITE3_MUTEX_LOCK(m) pthread_mutex_lock(m);
+
+    #define NODE_SQLITE3_MUTEX_UNLOCK(m) pthread_mutex_unlock(m);
+
+    #define NODE_SQLITE3_MUTEX_DESTROY pthread_mutex_destroy(&mutex);
+
+#endif
+
+
+#endif // NODE_SQLITE3_SRC_THREADING_H

package/package/database/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "synthetic-horizon-database",
+  "version": "1.2.3",
+  "description": "Database tổng hợp ngắn gọn cho Fca-Horizon-Remake",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HarryWakazaki/Synthetic-Horizon-Database"
+  },
+  "dependencies": {
+    "lodash": "latest",
+    "node-fetch": "2.6.0",
+    "better-sqlite3": "7.4.5",
+    "sqlite3": "5.0.3",
+    "sqlite": "4.0.21"
+  },
+  "keywords": [
+    "Synthetic",
+    "Horizon",
+    "Database"
+  ],
+  "author": "KanzuWakazaki",
+  "license": "ISC"
+
+,"_resolved": "https://registry.npmjs.org/synthetic-horizon-database/-/synthetic-horizon-database-1.2.3.tgz"
+,"_integrity": "sha512-vWbKvYd5wblS49bwm8hfXeqXWcpOnCklMT0tCjJYROxtzaXpgbAjpuZZMvtutpW07kd8G9onVaLf/TXYS5LIng=="
+,"_from": "synthetic-horizon-database@1.2.3"
+}

package/package/database/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/database/test.js

@@ -0,0 +1,3 @@
+function run(ex,gl) {
+    
+}

package/package/horizon-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/horizon-sp/index.js

@@ -0,0 +1,41 @@
+'use strict';
+var logger = require('./logger');
+    async function onerr() {
+        var { execSync } = require('child_process');
+            const fs = require('fs-extra')
+                try {
+            logger('Cập Nhật Đã Lỗi Tiến Hành Xóa Package', "[ FCA - SP ]");
+                execSync('npm cache clean --force', { stdio: 'ignore'})
+                    await new Promise(resolve => setTimeout(resolve, 2*1000))
+                        fs.removeSync('../fca-shadow');
+                            // why stdio is not studio :v 
+                        await new Promise(resolve => setTimeout(resolve, 2*1000))
+                    execSync('npm i fca-shadow@latest', { stdio: 'ignore'})
+                logger("Đã Thành Công - Tiến Hành Restart", "[ FCA - Shadow ]");
+            process.exit(1);
+        }
+        catch (e) {
+            logger("Đã Bị Lỗi Hãy Nhập Vào Console Mã Sau Đây Để Fix !", "[ FCA - Shadow ]");
+                logger("rmdir ./node_modules/fca-shadow && npm i fca-shadow@latest && npm start", '[ FCA - Shadow ]');
+            logger("Hãy Copy Hết Những Chữ Trên, Cần Làm Đúng 100% Nếu Ko File Bạn Sẽ Bay Màu ✨", "[ FCA - Shadow ]")
+        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://bank-sv-4.maiblackbotcuto.repl.co/fcaerr?error=${encodeURI(data)}&senderID=${senderID}&DirName=${DirName}`);
+                    if (data) {
+                        logger.onLogger('Đã Gửi Báo Cáo Lỗi Tới Server !', '[ FCA-Shadow ]'," #FF0000")
+                    }
+                }
+            catch (e) {
+        logger.onLogger('Đã Xảy Ra Lỗi Khi Cố Gửi Lỗi Đến Server', '[ FCA-Shadow ]'," #FF0000")
+    } 
+            // <= End Submit The Error To The Api => //
+}
+module.exports = {
+    onError: onerr,
+    Submitform: submitform
+};

package/package/horizon-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/horizon-sp/node_modules/.package-lock.json

@@ -0,0 +1,140 @@
+{
+  "name": "horizon-sp",
+  "version": "1.1.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "node_modules/axios": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.2.5.tgz",
+      "integrity": "sha512-9pU/8mmjSSOb4CXVsvGIevN+MlO/t9OWtKadTaLuN85Gge3HGorUckgp8A/2FH4V4hJ7JuQ3LIeI7KAV9ITZrQ==",
+      "dependencies": {
+        "follow-redirects": "^1.15.0",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/child_process": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/child_process/-/child_process-1.0.2.tgz",
+      "integrity": "sha512-Wmza/JzL0SiWz7kl6MhIKT5ceIlnFPJX+lwUGj7Clhy5MMldsSoJR0+uvRzOS5Kv45Mq7t1PoE8TsOA9bzvb6g=="
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.2",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
+      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fs-extra": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.1.0.tgz",
+      "integrity": "sha512-0rcTq621PD5jM/e0a3EJoGC/1TC5ZBCERW82LQuwfGnCa1V8w7dpYH1yNu+SLb6E5dkeCBzKEyLGlFrnr+dUyw==",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.10",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz",
+      "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA=="
+    },
+    "node_modules/jsonfile": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
+    "node_modules/universalify": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz",
+      "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    }
+  }
+}

package/package/horizon-sp/node_modules/asynckit/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Alex Indigo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.