xml-model 1.3.1 → 1.3.3

package/dist/model/registry.js

@@ -1,22 +1,15 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const Models = /* @__PURE__ */ new Map();
 function registrerModel(model) {
   return Models.set(model.type, model);
 }
-__name(registrerModel, "registrerModel");
 function findModel(id) {
   return Models.get(id);
 }
-__name(findModel, "findModel");
 function getModel(id) {
   const model = findModel(id);
-  if (model)
-    return model;
-  else
-    throw new TypeError(`couldn't find model for type ${id.name}`);
+  if (model) return model;
+  else throw new TypeError(`couldn't find model for type ${id.name}`);
 }
-__name(getModel, "getModel");
 export {
   Models,
   findModel,

package/dist/model/types.d.ts

@@ -2,57 +2,86 @@ import { ReflectedProperty } from 'typescript-rtti';
 import { XMLRoot, XMLElement } from '../types';
 import { Middleware } from '../middleware';
 import { XMLModel } from './index';
+/** The name of a property on type `T` (string keys only). */
 export type XMLModelProperty<T> = Extract<keyof T, string>;
+/** A partial record mapping property names to their runtime values. */
 export type PropertiesRecord<T> = {
     [key in keyof T]?: T[key];
 };
+/** A partial record mapping property names to their XML representations. */
 export type XMLPropertiesRecord<T> = {
     [key in keyof T]?: XMLRoot;
 };
+/** Context passed to a property's `toXML` conversion function. */
 export interface PropertyToXMLContext<T> extends Omit<toXMLContext<T>, "properties"> {
     property: XMLModelPropertyOptions<T>;
     value: T[keyof T];
 }
+/** Context passed to a property's `fromXML` conversion function. */
 export interface PropertyFromXMLContext<T> extends Omit<fromXMLContext<T>, "properties"> {
     property: XMLModelPropertyOptions<T>;
+    /** The XML elements resolved as source data for this property. */
     elements: XMLElement[];
 }
+/** Fully resolved runtime options for a single model property. */
 export interface XMLModelPropertyOptions<T> {
     name: keyof T;
     reflected: ReflectedProperty;
+    /** XML tag name used for this property. Derived from the property name in kebab-case by default. */
     tagname: string;
     ignored: boolean;
+    /** When `true`, array items are serialised/deserialised directly into the parent element without a wrapper tag. */
     inline: boolean;
+    /** Override model used to convert this property's value. */
     model?: XMLModel<any>;
+    /** Returns `true` when the given element should be considered a source for this property. */
     isSourceElement: (element: XMLElement, context: Omit<PropertyFromXMLContext<T>, "elements">) => boolean;
+    /** Collects the XML elements that will be passed to `fromXML` for this property. */
     resolveElements: (context: Omit<PropertyFromXMLContext<T>, "elements">) => XMLElement[];
     fromXML: (context: PropertyFromXMLContext<T>) => T[keyof T];
     toXML: (context: PropertyToXMLContext<T>) => XMLRoot;
 }
+/** User-facing options accepted by the `@Prop()` decorator and `createModel`. */
 export interface CreateXMLModelPropertyOptions<T> {
+    /** Override the XML tag name for this property. */
     tagname?: string;
+    /**
+     * Controls which XML elements are treated as the source for this property.
+     * - `string`: exact tag name match
+     * - `RegExp`: tag name pattern match
+     * - `function`: custom predicate
+     */
     sourceElements?: string | RegExp | XMLModelPropertyOptions<T>["isSourceElement"];
+    /** Custom element resolver; overrides the default source-element resolution logic. */
     resolveElements?: XMLModelPropertyOptions<T>["resolveElements"];
     toXML?: XMLModelPropertyOptions<T>["toXML"];
     fromXML?: XMLModelPropertyOptions<T>["fromXML"];
+    /** When `true`, array items are inlined directly into the parent element. */
     inline?: boolean;
+    /** When `true`, the property is excluded from XML conversion entirely. */
     ignore?: boolean;
+    /** Explicit model to use for this property's value. */
     model?: XMLModelPropertyOptions<T>["model"];
 }
 interface ConversionOptions<C, T> {
     parent: ConversionOptions<C, T> | null;
     middlewares: Middleware<C, T>[];
 }
+/** Context passed to the model-level `fromXML` middleware chain. */
 export interface fromXMLContext<T> {
     xml: XMLRoot;
+    /** Lazily computed property values derived from `xml`. */
     properties: PropertiesRecord<T>;
     model: XMLModel<T>;
 }
+/** Context passed to the model-level `toXML` middleware chain. */
 export interface toXMLContext<T> {
     object: T;
+    /** Lazily computed per-property XML fragments. */
     properties: XMLPropertiesRecord<T>;
     model: XMLModel<T>;
 }
+/** Internal fully-resolved model options (not the user-facing create options). */
 export interface XMLModelOptions<T> {
     parent?: XMLModel<T>;
     properties: {
@@ -62,12 +91,18 @@ export interface XMLModelOptions<T> {
     };
     fromXML: ConversionOptions<fromXMLContext<T>, T>;
     toXML: ConversionOptions<toXMLContext<T>, XMLRoot>;
+    /** XML tag name for the root element of this model. */
     tagname: string;
 }
+/** User-facing options for `createModel` / `@Model()`. */
 export interface CreateXMLModelOptions<T> {
+    /** Explicitly set the parent model (otherwise inferred from the prototype chain). */
     parent?: XMLModelOptions<T>["parent"];
+    /** Middleware that converts XML into an instance of `T`. Required unless a parent model provides one. */
     fromXML?: XMLModelOptions<T>["fromXML"]["middlewares"][number];
+    /** Middleware that converts an instance of `T` into XML. Optional — a default implementation is provided. */
     toXML?: XMLModelOptions<T>["toXML"]["middlewares"][number];
+    /** Override the root XML tag name. Defaults to the class name in kebab-case. */
     tagname?: XMLModelOptions<T>["tagname"];
 }
 export { XMLModel };

package/dist/node_modules/reflect-metadata/Reflect.js

@@ -1,18 +1,16 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { commonjsGlobal } from "../../_virtual/_commonjsHelpers.js";
 import { __exports as _Reflect } from "../../_virtual/Reflect2.js";
 var hasRequired_Reflect;
 function require_Reflect() {
   if (hasRequired_Reflect) return _Reflect;
   hasRequired_Reflect = 1;
-  var Reflect2;
-  (function(Reflect3) {
+  var Reflect;
+  (function(Reflect2) {
     (function(factory) {
       var root = typeof commonjsGlobal === "object" ? commonjsGlobal : typeof self === "object" ? self : typeof this === "object" ? this : Function("return this;")();
-      var exporter = makeExporter(Reflect3);
+      var exporter = makeExporter(Reflect2);
       if (typeof root.Reflect === "undefined") {
-        root.Reflect = Reflect3;
+        root.Reflect = Reflect2;
       } else {
         exporter = makeExporter(root.Reflect, exporter);
       }
@@ -26,7 +24,6 @@ function require_Reflect() {
             previous(key, value);
         };
       }
-      __name(makeExporter, "makeExporter");
     })(function(exporter) {
       var hasOwn = Object.prototype.hasOwnProperty;
       var supportsSymbol = typeof Symbol === "function";
@@ -81,7 +78,6 @@ function require_Reflect() {
           return DecorateConstructor(decorators, target);
         }
       }
-      __name(decorate, "decorate");
       exporter("decorate", decorate);
       function metadata(metadataKey, metadataValue) {
         function decorator(target, propertyKey) {
@@ -91,10 +87,8 @@ function require_Reflect() {
             throw new TypeError();
           OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
         }
-        __name(decorator, "decorator");
         return decorator;
       }
-      __name(metadata, "metadata");
       exporter("metadata", metadata);
       function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
         if (!IsObject(target))
@@ -103,7 +97,6 @@ function require_Reflect() {
           propertyKey = ToPropertyKey(propertyKey);
         return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
       }
-      __name(defineMetadata, "defineMetadata");
       exporter("defineMetadata", defineMetadata);
       function hasMetadata(metadataKey, target, propertyKey) {
         if (!IsObject(target))
@@ -112,7 +105,6 @@ function require_Reflect() {
           propertyKey = ToPropertyKey(propertyKey);
         return OrdinaryHasMetadata(metadataKey, target, propertyKey);
       }
-      __name(hasMetadata, "hasMetadata");
       exporter("hasMetadata", hasMetadata);
       function hasOwnMetadata(metadataKey, target, propertyKey) {
         if (!IsObject(target))
@@ -121,7 +113,6 @@ function require_Reflect() {
           propertyKey = ToPropertyKey(propertyKey);
         return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
       }
-      __name(hasOwnMetadata, "hasOwnMetadata");
       exporter("hasOwnMetadata", hasOwnMetadata);
       function getMetadata(metadataKey, target, propertyKey) {
         if (!IsObject(target))
@@ -130,7 +121,6 @@ function require_Reflect() {
           propertyKey = ToPropertyKey(propertyKey);
         return OrdinaryGetMetadata(metadataKey, target, propertyKey);
       }
-      __name(getMetadata, "getMetadata");
       exporter("getMetadata", getMetadata);
       function getOwnMetadata(metadataKey, target, propertyKey) {
         if (!IsObject(target))
@@ -139,7 +129,6 @@ function require_Reflect() {
           propertyKey = ToPropertyKey(propertyKey);
         return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
       }
-      __name(getOwnMetadata, "getOwnMetadata");
       exporter("getOwnMetadata", getOwnMetadata);
       function getMetadataKeys(target, propertyKey) {
         if (!IsObject(target))
@@ -148,7 +137,6 @@ function require_Reflect() {
           propertyKey = ToPropertyKey(propertyKey);
         return OrdinaryMetadataKeys(target, propertyKey);
       }
-      __name(getMetadataKeys, "getMetadataKeys");
       exporter("getMetadataKeys", getMetadataKeys);
       function getOwnMetadataKeys(target, propertyKey) {
         if (!IsObject(target))
@@ -157,7 +145,6 @@ function require_Reflect() {
           propertyKey = ToPropertyKey(propertyKey);
         return OrdinaryOwnMetadataKeys(target, propertyKey);
       }
-      __name(getOwnMetadataKeys, "getOwnMetadataKeys");
       exporter("getOwnMetadataKeys", getOwnMetadataKeys);
       function deleteMetadata(metadataKey, target, propertyKey) {
         if (!IsObject(target))
@@ -183,7 +170,6 @@ function require_Reflect() {
         Metadata.delete(target);
         return true;
       }
-      __name(deleteMetadata, "deleteMetadata");
       exporter("deleteMetadata", deleteMetadata);
       function DecorateConstructor(decorators, target) {
         for (var i = decorators.length - 1; i >= 0; --i) {
@@ -197,7 +183,6 @@ function require_Reflect() {
         }
         return target;
       }
-      __name(DecorateConstructor, "DecorateConstructor");
       function DecorateProperty(decorators, target, propertyKey, descriptor) {
         for (var i = decorators.length - 1; i >= 0; --i) {
           var decorator = decorators[i];
@@ -210,7 +195,6 @@ function require_Reflect() {
         }
         return descriptor;
       }
-      __name(DecorateProperty, "DecorateProperty");
       function GetOrCreateMetadataMap(O, P, Create) {
         var targetMetadata = Metadata.get(O);
         if (IsUndefined(targetMetadata)) {
@@ -228,7 +212,6 @@ function require_Reflect() {
         }
         return metadataMap;
       }
-      __name(GetOrCreateMetadataMap, "GetOrCreateMetadataMap");
       function OrdinaryHasMetadata(MetadataKey, O, P) {
         var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
         if (hasOwn2)
@@ -238,7 +221,6 @@ function require_Reflect() {
           return OrdinaryHasMetadata(MetadataKey, parent, P);
         return false;
       }
-      __name(OrdinaryHasMetadata, "OrdinaryHasMetadata");
       function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
         var metadataMap = GetOrCreateMetadataMap(
           O,
@@ -250,7 +232,6 @@ function require_Reflect() {
           return false;
         return ToBoolean(metadataMap.has(MetadataKey));
       }
-      __name(OrdinaryHasOwnMetadata, "OrdinaryHasOwnMetadata");
       function OrdinaryGetMetadata(MetadataKey, O, P) {
         var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
         if (hasOwn2)
@@ -260,7 +241,6 @@ function require_Reflect() {
           return OrdinaryGetMetadata(MetadataKey, parent, P);
         return void 0;
       }
-      __name(OrdinaryGetMetadata, "OrdinaryGetMetadata");
       function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
         var metadataMap = GetOrCreateMetadataMap(
           O,
@@ -272,7 +252,6 @@ function require_Reflect() {
           return void 0;
         return metadataMap.get(MetadataKey);
       }
-      __name(OrdinaryGetOwnMetadata, "OrdinaryGetOwnMetadata");
       function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
         var metadataMap = GetOrCreateMetadataMap(
           O,
@@ -282,7 +261,6 @@ function require_Reflect() {
         );
         metadataMap.set(MetadataKey, MetadataValue);
       }
-      __name(OrdinaryDefineOwnMetadata, "OrdinaryDefineOwnMetadata");
       function OrdinaryMetadataKeys(O, P) {
         var ownKeys = OrdinaryOwnMetadataKeys(O, P);
         var parent = OrdinaryGetPrototypeOf(O);
@@ -313,7 +291,6 @@ function require_Reflect() {
         }
         return keys;
       }
-      __name(OrdinaryMetadataKeys, "OrdinaryMetadataKeys");
       function OrdinaryOwnMetadataKeys(O, P) {
         var keys = [];
         var metadataMap = GetOrCreateMetadataMap(
@@ -346,7 +323,6 @@ function require_Reflect() {
           k++;
         }
       }
-      __name(OrdinaryOwnMetadataKeys, "OrdinaryOwnMetadataKeys");
       function Type(x) {
         if (x === null)
           return 1;
@@ -367,23 +343,18 @@ function require_Reflect() {
             return 6;
         }
       }
-      __name(Type, "Type");
       function IsUndefined(x) {
         return x === void 0;
       }
-      __name(IsUndefined, "IsUndefined");
       function IsNull(x) {
         return x === null;
       }
-      __name(IsNull, "IsNull");
       function IsSymbol(x) {
         return typeof x === "symbol";
       }
-      __name(IsSymbol, "IsSymbol");
       function IsObject(x) {
         return typeof x === "object" ? x !== null : typeof x === "function";
       }
-      __name(IsObject, "IsObject");
       function ToPrimitive(input, PreferredType) {
         switch (Type(input)) {
           case 0:
@@ -409,7 +380,6 @@ function require_Reflect() {
         }
         return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
       }
-      __name(ToPrimitive, "ToPrimitive");
       function OrdinaryToPrimitive(O, hint) {
         if (hint === "string") {
           var toString_1 = O.toString;
@@ -440,15 +410,12 @@ function require_Reflect() {
         }
         throw new TypeError();
       }
-      __name(OrdinaryToPrimitive, "OrdinaryToPrimitive");
       function ToBoolean(argument) {
         return !!argument;
       }
-      __name(ToBoolean, "ToBoolean");
       function ToString(argument) {
         return "" + argument;
       }
-      __name(ToString, "ToString");
       function ToPropertyKey(argument) {
         var key = ToPrimitive(
           argument,
@@ -459,19 +426,15 @@ function require_Reflect() {
           return key;
         return ToString(key);
       }
-      __name(ToPropertyKey, "ToPropertyKey");
       function IsArray(argument) {
         return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
       }
-      __name(IsArray, "IsArray");
       function IsCallable(argument) {
         return typeof argument === "function";
       }
-      __name(IsCallable, "IsCallable");
       function IsConstructor(argument) {
         return typeof argument === "function";
       }
-      __name(IsConstructor, "IsConstructor");
       function IsPropertyKey(argument) {
         switch (Type(argument)) {
           case 3:
@@ -482,7 +445,6 @@ function require_Reflect() {
             return false;
         }
       }
-      __name(IsPropertyKey, "IsPropertyKey");
       function GetMethod(V, P) {
         var func = V[P];
         if (func === void 0 || func === null)
@@ -491,7 +453,6 @@ function require_Reflect() {
           throw new TypeError();
         return func;
       }
-      __name(GetMethod, "GetMethod");
       function GetIterator(obj) {
         var method = GetMethod(obj, iteratorSymbol);
         if (!IsCallable(method))
@@ -501,22 +462,18 @@ function require_Reflect() {
           throw new TypeError();
         return iterator;
       }
-      __name(GetIterator, "GetIterator");
       function IteratorValue(iterResult) {
         return iterResult.value;
       }
-      __name(IteratorValue, "IteratorValue");
       function IteratorStep(iterator) {
         var result = iterator.next();
         return result.done ? false : result;
       }
-      __name(IteratorStep, "IteratorStep");
       function IteratorClose(iterator) {
         var f = iterator["return"];
         if (f)
           f.call(iterator);
       }
-      __name(IteratorClose, "IteratorClose");
       function OrdinaryGetPrototypeOf(O) {
         var proto = Object.getPrototypeOf(O);
         if (typeof O !== "function" || O === functionPrototype)
@@ -534,7 +491,6 @@ function require_Reflect() {
           return proto;
         return constructor;
       }
-      __name(OrdinaryGetPrototypeOf, "OrdinaryGetPrototypeOf");
       function CreateMapPolyfill() {
         var cacheSentinel = {};
         var arraySentinel = [];
@@ -547,7 +503,6 @@ function require_Reflect() {
               this._values = values;
               this._selector = selector;
             }
-            __name(MapIterator2, "MapIterator");
             MapIterator2.prototype["@@iterator"] = function() {
               return this;
             };
@@ -597,11 +552,10 @@ function require_Reflect() {
               this._cacheKey = cacheSentinel;
               this._cacheIndex = -2;
             }
-            __name(Map2, "Map");
             Object.defineProperty(Map2.prototype, "size", {
-              get: /* @__PURE__ */ __name(function() {
+              get: function() {
                 return this._keys.length;
-              }, "get"),
+              },
               enumerable: true,
               configurable: true
             });
@@ -689,17 +643,13 @@ function require_Reflect() {
         function getKey(key, _) {
           return key;
         }
-        __name(getKey, "getKey");
         function getValue(_, value) {
           return value;
         }
-        __name(getValue, "getValue");
         function getEntry(key, value) {
           return [key, value];
         }
-        __name(getEntry, "getEntry");
       }
-      __name(CreateMapPolyfill, "CreateMapPolyfill");
       function CreateSetPolyfill() {
         return (
           /** @class */
@@ -707,11 +657,10 @@ function require_Reflect() {
             function Set2() {
               this._map = new _Map();
             }
-            __name(Set2, "Set");
             Object.defineProperty(Set2.prototype, "size", {
-              get: /* @__PURE__ */ __name(function() {
+              get: function() {
                 return this._map.size;
-              }, "get"),
+              },
               enumerable: true,
               configurable: true
             });
@@ -746,7 +695,6 @@ function require_Reflect() {
           })()
         );
       }
-      __name(CreateSetPolyfill, "CreateSetPolyfill");
       function CreateWeakMapPolyfill() {
         var UUID_SIZE = 16;
         var keys = HashMap.create();
@@ -757,7 +705,6 @@ function require_Reflect() {
             function WeakMap2() {
               this._key = CreateUniqueKey();
             }
-            __name(WeakMap2, "WeakMap");
             WeakMap2.prototype.has = function(target) {
               var table = GetOrCreateWeakMapTable(
                 target,
@@ -805,7 +752,6 @@ function require_Reflect() {
           keys[key] = true;
           return key;
         }
-        __name(CreateUniqueKey, "CreateUniqueKey");
         function GetOrCreateWeakMapTable(target, create) {
           if (!hasOwn.call(target, rootKey)) {
             if (!create)
@@ -814,13 +760,11 @@ function require_Reflect() {
           }
           return target[rootKey];
         }
-        __name(GetOrCreateWeakMapTable, "GetOrCreateWeakMapTable");
         function FillRandomBytes(buffer, size) {
           for (var i = 0; i < size; ++i)
             buffer[i] = Math.random() * 255 | 0;
           return buffer;
         }
-        __name(FillRandomBytes, "FillRandomBytes");
         function GenRandomBytes(size) {
           if (typeof Uint8Array === "function") {
             if (typeof crypto !== "undefined")
@@ -831,7 +775,6 @@ function require_Reflect() {
           }
           return FillRandomBytes(new Array(size), size);
         }
-        __name(GenRandomBytes, "GenRandomBytes");
         function CreateUUID() {
           var data = GenRandomBytes(UUID_SIZE);
           data[6] = data[6] & 79 | 64;
@@ -847,20 +790,16 @@ function require_Reflect() {
           }
           return result;
         }
-        __name(CreateUUID, "CreateUUID");
       }
-      __name(CreateWeakMapPolyfill, "CreateWeakMapPolyfill");
       function MakeDictionary(obj) {
         obj.__ = void 0;
         delete obj.__;
         return obj;
       }
-      __name(MakeDictionary, "MakeDictionary");
     });
-  })(Reflect2 || (Reflect2 = {}));
+  })(Reflect || (Reflect = {}));
   return _Reflect;
 }
-__name(require_Reflect, "require_Reflect");
 export {
   require_Reflect as __require
 };

package/dist/types.d.ts

@@ -1,9 +1,16 @@
 export type { Constructor } from 'typescript-rtti';
+/** A record with unknown values, keyed by string, number, or symbol. */
 export type UnknownRecord = Record<string | number | symbol, unknown>;
+/** Any object type. Used instead of `UnknownRecord` because it is compatible with class instances. */
 export type UnknownObject = object;
+/** Key-value map of XML attributes. Values may be strings, numbers, or absent. */
 export interface XMLAttributes {
     [key: string]: string | number | undefined;
 }
+/**
+ * A single node in the xml-js element tree.
+ * Used as the internal representation for all XML parsing and serialisation.
+ */
 export interface XMLElement {
     type?: string;
     name?: string;
@@ -11,6 +18,7 @@ export interface XMLElement {
     elements?: Array<XMLElement>;
     text?: string | number | boolean;
 }
+/** The root of an xml-js document: a wrapper object whose `elements` array holds top-level nodes. */
 export type XMLRoot = {
     elements: XMLElement[];
 };

package/dist/util/is-regexp.js

@@ -1,9 +1,6 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function isRegExp(value) {
   return Object.prototype.toString.call(value) === "[object RegExp]";
 }
-__name(isRegExp, "isRegExp");
 export {
   isRegExp as default,
   isRegExp

package/dist/util/kebab-case.js

@@ -1,5 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const KEBAB_REGEX = new RegExp("\\p{Lu}", "gu");
 function kebabCase(str, keepLeadingDash = false) {
   const result = str.replace(KEBAB_REGEX, (match) => `-${match.toLowerCase()}`);
@@ -11,7 +9,6 @@ function kebabCase(str, keepLeadingDash = false) {
   }
   return result;
 }
-__name(kebabCase, "kebabCase");
 export {
   kebabCase
 };

package/dist/util/merge-maps.js

@@ -1,5 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function mergeMaps(...sources) {
   const res = /* @__PURE__ */ new Map();
   sources.forEach((source) => {
@@ -10,8 +8,7 @@ function mergeMaps(...sources) {
       const entries = Array.from(res.entries());
       entries.forEach((entry) => {
         const key = entry[0];
-        if (overrides.has(key))
-          entry[1] = overrides.get(key);
+        if (overrides.has(key)) entry[1] = overrides.get(key);
       });
       res.clear();
       entries.forEach(([key, val]) => res.set(key, val));
@@ -20,7 +17,6 @@ function mergeMaps(...sources) {
   });
   return res;
 }
-__name(mergeMaps, "mergeMaps");
 export {
   mergeMaps as default
 };