@tstdl/base 0.83.0-beta2 → 0.83.0-beta3

package/search-index/memory/memory-search-index.js

@@ -1,145 +1,166 @@
-import { compareByValueSelectionOrdered } from '../../utils/comparison.js';
-import { FactoryMap } from '../../utils/factory-map.js';
-import { normalizeText } from '../../utils/helpers.js';
-import { objectEntries } from '../../utils/object/object.js';
-import { intersectSets, unionSets } from '../../utils/set.js';
-import { Timer } from '../../utils/timer.js';
-import { isDefined, isNullOrUndefined, isString } from '../../utils/type-guards.js';
-import { SearchIndex } from '../search-index.js';
-export class MemorySearchIndex extends SearchIndex {
-    indexedFields;
-    allSet;
-    idMap;
-    indexMap;
-    constructor(indexedFields) {
-        super();
-        this.indexedFields = indexedFields;
-        this.allSet = new Set();
-        this.idMap = new Map();
-        this.indexMap = new FactoryMap(() => new FactoryMap(() => new Set()));
+"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 memory_search_index_exports = {};
+__export(memory_search_index_exports, {
+  MemorySearchIndex: () => MemorySearchIndex
+});
+module.exports = __toCommonJS(memory_search_index_exports);
+var import_comparison = require("../../utils/comparison.js");
+var import_factory_map = require("../../utils/factory-map.js");
+var import_helpers = require("../../utils/helpers.js");
+var import_object = require("../../utils/object/object.js");
+var import_set = require("../../utils/set.js");
+var import_timer = require("../../utils/timer.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_search_index = require("../search-index.js");
+class MemorySearchIndex extends import_search_index.SearchIndex {
+  indexedFields;
+  allSet;
+  idMap;
+  indexMap;
+  constructor(indexedFields) {
+    super();
+    this.indexedFields = indexedFields;
+    this.allSet = /* @__PURE__ */ new Set();
+    this.idMap = /* @__PURE__ */ new Map();
+    this.indexMap = new import_factory_map.FactoryMap(() => new import_factory_map.FactoryMap(() => /* @__PURE__ */ new Set()));
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async index(entities) {
+    for (const entity of entities) {
+      this._delete(entity.id);
+      this.indexEntity(entity);
     }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async index(entities) {
-        for (const entity of entities) {
-            this._delete(entity.id);
-            this.indexEntity(entity);
-        }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async delete(id) {
+    this._delete(id);
+  }
+  async deleteByQuery(query) {
+    const searchResult = await this.search(query);
+    for (const item of searchResult.items) {
+      this.deleteEntity(item.entity);
     }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async delete(id) {
-        this._delete(id);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await, max-statements, max-lines-per-function
+  async search(queryOrCursor, options = {}) {
+    if ((0, import_type_guards.isString)(queryOrCursor)) {
+      throw new Error("cursor not supported");
     }
-    async deleteByQuery(query) {
-        const searchResult = await this.search(query);
-        for (const item of searchResult.items) {
-            this.deleteEntity(item.entity);
+    const timer = new import_timer.Timer(true);
+    const entries = (0, import_object.objectEntries)(queryOrCursor);
+    let items;
+    if (entries.length == 0) {
+      items = [...this.allSet];
+    } else {
+      const sets = [];
+      for (const [field, query] of entries) {
+        const textQuery = query.$text;
+        const queryIsString = (0, import_type_guards.isString)(textQuery);
+        const text = queryIsString ? textQuery : textQuery.text;
+        const and = queryIsString ? true : textQuery.operator != "or";
+        const innerSets = [];
+        if ((0, import_type_guards.isString)(text)) {
+          const tokens = (0, import_helpers.normalizeText)(text).split(" ").filter((token) => token.length > 0);
+          if (tokens.length == 0) {
+            innerSets.push(this.allSet);
+          }
+          for (const token of tokens) {
+            innerSets.push(this.indexMap.get(field).get(token));
+          }
         }
+        const innerEntries = and ? (0, import_set.intersectSets)(...innerSets) : (0, import_set.unionSets)(...innerSets);
+        sets.push(new Set(innerEntries));
+      }
+      items = (0, import_set.intersectSets)(...sets);
     }
-    // eslint-disable-next-line @typescript-eslint/require-await, max-statements, max-lines-per-function
-    async search(queryOrCursor, options = {}) {
-        if (isString(queryOrCursor)) {
-            throw new Error('cursor not supported');
-        }
-        const timer = new Timer(true);
-        const entries = objectEntries(queryOrCursor);
-        let items;
-        if (entries.length == 0) {
-            items = [...this.allSet];
-        }
-        else {
-            const sets = [];
-            for (const [field, query] of entries) {
-                const textQuery = query.$text;
-                const queryIsString = isString(textQuery);
-                const text = queryIsString ? textQuery : textQuery.text;
-                const and = queryIsString ? true : textQuery.operator != 'or';
-                const innerSets = [];
-                if (isString(text)) {
-                    const tokens = normalizeText(text).split(' ').filter((token) => token.length > 0);
-                    if (tokens.length == 0) {
-                        innerSets.push(this.allSet);
-                    }
-                    for (const token of tokens) {
-                        innerSets.push(this.indexMap.get(field).get(token));
-                    }
-                }
-                const innerEntries = and ? intersectSets(...innerSets) : unionSets(...innerSets);
-                sets.push(new Set(innerEntries));
-            }
-            items = intersectSets(...sets);
-        }
-        if (isDefined(options.sort)) {
-            items.sort(compareByValueSelectionOrdered(...options.sort.map((sort) => [(item) => item[sort.field], sort.order == 'desc' ? -1 : 1])));
-        }
-        if (isDefined(options.skip) || isDefined(options.limit)) {
-            const start = options.skip ?? 0;
-            const end = isDefined(options.limit) ? (start + options.limit) : undefined;
-            items = items.slice(start, end);
-        }
-        const resultItems = items.map((item) => ({ entity: item, score: 1 }));
-        const result = {
-            total: resultItems.length,
-            totalIsLowerBound: false,
-            milliseconds: timer.milliseconds,
-            items: resultItems
-        };
-        return result;
+    if ((0, import_type_guards.isDefined)(options.sort)) {
+      items.sort((0, import_comparison.compareByValueSelectionOrdered)(...options.sort.map((sort) => [(item) => item[sort.field], sort.order == "desc" ? -1 : 1])));
     }
-    async count(query, options) {
-        const items = await this.searchAll(query ?? {}, options);
-        return items.length;
+    if ((0, import_type_guards.isDefined)(options.skip) || (0, import_type_guards.isDefined)(options.limit)) {
+      const start = options.skip ?? 0;
+      const end = (0, import_type_guards.isDefined)(options.limit) ? start + options.limit : void 0;
+      items = items.slice(start, end);
     }
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async drop() {
-        this.allSet.clear();
-        this.idMap.clear();
-        this.indexMap.clear();
+    const resultItems = items.map((item) => ({ entity: item, score: 1 }));
+    const result = {
+      total: resultItems.length,
+      totalIsLowerBound: false,
+      milliseconds: timer.milliseconds,
+      items: resultItems
+    };
+    return result;
+  }
+  async count(query, options) {
+    const items = await this.searchAll(query ?? {}, options);
+    return items.length;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async drop() {
+    this.allSet.clear();
+    this.idMap.clear();
+    this.indexMap.clear();
+  }
+  _delete(id) {
+    const entity = this.idMap.get(id);
+    if ((0, import_type_guards.isDefined)(entity)) {
+      this.deleteEntity(entity);
     }
-    _delete(id) {
-        const entity = this.idMap.get(id);
-        if (isDefined(entity)) {
-            this.deleteEntity(entity);
-        }
+  }
+  indexEntity(entity) {
+    this.allSet.add(entity);
+    this.idMap.set(entity.id, entity);
+    for (const field of this.indexedFields) {
+      const value = entity[field];
+      const tokens = getTokens(value);
+      for (const token of tokens) {
+        this.indexMap.get(field).get(token).add(entity);
+      }
     }
-    indexEntity(entity) {
-        this.allSet.add(entity);
-        this.idMap.set(entity.id, entity);
-        for (const field of this.indexedFields) {
-            const value = entity[field];
-            const tokens = getTokens(value);
-            for (const token of tokens) {
-                this.indexMap.get(field).get(token).add(entity);
-            }
-        }
-    }
-    deleteEntity(entity) {
-        for (const field of this.indexedFields) {
-            const value = entity[field];
-            const tokens = getTokens(value);
-            for (const token of tokens) {
-                this.indexMap.get(field).get(token).delete(entity);
-            }
-        }
-        this.allSet.delete(entity);
-        this.idMap.delete(entity.id);
+  }
+  deleteEntity(entity) {
+    for (const field of this.indexedFields) {
+      const value = entity[field];
+      const tokens = getTokens(value);
+      for (const token of tokens) {
+        this.indexMap.get(field).get(token).delete(entity);
+      }
     }
+    this.allSet.delete(entity);
+    this.idMap.delete(entity.id);
+  }
 }
 function getTokens(value) {
-    if (isNullOrUndefined(value)) {
-        return [value];
-    }
-    if (!isString(value)) {
-        throw new Error('value is neither string nor null or undefined');
-    }
-    const normalizedParts = normalizeText(value).split(' ');
-    const tokens = new Set();
-    for (const part of normalizedParts) {
-        for (let i = 0; i < part.length; i++) {
-            for (let j = i; j < part.length; j++) {
-                tokens.add(part.slice(i, j + 1));
-            }
-        }
+  if ((0, import_type_guards.isNullOrUndefined)(value)) {
+    return [value];
+  }
+  if (!(0, import_type_guards.isString)(value)) {
+    throw new Error("value is neither string nor null or undefined");
+  }
+  const normalizedParts = (0, import_helpers.normalizeText)(value).split(" ");
+  const tokens = /* @__PURE__ */ new Set();
+  for (const part of normalizedParts) {
+    for (let i = 0; i < part.length; i++) {
+      for (let j = i; j < part.length; j++) {
+        tokens.add(part.slice(i, j + 1));
+      }
     }
-    return [...tokens];
+  }
+  return [...tokens];
 }
-//# sourceMappingURL=memory-search-index.js.map

package/search-index/search-index.js

@@ -1,32 +1,54 @@
-import { isDefined } from '../utils/type-guards.js';
-export class SearchIndex {
-    /**
-     * search all entities using an automatic cursor
-     * @param query search query
-     * @param options search options
-     */
-    async *searchCursor(query, options) {
-        let cursor;
-        do {
-            const result = await this.search(cursor ?? query, options);
-            cursor = result.cursor;
-            yield* result.items;
-        } while (isDefined(cursor));
-    }
-    /**
-     * search all entities instead of just a chunk
-     * @param query search query
-     * @param options search option
-     */
-    async searchAll(query, options) {
-        const batches = [];
-        let cursor;
-        do {
-            const result = await this.search(cursor ?? query, options);
-            cursor = result.cursor;
-            batches.push(result.items);
-        } while (isDefined(cursor));
-        return [].concat(...batches);
-    }
+"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 search_index_exports = {};
+__export(search_index_exports, {
+  SearchIndex: () => SearchIndex
+});
+module.exports = __toCommonJS(search_index_exports);
+var import_type_guards = require("../utils/type-guards.js");
+class SearchIndex {
+  /**
+   * search all entities using an automatic cursor
+   * @param query search query
+   * @param options search options
+   */
+  async *searchCursor(query, options) {
+    let cursor;
+    do {
+      const result = await this.search(cursor ?? query, options);
+      cursor = result.cursor;
+      yield* result.items;
+    } while ((0, import_type_guards.isDefined)(cursor));
+  }
+  /**
+   * search all entities instead of just a chunk
+   * @param query search query
+   * @param options search option
+   */
+  async searchAll(query, options) {
+    const batches = [];
+    let cursor;
+    do {
+      const result = await this.search(cursor ?? query, options);
+      cursor = result.cursor;
+      batches.push(result.items);
+    } while ((0, import_type_guards.isDefined)(cursor));
+    return [].concat(...batches);
+  }
 }
-//# sourceMappingURL=search-index.js.map

package/search-index/search-result.js

@@ -1,2 +1,16 @@
-export {};
-//# sourceMappingURL=search-result.js.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 search_result_exports = {};
+module.exports = __toCommonJS(search_result_exports);

package/serializer/handlers/binary.js

@@ -1,26 +1,53 @@
-import { decodeBase64, encodeBase64 } from '../../utils/base64.js';
-import { toArrayBuffer } from '../../utils/binary.js';
-export function serializeArrayBuffer(buffer) {
-    return encodeBase64(buffer);
+"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 binary_exports = {};
+__export(binary_exports, {
+  deserializeArrayBuffer: () => deserializeArrayBuffer,
+  deserializeBuffer: () => deserializeBuffer,
+  getTypedArrayDeserializer: () => getTypedArrayDeserializer,
+  serializeArrayBuffer: () => serializeArrayBuffer,
+  serializeBuffer: () => serializeBuffer,
+  serializeTypedArray: () => serializeTypedArray
+});
+module.exports = __toCommonJS(binary_exports);
+var import_base64 = require("../../utils/base64.js");
+var import_binary = require("../../utils/binary.js");
+function serializeArrayBuffer(buffer) {
+  return (0, import_base64.encodeBase64)(buffer);
 }
-export function deserializeArrayBuffer(data) {
-    const uint8Array = decodeBase64(data);
-    return toArrayBuffer(uint8Array);
+function deserializeArrayBuffer(data) {
+  const uint8Array = (0, import_base64.decodeBase64)(data);
+  return (0, import_binary.toArrayBuffer)(uint8Array);
 }
-export function serializeTypedArray(array) {
-    return encodeBase64(array);
+function serializeTypedArray(array) {
+  return (0, import_base64.encodeBase64)(array);
 }
-export function getTypedArrayDeserializer(constructor) {
-    function deserializeTypedArray(data) {
-        const uint8Array = decodeBase64(data);
-        return new constructor(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength / constructor.BYTES_PER_ELEMENT);
-    }
-    return deserializeTypedArray;
+function getTypedArrayDeserializer(constructor) {
+  function deserializeTypedArray(data) {
+    const uint8Array = (0, import_base64.decodeBase64)(data);
+    return new constructor(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength / constructor.BYTES_PER_ELEMENT);
+  }
+  return deserializeTypedArray;
 }
-export function serializeBuffer(buffer) {
-    return buffer.toString('base64');
+function serializeBuffer(buffer) {
+  return buffer.toString("base64");
 }
-export function deserializeBuffer(data) {
-    return Buffer.from(data, 'base64');
+function deserializeBuffer(data) {
+  return Buffer.from(data, "base64");
 }
-//# sourceMappingURL=binary.js.map

package/serializer/handlers/date.js

@@ -1,7 +1,30 @@
-export function serializeDate(date) {
-    return date.getTime();
+"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 date_exports = {};
+__export(date_exports, {
+  deserializeDate: () => deserializeDate,
+  serializeDate: () => serializeDate
+});
+module.exports = __toCommonJS(date_exports);
+function serializeDate(date) {
+  return date.getTime();
 }
-export function deserializeDate(timestamp) {
-    return new Date(timestamp);
+function deserializeDate(timestamp) {
+  return new Date(timestamp);
 }
-//# sourceMappingURL=date.js.map

package/serializer/handlers/error.js

@@ -1,10 +1,33 @@
-export function serializeError(error) {
-    return { name: error.name, message: error.message, stack: error.stack };
+"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 error_exports = {};
+__export(error_exports, {
+  deserializeError: () => deserializeError,
+  serializeError: () => serializeError
+});
+module.exports = __toCommonJS(error_exports);
+function serializeError(error) {
+  return { name: error.name, message: error.message, stack: error.stack };
 }
-export function deserializeError(data) {
-    const error = new Error(data.message);
-    error.name = data.name;
-    error.stack = data.stack;
-    return error;
+function deserializeError(data) {
+  const error = new Error(data.message);
+  error.name = data.name;
+  error.stack = data.stack;
+  return error;
 }
-//# sourceMappingURL=error.js.map

package/serializer/handlers/index.js

@@ -1,8 +1,24 @@
-export * from './binary.js';
-export * from './date.js';
-export * from './error.js';
-export * from './map.js';
-export * from './regex.js';
-export * from './register.js';
-export * from './set.js';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handlers_exports = {};
+module.exports = __toCommonJS(handlers_exports);
+__reExport(handlers_exports, require("./binary.js"), module.exports);
+__reExport(handlers_exports, require("./date.js"), module.exports);
+__reExport(handlers_exports, require("./error.js"), module.exports);
+__reExport(handlers_exports, require("./map.js"), module.exports);
+__reExport(handlers_exports, require("./regex.js"), module.exports);
+__reExport(handlers_exports, require("./register.js"), module.exports);
+__reExport(handlers_exports, require("./set.js"), module.exports);

package/serializer/handlers/map.js

@@ -1,20 +1,43 @@
-export function serializeMap(map) {
-    return [...map.entries()];
+"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 map_exports = {};
+__export(map_exports, {
+  deserializeMap: () => deserializeMap,
+  serializeMap: () => serializeMap
+});
+module.exports = __toCommonJS(map_exports);
+function serializeMap(map) {
+  return [...map.entries()];
 }
-export function deserializeMap(data, tryDereference) {
-    const map = new Map();
-    for (let [key, value] of data) {
-        const hasKey = tryDereference(key, (dereferenced) => {
-            key = dereferenced;
-            if (!hasValue) { // eslint-disable-line @typescript-eslint/no-use-before-define
-                map.set(key, value);
-            }
-        });
-        const hasValue = tryDereference(value, (dereferenced) => map.set(key, dereferenced));
-        if (!hasKey && !hasValue) {
-            map.set(key, value);
-        }
+function deserializeMap(data, tryDereference) {
+  const map = /* @__PURE__ */ new Map();
+  for (let [key, value] of data) {
+    const hasKey = tryDereference(key, (dereferenced) => {
+      key = dereferenced;
+      if (!hasValue) {
+        map.set(key, value);
+      }
+    });
+    const hasValue = tryDereference(value, (dereferenced) => map.set(key, dereferenced));
+    if (!hasKey && !hasValue) {
+      map.set(key, value);
     }
-    return map;
+  }
+  return map;
 }
-//# sourceMappingURL=map.js.map