@tstdl/base 0.85.13 → 0.86.0-beta1

package/database/mongo/operations.js

@@ -1,82 +1,54 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var operations_exports = {};
-__export(operations_exports, {
-  deleteManyOperation: () => deleteManyOperation,
-  deleteOneOperation: () => deleteOneOperation,
-  insertOneOperation: () => insertOneOperation,
-  replaceOneOperation: () => replaceOneOperation,
-  updateManyOperation: () => updateManyOperation,
-  updateOneOperation: () => updateOneOperation
-});
-module.exports = __toCommonJS(operations_exports);
-function insertOneOperation(document) {
-  const operation = {
-    insertOne: {
-      document
-    }
-  };
-  return operation;
+export function insertOneOperation(document) {
+    const operation = {
+        insertOne: {
+            document: document
+        }
+    };
+    return operation;
 }
-function replaceOneOperation(filter, replacement, options = {}) {
-  const operation = {
-    replaceOne: {
-      filter,
-      replacement,
-      upsert: options.upsert
-    }
-  };
-  return operation;
+export function replaceOneOperation(filter, replacement, options = {}) {
+    const operation = {
+        replaceOne: {
+            filter,
+            replacement,
+            upsert: options.upsert
+        }
+    };
+    return operation;
 }
-function updateOneOperation(filter, update, options = {}) {
-  const operation = {
-    updateOne: {
-      filter,
-      update,
-      upsert: options.upsert
-    }
-  };
-  return operation;
+export function updateOneOperation(filter, update, options = {}) {
+    const operation = {
+        updateOne: {
+            filter,
+            update,
+            upsert: options.upsert
+        }
+    };
+    return operation;
 }
-function updateManyOperation(filter, update, options = {}) {
-  const operation = {
-    updateMany: {
-      filter,
-      update,
-      upsert: options.upsert
-    }
-  };
-  return operation;
+export function updateManyOperation(filter, update, options = {}) {
+    const operation = {
+        updateMany: {
+            filter,
+            update,
+            upsert: options.upsert
+        }
+    };
+    return operation;
 }
-function deleteOneOperation(filter) {
-  const operation = {
-    deleteOne: {
-      filter
-    }
-  };
-  return operation;
+export function deleteOneOperation(filter) {
+    const operation = {
+        deleteOne: {
+            filter
+        }
+    };
+    return operation;
 }
-function deleteManyOperation(filter) {
-  const operation = {
-    deleteMany: {
-      filter
-    }
-  };
-  return operation;
+export function deleteManyOperation(filter) {
+    const operation = {
+        deleteMany: {
+            filter
+        }
+    };
+    return operation;
 }

package/database/mongo/query-converter.js

@@ -1,106 +1,83 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var query_converter_exports = {};
-__export(query_converter_exports, {
-  convertQuery: () => convertQuery,
-  convertSort: () => convertSort
-});
-module.exports = __toCommonJS(query_converter_exports);
-var import_database = require("../../database/index.js");
-var import_object = require("../../utils/object/object.js");
-var import_type_guards = require("../../utils/type-guards.js");
-const operatorsSet = new Set(import_database.allQueryTypes);
-function convertQuery(query, mappingMap = /* @__PURE__ */ new Map(), transform) {
-  let filterQuery = {};
-  const entries = (0, import_object.objectEntries)(query);
-  for (const [property, value] of entries) {
-    const mapping = mappingMap.get(property);
-    switch (property) {
-      case "$and":
-        filterQuery.$and = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
-        break;
-      case "$or":
-        filterQuery.$or = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
-        break;
-      case "$nor":
-        filterQuery.$nor = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
-        break;
-      default:
-        if (operatorsSet.has(property)) {
-          const operatorQuery = convertOperator(property, value, mapping?.transform ?? transform, mappingMap);
-          filterQuery = { ...filterQuery, ...operatorQuery };
-        } else {
-          const mappedPropertyName = getPropertyName(mapping?.key ?? property);
-          filterQuery[mappedPropertyName] = convertInnerQuery(value, mapping?.transform ?? transform, mappingMap);
+import { allQueryTypes } from '../../database/index.js';
+import { objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, isDefined, isObject, isPrimitive, isRegExp, isString } from '../../utils/type-guards.js';
+const operatorsSet = new Set(allQueryTypes);
+export function convertQuery(query, mappingMap = new Map(), transform) {
+    let filterQuery = {};
+    const entries = objectEntries(query);
+    for (const [property, value] of entries) {
+        const mapping = mappingMap.get(property);
+        switch (property) {
+            case '$and':
+                filterQuery.$and = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
+                break;
+            case '$or':
+                filterQuery.$or = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
+                break;
+            case '$nor':
+                filterQuery.$nor = value.map((innerQuery) => convertQuery(innerQuery, mappingMap, transform));
+                break;
+            default:
+                if (operatorsSet.has(property)) {
+                    const operatorQuery = convertOperator(property, value, mapping?.transform ?? transform, mappingMap);
+                    filterQuery = { ...filterQuery, ...operatorQuery };
+                }
+                else {
+                    const mappedPropertyName = getPropertyName(mapping?.key ?? property);
+                    filterQuery[mappedPropertyName] = convertInnerQuery(value, mapping?.transform ?? transform, mappingMap);
+                }
         }
     }
-  }
-  return filterQuery;
+    return filterQuery;
 }
 function getPropertyName(property) {
-  return property == "id" ? "_id" : property;
+    return (property == 'id') ? '_id' : property;
 }
 function convertInnerQuery(query, transform, mapping) {
-  if ((0, import_type_guards.isPrimitive)(query)) {
-    return transform?.(query) ?? query;
-  }
-  const queryEntries = (0, import_object.objectEntries)(query);
-  if (queryEntries.length > 1) {
-    const operators = queryEntries.map((entry) => entry[0]);
-    throw new Error(`only one operator allowed but got ${JSON.stringify(operators)}`);
-  }
-  const [operator, value] = (0, import_type_guards.assertDefinedPass)(queryEntries[0], "missing query body");
-  return convertOperator(operator, value, transform, mapping);
+    if (isPrimitive(query)) {
+        return transform?.(query) ?? query;
+    }
+    const queryEntries = objectEntries(query);
+    if (queryEntries.length > 1) {
+        const operators = queryEntries.map((entry) => entry[0]);
+        throw new Error(`only one operator allowed but got ${JSON.stringify(operators)}`);
+    }
+    const [operator, value] = assertDefinedPass(queryEntries[0], 'missing query body');
+    return convertOperator(operator, value, transform, mapping);
 }
+// eslint-disable-next-line complexity
 function convertOperator(operator, value, transform, mapping) {
-  switch (operator) {
-    case "$eq":
-    case "$not":
-    case "$exists":
-    case "$gt":
-    case "$gte":
-    case "$lt":
-    case "$lte":
-      return { [operator]: convertInnerQuery(value, transform) };
-    case "$neq":
-      return { $ne: convertInnerQuery(value, transform) };
-    case "$in":
-      return { $in: (0, import_type_guards.isDefined)(transform) ? value.map(transform) : value };
-    case "$nin":
-      return { $nin: (0, import_type_guards.isDefined)(transform) ? value.map(transform) : value };
-    case "$all":
-      return { $all: (0, import_type_guards.isDefined)(transform) ? value.map(transform) : value };
-    case "$item":
-      return { $elemMatch: (0, import_type_guards.isObject)(value) ? convertQuery(value, mapping, transform) : transform?.(value) ?? value };
-    case "$regex":
-      if ((0, import_type_guards.isString)(value) || (0, import_type_guards.isRegExp)(value)) {
-        return { $regex: value };
-      }
-      return {
-        $regex: value.pattern,
-        $options: value.flags
-      };
-    default:
-      throw new Error(`unsupported inner-operator ${operator}`);
-  }
+    switch (operator) {
+        case '$eq':
+        case '$not':
+        case '$exists':
+        case '$gt':
+        case '$gte':
+        case '$lt':
+        case '$lte':
+            return { [operator]: convertInnerQuery(value, transform) };
+        case '$neq':
+            return { $ne: convertInnerQuery(value, transform) };
+        case '$in':
+            return { $in: isDefined(transform) ? value.map(transform) : value };
+        case '$nin':
+            return { $nin: isDefined(transform) ? value.map(transform) : value };
+        case '$all':
+            return { $all: isDefined(transform) ? value.map(transform) : value };
+        case '$item':
+            return { $elemMatch: isObject(value) ? convertQuery(value, mapping, transform) : transform?.(value) ?? value };
+        case '$regex':
+            if (isString(value) || isRegExp(value)) {
+                return { $regex: value };
+            }
+            return {
+                $regex: value.pattern,
+                $options: value.flags
+            };
+        default: throw new Error(`unsupported inner-operator ${operator}`);
+    }
 }
-function convertSort(sort, mappingMap) {
-  const field = mappingMap.get(sort.field)?.key ?? sort.field;
-  return [field, sort.order == "desc" ? -1 : 1];
+export function convertSort(sort, mappingMap) {
+    const field = mappingMap.get(sort.field)?.key ?? sort.field;
+    return [field, sort.order == 'desc' ? -1 : 1];
 }

package/database/mongo/simple-entity-repository.js

@@ -1,29 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var simple_entity_repository_exports = {};
-__export(simple_entity_repository_exports, {
-  SimpleMongoEntityRepository: () => SimpleMongoEntityRepository
-});
-module.exports = __toCommonJS(simple_entity_repository_exports);
-var import_mongo_entity_repository = require("./mongo-entity-repository.js");
-class SimpleMongoEntityRepository extends import_mongo_entity_repository.MongoEntityRepository {
-  constructor(collection, logger) {
-    super(collection, import_mongo_entity_repository.noopTransformer, { logger });
-  }
+import { MongoEntityRepository, noopTransformer } from './mongo-entity-repository.js';
+export class SimpleMongoEntityRepository extends MongoEntityRepository {
+    constructor(collection, logger) {
+        super(collection, noopTransformer, { logger });
+    }
 }

package/database/mongo/types.js

@@ -1,26 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-__export(types_exports, {
-  getMongoRepositoryConfig: () => getMongoRepositoryConfig
-});
-module.exports = __toCommonJS(types_exports);
-function getMongoRepositoryConfig(config) {
-  return config;
+export function getMongoRepositoryConfig(config) {
+    return config;
 }

package/database/query.js

@@ -1,36 +1,7 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var query_exports = {};
-__export(query_exports, {
-  allComparisonQueryTypes: () => allComparisonQueryTypes,
-  allLogicalQueryTypes: () => allLogicalQueryTypes,
-  allOperators: () => allOperators,
-  allOrders: () => allOrders,
-  allQueryTypes: () => allQueryTypes,
-  allSpecialQueryTypes: () => allSpecialQueryTypes,
-  allTextSpanQueryModes: () => allTextSpanQueryModes
-});
-module.exports = __toCommonJS(query_exports);
-const allLogicalQueryTypes = ["$and", "$or", "$nor"];
-const allComparisonQueryTypes = ["$all", "$not", "$eq", "$exists", "$gt", "$gte", "$in", "$item", "$lt", "$lte", "$neq", "$nin", "$regex", "$text", "$geoDistance", "$geoShape"];
-const allSpecialQueryTypes = ["$textSpan"];
-const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];
-const allOrders = ["asc", "desc"];
-const allOperators = ["and", "or"];
-const allTextSpanQueryModes = ["best", "most", "cross"];
+export const allLogicalQueryTypes = ['$and', '$or', '$nor'];
+export const allComparisonQueryTypes = ['$all', '$not', '$eq', '$exists', '$gt', '$gte', '$in', '$item', '$lt', '$lte', '$neq', '$nin', '$regex', '$text', '$geoDistance', '$geoShape'];
+export const allSpecialQueryTypes = ['$textSpan'];
+export const allQueryTypes = [...allLogicalQueryTypes, ...allComparisonQueryTypes, ...allSpecialQueryTypes];
+export const allOrders = ['asc', 'desc'];
+export const allOperators = ['and', 'or'];
+export const allTextSpanQueryModes = ['best', 'most', 'cross'];

package/database/utils.js

@@ -1,26 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  getEntityMap: () => getEntityMap
-});
-module.exports = __toCommonJS(utils_exports);
-function getEntityMap(entities) {
-  return new Map(entities.map((entity) => [entity.id, entity]));
+export function getEntityMap(entities) {
+    return new Map(entities.map((entity) => [entity.id, entity]));
 }

package/disposable/async-disposer.js

@@ -1,111 +1,99 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var async_disposer_exports = {};
-__export(async_disposer_exports, {
-  AsyncDisposer: () => AsyncDisposer
-});
-module.exports = __toCommonJS(async_disposer_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_multi_error = require("../error/multi.error.js");
-var import_cancellation_token = require("../utils/cancellation-token.js");
-var import_disposable = require("./disposable.js");
-const deferrerToken = Symbol("DeferrerToken");
-class AsyncDisposer {
-  deferrers;
-  tasks;
-  _disposingToken;
-  _disposedToken;
-  get disposingToken() {
-    return this._disposingToken;
-  }
-  get disposedToken() {
-    return this._disposedToken;
-  }
-  get disposing() {
-    return this._disposingToken.isSet;
-  }
-  get disposed() {
-    return this._disposedToken.isSet;
-  }
-  constructor() {
-    this.deferrers = /* @__PURE__ */ new Set();
-    this.tasks = [];
-    this._disposingToken = new import_cancellation_token.CancellationToken();
-    this._disposedToken = new import_cancellation_token.CancellationToken();
-  }
-  getDeferrer() {
-    const deferrer = {
-      [deferrerToken]: new import_cancellation_token.CancellationToken(),
-      yield: () => {
-        deferrer[deferrerToken].set();
-        this.deferrers.delete(deferrer);
-      }
-    };
-    this.deferrers.add(deferrer);
-    return deferrer;
-  }
-  async defer(func) {
-    const deferrer = this.getDeferrer();
-    try {
-      const result = await func();
-      return result;
-    } finally {
-      deferrer.yield();
+import { isDefined } from '../utils/type-guards.js';
+import { MultiError } from '../error/multi.error.js';
+import { CancellationToken } from '../utils/cancellation-token.js';
+import { dispose, disposeAsync, isAsyncDisposable, isDisposable } from './disposable.js';
+const deferrerToken = Symbol('DeferrerToken');
+export class AsyncDisposer {
+    deferrers;
+    tasks;
+    _disposingToken;
+    _disposedToken;
+    get disposingToken() {
+        return this._disposingToken;
     }
-  }
-  /**
-   *
-   * @param fnOrDisposable
-   */
-  add(fnOrDisposable) {
-    const fn = (0, import_disposable.isAsyncDisposable)(fnOrDisposable) ? async () => fnOrDisposable[import_disposable.disposeAsync]() : (0, import_disposable.isDisposable)(fnOrDisposable) ? () => fnOrDisposable[import_disposable.dispose]() : fnOrDisposable;
-    this.tasks.push({ taskFunction: fn });
-  }
-  async dispose() {
-    if (this.disposing) {
-      return this._disposedToken.$set;
+    get disposedToken() {
+        return this._disposedToken;
     }
-    this._disposingToken.set();
-    const errors = [];
-    for (const deferrer of this.deferrers) {
-      try {
-        await deferrer[deferrerToken];
-      } catch (error2) {
-        errors.push(error2);
-      }
+    get disposing() {
+        return this._disposingToken.isSet;
     }
-    for (let i = this.tasks.length - 1; i >= 0; i--) {
-      try {
-        const task = this.tasks[i];
-        await task.taskFunction();
-      } catch (error2) {
-        errors.push(error2);
-      }
+    get disposed() {
+        return this._disposedToken.isSet;
     }
-    const error = errors.length == 1 ? errors[0] : errors.length > 1 ? new import_multi_error.MultiError(errors, "dispose errors") : void 0;
-    if ((0, import_type_guards.isDefined)(error)) {
-      this._disposedToken.error(error);
-      throw error;
+    constructor() {
+        this.deferrers = new Set();
+        this.tasks = [];
+        this._disposingToken = new CancellationToken();
+        this._disposedToken = new CancellationToken();
+    }
+    getDeferrer() {
+        const deferrer = {
+            [deferrerToken]: new CancellationToken(),
+            yield: () => {
+                deferrer[deferrerToken].set();
+                this.deferrers.delete(deferrer);
+            }
+        };
+        this.deferrers.add(deferrer);
+        return deferrer;
+    }
+    async defer(func) {
+        const deferrer = this.getDeferrer();
+        try {
+            const result = await func();
+            return result;
+        }
+        finally {
+            deferrer.yield();
+        }
+    }
+    /**
+     *
+     * @param fnOrDisposable
+     */
+    add(fnOrDisposable) {
+        const fn = isAsyncDisposable(fnOrDisposable)
+            ? async () => fnOrDisposable[disposeAsync]()
+            : isDisposable(fnOrDisposable)
+                ? () => fnOrDisposable[dispose]()
+                : fnOrDisposable;
+        this.tasks.push({ taskFunction: fn });
+    }
+    async dispose() {
+        if (this.disposing) {
+            return this._disposedToken.$set;
+        }
+        this._disposingToken.set();
+        const errors = [];
+        for (const deferrer of this.deferrers) {
+            try {
+                await deferrer[deferrerToken];
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        for (let i = this.tasks.length - 1; i >= 0; i--) {
+            try {
+                const task = this.tasks[i];
+                await task.taskFunction();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        const error = (errors.length == 1)
+            ? errors[0]
+            : (errors.length > 1)
+                ? new MultiError(errors, 'dispose errors')
+                : undefined;
+        if (isDefined(error)) {
+            this._disposedToken.error(error);
+            throw error;
+        }
+        this._disposedToken.set();
+    }
+    async [disposeAsync]() {
+        return this.dispose();
     }
-    this._disposedToken.set();
-  }
-  async [import_disposable.disposeAsync]() {
-    return this.dispose();
-  }
 }