imodel 0.17.0 → 0.17.2

package/index.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.17.0
+ * imodel v0.17.2
  * (c) 2019-2026 undefined
  * @license undefined
  */
@@ -467,6 +467,21 @@ declare function updating(size?: number): FieldDecorator<Date | null>;
  */
 declare function deleting(size?: number): FieldDecorator<Date | null>;
 
+/**
+ * @overload
+ * @param {Hooks} hook
+ * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
+ * @returns {ClassDecorator}
+ */
+declare function hooks(hook: Hooks, approach?: boolean | undefined): ClassDecorator;
+/**
+ * @overload
+ * @param {Function} Model
+ * @param {Hooks} hook
+ * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
+ * @returns {void}
+ */
+declare function hooks(Model: Function, hook: Hooks, approach?: boolean | undefined): void;
 /** @type {Hook<Hooks['where']>} */
 declare const where: Hook<Hooks["where"]>;
 /** @type {Hook<Hooks['beforeCreateMany']>} */
@@ -1206,15 +1221,15 @@ interface Index extends IndexInfo {
     name: string;
 }
 interface Hooks<T extends Record<string, any> = Record<string, any>> {
-    where(conn: Connection, model: TableDefine): PromiseLike<void | Where> | void;
-    beforeCreateMany(conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void | Record<string, any>[]> | void | Record<string, any>[];
-    afterCreateMany(conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void> | void;
-    beforeCreate(conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
-    afterCreate(conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void> | void;
-    beforeUpdate(conn: Connection, model: TableDefine, record: Record<string, any>, set: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
-    afterUpdate(conn: Connection, model: TableDefine, record: Record<string, any>, oldRecord: Record<string, any>): PromiseLike<void> | void;
-    beforeDelete(conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
-    afterDelete(conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+    where(this: unknown, conn: Connection, model: TableDefine): PromiseLike<void | Where> | void;
+    beforeCreateMany(this: unknown, conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void | Record<string, any>[]> | void | Record<string, any>[];
+    afterCreateMany(this: unknown, conn: Connection, model: TableDefine, records: Record<string, any>[]): PromiseLike<void> | void;
+    beforeCreate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterCreate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>): PromiseLike<void> | void;
+    beforeUpdate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>, set: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterUpdate(this: unknown, conn: Connection, model: TableDefine, record: Record<string, any>, oldRecord: Record<string, any>): PromiseLike<void> | void;
+    beforeDelete(this: unknown, conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+    afterDelete(this: unknown, conn: Connection, model: TableDefine, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
 }
 interface TableDefine<T extends Fields = Fields, TT extends string | VirtualTable | undefined = string | VirtualTable | undefined> {
     readonly connect?: TableConnect<any> | null;
@@ -1257,6 +1272,7 @@ interface Join<T extends TableDefine = TableDefine> {
     };
 }
 interface Options {
+    distinct?: boolean;
     range?: FindRange;
     select?: Record<string, Select> | null;
     /** 排序配置，true 表示逆序 */
@@ -1465,25 +1481,25 @@ declare class Connection<E extends {} = {}> {
      * @overload
      * @param {T} model
      * @param {object[]} list
-     * @returns {Promise<object[]>}
+     * @returns {Promise<TableValue<T>[]>}
      */
-    create<T extends TableDefine>(model: T, list: object[]): Promise<object[]>;
+    create<T extends TableDefine>(model: T, list: object[]): Promise<TableValue<T>[]>;
     /**
      * @template {TableDefine} T
      * @overload
      * @param {T} model
      * @param {object} value
-     * @returns {Promise<T extends Build<infer R> ? R : object>}
+     * @returns {Promise<T extends Build<infer R> ? R : TableValue<T>>}
      */
-    create<T extends TableDefine>(model: T, value: object): Promise<T extends Build<infer R> ? R : object>;
+    create<T extends TableDefine>(model: T, value: object): Promise<T extends Build<infer R> ? R : TableValue<T>>;
     /**
      * @template {TableDefine} T
      * @overload
      * @param {T} model
      * @param {object | object[]} value
-     * @returns {Promise<object[] | (T extends Build<infer R> ? R : object)>}
+     * @returns {Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>}
      */
-    create<T extends TableDefine>(model: T, value: object | object[]): Promise<object[] | (T extends Build<infer R> ? R : object)>;
+    create<T extends TableDefine>(model: T, value: object | object[]): Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>;
     /**
      *
      * @template {TableDefine} T
@@ -2111,6 +2127,11 @@ declare class Query<T extends Fields, TB extends unknown = any> extends Subquery
      * @param  {...string | string[]} groups
      */
     groupBy(...groups: (string | string[])[]): this;
+    /**
+     *
+     * @param  {boolean} [distinct]
+     */
+    distinct(distinct?: boolean): this;
     /**
      *
      * @param {object} a
@@ -2138,6 +2159,20 @@ declare function toPrimary(fields: string[], data: Record<string, any>): string;
  */
 declare function toPrimaries(model: any, documents: any): string | string[];
 
+/**
+ *
+ * @param  {...Readonly<Partial<Hooks>> | Readonly<Partial<Hooks>>[]} hooks
+ * @returns {Readonly<Partial<Hooks>>}
+ */
+declare function mergeHooks(...hooks: (Readonly<Partial<Hooks>> | Readonly<Partial<Hooks>>[])[]): Readonly<Partial<Hooks>>;
+/**
+ *
+ * @param  {Readonly<Partial<Hooks>>} hooks
+ * @param  {any} that
+ * @returns {Readonly<Partial<Hooks>>}
+ */
+declare function bindHooks(hooks: Readonly<Partial<Hooks>>, that: any): Readonly<Partial<Hooks>>;
+
 /**
  * @typedef {object} Scene.Define
  * @property {string} table
@@ -2536,4 +2571,4 @@ declare function field<T extends MainFieldType>(type: T, options: {
 declare function setDevelopment(d?: boolean): void;
 declare let isDevelopment: boolean;
 
-export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type Hook, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, type JOIN, type Join, type JoinType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, type SelectItem, SetValue, type Skip, Submodel, type Support, type TableConnect, type TableConnection, type TableDefine, type TableType, type TableValue, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };
+export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type Hook, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, type JOIN, type Join, type JoinType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, type SelectItem, SetValue, type Skip, Submodel, type Support, type TableConnect, type TableConnection, type TableDefine, type TableType, type TableValue, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, bindHooks, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, hooks, immutable, increment, index, isDevelopment, isPseudo, mergeHooks, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.17.0
+ * imodel v0.17.2
  * (c) 2019-2026 undefined
  * @license undefined
  */
@@ -2136,12 +2136,12 @@ function getSelectFields(select, columns, tableFields, baseFieldSet) {
  * @param {TableConnection} conn
  * @param {any[]} list
  * @param {[string, FieldDefine<TableDefine>][]} fields
- * @param {Set<string>} baseFieldSet
+ * @param {Set<string>} baseParentFieldSet
  * @param {Environment} env
  * @param {Record<string, string[] | undefined>?} [returnFields]
  * @returns {Promise<any[]>}
  */
-async function findSub(conn, list, fields, baseFieldSet, env, returnFields) {
+async function findSub(conn, list, fields, baseParentFieldSet, env, returnFields) {
   if (!list.length) {
     return list;
   }
@@ -2163,7 +2163,7 @@ async function findSub(conn, list, fields, baseFieldSet, env, returnFields) {
     if (returnFields && !fieldMap) {
       continue;
     }
-    const mapList = getMapList(fields, baseFieldSet, constraints);
+    const mapList = getMapList(fields, baseParentFieldSet, constraints);
     if (!mapList) {
       continue;
     }
@@ -2172,6 +2172,7 @@ async function findSub(conn, list, fields, baseFieldSet, env, returnFields) {
     const [columns, fieldColumns, tableFields] = toColumns(fields);
     const noColumn = noField && fieldColumns ? fieldColumns[noField] : noField;
     const where = [subList2where(list, mapList, fieldColumns), ...getValueWhere(constraints, columns, fieldColumns)];
+    const baseFieldSet = new Set(Object.keys(fieldColumns || columns));
     const selected = fieldMap && getSelectFields(fieldMap[''] || [], columns, tableFields, baseFieldSet) || null;
     const select = select2column(columns, fieldColumns, selected && [...selected, ...mapList.map(v => v[0])]);
     /** @type {SelectItem[]} */
@@ -2186,7 +2187,7 @@ async function findSub(conn, list, fields, baseFieldSet, env, returnFields) {
     }];
     /** @type {PromiseLike<object[]>} */
     const result = table && typeof table === 'object' ? table.select(env, conn, selects) : conn.select(env, selects);
-    let promise = result.then(list => findSub(conn, list, tableFields, new Set(Object.keys(fieldColumns || columns)), env, fieldMap));
+    let promise = result.then(list => findSub(conn, list, tableFields, baseFieldSet, env, fieldMap));
     promises.push(array ? promise.then(subList => {
       for (const item of list) {
         item[key] = subList.filter(createFilter(item, mapList));
@@ -2498,6 +2499,7 @@ function toSelect(queryable) {
     select,
     sort: sort?.length ? sort2column(sort, fieldColumns) : getDefaultSort(columns),
     group: options.group || [],
+    distinct: Boolean(options.distinct),
     having: []
   }];
   return result;
@@ -2651,28 +2653,28 @@ class Connection {
    * @overload
    * @param {T} model
    * @param {object[]} list
-   * @returns {Promise<object[]>}
+   * @returns {Promise<TableValue<T>[]>}
    */
   /**
    * @template {TableDefine} T
    * @overload
    * @param {T} model
    * @param {object} value
-   * @returns {Promise<T extends Build<infer R> ? R : object>}
+   * @returns {Promise<T extends Build<infer R> ? R : TableValue<T>>}
    */
   /**
    * @template {TableDefine} T
    * @overload
    * @param {T} model
    * @param {object | object[]} value
-   * @returns {Promise<object[] | (T extends Build<infer R> ? R : object)>}
+   * @returns {Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>}
    */
   /**
    * @template {TableDefine} T
    * @param {T} model
    * @param {object | object[]} p
    * @param {Skip} [skip]
-   * @returns {Promise<object[] | (T extends Build<infer R> ? R : object)>}
+   * @returns {Promise<TableValue<T>[] | (T extends Build<infer R> ? R : TableValue<T>)>}
    */
   async create(model, p, skip) {
     const {
@@ -2731,6 +2733,7 @@ class Connection {
       }
       return r;
     }, model);
+    // @ts-ignore
     return isArray ? [result] : result;
   }
   /**
@@ -3956,6 +3959,76 @@ function buildHooks(Model) {
     }
   };
 }
+/** @type {[keyof Hooks, boolean][]} */
+const isBeforeList = [['where', true], ['beforeCreateMany', true], ['afterCreateMany', false], ['beforeCreate', true], ['afterCreate', false], ['beforeUpdate', true], ['afterUpdate', false], ['beforeDelete', true], ['afterDelete', false]];
+/**
+ * @overload
+ * @param {Hooks} hook
+ * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
+ * @returns {ClassDecorator}
+ */
+/**
+ * @overload
+ * @param {Function} Model
+ * @param {Hooks} hook
+ * @param  {boolean} [approach] 插入位置是否为更靠近执行的位置
+ * @returns {void}
+ */
+/**
+ * @param {*[]} p
+ * @returns {MethodDecorator<Hooks> | ClassDecorator | void}
+ */
+function hooks(...p) {
+  let first = p.shift();
+  /** @type {Function?} */
+  const Model = typeof first === 'function' ? first : null;
+  if (Model) {
+    first = p.shift();
+  }
+  /** @type {Partial<Hooks>} */
+  const hookFns = first;
+  const approach = p.shift();
+  if (approach && typeof approach !== 'boolean') {
+    const call = Model ? `hooks(Model, hooks, approach?)` : `@hooks(hooks, approach?)`;
+    throw new Error(`${call} 的 approach 参数只能是布尔型`);
+  }
+  function add(metadata) {
+    for (const [key, isBefore] of isBeforeList) {
+      const hook = hookFns[key];
+      if (typeof hook !== 'function') {
+        continue;
+      }
+      const insert = isBefore ? !approach : Boolean(approach);
+      const metaKey = insert ? insertHookMetaKey : appendHookMetaKey;
+      /** @type {Record<string, HookItem[]>} */
+      const hooks = metadata[metaKey] ||= {};
+      const list = hooks[key];
+      const item = {
+        static: true,
+        hook
+      };
+      if (Array.isArray(list)) {
+        if (insert) {
+          list.unshift(item);
+        } else {
+          list.push(item);
+        }
+      } else {
+        hooks[key] = [item];
+      }
+    }
+  }
+  if (Model) {
+    return add(Model[Symbol.metadata] ||= {});
+  }
+  /** @type {ClassDecorator} */
+  return (value, ctx) => {
+    if (!ctx || ctx.kind !== 'class') {
+      throw new Error('钩子属性只能是类(class)');
+    }
+    add(ctx.metadata);
+  };
+}
 
 const propsKey = Symbol();
 /**
@@ -5301,6 +5374,14 @@ class Query extends Subquery {
     this.#options.group = [this.#options.group || [], groups].flat(2);
     return this;
   }
+  /**
+   *
+   * @param  {boolean} [distinct]
+   */
+  distinct(distinct = true) {
+    this.#options.distinct = Boolean(distinct);
+    return this;
+  }
 }
 
 /** @import { Fields, IndexInfo, FieldDefine } from './types' */
@@ -5328,6 +5409,141 @@ function toPrimaries(model, documents) {
   return Array.isArray(documents) ? documents.map(document => toPrimary(fields, document)) : toPrimary(fields, documents);
 }
 
+/** @import { Hooks, MaybePromise } from './types' */
+/**
+ *
+ * @param {Hooks['where'][]} hooks
+ * @returns {Hooks['where'] | undefined}
+ */
+function mergeWhere(hooks) {
+  if (!hooks.length) {
+    return;
+  }
+  return async function (conn, model) {
+    let that;
+    for (const hook of hooks) {
+      const where = await hook.call(this, conn, model);
+      if (!where) {
+        continue;
+      }
+      that = (that || Where).and(where);
+    }
+    return that;
+  };
+}
+/**
+ *
+ * @param {Hooks['beforeCreateMany'][]} hooks
+ * @returns {Hooks['beforeCreateMany'] | undefined}
+ */
+function mergeBeforeCreateMany(hooks) {
+  if (!hooks.length) {
+    return;
+  }
+  return async function (conn, model, record) {
+    let data = record;
+    for (const hook of hooks) {
+      data = (await hook.call(this, conn, model, data)) || data;
+    }
+    return data;
+  };
+}
+/**
+ *
+ * @param {Hooks['beforeCreate'][]} hooks
+ * @returns {Hooks['beforeCreate'] | undefined}
+ */
+function mergeBeforeCreate(hooks) {
+  if (!hooks.length) {
+    return;
+  }
+  return async function (conn, model, record) {
+    let data = record;
+    for (const hook of hooks) {
+      data = (await hook.call(this, conn, model, data)) || data;
+    }
+    return data;
+  };
+}
+/**
+ *
+ * @param {Hooks['beforeUpdate'][]} hooks
+ * @returns {Hooks['beforeUpdate'] | undefined}
+ */
+function mergeBeforeUpdate(hooks) {
+  if (!hooks.length) {
+    return;
+  }
+  return async function (conn, model, record, set) {
+    let data = set;
+    for (const hook of hooks) {
+      data = (await hook.call(this, conn, model, record, data)) || data;
+    }
+    return data;
+  };
+}
+/**
+ * @template {any[]} T
+ * @param {((this: any, ...argv: T) => MaybePromise<void>)[]} hooks
+ * @returns {((this: any, ...argv: T) => MaybePromise<void>) | undefined}
+ */
+function mergeRun(hooks) {
+  if (!hooks.length) {
+    return;
+  }
+  return async function (...p) {
+    for (const hook of hooks) {
+      await hook.apply(this, p);
+    }
+  };
+}
+/**
+ * @template {(...p: any[]) => any} T
+ * @param {T?} [v]
+ * @returns {v is T}
+ */
+function filterFunction(v) {
+  return typeof v === 'function';
+}
+/**
+ *
+ * @param  {...Readonly<Partial<Hooks>> | Readonly<Partial<Hooks>>[]} hooks
+ * @returns {Readonly<Partial<Hooks>>}
+ */
+function mergeHooks(...hooks) {
+  const allHooks = hooks.flat();
+  return {
+    where: mergeWhere(allHooks.map(v => v.where).filter(filterFunction)),
+    beforeCreateMany: mergeBeforeCreateMany(allHooks.map(v => v.beforeCreateMany).filter(filterFunction)),
+    afterCreateMany: mergeRun(allHooks.map(v => v.afterCreateMany).filter(filterFunction)),
+    beforeCreate: mergeBeforeCreate(allHooks.map(v => v.beforeCreate).filter(filterFunction)),
+    afterCreate: mergeRun(allHooks.map(v => v.afterCreate).filter(filterFunction)),
+    beforeUpdate: mergeBeforeUpdate(allHooks.map(v => v.beforeUpdate).filter(filterFunction)),
+    afterUpdate: mergeRun(allHooks.map(v => v.afterUpdate).filter(filterFunction)),
+    beforeDelete: mergeRun(allHooks.map(v => v.beforeDelete).filter(filterFunction)),
+    afterDelete: mergeRun(allHooks.map(v => v.afterDelete).filter(filterFunction))
+  };
+}
+/**
+ *
+ * @param  {Readonly<Partial<Hooks>>} hooks
+ * @param  {any} that
+ * @returns {Readonly<Partial<Hooks>>}
+ */
+function bindHooks(hooks, that) {
+  return {
+    where: hooks.where?.bind(that),
+    beforeCreateMany: hooks.beforeCreateMany?.bind(that),
+    afterCreateMany: hooks.afterCreateMany?.bind(that),
+    beforeCreate: hooks.beforeCreate?.bind(that),
+    afterCreate: hooks.afterCreate?.bind(that),
+    beforeUpdate: hooks.beforeUpdate?.bind(that),
+    afterUpdate: hooks.afterUpdate?.bind(that),
+    beforeDelete: hooks.beforeDelete?.bind(that),
+    afterDelete: hooks.afterDelete?.bind(that)
+  };
+}
+
 /* eslint-disable max-lines */
 /** @import { Fields, IndexInfo, FieldDefine, TableDefine } from './types' */
 /** @import { Scene } from './Scene.mjs' */
@@ -6486,4 +6702,4 @@ function field(type, {
   };
 }
 
-export { Build, Connection, Create, Destroy, Model, PseudoDestroy, Query, Save, Scene, Submodel, Where, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };
+export { Build, Connection, Create, Destroy, Model, PseudoDestroy, Query, Save, Scene, Submodel, Where, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, bindHooks, coefficient, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, hooks, immutable, increment, index, isDevelopment, isPseudo, mergeHooks, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, where, withDeleted };

package/migrate.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.17.0
+ * imodel v0.17.2
  * (c) 2019-2026 undefined
  * @license undefined
  */

package/migrate.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.17.0
+ * imodel v0.17.2
  * (c) 2019-2026 undefined
  * @license undefined
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imodel",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "main": "index.mjs",
   "type": "module",
   "repository": {