@rnaga/wp-node 1.1.0

package/common/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hierarchy = void 0;
+__exportStar(require("./config/define-wp.config."), exports);
+__exportStar(require("./async-constructor"), exports);
+__exportStar(require("./php-serialize"), exports);
+__exportStar(require("./date"), exports);
+__exportStar(require("./formatting"), exports);
+__exportStar(require("./password"), exports);
+__exportStar(require("./validating"), exports);
+__exportStar(require("./config"), exports);
+exports.hierarchy = __importStar(require("./hierarchy"));
+__exportStar(require("./define-hooks"), exports);

package/common/password.d.ts

@@ -0,0 +1,4 @@
+export declare const hashPassword: (plainText: string) => string;
+export declare const checkPassword: (plainText: string, storedHash: string) => boolean;
+export declare const generatePassword: (length?: number, specialChars?: boolean, extraSpecialChars?: boolean) => string;
+//# sourceMappingURL=password.d.ts.map

package/common/password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../src/common/password.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,GAAI,WAAW,MAAM,WAG7C,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,WAAW,MAAM,EAAE,YAAY,MAAM,YAGlE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,SAAQ,MAAW,EACnB,eAAc,OAAc,EAC5B,oBAAmB,OAAe,KACjC,MAmBF,CAAC"}

package/common/password.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePassword = exports.checkPassword = exports.hashPassword = void 0;
+const crypto = __importStar(require("crypto"));
+const hashPassword = (plainText) => {
+    const passwordHash = new PasswordHash(8, true);
+    return passwordHash.hashPassword(plainText);
+};
+exports.hashPassword = hashPassword;
+const checkPassword = (plainText, storedHash) => {
+    const passwordHash = new PasswordHash(8, true);
+    return passwordHash.checkPassword(plainText, storedHash);
+};
+exports.checkPassword = checkPassword;
+const generatePassword = (length = 12, specialChars = true, extraSpecialChars = false) => {
+    let chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    if (specialChars) {
+        chars += "!@#$%^&*()";
+    }
+    if (extraSpecialChars) {
+        chars += "-_ []{}<>~`+=,.;:/?|";
+    }
+    let password = "";
+    for (let i = 0; i < length; i++) {
+        password += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return password;
+};
+exports.generatePassword = generatePassword;
+const CRYPT_BLOWFISH = 1;
+class PasswordHash {
+    itoa64;
+    iterationCountLog2;
+    portableHashes;
+    randomState;
+    constructor(iterationCountLog2, portableHashes) {
+        this.itoa64 =
+            "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        if (iterationCountLog2 < 4 || iterationCountLog2 > 31) {
+            iterationCountLog2 = 8;
+        }
+        this.iterationCountLog2 = iterationCountLog2;
+        this.portableHashes = portableHashes;
+        this.randomState = Date.now().toString();
+        if (typeof process !== "undefined" && typeof process.pid !== "undefined") {
+            this.randomState += process.pid.toString();
+        }
+    }
+    getRandomBytes(count) {
+        let output = "";
+        try {
+            const randomBytes = crypto.randomBytes(count);
+            output = randomBytes.toString("hex");
+        }
+        catch (err) {
+            for (let i = 0; i < count; i += 16) {
+                this.randomState = crypto
+                    .createHash("md5")
+                    .update(this.randomState + Math.random())
+                    .digest("binary");
+                output += crypto
+                    .createHash("md5")
+                    .update(this.randomState, "binary")
+                    .digest("binary");
+            }
+            output = output.substring(0, count);
+        }
+        return output;
+    }
+    encode64(input, count) {
+        let output = "";
+        let i = 0;
+        do {
+            let value = input.charCodeAt(i++);
+            output += this.itoa64[value & 0x3f];
+            if (i < count) {
+                value |= input.charCodeAt(i) << 8;
+            }
+            output += this.itoa64[(value >> 6) & 0x3f];
+            if (i++ >= count) {
+                break;
+            }
+            if (i < count) {
+                value |= input.charCodeAt(i) << 16;
+            }
+            output += this.itoa64[(value >> 12) & 0x3f];
+            if (i++ >= count) {
+                break;
+            }
+            output += this.itoa64[(value >> 18) & 0x3f];
+        } while (i < count);
+        return output;
+    }
+    genSaltPrivate(input) {
+        let output = "$P$";
+        output +=
+            this.itoa64[Math.min(this.iterationCountLog2 +
+                (parseInt(process.versions.node, 10) >= 5 ? 5 : 3), 30)];
+        output += this.encode64(input, 6);
+        return output;
+    }
+    cryptPrivate(password, setting) {
+        let output = "*0";
+        if (setting.substring(0, 2) === output) {
+            output = "*1";
+        }
+        const id = setting.substring(0, 3);
+        if (id !== "$P$" && id !== "$H$") {
+            return output;
+        }
+        const countLog2 = this.itoa64.indexOf(setting[3]);
+        if (countLog2 < 7 || countLog2 > 30) {
+            return output;
+        }
+        let count = 1 << countLog2;
+        const salt = setting.substring(4, 12);
+        if (salt.length !== 8) {
+            return output;
+        }
+        let hash = crypto
+            .createHash("md5")
+            .update(salt + password, "binary")
+            .digest("binary");
+        do {
+            hash = crypto
+                .createHash("md5")
+                .update(hash + password, "binary")
+                .digest("binary");
+        } while (--count);
+        output = setting.substring(0, 12) + this.encode64(hash, 16);
+        return output;
+    }
+    genSaltBlowfish(input) {
+        const itoa64 = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+        let output = "$2a$";
+        output += String.fromCharCode(parseInt("0", 10) + Math.floor(this.iterationCountLog2 / 10));
+        output += String.fromCharCode(parseInt("0", 10) + (this.iterationCountLog2 % 10));
+        output += "$";
+        let i = 0;
+        do {
+            const c1 = input.charCodeAt(i++);
+            output += itoa64[c1 >> 2];
+            const c2 = input.charCodeAt(i++);
+            output += itoa64[((c1 & 0x03) << 4) | (c2 >> 4)];
+            if (i >= 16) {
+                output += itoa64[c2 & 0x0f];
+                break;
+            }
+            const c3 = input.charCodeAt(i++);
+            output += itoa64[((c2 & 0x0f) << 2) | (c3 >> 6)];
+            output += itoa64[c3 & 0x3f];
+            // eslint-disable-next-line no-constant-condition
+        } while (true);
+        return output;
+    }
+    hashPassword(password) {
+        if (password.length > 4096) {
+            return "*";
+        }
+        let random = "";
+        if (CRYPT_BLOWFISH === 1 && !this.portableHashes) {
+            random = this.getRandomBytes(16);
+            const hash = this.cryptPrivate(password, this.genSaltBlowfish(random));
+            if (hash.length === 60) {
+                return hash;
+            }
+        }
+        if (random.length < 6) {
+            random = this.getRandomBytes(6);
+        }
+        const hash = this.cryptPrivate(password, this.genSaltPrivate(random));
+        if (hash.length === 34) {
+            return hash;
+        }
+        return "*";
+    }
+    checkPassword(password, storedHash) {
+        if (password.length > 4096) {
+            return false;
+        }
+        let hash = this.cryptPrivate(password, storedHash);
+        if (hash[0] === "*") {
+            hash = crypto
+                .createHash("md5")
+                .update(password, "binary")
+                .digest("binary");
+            hash = this.cryptPrivate(password, storedHash);
+        }
+        return hash === storedHash;
+    }
+}

package/common/php-serialize.d.ts

@@ -0,0 +1,3 @@
+export declare const phpSerialize: (data: any) => string;
+export declare const phpUnserialize: <T = any>(data: any, failSafe?: boolean) => T;
+//# sourceMappingURL=php-serialize.d.ts.map

package/common/php-serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"php-serialize.d.ts","sourceRoot":"","sources":["../../src/common/php-serialize.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,GAAI,MAAM,GAAG,WAAoB,CAAC;AAE3D,eAAO,MAAM,cAAc,GAAI,CAAC,GAAG,GAAG,EAAE,MAAM,GAAG,EAAE,kBAAe,MAOjE,CAAC"}

package/common/php-serialize.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpUnserialize = exports.phpSerialize = void 0;
+const php_serialize_1 = require("php-serialize");
+const phpSerialize = (data) => (0, php_serialize_1.serialize)(data);
+exports.phpSerialize = phpSerialize;
+const phpUnserialize = (data, failSafe = true) => {
+    try {
+        return (0, php_serialize_1.unserialize)(data);
+    }
+    catch (e) {
+        if (failSafe)
+            return data;
+        throw e;
+    }
+};
+exports.phpUnserialize = phpUnserialize;

package/common/validating.d.ts

@@ -0,0 +1,10 @@
+import type * as types from "../types";
+export declare namespace validating {
+    const fieldSafe: <T extends types.validating.Tables, V>(table: T, field: types.validating.Field<T>, value: V) => V | undefined;
+    const field: <T extends types.validating.Tables, V>(table: T, field: types.validating.Field<T>, value: V) => Exclude<V, undefined>;
+    const execAny: <T extends types.validating.Parser>(func: T, v: any) => types.validating.ParserReturnType<T>;
+    const exec: <T extends types.validating.Parser>(func: T, v: types.validating.ParserReturnType<T>) => types.validating.ParserReturnType<T>;
+    const execSafeAny: <T extends types.validating.Parser>(func: T, v: any) => types.validating.ParserReturnType<T> | undefined;
+    const execSafe: <T extends types.validating.Parser>(func: T, v: types.validating.ParserReturnType<T>) => types.validating.ParserReturnType<T> | undefined;
+}
+//# sourceMappingURL=validating.d.ts.map

package/common/validating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validating.d.ts","sourceRoot":"","sources":["../../src/common/validating.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAGvC,yBAAiB,UAAU,CAAC;IACnB,MAAM,SAAS,GAAI,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAC5D,OAAO,CAAC,EACR,OAAO,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAChC,OAAO,CAAC,kBAUT,CAAC;IAEK,MAAM,KAAK,GAAI,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EACxD,OAAO,CAAC,EACR,OAAO,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAChC,OAAO,CAAC,KAIH,OAAO,CAAC,CAAC,EAAE,SAAS,CAC1B,CAAC;IAEK,MAAM,OAAO,GAAI,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,MAAM,EACvD,MAAM,CAAC,EACP,GAAG,GAAG,KACL,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAErC,CAAC;IAEK,MAAM,IAAI,GAAI,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,MAAM,EACpD,MAAM,CAAC,EACP,GAAG,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,KACtC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAErC,CAAC;IAEK,MAAM,WAAW,GAAI,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,MAAM,EAC3D,MAAM,CAAC,EACP,GAAG,GAAG,KACL,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAEzC,CAAC;IAEK,MAAM,QAAQ,GAAI,CAAC,SAAS,KAAK,CAAC,UAAU,CAAC,MAAM,EACxD,MAAM,CAAC,EACP,GAAG,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,KACtC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAWzC,CAAC;CACH"}

package/common/validating.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validating = void 0;
+const val = __importStar(require("../validators"));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var validating;
+(function (validating) {
+    validating.fieldSafe = (table, field, value) => {
+        const result = val.database.wpTables[table].shape[field].safeParse(value);
+        return result.success ? result.data : undefined;
+    };
+    validating.field = (table, field, value) => {
+        return val.database.wpTables[table].shape[field].parse(value);
+    };
+    validating.execAny = (func, v) => {
+        return validating.exec(func, v);
+    };
+    validating.exec = (func, v) => {
+        return func.parse(v);
+    };
+    validating.execSafeAny = (func, v) => {
+        return validating.execSafe(func, v);
+    };
+    validating.execSafe = (func, v) => {
+        const result = func.safeParse(v);
+        // if (!result.success) {
+        //   console.log(`BEFORE`, v, `AFTER`, result);
+        //   console.info((result as any).error);
+        // }
+        return result.success ? result.data : undefined;
+    };
+})(validating || (exports.validating = validating = {}));

package/config.d.ts

@@ -0,0 +1,99 @@
+import type * as types from "./types";
+export declare class Config {
+    #private;
+    constructor(config: types.Config);
+    isMultiSite(): boolean;
+    isSsl(): boolean;
+    isSubdomainInstall(): boolean;
+    get config(): {
+        options: {
+            protected: string[];
+            defaults: string[];
+        };
+        posts: {
+            types: Record<string, {
+                public: boolean;
+                supports: string[];
+                _builtin: boolean;
+                capabilityType: string | [string, string];
+                mapMetaCap: boolean;
+                deleteWithUser: boolean;
+                publiclyQueryable: boolean;
+                hierarchical?: boolean | undefined;
+                capabilities?: Record<string, string> | undefined;
+            }>;
+            typeNames: string[] | "attachment" | "page" | "post" | "revision";
+            statusNames: string[] | "inherit" | "private" | "pending" | "publish" | "future" | "draft" | "trash" | "auto-draft" | "request-pending" | "request-confirmed" | "request-failed" | "request-completed";
+            statuses: Record<string, {
+                label: string;
+                internal?: boolean | undefined;
+                private?: boolean | undefined;
+                public?: boolean | undefined;
+                _builtin?: boolean | undefined;
+                protected?: boolean | undefined;
+            }>;
+        };
+        constants: {
+            ALLOW_UNFILTERED_UPLOADS: boolean;
+            DISALLOW_UNFILTERED_HTML: boolean;
+            DISALLOW_FILE_EDIT: boolean;
+            LINK_USE_SSL: boolean;
+            TRASHED_SUFFIX_TO_POST_NAME_FOR_POST: "__trashed";
+            ALLOW_FILESYSTEM_OPERATIONS: boolean;
+            WP_DEFAULT_THEME: string;
+            WP_DB_VERSION: number;
+            WPLANG: string;
+            EMPTY_TRASH_DAYS: number;
+            MEDIA_TRASH: boolean;
+            WP_POST_REVISIONS: number;
+            WP_LOG_LEVEL: "error" | "debug" | "info" | "warn";
+        };
+        extensions: {
+            audio: string[];
+            video: string[];
+            misc: string[];
+        };
+        timezoneOffset: string;
+        staticAssetsPath: string;
+        multisite: {
+            enabled: boolean;
+            defaultBlogId: number;
+            defaultSiteId: number;
+            defaultSitemetaKeys: string[];
+            subdomainInstall: boolean;
+            subdirectoryReservedNames: string[];
+            vhost: "no" | "yes";
+            uploadBlogsDir: string;
+        };
+        tableCharset: string;
+        tableCollate: string;
+        tablePrefix: string;
+        database: {
+            client: string;
+            connection: {
+                port: number;
+                charset: string;
+                host?: string | undefined;
+                user?: string | undefined;
+                database?: string | undefined;
+                password?: string | undefined;
+            };
+        };
+        taxonomy: {
+            names: string[] | "category" | "post_tag" | "post_format" | "link_category";
+            settings: Record<string, {
+                objectType: string;
+                hierarchical: boolean;
+                _builtin: boolean;
+                showUi: boolean;
+                capabilities?: Partial<Record<"manage_terms" | "edit_terms" | "delete_terms" | "assign_terms", string>> | undefined;
+            }>;
+        };
+        roles: Record<string, {
+            name: string;
+            capabilities: string[];
+        }>;
+    };
+    set(config: types.DeepPartial<types.Config>): void;
+}
+//# sourceMappingURL=config.d.ts.map

package/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,KAAK,MAAM,SAAS,CAAC;AAGtC,qBACa,MAAM;;gBAGL,MAAM,EAAE,KAAK,CAAC,MAAM;IAIhC,WAAW;IAIX,KAAK;IAKL,kBAAkB;IAOlB,IAAI,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAET;IAED,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC;CAG5C"}

package/config.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const scope_1 = require("./constants/scope");
+const component_1 = require("./decorators/component");
+const val = __importStar(require("./validators"));
+let Config = class Config {
+    #config;
+    constructor(config) {
+        this.#config = structuredClone(config); //Application.config);
+    }
+    isMultiSite() {
+        return this.#config.multisite?.enabled ?? false;
+    }
+    isSsl() {
+        return this.#config.constants.LINK_USE_SSL ?? true;
+    }
+    // is_subdomain_install
+    isSubdomainInstall() {
+        return (this.#config.multisite.subdomainInstall ||
+            "yes" === this.#config.multisite.vhost);
+    }
+    get config() {
+        return this.#config;
+    }
+    set(config) {
+        this.#config = val.config.config.parse({ ...this.#config, ...config });
+    }
+};
+exports.Config = Config;
+exports.Config = Config = __decorate([
+    (0, component_1.component)({ scope: scope_1.Scope.Singleton }),
+    __metadata("design:paramtypes", [Object])
+], Config);

package/constants/async-init.d.ts

@@ -0,0 +1,2 @@
+export declare const REFLECT_METADATA_KEY_ASYNC_INIT = "__REFLECT_METADATA_KEY_ASYNC_INIT__";
+//# sourceMappingURL=async-init.d.ts.map

package/constants/async-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-init.d.ts","sourceRoot":"","sources":["../../src/constants/async-init.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,+BAA+B,wCACL,CAAC"}

package/constants/async-init.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFLECT_METADATA_KEY_ASYNC_INIT = void 0;
+exports.REFLECT_METADATA_KEY_ASYNC_INIT = "__REFLECT_METADATA_KEY_ASYNC_INIT__";

package/constants/component.d.ts

@@ -0,0 +1,3 @@
+export declare const REFLECT_METADATA_KEY_COMPONENT = "__REFLECT_METADATA_KEY_COMPONENT__";
+export declare const REFLECT_METADATA_KEY_COMPONENT_ARGUMENTS = "__REFLECT_METADATA_KEY_COMPONENT_ARGUMENTS__";
+//# sourceMappingURL=component.d.ts.map

package/constants/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/constants/component.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,uCACL,CAAC;AAEvC,eAAO,MAAM,wCAAwC,iDACL,CAAC"}

package/constants/component.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFLECT_METADATA_KEY_COMPONENT_ARGUMENTS = exports.REFLECT_METADATA_KEY_COMPONENT = void 0;
+exports.REFLECT_METADATA_KEY_COMPONENT = "__REFLECT_METADATA_KEY_COMPONENT__";
+exports.REFLECT_METADATA_KEY_COMPONENT_ARGUMENTS = "__REFLECT_METADATA_KEY_COMPONENT_ARGUMENTS__";

package/constants/database.d.ts

@@ -0,0 +1,2 @@
+export declare const TABLE_NAMES: readonly (keyof import("../types").Tables)[];
+//# sourceMappingURL=database.d.ts.map

package/constants/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/constants/database.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW,8CAId,CAAC"}

package/constants/database.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TABLE_NAMES = void 0;
+const default_database_tables_1 = require("./default-database-tables");
+exports.TABLE_NAMES = [
+    ...default_database_tables_1.DEFAULT_DATABASE_TABLES.blog,
+    ...default_database_tables_1.DEFAULT_DATABASE_TABLES.global,
+    ...default_database_tables_1.DEFAULT_DATABASE_TABLES.ms_global,
+];

package/constants/default-database-tables.d.ts

@@ -0,0 +1,7 @@
+import type * as types from "../types";
+export declare const DEFAULT_DATABASE_TABLES: {
+    blog: types.TableNames[];
+    global: types.TableNames[];
+    ms_global: types.TableNames[];
+};
+//# sourceMappingURL=default-database-tables.d.ts.map

package/constants/default-database-tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-database-tables.d.ts","sourceRoot":"","sources":["../../src/constants/default-database-tables.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,uBAAuB;UAY7B,KAAK,CAAC,UAAU,EAAE;YACU,KAAK,CAAC,UAAU,EAAE;eAQ9C,KAAK,CAAC,UAAU,EAAE;CACxB,CAAC"}

package/constants/default-database-tables.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DATABASE_TABLES = void 0;
+exports.DEFAULT_DATABASE_TABLES = {
+    blog: [
+        "posts",
+        "comments",
+        "links",
+        "options",
+        "postmeta",
+        "terms",
+        "term_taxonomy",
+        "term_relationships",
+        "termmeta",
+        "commentmeta",
+    ],
+    global: ["users", "usermeta"],
+    ms_global: [
+        "blogs",
+        "blogmeta",
+        "signups",
+        "site",
+        "sitemeta",
+        "registration_log",
+    ],
+};