@ragestudio/scylla-odm 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,113 @@
+import * as _$cassandra_driver0 from "cassandra-driver";
+import { Client, mapping } from "cassandra-driver";
+import { mapping as mapping$1 } from "cassandra-driver/lib/mapping/index.js";
+
+//#region src/schema/index.d.ts
+declare class Schema<T> {
+  readonly table_name: string;
+  readonly clustering_order: any;
+  readonly keys: TableKeys;
+  readonly fields: T;
+  constructor(params: any, fields: T);
+}
+//#endregion
+//#region src/operations/tableExists.d.ts
+declare function export_default(this: Model): Promise<boolean>;
+//#endregion
+//#region src/operations/sync.d.ts
+declare function syncOP(this: Model): Promise<void>;
+//#endregion
+//#region src/model/index.d.ts
+declare class Model<TDoc = any> {
+  name: string;
+  schema: Schema<any>;
+  driver: ScyllaClient;
+  mapper: mapping$1.ModelMapper;
+  constructor(name: string, schema: Schema<any>);
+  create: (data: Partial<TDoc>) => DocumentResult<TDoc>;
+  find: {
+    (query: Query<TDoc>, options: QueryOptions & {
+      raw: true;
+    }): Promise<TDoc[]>;
+    (query?: Query<TDoc>, options?: QueryOptions): Promise<DocumentResult<TDoc>[]>;
+  };
+  findOne: {
+    (query: Query<TDoc>, options: QueryOptions & {
+      raw: true;
+    }): Promise<TDoc>;
+    (query?: Query<TDoc>, options?: QueryOptions): Promise<DocumentResult<TDoc>>;
+  };
+  update: (query: Query<TDoc>) => Promise<DocumentResult<TDoc>>;
+  delete: (query: Query<TDoc>) => Promise<mapping$1.Result>;
+  countAll: () => Promise<number>;
+  _sync: typeof syncOP;
+  _tableExists: typeof export_default;
+  _wrap(row: any): DocumentResult<TDoc> | null;
+  _connect(driver: ScyllaClient): void;
+}
+//#endregion
+//#region src/result/index.d.ts
+declare class Result<TDoc = any> {
+  constructor(data: TDoc, model: Model<TDoc>);
+  _model: Model<TDoc>;
+  save(): Promise<DocumentResult<TDoc>>;
+  delete(): Promise<_$cassandra_driver0.mapping.Result<any>>;
+  toRaw(): TDoc;
+  isValid(): boolean;
+  getChangedFields(original: Partial<TDoc>): (keyof TDoc)[];
+}
+//#endregion
+//#region src/types.d.ts
+type ClientConfig = {
+  modelsPath?: string;
+  contactPoints?: string[];
+  localDataCenter?: string;
+  keyspace?: string;
+  port?: number;
+  maxRetries?: number;
+  retryDelay?: number;
+  pooling?: {
+    coreConnectionsPerHost?: Record<string, number>;
+    maxRequestsPerConnection?: number;
+  };
+};
+type QueryOperators<TValue> = {
+  $eq?: TValue;
+  $ne?: TValue;
+  $in?: TValue[];
+  $gt?: TValue;
+  $gte?: TValue;
+  $lt?: TValue;
+  $lte?: TValue;
+};
+type TableKeys = (string | TableKeys)[];
+type DocumentResult<TDoc> = Result<TDoc> & TDoc;
+type QueryOptions = {
+  raw?: boolean;
+};
+type OrderBy<TDoc> = { [K in keyof TDoc]?: "asc" | "desc" };
+type Query<TDoc> = { [K in keyof TDoc]?: TDoc[K] | QueryOperators<TDoc[K]> } & {
+  $and?: Query<TDoc>[];
+  $limit?: number;
+  $orderby?: OrderBy<TDoc>;
+};
+//#endregion
+//#region src/index.d.ts
+declare class ScyllaClient {
+  constructor(config?: ClientConfig);
+  config: ClientConfig;
+  client: Client;
+  mapper: mapping.Mapper;
+  models: Map<string, Model<any>>;
+  initialize(options?: {
+    sync?: boolean;
+  }): Promise<void>;
+  private connectWithRetry;
+  private delay;
+  shutdown(): Promise<void>;
+  executeWithRetry<T>(operation: () => Promise<T>, operationName?: string): Promise<T>;
+  private isRetryableError;
+}
+//#endregion
+export { ScyllaClient as default };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,519 @@
+import path from "node:path";
+import Cassandra from "cassandra-driver";
+import fs from "node:fs";
+//#region src/utils/loadSchemas.ts
+var loadSchemas_default = async (fromPath) => {
+	if (typeof fromPath !== "string") return [];
+	if (!fs.existsSync(fromPath)) {
+		console.warn(`Cannot load models from [${fromPath}] case this path does not exist`);
+		return [];
+	}
+	let schemas = [];
+	let files = await fs.promises.readdir(fromPath);
+	files = files.filter((file) => file.endsWith(".js") || file.endsWith(".ts"));
+	for await (const file of files) {
+		const name = file.replace(".js", "");
+		const file_path = path.join(fromPath, file);
+		try {
+			let mod = await import(file_path);
+			mod = mod.default;
+			schemas.push(mod);
+		} catch (error) {
+			console.error(`Failed to load schema [${name}]:`, error);
+			continue;
+		}
+	}
+	return schemas;
+};
+//#endregion
+//#region src/utils/buildMapper.ts
+var buildMapper_default = (map) => {
+	return map.reduce((obj, { name, schema }) => {
+		return {
+			...obj,
+			[name]: { tables: [schema.table_name] }
+		};
+	}, {});
+};
+//#endregion
+//#region src/utils/queryParser.ts
+const { q } = Cassandra.mapping;
+const MAX_QUERY_DEPTH = 3;
+const MAX_IN_ELEMENTS = 1e3;
+const VALID_OPERATORS = new Set([
+	"$eq",
+	"$ne",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte",
+	"$in"
+]);
+function requireNotNull(value, operator) {
+	if (value === null || value === void 0) throw new Error(`${operator} operator cannot compare with null or undefined`);
+}
+function buildOperator(operator, opValue) {
+	if (!VALID_OPERATORS.has(operator)) throw new Error(`Invalid operator: ${operator}`);
+	switch (operator) {
+		case "$eq": return opValue;
+		case "$ne":
+			requireNotNull(opValue, "$ne");
+			return q.notEq(opValue);
+		case "$in":
+			if (!Array.isArray(opValue)) throw new Error("$in operator requires an array");
+			if (opValue.length > MAX_IN_ELEMENTS) throw new Error(`$in operator exceeds maximum of ${MAX_IN_ELEMENTS} elements`);
+			for (let i = 0; i < opValue.length; i++) if (opValue[i] === null || opValue[i] === void 0) throw new Error(`$in array element at index ${i} cannot be null or undefined`);
+			return q.in_(opValue);
+		case "$gt":
+			requireNotNull(opValue, "$gt");
+			return q.gt(opValue);
+		case "$gte":
+			requireNotNull(opValue, "$gte");
+			return q.gte(opValue);
+		case "$lt":
+			requireNotNull(opValue, "$lt");
+			return q.lt(opValue);
+		case "$lte":
+			requireNotNull(opValue, "$lte");
+			return q.lte(opValue);
+	}
+}
+function queryParser(model, query, depth = 0) {
+	if (depth > MAX_QUERY_DEPTH) throw new Error(`Query depth exceeds maximum of ${MAX_QUERY_DEPTH}`);
+	if (!query || typeof query !== "object") return query;
+	const parsedQuery = {};
+	const fields = model.schema.fields;
+	for (const field of Object.keys(query)) {
+		const value = query[field];
+		if (field === "$and") {
+			handleAnd(model, value, parsedQuery, depth);
+			continue;
+		}
+		if (field === "$or") throw new Error("ScyllaDB does not support OR queries across different columns. Use $in for a single column.");
+		if (!isValidFieldName(fields, field)) throw new Error(`Invalid field name: [${field}] or it does not exist in schema`);
+		parsedQuery[field] = parseField(value);
+	}
+	return parsedQuery;
+}
+function handleAnd(model, conditions, parsedQuery, depth) {
+	if (!Array.isArray(conditions)) throw new Error("$and operator requires an array");
+	if (conditions.length > 10) throw new Error("$and operator exceeds maximum of 10 conditions");
+	for (let i = 0; i < conditions.length; i++) {
+		const condition = conditions[i];
+		if (!condition || typeof condition !== "object") throw new Error(`$and condition at index ${i} must be an object`);
+		const parsed = queryParser(model, condition, depth + 1);
+		for (const key of Object.keys(parsed)) if (key in parsedQuery) throw new Error(`$and conflict: field "${key}" appears in multiple conditions`);
+		Object.assign(parsedQuery, parsed);
+	}
+}
+function parseField(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Date) {
+		if (Array.isArray(value)) throw new Error("Array values require explicit operator (e.g., $in)");
+		return value;
+	}
+	const compiledOps = Object.keys(value).map((op) => buildOperator(op, value[op]));
+	return compiledOps.length === 1 ? compiledOps[0] : q.and(...compiledOps);
+}
+function isValidFieldName(fields, fieldName) {
+	for (const pattern of [
+		/^[0-9]/,
+		/[^a-zA-Z0-9_]/,
+		/^(select|insert|update|delete|drop|create|alter|truncate)$/i
+	]) if (pattern.test(fieldName)) return false;
+	return fieldName in fields;
+}
+//#endregion
+//#region src/utils/typeChecker.ts
+const { types } = Cassandra;
+const stringTypes = new Set([
+	"ascii",
+	"text",
+	"varchar",
+	"inet"
+]);
+const intTypes = new Set([
+	"int",
+	"smallint",
+	"tinyint"
+]);
+const floatTypes = new Set(["double", "float"]);
+const longTypes = new Set(["bigint", "counter"]);
+function isValidValue(value, expectedType) {
+	if (value === null || value === void 0) return true;
+	if (stringTypes.has(expectedType)) return typeof value === "string";
+	if (intTypes.has(expectedType)) return Number.isInteger(value);
+	if (floatTypes.has(expectedType)) return typeof value === "number";
+	if (longTypes.has(expectedType)) return typeof value === "bigint" || typeof value === "number" || value instanceof types.Long;
+	switch (expectedType) {
+		case "boolean": return typeof value === "boolean";
+		case "decimal": return typeof value === "number" || typeof value === "string" || value instanceof types.BigDecimal;
+		case "varint": return typeof value === "bigint" || typeof value === "number" || value instanceof types.Integer;
+		case "timestamp": return value instanceof Date || typeof value === "number" || typeof value === "string";
+		case "date": return typeof value === "string" || value instanceof types.LocalDate;
+		case "time": return typeof value === "string" || value instanceof types.LocalTime;
+		case "uuid": return typeof value === "string" || value instanceof types.Uuid;
+		case "timeuuid": return typeof value === "string" || value instanceof types.TimeUuid;
+		case "blob": return Buffer.isBuffer(value) || value instanceof Uint8Array;
+	}
+	if (expectedType.startsWith("list<") || expectedType.startsWith("set<")) return Array.isArray(value) || value instanceof Set;
+	if (expectedType.startsWith("map<")) return typeof value === "object" && !Array.isArray(value) && value !== null;
+	return false;
+}
+function typeChecker(model, data) {
+	if (!data || typeof data !== "object" || Array.isArray(data)) throw new TypeError(`[${model.name}] Validation error: Data payload must be an object`);
+	const fields = model.schema.fields;
+	for (const [key, value] of Object.entries(data)) {
+		if (!isValidFieldName(fields, key)) throw new Error(`[${model.name}] Validation error: Field '${key}' does not exist in schema`);
+		const expectedType = (fields[key].type || "text").toLowerCase();
+		if (!isValidValue(value, expectedType)) {
+			const receivedType = Array.isArray(value) ? "array" : typeof value;
+			throw new TypeError(`[${model.name}] Validation error: Invalid type for field '${key}'. Expected[${expectedType}], but received [${receivedType}]`);
+		}
+	}
+	return true;
+}
+//#endregion
+//#region src/result/index.ts
+var Result = class {
+	constructor(data, model) {
+		if (data == null) throw new Error("Cannot create Result with null or undefined data");
+		if (typeof data !== "object" || Array.isArray(data)) throw new Error("Result data must be an object");
+		Object.assign(this, data);
+		Object.defineProperty(this, "_model", {
+			value: model,
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+	}
+	_model;
+	async save() {
+		try {
+			const data = this.toRaw();
+			typeChecker(this._model, data);
+			return await this._model.update(data);
+		} catch (error) {
+			throw new Error(`Failed to save result: ${error.message}`);
+		}
+	}
+	async delete() {
+		try {
+			return await this._model.delete(this.toRaw());
+		} catch (error) {
+			throw new Error(`Failed to delete result: ${error.message}`);
+		}
+	}
+	toRaw() {
+		const raw = {};
+		for (const key in this) {
+			if (key === "_model") continue;
+			if (this.propertyIsEnumerable(key)) {
+				const value = this[key];
+				try {
+					JSON.stringify(value);
+					raw[key] = value;
+				} catch (error) {
+					raw[key] = String(value);
+				}
+			}
+		}
+		return raw;
+	}
+	isValid() {
+		try {
+			typeChecker(this._model, this.toRaw());
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	getChangedFields(original) {
+		const current = this.toRaw();
+		const changed = [];
+		for (const key in current) if (!(key in original) || current[key] !== original[key]) changed.push(key);
+		return changed;
+	}
+};
+//#endregion
+//#region src/utils/fillDefaults.ts
+function fillDefaults(schema, data) {
+	const defaults = schema.options?.defaults;
+	if (!defaults || Object.keys(defaults).length === 0) return data;
+	let needsDefaults = false;
+	for (const key in defaults) if (data[key] == null) {
+		needsDefaults = true;
+		break;
+	}
+	if (!needsDefaults) return data;
+	const result = Object.assign({}, data);
+	for (const key in defaults) if (result[key] == null) result[key] = defaults[key];
+	return result;
+}
+//#endregion
+//#region src/operations/findOne.ts
+function findOne_default(query, options) {
+	query = queryParser(this, query);
+	const operation = async () => {
+		let result = await this.mapper.get(query);
+		if (!result) return null;
+		result = this._wrap(result);
+		if (options?.raw === true) return result.toRaw();
+		return result;
+	};
+	return this.driver.executeWithRetry(operation, `findOne on ${this.name}`);
+}
+//#endregion
+//#region src/operations/find.ts
+async function findOP(query = {}, options) {
+	const { $limit, $orderby, ...rest } = query;
+	let parsedQuery = queryParser(this, rest);
+	const docInfo = {};
+	if ($limit !== void 0) {
+		if (typeof $limit !== "number" || $limit <= 0) throw new TypeError(`{$limit} operator must be a number greater than 0`);
+		docInfo.limit = $limit;
+	}
+	if ($orderby !== void 0) docInfo.orderBy = $orderby;
+	const operation = async () => {
+		const rows = (await this.mapper.find(parsedQuery, docInfo)).toArray();
+		if (options?.raw === true) return rows;
+		return rows.map((row) => this._wrap(row));
+	};
+	return this.driver.executeWithRetry(operation, `find on ${this.name}`);
+}
+//#endregion
+//#region src/operations/update.ts
+async function update_default(query) {
+	query = fillDefaults(this.schema, query);
+	typeChecker(this, query);
+	if (typeof query.__v !== "undefined") if (Number.isNaN(query.__v)) query.__v = 0;
+	else query.__v = query.__v + 1;
+	const operation = async () => {
+		await this.mapper.update(query);
+		return this._wrap(query);
+	};
+	return this.driver.executeWithRetry(operation, `update on ${this.name}`);
+}
+//#endregion
+//#region src/operations/delete.ts
+async function delete_default(query) {
+	const operation = async () => {
+		return await this.mapper.remove(query);
+	};
+	return this.driver.executeWithRetry(operation, `delete on ${this.name}`);
+}
+//#endregion
+//#region src/operations/countAll.ts
+async function countAll_default(timeoutMs = 6e4) {
+	const cql = `SELECT COUNT(1) FROM ${this.driver.config.keyspace}.${this.schema.table_name}`;
+	const queryOptions = {
+		prepare: true,
+		readTimeout: timeoutMs
+	};
+	const operation = async () => {
+		return (await this.driver.client.execute(cql, [], queryOptions)).rows[0].count.toNumber();
+	};
+	return this.driver.executeWithRetry(operation, `countAll on ${this.name}`);
+}
+//#endregion
+//#region src/operations/tableExists.ts
+async function tableExists_default() {
+	const cql = `
+			SELECT table_name
+			FROM system_schema.tables
+			WHERE keyspace_name = ?
+			AND table_name = ?
+		`;
+	try {
+		return (await this.driver.client.execute(cql, [this.driver.config.keyspace, this.schema.table_name], { prepare: true })).rows.length > 0;
+	} catch (error) {
+		console.error(`Failed to check if table "${this.schema.table_name}" exists:`, error);
+		return false;
+	}
+}
+//#endregion
+//#region src/cql_gen/create_table.ts
+function create_table_default(model) {
+	const desc = model.schema;
+	const tableName = desc.table_name;
+	const keyspace = model.driver.config.keyspace;
+	const fields = desc.fields;
+	const key = desc.keys;
+	const clusteringOrder = desc.clustering_order;
+	let columnsDef = "";
+	for (const fieldName in fields) {
+		const field = fields[fieldName];
+		const typeStr = typeof field === "string" ? field : field?.type;
+		if (!typeStr) throw new Error(`Invalid field type for "${fieldName}" in model "${tableName}"`);
+		columnsDef += `"${fieldName}" ${typeStr.toUpperCase()}, `;
+	}
+	let pkDef = "";
+	if (typeof key === "string") pkDef = `"${key}"`;
+	else if (Array.isArray(key) && key.length > 0) {
+		const first = key[0];
+		if (Array.isArray(first)) pkDef = `(${first.map((k) => `"${k}"`).join(", ")})`;
+		else pkDef = `"${first}"`;
+		for (let i = 1; i < key.length; i++) pkDef += `, "${key[i]}"`;
+	} else throw new Error(`Missing or invalid primary key in model "${tableName}"`);
+	let clusterClause = "";
+	if (clusteringOrder) {
+		let orderDef = "";
+		for (const col in clusteringOrder) {
+			if (orderDef !== "") orderDef += ", ";
+			orderDef += `"${col}" ${clusteringOrder[col].toUpperCase()}`;
+		}
+		if (orderDef !== "") clusterClause = ` WITH CLUSTERING ORDER BY (${orderDef})`;
+	}
+	return `CREATE TABLE IF NOT EXISTS ${keyspace}.${tableName} (${columnsDef}PRIMARY KEY (${pkDef}))${clusterClause}`;
+}
+//#endregion
+//#region src/operations/sync.ts
+async function syncOP() {
+	if (await this._tableExists()) return;
+	try {
+		await this.driver.client.execute(create_table_default(this));
+		console.log(`Table "${this.schema.table_name}" created successfully`);
+	} catch (error) {
+		console.error(`Failed to create table "${this.schema.table_name}":`, error);
+		throw error;
+	}
+}
+//#endregion
+//#region src/model/index.ts
+var Model = class {
+	name;
+	schema;
+	driver;
+	mapper;
+	constructor(name, schema) {
+		this.name = name;
+		this.schema = schema;
+		if (!Array.isArray(this.schema.keys)) throw new Error(`[${this.name}] model has missing "keys" array`);
+		if (!this.schema.table_name) throw new Error(`[${this.name}] model has missing "table_name"`);
+		if (!this.schema.fields || typeof this.schema.fields !== "object") throw new Error(`[${this.name}] model has missing or invalid "fields"`);
+	}
+	create = (data) => this._wrap(data);
+	find = findOP.bind(this);
+	findOne = findOne_default.bind(this);
+	update = update_default.bind(this);
+	delete = delete_default.bind(this);
+	countAll = countAll_default.bind(this);
+	_sync = syncOP.bind(this);
+	_tableExists = tableExists_default.bind(this);
+	_wrap(row) {
+		if (!row) return null;
+		row = fillDefaults(this.schema, row);
+		return new Result(row, this);
+	}
+	_connect(driver) {
+		this.driver = driver;
+		this.mapper = driver.mapper.forModel(this.name);
+	}
+};
+//#endregion
+//#region src/index.ts
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY = 1e3;
+const { SCYLLA_CONTACT_POINTS, SCYLLA_LOCAL_DATA_CENTER, SCYLLA_KEYSPACE } = process.env;
+var ScyllaClient = class {
+	constructor(config = {}) {
+		this.config = {
+			modelsPath: path.resolve(__dirname, "../../db"),
+			contactPoints: config.contactPoints ?? SCYLLA_CONTACT_POINTS ? SCYLLA_CONTACT_POINTS.split(",") : ["127.0.0.1"],
+			localDataCenter: config.localDataCenter ?? SCYLLA_LOCAL_DATA_CENTER ?? "datacenter1",
+			keyspace: config.keyspace ?? SCYLLA_KEYSPACE ?? "default",
+			port: 9042,
+			maxRetries: DEFAULT_MAX_RETRIES,
+			retryDelay: DEFAULT_RETRY_DELAY,
+			...config
+		};
+		const clientOptions = {
+			contactPoints: this.config.contactPoints,
+			localDataCenter: this.config.localDataCenter,
+			keyspace: this.config.keyspace,
+			protocolOptions: { port: this.config.port }
+		};
+		if (this.config.pooling) clientOptions.pooling = this.config.pooling;
+		this.client = new Cassandra.Client(clientOptions);
+	}
+	config;
+	client;
+	mapper;
+	models = /* @__PURE__ */ new Map();
+	async initialize(options = {}) {
+		let models;
+		try {
+			models = await loadSchemas_default(this.config.modelsPath);
+		} catch (error) {
+			throw new Error(`Failed to load models: ${error.message}`);
+		}
+		models = models.filter((schema) => schema instanceof Model);
+		this.mapper = new Cassandra.mapping.Mapper(this.client, { models: buildMapper_default(models) });
+		for (let model of models) {
+			model._connect(this);
+			this.models.set(model.name, model);
+			if (options?.sync === true) await model._sync();
+		}
+		console.log("Connecting to ScyllaDB");
+		await this.connectWithRetry();
+		console.log("ScyllaDB Connected");
+	}
+	async connectWithRetry() {
+		let lastError = null;
+		for (let attempt = 1; attempt <= this.config.maxRetries; attempt++) try {
+			await this.client.connect();
+			return;
+		} catch (error) {
+			lastError = error;
+			console.warn(`Connection attempt ${attempt} failed: ${error.message}`);
+			if (attempt < this.config.maxRetries) {
+				console.log(`Retrying in ${this.config.retryDelay}ms...`);
+				await this.delay(this.config.retryDelay);
+			}
+		}
+		throw new Error(`Failed to connect to ScyllaDB after ${this.config.maxRetries} attempts: ${lastError?.message}`);
+	}
+	delay(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	async shutdown() {
+		try {
+			await this.client.shutdown();
+			console.log("ScyllaDB connection closed");
+		} catch (error) {
+			console.error("Error shutting down ScyllaDB connection:", error);
+			throw error;
+		}
+	}
+	async executeWithRetry(operation, operationName = "operation") {
+		let lastError = null;
+		for (let attempt = 1; attempt <= this.config.maxRetries; attempt++) try {
+			return await operation();
+		} catch (error) {
+			lastError = error;
+			if (this.isRetryableError(error) && attempt < this.config.maxRetries) {
+				console.warn(`Operation ${operationName} attempt ${attempt} failed: ${error.message}`);
+				console.log(`Retrying in ${this.config.retryDelay}ms...`);
+				await this.delay(this.config.retryDelay);
+				continue;
+			}
+			throw error;
+		}
+		throw new Error(`Operation ${operationName} failed after ${this.config.maxRetries} attempts: ${lastError?.message}`);
+	}
+	isRetryableError(error) {
+		const retryableMessages = [
+			"timeout",
+			"connection",
+			"network",
+			"unavailable",
+			"overloaded",
+			"no hosts available"
+		];
+		const errorMessage = error.message?.toLowerCase() || "";
+		return retryableMessages.some((msg) => errorMessage.includes(msg));
+	}
+};
+//#endregion
+export { ScyllaClient as default };
+
+//# sourceMappingURL=index.mjs.map