@h3ravel/arquebus 0.6.6 → 0.6.7

package/dist/browser/index.cjs

@@ -1,1271 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let collect_js = require("collect.js");
-collect_js = __toESM(collect_js);
-let radashi = require("radashi");
-radashi = __toESM(radashi);
-let dayjs_plugin_advancedFormat_js = require("dayjs/plugin/advancedFormat.js");
-dayjs_plugin_advancedFormat_js = __toESM(dayjs_plugin_advancedFormat_js);
-let dayjs = require("dayjs");
-dayjs = __toESM(dayjs);
-let pluralize = require("pluralize");
-pluralize = __toESM(pluralize);
-
-//#region src/casts/attribute.ts
-var Attribute = class Attribute {
-	get;
-	set;
-	withCaching = false;
-	withObjectCaching = true;
-	constructor({ get = null, set = null }) {
-		this.get = get;
-		this.set = set;
-	}
-	static make({ get = null, set = null }) {
-		return new Attribute({
-			get,
-			set
-		});
-	}
-	static get(get) {
-		return new Attribute({ get });
-	}
-	static set(set) {
-		return new Attribute({ set });
-	}
-	withoutObjectCaching() {
-		this.withObjectCaching = false;
-		return this;
-	}
-	shouldCache() {
-		this.withCaching = true;
-		return this;
-	}
-};
-var attribute_default = Attribute;
-
-//#endregion
-//#region src/casts-attributes.ts
-var CastsAttributes = class CastsAttributes {
-	constructor() {
-		if (this.constructor === CastsAttributes) throw new Error("CastsAttributes cannot be instantiated");
-	}
-	static get(_model, _key, _value, _attributes) {
-		throw new Error("get not implemented");
-	}
-	static set(_model, _key, _value, _attributes) {
-		throw new Error("set not implemented");
-	}
-};
-var casts_attributes_default = CastsAttributes;
-
-//#endregion
-//#region src/mixin.ts
-var mixin_exports = /* @__PURE__ */ __export({ compose: () => compose$1 });
-/**
-* Compose function that merges multiple classes and mixins
-*
-* @example
-* const SomePlugin = <TBase extends new (...args: any[]) => TGeneric> (Base: TBase) => {
-*     return class extends Base {
-*         pluginAttribtue = 'plugin'
-*         pluginMethod () {
-*             return this.pluginAttribtue
-*         }
-*     }
-* }
-*
-* // Base class
-* class Model {
-*     make () {
-*         console.log('make')
-*     }
-*     pluginMethod (id: string) {
-*     }
-* }
-*
-* class User extends compose(
-*     Model,
-*     SomePlugin,
-* ) {
-*     relationPosts () {
-*         return 'hasMany Posts'
-*     }
-* }
-*
-* const user = new User()
-* user.make() // from Model
-* user.pluginMethod() // from SomePlugin
-* user.relationPosts() // from User
-*
-* console.log(user.pluginMethod('w')) // "plugin"
-* console.log(user.pluginMethod()) // "plugin"
-* console.log(user.relationPosts()) // "hasMany Posts"
-*
-* @param Base
-* @param mixins
-* @returns
-*/
-function compose$1(Base, ...mixins) {
-	/**
-	* Apply each mixin or class in sequence
-	*/
-	return mixins.reduce((acc, mixin) => {
-		if (typeof mixin === "function" && mixin.prototype)
- /**
-		* If it's a class constructor, extend it
-		*/
-		return class extends acc {
-			constructor(...args) {
-				super(...args);
-				/**
-				* Copy instance properties from mixin prototype
-				*/
-				Object.getOwnPropertyNames(mixin.prototype).forEach((name) => {
-					if (name !== "constructor") Object.defineProperty(this, name, Object.getOwnPropertyDescriptor(mixin.prototype, name));
-				});
-			}
-		};
-		else if (typeof mixin === "function")
- /**
-		* If it's a mixin function, call it with current class
-		*/
-		return mixin(acc);
-		return acc;
-	}, Base);
-}
-
-//#endregion
-//#region src/utils.ts
-dayjs.default.extend(dayjs_plugin_advancedFormat_js.default);
-const now = (format = "YYYY-MM-DD HH:mm:ss") => (0, dayjs.default)().format(format);
-const getRelationName = (relationMethod) => {
-	return (0, radashi.snake)(relationMethod.substring(8));
-};
-const getScopeName = (scopeMethod) => {
-	return (0, radashi.snake)(scopeMethod.substring(5));
-};
-const getRelationMethod = (relation) => {
-	return (0, radashi.camel)(`relation_${relation}`);
-};
-const getScopeMethod = (scope) => {
-	return (0, radashi.camel)(`scope_${scope}`);
-};
-const getAttrMethod = (attr) => {
-	return (0, radashi.camel)(`attribute_${attr}`);
-};
-const getGetterMethod = (attr) => {
-	return (0, radashi.camel)(`get_${attr}_attribute`);
-};
-const getSetterMethod = (attr) => {
-	return (0, radashi.camel)(`set_${attr}_attribute`);
-};
-const getAttrName = (attrMethod) => {
-	return attrMethod.substring(3, attrMethod.length - 9).toLowerCase();
-};
-/**
-* Tap into a model a collection instance
-*
-* @param instance
-* @param callback
-* @returns
-*/
-const tap = (instance, callback) => {
-	const result = callback(instance);
-	return result instanceof Promise ? result.then(() => instance) : instance;
-};
-const { compose } = mixin_exports;
-const flatten = (arr) => arr.flat();
-const flattenDeep = (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
-const kebabCase = (str) => (0, radashi.trim)((0, radashi.dash)(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
-const snakeCase = (str) => (0, radashi.trim)((0, radashi.snake)(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
-const defineConfig = (config) => {
-	return config;
-};
-
-//#endregion
-//#region src/browser/relations/relation.ts
-var Relation = class {
-	parent;
-	related;
-	eagerKeysWereEmpty = false;
-	static constraints = true;
-	constructor(related, parent) {
-		this.parent = parent;
-		this.related = related;
-	}
-	asProxy() {
-		return new Proxy(this, { get: function(target, prop) {
-			if (typeof target[prop] !== "undefined") return target[prop];
-			if (typeof prop === "string") return () => target.asProxy();
-		} });
-	}
-	getRelated() {
-		return this.related;
-	}
-};
-var relation_default = Relation;
-
-//#endregion
-//#region src/browser/relations/belongs-to.ts
-var BelongsTo = class extends relation_default {
-	foreignKey;
-	ownerKey;
-	child;
-	relationName;
-	constructor(related, child, foreignKey, ownerKey, relationName) {
-		super(related, child);
-		this.foreignKey = foreignKey;
-		this.ownerKey = ownerKey;
-		this.child = child;
-		this.relationName = relationName;
-		return this.asProxy();
-	}
-};
-var belongs_to_default = BelongsTo;
-
-//#endregion
-//#region src/browser/relations/belongs-to-many.ts
-var BelongsToMany = class extends relation_default {
-	table;
-	foreignPivotKey;
-	relatedPivotKey;
-	parentKey;
-	relatedKey;
-	pivotColumns = [];
-	pivotValues = [];
-	pivotWheres = [];
-	pivotWhereIns = [];
-	pivotWhereNulls = [];
-	accessor = "pivot";
-	using;
-	pivotCreatedAt;
-	pivotUpdatedAt;
-	constructor(related, parent, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
-		super(related, parent);
-		this.table = table;
-		this.foreignPivotKey = foreignPivotKey;
-		this.relatedPivotKey = relatedPivotKey;
-		this.parentKey = parentKey;
-		this.relatedKey = relatedKey;
-		return this.asProxy();
-	}
-};
-var belongs_to_many_default = BelongsToMany;
-
-//#endregion
-//#region src/concerns/has-attributes.ts
-const HasAttributes = (Model$1) => {
-	return class extends Model$1 {
-		static castTypeCache = {};
-		attributes = {};
-		original = {};
-		casts = {};
-		changes = {};
-		appends = [];
-		setAppends(appends) {
-			this.appends = appends;
-			return this;
-		}
-		append(...keys) {
-			const appends = flattenDeep(keys);
-			this.appends = [...this.appends, ...appends];
-			return this;
-		}
-		normalizeCastClassResponse(key, value) {
-			var _value$constructor;
-			return (value === null || value === void 0 || (_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name) === "Object" ? value : { [key]: value };
-		}
-		syncOriginal() {
-			this.original = this.getAttributes();
-			return this;
-		}
-		syncChanges() {
-			this.changes = this.getDirty();
-			return this;
-		}
-		syncOriginalAttribute(attribute) {
-			this.syncOriginalAttributes(attribute);
-		}
-		syncOriginalAttributes(...attributes) {
-			attributes = flattenDeep(attributes);
-			const modelAttributes = this.getAttributes();
-			for (const attribute of attributes) this.original[attribute] = modelAttributes[attribute];
-			return this;
-		}
-		isDirty(...attributes) {
-			const changes = this.getDirty();
-			attributes = flattenDeep(attributes);
-			if (attributes.length === 0) return Object.keys(changes).length > 0;
-			for (const attribute of attributes) if (attribute in changes) return true;
-			return false;
-		}
-		getDirty() {
-			const dirty = {};
-			const attributes = this.getAttributes();
-			for (const key in attributes) {
-				const value = attributes[key];
-				if (!this.originalIsEquivalent(key)) dirty[key] = value;
-			}
-			return dirty;
-		}
-		originalIsEquivalent(key) {
-			if (this.original[key] === void 0) return false;
-			const attribute = this.attributes[key];
-			const original = this.original[key];
-			if (attribute === original) return true;
-			else return false;
-		}
-		setAttributes(attributes) {
-			this.attributes = { ...attributes };
-		}
-		setRawAttributes(attributes, sync = false) {
-			this.attributes = attributes;
-			if (sync) this.syncOriginal();
-			return this;
-		}
-		getAttributes() {
-			return { ...this.attributes };
-		}
-		setAttribute(key, value) {
-			const setterMethod = getSetterMethod(key);
-			if (typeof this[setterMethod] === "function") {
-				this[setterMethod](value);
-				return this;
-			}
-			const attrMethod = getAttrMethod(key);
-			if (typeof this[attrMethod] === "function") {
-				const callback = this[attrMethod]().set || ((value$1) => {
-					this.attributes[key] = value$1;
-				});
-				this.attributes = {
-					...this.attributes,
-					...this.normalizeCastClassResponse(key, callback(value, this.attributes))
-				};
-				return this;
-			}
-			const castType = this.getCasts()[key];
-			if (this.isCustomCast(castType) && typeof castType !== "string") value = castType.set(this, key, value, this.attributes) ?? "";
-			if (castType === "json") value = JSON.stringify(value);
-			if (castType === "collection") value = JSON.stringify(value);
-			if (value !== null && this.isDateAttribute(key)) value = this.fromDateTime(value);
-			this.attributes[key] = value;
-			return this;
-		}
-		getAttribute(key) {
-			if (!key) return;
-			const getterMethod = getGetterMethod(key);
-			if (typeof this[getterMethod] === "function") return this[getterMethod](this.attributes[key], this.attributes);
-			const attrMethod = getAttrMethod(key);
-			if (typeof this[attrMethod] === "function") return this[attrMethod]().get(this.attributes[key], this.attributes);
-			if (key in this.attributes) {
-				if (this.hasCast(key)) return this.castAttribute(key, this.attributes[key]);
-				if (this.getDates().includes(key)) return this.asDateTime(this.attributes[key]);
-				return this.attributes[key];
-			}
-			if (key in this.relations) return this.relations[key];
-		}
-		castAttribute(key, value) {
-			const castType = this.getCastType(key);
-			if (!castType) return value;
-			if (value === null) return value;
-			switch (castType) {
-				case "int":
-				case "integer": return parseInt(value);
-				case "real":
-				case "float":
-				case "double": return parseFloat(value);
-				case "decimal": return this.asDecimal(value, castType.split(":")[1]);
-				case "string": return String(value);
-				case "bool":
-				case "boolean": return Boolean(value);
-				case "object":
-				case "json": try {
-					return JSON.parse(value);
-				} catch {
-					return null;
-				}
-				case "collection": try {
-					return (0, collect_js.default)(JSON.parse(value));
-				} catch {
-					return (0, collect_js.default)([]);
-				}
-				case "date": return this.asDate(value);
-				case "datetime":
-				case "custom_datetime": return this.asDateTime(value);
-				case "timestamp": return this.asTimestamp(value);
-			}
-			if (this.isCustomCast(castType)) return castType.get(this, key, value, this.attributes);
-			return value;
-		}
-		attributesToData() {
-			let attributes = { ...this.attributes };
-			for (const key in attributes) {
-				if (this.hidden.includes(key)) attributes = (0, radashi.omit)(attributes, [key]);
-				if (this.visible.length > 0 && this.visible.includes(key) === false) attributes = (0, radashi.omit)(attributes, [key]);
-			}
-			for (const key of this.getDates()) {
-				if (attributes[key] === void 0) continue;
-				attributes[key] = this.serializeDate(this.asDateTime(attributes[key]));
-			}
-			const casts = this.getCasts();
-			for (const key in casts) {
-				const value = casts[key];
-				if (key in attributes === false) continue;
-				attributes[key] = this.castAttribute(key, attributes[key]);
-				if (key in attributes && ["date", "datetime"].includes(String(value))) attributes[key] = this.serializeDate(attributes[key]);
-				if (key in attributes && this.isCustomDateTimeCast(value)) attributes[key] = (0, dayjs.default)(attributes[key]).format(String(value).split(":")[1]);
-			}
-			for (const key of this.appends) attributes[key] = this.mutateAttribute(key, null);
-			return attributes;
-		}
-		mutateAttribute(key, value) {
-			if (typeof this[getGetterMethod(key)] === "function") return this[getGetterMethod(key)](value);
-			else if (typeof this[getAttrMethod(key)] === "function") return this[getAttrMethod(key)]().get(key, this.attributes);
-			else if (key in this) return this[key];
-			return value;
-		}
-		mutateAttributeForArray(_key, _value) {}
-		isDateAttribute(key) {
-			return this.getDates().includes(key) || this.isDateCastable(key);
-		}
-		serializeDate(date) {
-			return date ? (0, dayjs.default)(date).toISOString() : null;
-		}
-		getDates() {
-			return this.usesTimestamps() ? [this.getCreatedAtColumn(), this.getUpdatedAtColumn()] : [];
-		}
-		getCasts() {
-			if (this.getIncrementing()) return {
-				[this.getKeyName()]: this.getKeyType(),
-				...this.casts
-			};
-			return this.casts;
-		}
-		getCastType(key) {
-			const castType = this.getCasts()[key];
-			let castTypeCacheKey;
-			if (typeof castType === "string") castTypeCacheKey = castType;
-			else if (new castType() instanceof casts_attributes_default) castTypeCacheKey = castType.name;
-			if (castTypeCacheKey && this.getConstructor().castTypeCache[castTypeCacheKey] !== void 0) return this.getConstructor().castTypeCache[castTypeCacheKey];
-			let convertedCastType;
-			if (this.isCustomDateTimeCast(castType)) convertedCastType = "custom_datetime";
-			else if (this.isDecimalCast(castType)) convertedCastType = "decimal";
-			else if (this.isCustomCast(castType)) convertedCastType = castType;
-			else convertedCastType = String(castType).toLocaleLowerCase().trim();
-			return this.getConstructor()[castTypeCacheKey] = convertedCastType;
-		}
-		hasCast(key, types = []) {
-			if (key in this.casts) {
-				types = (0, radashi.flat)(types);
-				return types.length > 0 ? types.includes(this.getCastType(key)) : true;
-			}
-			return false;
-		}
-		withDayjs(date) {
-			return (0, dayjs.default)(date);
-		}
-		isCustomCast(cast) {
-			return typeof cast === "function" && new cast() instanceof casts_attributes_default;
-		}
-		isCustomDateTimeCast(cast) {
-			if (typeof cast !== "string") return false;
-			return cast.startsWith("date:") || cast.startsWith("datetime:");
-		}
-		isDecimalCast(cast) {
-			if (typeof cast !== "string") return false;
-			return cast.startsWith("decimal:");
-		}
-		isDateCastable(key) {
-			return this.hasCast(key, ["date", "datetime"]);
-		}
-		fromDateTime(value) {
-			return (0, dayjs.default)(this.asDateTime(value)).format(this.getDateFormat());
-		}
-		getDateFormat() {
-			return this.dateFormat || "YYYY-MM-DD HH:mm:ss";
-		}
-		asDecimal(value, decimals) {
-			return parseFloat(value).toFixed(decimals);
-		}
-		asDateTime(value) {
-			if (value === null) return null;
-			if (value instanceof Date) return value;
-			if (typeof value === "number") return /* @__PURE__ */ new Date(value * 1e3);
-			return new Date(value);
-		}
-		asDate(value) {
-			const date = this.asDateTime(value);
-			return (0, dayjs.default)(date).startOf("day").toDate();
-		}
-	};
-};
-var has_attributes_default = HasAttributes;
-
-//#endregion
-//#region src/browser/relations/has-many.ts
-var HasMany = class extends relation_default {
-	foreignKey;
-	localKey;
-	constructor(related, parent, foreignKey, localKey) {
-		super(related, parent);
-		this.foreignKey = foreignKey;
-		this.localKey = localKey;
-		return this.asProxy();
-	}
-};
-var has_many_default = HasMany;
-
-//#endregion
-//#region src/browser/relations/has-one.ts
-var HasOne = class extends relation_default {
-	foreignKey;
-	localKey;
-	constructor(related, parent, foreignKey, localKey) {
-		super(related, parent);
-		this.foreignKey = foreignKey;
-		this.localKey = localKey;
-		return this.asProxy();
-	}
-};
-var has_one_default = HasOne;
-
-//#endregion
-//#region src/browser/relations/has-many-through.ts
-var HasManyThrough = class extends relation_default {
-	throughParent;
-	farParent;
-	firstKey;
-	secondKey;
-	localKey;
-	secondLocalKey;
-	constructor(query, farParent, throughParent, firstKey, secondKey, localKey, secondLocalKey) {
-		super(query, throughParent);
-		this.localKey = localKey;
-		this.firstKey = firstKey;
-		this.secondKey = secondKey;
-		this.farParent = farParent;
-		this.throughParent = throughParent;
-		this.secondLocalKey = secondLocalKey;
-		return this.asProxy();
-	}
-};
-var has_many_through_default = HasManyThrough;
-
-//#endregion
-//#region src/browser/relations/has-one-through.ts
-var HasOneThrough = class extends has_many_through_default {};
-var has_one_through_default = HasOneThrough;
-
-//#endregion
-//#region src/errors.ts
-var BaseError = class extends Error {
-	constructor(message, _entity) {
-		super(message);
-		Error.captureStackTrace(this, this.constructor);
-		this.name = this.constructor.name;
-		this.message = message;
-	}
-};
-var ModelNotFoundError = class extends BaseError {
-	model;
-	ids = [];
-	constructor() {
-		super("");
-	}
-	setModel(model, ids = []) {
-		this.model = model;
-		this.ids = (0, radashi.isArray)(ids) ? ids : [ids];
-		this.message = `No query results for model [${model}]`;
-		if (this.ids.length > 0) this.message += " " + this.ids.join(", ");
-		else this.message += ".";
-		return this;
-	}
-	getModel() {
-		return this.model;
-	}
-	getIds() {
-		return this.ids;
-	}
-};
-var RelationNotFoundError = class extends BaseError {};
-var InvalidArgumentError = class extends BaseError {};
-
-//#endregion
-//#region src/browser/concerns/has-relations.ts
-const HasRelations = (Instance) => {
-	return class extends Instance {
-		relations = {};
-		getRelation(relation) {
-			return this.relations[relation];
-		}
-		setRelation(relation, value) {
-			this.relations[relation] = value;
-			return this;
-		}
-		unsetRelation(relation) {
-			this.relations = (0, radashi.omit)(this.relations, [relation]);
-			return this;
-		}
-		relationLoaded(relation) {
-			return this.relations[relation] !== void 0;
-		}
-		related(relation) {
-			if (typeof this[getRelationMethod(relation)] !== "function") {
-				const message = `Model [${this.constructor.name}]'s relation [${relation}] doesn't exist.`;
-				throw new RelationNotFoundError(message);
-			}
-			return this[getRelationMethod(relation)]();
-		}
-		async getRelated(relation) {
-			return await this.related(relation).getResults();
-		}
-		relationsToData() {
-			const data = {};
-			for (const key in this.relations) {
-				if (this.hidden.includes(key)) continue;
-				if (this.visible.length > 0 && this.visible.includes(key) === false) continue;
-				data[key] = this.relations[key] instanceof Array ? this.relations[key].map((item) => item.toData()) : this.relations[key] === null ? null : this.relations[key].toData();
-			}
-			return data;
-		}
-		guessBelongsToRelation() {
-			var _e$stack;
-			const frame = (_e$stack = (/* @__PURE__ */ new Error()).stack) === null || _e$stack === void 0 ? void 0 : _e$stack.split("\n")[2];
-			const functionName = frame === null || frame === void 0 ? void 0 : frame.split(" ")[5];
-			return getRelationName(functionName);
-		}
-		joiningTable(related, instance = null) {
-			return [instance ? instance.joiningTableSegment() : snakeCase(related.name), this.joiningTableSegment()].sort().join("_").toLocaleLowerCase();
-		}
-		joiningTableSegment() {
-			return snakeCase(this.constructor.name);
-		}
-		hasOne(related, foreignKey = null, localKey = null) {
-			const instance = new related();
-			foreignKey = foreignKey || this.getForeignKey();
-			localKey = localKey || this.getKeyName();
-			return new has_one_default(related, this, instance.getTable() + "." + foreignKey, localKey);
-		}
-		hasMany(related, foreignKey = null, localKey = null) {
-			const instance = new related();
-			foreignKey = foreignKey || this.getForeignKey();
-			localKey = localKey || this.getKeyName();
-			return new has_many_default(related, this, instance.getTable() + "." + foreignKey, localKey);
-		}
-		belongsTo(related, foreignKey = null, ownerKey = null, relation = null) {
-			const instance = new related();
-			foreignKey = foreignKey || instance.getForeignKey();
-			ownerKey = ownerKey || instance.getKeyName();
-			relation = relation || this.guessBelongsToRelation();
-			return new belongs_to_default(related, this, foreignKey, ownerKey, relation);
-		}
-		belongsToMany(related, table = null, foreignPivotKey = null, relatedPivotKey = null, parentKey = null, relatedKey = null) {
-			const instance = new related();
-			const query = related.query();
-			table = table || this.joiningTable(related, instance);
-			foreignPivotKey = foreignPivotKey || this.getForeignKey();
-			relatedPivotKey = relatedPivotKey || instance.getForeignKey();
-			parentKey = parentKey || this.getKeyName();
-			relatedKey = relatedKey || instance.getKeyName();
-			return new belongs_to_many_default(query, this, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey);
-		}
-		hasOneThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
-			through = new through();
-			const query = related.query();
-			firstKey = firstKey || this.getForeignKey();
-			secondKey = secondKey || through.getForeignKey();
-			return new has_one_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
-		}
-		hasManyThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
-			through = new through();
-			const query = related.query();
-			firstKey = firstKey || this.getForeignKey();
-			secondKey = secondKey || through.getForeignKey();
-			return new has_many_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
-		}
-	};
-};
-var has_relations_default = HasRelations;
-
-//#endregion
-//#region src/concerns/has-timestamps.ts
-const HasTimestamps = (Model$1) => {
-	return class extends Model$1 {
-		static CREATED_AT = "created_at";
-		static UPDATED_AT = "updated_at";
-		static DELETED_AT = "deleted_at";
-		timestamps = true;
-		dateFormat = "YYYY-MM-DD HH:mm:ss";
-		usesTimestamps() {
-			return this.timestamps;
-		}
-		updateTimestamps() {
-			const time = this.freshTimestampString();
-			const updatedAtColumn = this.getUpdatedAtColumn();
-			if (updatedAtColumn && !this.isDirty(updatedAtColumn)) this.setUpdatedAt(time);
-			const createdAtColumn = this.getCreatedAtColumn();
-			if (!this.exists && createdAtColumn && !this.isDirty(createdAtColumn)) this.setCreatedAt(time);
-			return this;
-		}
-		getCreatedAtColumn() {
-			return this.constructor.CREATED_AT;
-		}
-		getUpdatedAtColumn() {
-			return this.constructor.UPDATED_AT;
-		}
-		setCreatedAt(value) {
-			this.attributes[this.getCreatedAtColumn()] = value;
-			return this;
-		}
-		setUpdatedAt(value) {
-			this.attributes[this.getUpdatedAtColumn()] = value;
-			return this;
-		}
-		freshTimestamp() {
-			const time = /* @__PURE__ */ new Date();
-			time.setMilliseconds(0);
-			return time;
-		}
-		freshTimestampString() {
-			return this.fromDateTime(this.freshTimestamp());
-		}
-	};
-};
-var has_timestamps_default = HasTimestamps;
-
-//#endregion
-//#region src/concerns/hides-attributes.ts
-const HidesAttributes = (Model$1) => {
-	return class extends Model$1 {
-		hidden = [];
-		visible = [];
-		makeVisible(...keys) {
-			const visible = flattenDeep(keys);
-			if (this.visible.length > 0) this.visible = [...this.visible, ...visible];
-			this.hidden = (0, radashi.diff)(this.hidden, visible);
-			return this;
-		}
-		makeHidden(key, ...keys) {
-			const hidden = flattenDeep([...key, ...keys]);
-			if (this.hidden.length > 0) this.hidden = [...this.hidden, ...hidden];
-			return this;
-		}
-		getHidden() {
-			return this.hidden;
-		}
-		getVisible() {
-			return this.visible;
-		}
-		setHidden(hidden) {
-			this.hidden = hidden;
-			return this;
-		}
-		setVisible(visible) {
-			this.visible = visible;
-			return this;
-		}
-	};
-};
-var hides_attributes_default = HidesAttributes;
-
-//#endregion
-//#region src/browser/model.ts
-const BaseModel = compose(class {}, has_attributes_default, hides_attributes_default, has_relations_default, has_timestamps_default);
-var Model = class Model extends BaseModel {
-	primaryKey = "id";
-	perPage = 15;
-	static globalScopes = {};
-	static pluginInitializers = {};
-	static _booted = {};
-	static resolver;
-	static browser = true;
-	connection = null;
-	constructor(attributes = {}) {
-		super();
-		this.bootIfNotBooted();
-		this.initializePlugins();
-		this.syncOriginal();
-		this.fill(attributes);
-		return this.asProxy();
-	}
-	static init(attributes = {}) {
-		return new this(attributes);
-	}
-	static extend(plugin, options) {
-		plugin(this, options);
-	}
-	static make(attributes = {}) {
-		const instance = new this();
-		for (const attribute in attributes) if (typeof instance[getRelationMethod(attribute)] !== "function") instance.setAttribute(attribute, attributes[attribute]);
-		else {
-			const relation = instance[getRelationMethod(attribute)]();
-			if (relation instanceof has_one_default || relation instanceof belongs_to_default) instance.setRelation(attribute, relation.related.make(attributes[attribute]));
-			else if ((relation instanceof has_many_default || relation instanceof belongs_to_many_default) && Array.isArray(attributes[attribute])) instance.setRelation(attribute, new collection_default(attributes[attribute].map((item) => relation.related.make(item))));
-		}
-		return instance;
-	}
-	bootIfNotBooted() {
-		if (this.constructor._booted[this.constructor.name] === void 0) {
-			this.constructor._booted[this.constructor.name] = true;
-			this.constructor.booting();
-			this.initialize();
-			this.constructor.boot();
-			this.constructor.booted();
-		}
-	}
-	static booting() {}
-	static boot() {}
-	static booted() {}
-	static setConnectionResolver(resolver) {
-		this.resolver = resolver;
-	}
-	initialize() {}
-	initializePlugins() {
-		if (typeof this.constructor.pluginInitializers[this.constructor.name] === "undefined") return;
-		for (const method of this.constructor.pluginInitializers[this.constructor.name]) this[method]();
-	}
-	addPluginInitializer(method) {
-		if (!this.constructor.pluginInitializers[this.constructor.name]) this.constructor.pluginInitializers[this.constructor.name] = [];
-		this.constructor.pluginInitializers[this.constructor.name].push(method);
-	}
-	newInstance(attributes = {}, exists = false) {
-		const model = new this.constructor();
-		model.exists = exists;
-		model.setTable(this.getTable());
-		model.fill(attributes);
-		return model;
-	}
-	asProxy() {
-		return new Proxy(this, {
-			get: function(target, prop) {
-				if (target[prop] !== void 0) return target[prop];
-				if (typeof prop === "string") return target.getAttribute(prop);
-			},
-			set: function(target, prop, value) {
-				if (target[prop] !== void 0 && typeof target !== "function") {
-					target[prop] = value;
-					return target;
-				}
-				if (typeof prop === "string") return target.setAttribute(prop, value);
-				return target;
-			}
-		});
-	}
-	getKey() {
-		return this.getAttribute(this.getKeyName());
-	}
-	getKeyName() {
-		return this.primaryKey;
-	}
-	getForeignKey() {
-		return snakeCase(this.constructor.name) + "_" + this.getKeyName();
-	}
-	getConnectionName() {
-		return this.connection;
-	}
-	getTable() {
-		return this.table || (0, pluralize.default)(snakeCase(this.constructor.name));
-	}
-	setConnection(connection) {
-		this.connection = connection;
-		return this;
-	}
-	getKeyType() {
-		return this.keyType;
-	}
-	hasNamedScope(name) {
-		const scope = getScopeMethod(name);
-		return typeof this[scope] === "function";
-	}
-	callNamedScope(scope, parameters) {
-		const scopeMethod = getScopeMethod(scope);
-		return this[scopeMethod](...parameters);
-	}
-	setTable(table) {
-		this.table = table;
-		return this;
-	}
-	newCollection(models = []) {
-		return new collection_default(models);
-	}
-	getIncrementing() {
-		return this.incrementing;
-	}
-	setIncrementing(value) {
-		this.incrementing = value;
-		return this;
-	}
-	toData() {
-		return (0, radashi.assign)(this.attributesToData(), this.relationsToData());
-	}
-	toJSON() {
-		return this.toData();
-	}
-	toJson(...args) {
-		return JSON.stringify(this.toData(), ...args);
-	}
-	toString() {
-		return this.toJson();
-	}
-	fill(attributes) {
-		for (const key in attributes) this.setAttribute(key, attributes[key]);
-		return this;
-	}
-	transacting(trx) {
-		this.trx = trx;
-		return this;
-	}
-	trashed() {
-		return this[this.getDeletedAtColumn()] !== null;
-	}
-	newPivot(parent, attributes, table, exists, using = null) {
-		return using ? using.fromRawAttributes(parent, attributes, table, exists) : Pivot.fromAttributes(parent, attributes, table, exists);
-	}
-	qualifyColumn(column) {
-		if (column.includes(".")) return column;
-		return `${this.getTable()}.${column}`;
-	}
-	getQualifiedKeyName() {
-		return this.qualifyColumn(this.getKeyName());
-	}
-	is(model) {
-		return model && model instanceof Model && this.getKey() === model.getKey() && this.getTable() === model.getTable();
-	}
-	isNot(model) {
-		return !this.is(model);
-	}
-};
-var Pivot = class extends Model {
-	incrementing = false;
-	guarded = [];
-	pivotParent = null;
-	foreignKey = null;
-	relatedKey = null;
-	setPivotKeys(foreignKey, relatedKey) {
-		this.foreignKey = foreignKey;
-		this.relatedKey = relatedKey;
-		return this;
-	}
-	static fromRawAttributes(parent, attributes, table, exists = false) {
-		const instance = this.fromAttributes(parent, {}, table, exists);
-		instance.timestamps = instance.hasTimestampAttributes(attributes);
-		instance.attributes = attributes;
-		instance.exists = exists;
-		return instance;
-	}
-	static fromAttributes(parent, attributes, table, exists = false) {
-		const instance = new this();
-		instance.timestamps = instance.hasTimestampAttributes(attributes);
-		instance.setConnection(parent.connection).setTable(table).fill(attributes).syncOriginal();
-		instance.pivotParent = parent;
-		instance.exists = exists;
-		return instance;
-	}
-	hasTimestampAttributes(attributes = null) {
-		return (attributes || this.attributes)[this.constructor.CREATED_AT] !== void 0;
-	}
-};
-var model_default = Model;
-
-//#endregion
-//#region src/browser/collection.ts
-var Collection = class Collection extends collect_js.Collection {
-	mapThen(callback) {
-		return Promise.all(this.map(callback));
-	}
-	modelKeys() {
-		return this.all().map((item) => item.getKey());
-	}
-	contains(key, operator, value) {
-		if (arguments.length > 1) return super.contains(key, value ?? operator);
-		if (key instanceof model_default) return super.contains((model) => {
-			return model.is(key);
-		});
-		return super.contains((model) => {
-			return model.getKey() == key;
-		});
-	}
-	diff(items) {
-		const diff = new this.constructor();
-		const dictionary = this.getDictionary(items);
-		this.items.map((item) => {
-			if (dictionary[item.getKey()] === void 0) diff.add(item);
-		});
-		return diff;
-	}
-	except(keys) {
-		const dictionary = (0, radashi.omit)(this.getDictionary(), keys);
-		return new this.constructor(Object.values(dictionary));
-	}
-	intersect(items) {
-		const intersect = new this.constructor();
-		if ((0, radashi.isEmpty)(items)) return intersect;
-		const dictionary = this.getDictionary(items);
-		for (const item of this.items) if (dictionary[item.getKey()] !== void 0) intersect.add(item);
-		return intersect;
-	}
-	unique(key, _strict = false) {
-		if (key) return super.unique(key);
-		return new this.constructor(Object.values(this.getDictionary()));
-	}
-	find(key, defaultValue = null) {
-		if (key instanceof model_default) key = key.getKey();
-		if ((0, radashi.isArray)(key)) {
-			if (this.isEmpty()) return new this.constructor();
-			return this.whereIn(this.first().getKeyName(), key);
-		}
-		(0, collect_js.collect)(this.items).first((model) => {
-			return model.getKey() == key;
-		});
-		return this.items.filter((model) => {
-			return model.getKey() == key;
-		})[0] || defaultValue;
-	}
-	makeVisible(attributes) {
-		return this.each((item) => {
-			item.makeVisible(attributes);
-		});
-	}
-	makeHidden(attributes) {
-		return this.each((item) => {
-			item.makeHidden(attributes);
-		});
-	}
-	append(attributes) {
-		return this.each((item) => {
-			item.append(attributes);
-		});
-	}
-	only(keys) {
-		if (keys === null) return new Collection(this.items);
-		const dictionary = (0, radashi.pick)(this.getDictionary(), keys);
-		return new this.constructor(Object.values(dictionary));
-	}
-	getDictionary(items) {
-		items = !items ? this.items : items;
-		const dictionary = {};
-		items.map((value) => {
-			dictionary[value.getKey()] = value;
-		});
-		return dictionary;
-	}
-	toData() {
-		return this.all().map((item) => typeof item.toData == "function" ? item.toData() : item);
-	}
-	toJSON() {
-		return this.toData();
-	}
-	toJson(...args) {
-		return JSON.stringify(this.toData(), ...args);
-	}
-	[Symbol.iterator] = () => {
-		const items = this.items;
-		const length = this.items.length;
-		let n = 0;
-		return { next() {
-			return n < length ? {
-				value: items[n++],
-				done: false
-			} : { done: true };
-		} };
-	};
-};
-var collection_default = Collection;
-
-//#endregion
-//#region src/concerns/has-unique-ids.ts
-const HasUniqueIds = (Model$1) => {
-	return class extends Model$1 {
-		useUniqueIds = true;
-		uniqueIds() {
-			return [this.getKeyName()];
-		}
-		getKeyType() {
-			if (this.uniqueIds().includes(this.getKeyName())) return "string";
-			return this.keyType;
-		}
-		getIncrementing() {
-			if (this.uniqueIds().includes(this.getKeyName())) return false;
-			return this.incrementing;
-		}
-	};
-};
-var has_unique_ids_default = HasUniqueIds;
-
-//#endregion
-//#region src/browser/paginator.ts
-var Paginator = class {
-	static formatter;
-	_items;
-	_total;
-	_perPage;
-	_lastPage;
-	_currentPage;
-	hasMore = false;
-	options = {};
-	constructor(items, total, perPage, currentPage = 1, options = {}) {
-		this.options = options;
-		for (const key in options) this[key] = options[key];
-		this._items = new collection_default([]);
-		this._total = total;
-		this._perPage = parseInt(String(perPage));
-		this._lastPage = Math.max(Math.ceil(total / perPage), 1);
-		this._currentPage = currentPage;
-		this.setItems(items);
-	}
-	static setFormatter(formatter) {
-		if (typeof formatter !== "function" && formatter !== null && formatter !== void 0) throw new Error("Paginator formatter must be a function or null");
-		this.formatter = formatter;
-	}
-	setItems(items) {
-		this._items = items instanceof collection_default ? items : new collection_default(items);
-		this.hasMore = this._items.count() > this._perPage;
-		this._items = this._items.slice(0, this._perPage);
-	}
-	firstItem() {
-		return this.count() > 0 ? (this._currentPage - 1) * this._perPage + 1 : null;
-	}
-	lastItem() {
-		return this.count() > 0 ? (this.firstItem() ?? 0) + this.count() - 1 : null;
-	}
-	hasMorePages() {
-		return this._currentPage < this._lastPage;
-	}
-	get(index) {
-		return this._items.get(index);
-	}
-	count() {
-		return this._items.count();
-	}
-	items() {
-		return this._items;
-	}
-	map(callback) {
-		return this._items.map(callback);
-	}
-	currentPage() {
-		return this._currentPage;
-	}
-	onFirstPage() {
-		return this._currentPage === 1;
-	}
-	perPage() {
-		return this._perPage;
-	}
-	lastPage() {
-		return this._lastPage;
-	}
-	total() {
-		return this._total;
-	}
-	toData() {
-		if (this.constructor.formatter && typeof this.constructor.formatter === "function") return this.constructor.formatter(this);
-		return {
-			current_page: this._currentPage,
-			data: this._items.toData(),
-			per_page: this._perPage,
-			total: this._total,
-			last_page: this._lastPage,
-			count: this.count()
-		};
-	}
-	toJSON() {
-		return this.toData();
-	}
-	toJson(...args) {
-		return JSON.stringify(this.toData(), ...args);
-	}
-};
-var paginator_default = Paginator;
-
-//#endregion
-//#region src/browser/pivot.ts
-var pivot_default = Pivot;
-
-//#endregion
-//#region src/browser/index.ts
-const make = (model, data, options = {}) => {
-	const { paginated } = options;
-	if (paginated) return new paginator_default(data.data.map((item) => model.make(item)), data.total, data.per_page, data.current_page);
-	if ((0, radashi.isArray)(data)) return new collection_default(data.map((item) => model.make(item)));
-	return model.make(data);
-};
-const makeCollection = (model, data) => new collection_default(data.map((item) => model.make(item)));
-const makePaginator = (model, data) => new paginator_default(data.data.map((item) => model.make(item)), data.total, data.per_page, data.current_page);
-const isBrowser = true;
-var browser_default = {
-	isBrowser,
-	Paginator: paginator_default,
-	Collection: collection_default,
-	Model: model_default,
-	Pivot: pivot_default,
-	Attribute: attribute_default,
-	CastsAttributes: casts_attributes_default,
-	HasUniqueIds: has_unique_ids_default,
-	make,
-	makeCollection,
-	makePaginator
-};
-
-//#endregion
-exports.Attribute = attribute_default;
-exports.CastsAttributes = casts_attributes_default;
-exports.Collection = collection_default;
-exports.HasUniqueIds = has_unique_ids_default;
-exports.InvalidArgumentError = InvalidArgumentError;
-exports.Model = model_default;
-exports.ModelNotFoundError = ModelNotFoundError;
-exports.Paginator = paginator_default;
-exports.Pivot = pivot_default;
-exports.RelationNotFoundError = RelationNotFoundError;
-exports.compose = compose;
-exports.default = browser_default;
-exports.defineConfig = defineConfig;
-exports.flatten = flatten;
-exports.flattenDeep = flattenDeep;
-exports.getAttrMethod = getAttrMethod;
-exports.getAttrName = getAttrName;
-exports.getGetterMethod = getGetterMethod;
-exports.getRelationMethod = getRelationMethod;
-exports.getRelationName = getRelationName;
-exports.getScopeMethod = getScopeMethod;
-exports.getScopeName = getScopeName;
-exports.getSetterMethod = getSetterMethod;
-exports.isBrowser = isBrowser;
-exports.kebabCase = kebabCase;
-exports.make = make;
-exports.makeCollection = makeCollection;
-exports.now = now;
-exports.snakeCase = snakeCase;
-exports.tap = tap;