xml-model 1.3.1 → 1.3.3

package/dist/_virtual/_commonjsHelpers.js

@@ -1,23 +1,18 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
-__name(getDefaultExportFromCjs, "getDefaultExportFromCjs");
 function getDefaultExportFromNamespaceIfPresent(n) {
   return n && Object.prototype.hasOwnProperty.call(n, "default") ? n["default"] : n;
 }
-__name(getDefaultExportFromNamespaceIfPresent, "getDefaultExportFromNamespaceIfPresent");
 function getDefaultExportFromNamespaceIfNotNamed(n) {
   return n && Object.prototype.hasOwnProperty.call(n, "default") && Object.keys(n).length === 1 ? n["default"] : n;
 }
-__name(getDefaultExportFromNamespaceIfNotNamed, "getDefaultExportFromNamespaceIfNotNamed");
 function getAugmentedNamespace(n) {
   if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
   var f = n.default;
   if (typeof f == "function") {
-    var a = /* @__PURE__ */ __name(function a2() {
+    var a = function a2() {
       var isInstance = false;
       try {
         isInstance = this instanceof a2;
@@ -27,7 +22,7 @@ function getAugmentedNamespace(n) {
         return Reflect.construct(f, arguments, this.constructor);
       }
       return f.apply(this, arguments);
-    }, "a");
+    };
     a.prototype = f.prototype;
   } else a = {};
   Object.defineProperty(a, "__esModule", { value: true });
@@ -35,14 +30,13 @@ function getAugmentedNamespace(n) {
     var d = Object.getOwnPropertyDescriptor(n, k);
     Object.defineProperty(a, k, d.get ? d : {
       enumerable: true,
-      get: /* @__PURE__ */ __name(function() {
+      get: function() {
         return n[k];
-      }, "get")
+      }
     });
   });
   return a;
 }
-__name(getAugmentedNamespace, "getAugmentedNamespace");
 export {
   commonjsGlobal,
   getAugmentedNamespace,

package/dist/defaults.d.ts

@@ -10,6 +10,19 @@ interface Defaults {
     tagnameFromProperty<T>(property: XMLModelPropertyOptions<T>): string;
     propertyToXML<T>(context: PropertyToXMLContext<T>): XMLRoot;
 }
+/**
+ * Global defaults used by all models and properties when no override is provided.
+ *
+ * You can mutate individual entries to change library-wide behaviour — for example,
+ * replace `defaults.fromXML` to provide a base deserialization strategy instead of
+ * having to specify `fromXML` on every `@Model()`.
+ *
+ * Key behaviours:
+ * - `fromXML` — throws by default; every root model **must** provide its own implementation.
+ * - `tagnameFromModel` / `tagnameFromProperty` — convert class/property names to kebab-case.
+ * - `propertyFromXML` — handles class, array, and union-of-literal property types via runtime reflection.
+ * - `propertyToXML` — serialises class, array, and union-of-literal values; respects `inline`.
+ */
 export declare const defaults: Defaults;
 export {};
 //# sourceMappingURL=defaults.d.ts.map

package/dist/defaults.js

@@ -1,18 +1,36 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { getModel } from "./model/registry.js";
 import { kebabCase } from "./util/kebab-case.js";
 const defaults = {
+  /**
+   * Default model-level `fromXML` handler.
+   * Always throws — models must supply their own `fromXML` or inherit one from a parent.
+   * @throws {TypeError}
+   */
   fromXML() {
-    throw new TypeError("you should define 'defaults.fromXML' yourself or provide a 'fromXML' function to @Model() decorator's options");
+    throw new TypeError(
+      "you should define 'defaults.fromXML' yourself or provide a 'fromXML' function to @Model() decorator's options"
+    );
   },
+  /**
+   * Collects the XML elements that are the source data for a property.
+   * Assumes `xml.elements[0]` is the wrapper element that contains all property tags.
+   */
   propertyResolveSourceElements(context) {
     const innerElements = context.xml.elements[0]?.elements || [];
     return innerElements.filter((el) => context.property.isSourceElement(el, context));
   },
+  /**
+   * Returns `true` when the element's tag name matches the property's tagname.
+   */
   propertySourceElementsFilter(element, context) {
     return context.property.tagname === element.name;
   },
+  /**
+   * Converts resolved XML elements into a typed property value.
+   * Handles class types, arrays of class types, and union-of-literal types.
+   * Returns `undefined` for optional properties with no matching elements,
+   * and also for unrecognised types.
+   */
   propertyFromXML(context) {
     const prop = context.property;
     const elements = context.elements;
@@ -54,7 +72,11 @@ const defaults = {
     }
     return void 0;
   },
-  /* Object -> XML */
+  /**
+   * Default model-level `toXML` handler.
+   * Collects serialised property fragments and wraps them in a root element
+   * named after the model's tagname.
+   */
   toXML({ properties, model }) {
     const elements = [];
     model.resolveAllProperties().forEach((prop) => {
@@ -76,12 +98,25 @@ const defaults = {
       ]
     };
   },
+  /**
+   * Derives the XML tag name for a model from its class name, converted to kebab-case.
+   * e.g. `MyClass` → `my-class`.
+   */
   tagnameFromModel(model) {
     return kebabCase(model.type.name);
   },
+  /**
+   * Derives the XML tag name for a property from its name, converted to kebab-case.
+   * e.g. `myProp` → `my-prop`.
+   */
   tagnameFromProperty(property) {
     return kebabCase(String(property.name));
   },
+  /**
+   * Converts a typed property value to an `XMLRoot` fragment.
+   * Handles class types, arrays of class types, and union-of-literal types.
+   * When the property has `inline: true`, array items are flattened into the parent element.
+   */
   propertyToXML(context) {
     const property = context.property;
     const type = property.reflected.type;
@@ -92,7 +127,7 @@ const defaults = {
     if (property.model) {
       return property.model.toXML(value);
     }
-    const getXML = /* @__PURE__ */ __name(() => {
+    const getXML = () => {
       if (type.is("class")) {
         const model = getModel(type.class);
         return model.toXML(value);
@@ -108,19 +143,20 @@ const defaults = {
         const firstType = type.types[0];
         if (firstType.is("literal")) {
           const firstTypeCtor = firstType.value.constructor;
-          if (type.types.every((type2) => type2.is("literal") && type2.value.constructor === firstTypeCtor)) {
+          if (type.types.every(
+            (type2) => type2.is("literal") && type2.value.constructor === firstTypeCtor
+          )) {
             const model = getModel(firstTypeCtor);
             return model.toXML(context.value);
           }
         }
       }
       return { elements: [] };
-    }, "getXML");
+    };
     const xml = getXML();
     if (context.property.inline)
       return { elements: xml.elements.map((el) => el.elements || []).flat() };
-    else
-      return xml;
+    else return xml;
   }
 };
 export {

package/dist/errors.d.ts

@@ -1,21 +1,37 @@
 import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext } from './model/types';
+/**
+ * Thrown when model-level XML → object conversion fails.
+ * Wraps the original error along with the conversion context.
+ */
 export declare class FromXMLConversionError<T> extends Error {
     context: Omit<fromXMLContext<T>, "properties">;
     error: unknown;
     name: string;
     constructor(context: Omit<fromXMLContext<T>, "properties">, error: unknown);
 }
+/**
+ * Thrown when a single property's XML → value conversion fails.
+ * Extends `FromXMLConversionError` with additional property context.
+ */
 export declare class PropertyFromXMLConversionError<T> extends FromXMLConversionError<T> {
     propertyContext: PropertyFromXMLContext<T>;
     name: string;
     constructor(context: Omit<fromXMLContext<T>, "properties">, propertyContext: PropertyFromXMLContext<T>, error: unknown);
 }
+/**
+ * Thrown when model-level object → XML conversion fails.
+ * Wraps the original cause along with the conversion context.
+ */
 export declare class ToXMLConversionError<T> extends Error {
     context: Omit<toXMLContext<T>, "properties">;
     cause: unknown;
     name: string;
     constructor(context: Omit<toXMLContext<T>, "properties">, cause: unknown);
 }
+/**
+ * Thrown when a single property's value → XML conversion fails.
+ * Extends `ToXMLConversionError` with additional property context.
+ */
 export declare class PropertyToXMLConversionError<T> extends ToXMLConversionError<T> {
     propertyContext: PropertyToXMLContext<T>;
     name: string;

package/dist/errors.js

@@ -1,6 +1,4 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const _FromXMLConversionError = class _FromXMLConversionError extends Error {
+class FromXMLConversionError extends Error {
   constructor(context, error) {
     const message = `[Model: ${context.model.type.name}] failed to convert from XML`;
     super(message);
@@ -8,20 +6,18 @@ const _FromXMLConversionError = class _FromXMLConversionError extends Error {
     this.error = error;
     this.name = "FromXMLConversionError";
   }
-};
-__name(_FromXMLConversionError, "FromXMLConversionError");
-let FromXMLConversionError = _FromXMLConversionError;
-const _PropertyFromXMLConversionError = class _PropertyFromXMLConversionError extends FromXMLConversionError {
+}
+class PropertyFromXMLConversionError extends FromXMLConversionError {
   constructor(context, propertyContext, error) {
     super(context, error);
     this.propertyContext = propertyContext;
     this.name = "PropertyFromXMLConversionError";
-    this.message = `[Model: ${context.model.type.name}] failed to convert prop <${String(propertyContext.property.name)}> from XML`;
+    this.message = `[Model: ${context.model.type.name}] failed to convert prop <${String(
+      propertyContext.property.name
+    )}> from XML`;
   }
-};
-__name(_PropertyFromXMLConversionError, "PropertyFromXMLConversionError");
-let PropertyFromXMLConversionError = _PropertyFromXMLConversionError;
-const _ToXMLConversionError = class _ToXMLConversionError extends Error {
+}
+class ToXMLConversionError extends Error {
   constructor(context, cause) {
     const message = `[Model: ${context.model.type.name}] failed to convert to XML`;
     super(message);
@@ -29,19 +25,17 @@ const _ToXMLConversionError = class _ToXMLConversionError extends Error {
     this.cause = cause;
     this.name = "ToXMLConversionError";
   }
-};
-__name(_ToXMLConversionError, "ToXMLConversionError");
-let ToXMLConversionError = _ToXMLConversionError;
-const _PropertyToXMLConversionError = class _PropertyToXMLConversionError extends ToXMLConversionError {
+}
+class PropertyToXMLConversionError extends ToXMLConversionError {
   constructor(context, propertyContext, cause) {
     super(context, cause);
     this.propertyContext = propertyContext;
     this.name = "PropertyToXMLConversionError";
-    this.message = `[Model: ${context.model.type.name}] failed to convert prop <${String(propertyContext.property.name)}> to XML`;
+    this.message = `[Model: ${context.model.type.name}] failed to convert prop <${String(
+      propertyContext.property.name
+    )}> to XML`;
   }
-};
-__name(_PropertyToXMLConversionError, "PropertyToXMLConversionError");
-let PropertyToXMLConversionError = _PropertyToXMLConversionError;
+}
 export {
   FromXMLConversionError,
   PropertyFromXMLConversionError,

package/dist/middleware.js

@@ -1,29 +1,23 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 function* MiddlewareChain(options) {
   do {
     for (let index = options.middlewares.length - 1; index >= 0; index--) {
       yield options.middlewares[index];
     }
-    if (options.parent)
-      options = options.parent;
-    else
-      return;
+    if (options.parent) options = options.parent;
+    else return;
   } while (true);
 }
-__name(MiddlewareChain, "MiddlewareChain");
 function resolve(middlewares, context) {
-  const next = /* @__PURE__ */ __name(() => {
+  const next = () => {
     const { value: nextMiddleware, done } = middlewares.next();
     if (done || !nextMiddleware) {
       throw new Error("no more next middleware");
     } else {
       return nextMiddleware(context, next);
     }
-  }, "next");
+  };
   return next();
 }
-__name(resolve, "resolve");
 export {
   MiddlewareChain,
   resolve

package/dist/model/built-ins.js

@@ -1,5 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { getContent, fromContent } from "../xml/index.js";
 function registerBuiltIns(create) {
   create(String, {
@@ -39,7 +37,6 @@ function registerBuiltIns(create) {
     }
   });
 }
-__name(registerBuiltIns, "registerBuiltIns");
 export {
   registerBuiltIns as default
 };

package/dist/model/index.d.ts

@@ -1,19 +1,67 @@
 import { Constructor } from 'typescript-rtti';
 import { XMLModelOptions, XMLModelPropertyOptions, CreateXMLModelOptions } from './types';
 import { XMLRoot } from '../types';
+/**
+ * Returns the parent `XMLModel` for the given model, walking the prototype chain
+ * if no explicit parent was set in options.
+ */
 export declare function getParentModel(model: XMLModel<any>): XMLModel<any>;
+/**
+ * Encapsulates the XML ↔ TypeScript conversion logic for a specific class.
+ *
+ * Create instances via `createModel` or the `@Model()` decorator rather than
+ * calling this constructor directly.
+ */
 export declare class XMLModel<T = any> {
     readonly type: Constructor<T>;
     options: XMLModelOptions<T>;
     constructor(type: Constructor<T>, options: CreateXMLModelOptions<T>);
+    /**
+     * Converts an XML document (string or parsed `XMLRoot`) into an instance of `T`.
+     *
+     * @param xml - Raw XML string or a pre-parsed `XMLRoot` object.
+     * @returns The converted instance produced by the model's `fromXML` middleware chain.
+     * @throws {FromXMLConversionError} When model-level conversion fails.
+     * @throws {PropertyFromXMLConversionError} When a property-level conversion fails.
+     */
     fromXML(xml: XMLRoot | string): T;
+    /**
+     * Converts an instance of `T` into an XML document.
+     *
+     * @param instance - An instance of the class this model was created for.
+     * @returns An `XMLRoot` representing the serialised object.
+     * @throws {TypeError} When `instance` is not an instance of the expected type.
+     * @throws {ToXMLConversionError} When model-level conversion fails.
+     * @throws {PropertyToXMLConversionError} When a property-level conversion fails.
+     */
     toXML(instance: unknown): XMLRoot;
+    /** The typescript-rtti reflection metadata for the model's class. */
     get reflectedClass(): import('typescript-rtti').ReflectedClass<Constructor<T>>;
+    /**
+     * Returns a merged map of all property options for this model, including inherited properties.
+     * Own properties override parent properties with the same name.
+     */
     resolveAllProperties(): Map<string, XMLModelPropertyOptions<any> & {
         model: any;
     }>;
 }
+/**
+ * Creates and registers a new `XMLModel` for the given constructor.
+ *
+ * @param type - The class constructor to create a model for.
+ * @param options - Model creation options including `fromXML` and `toXML` middlewares.
+ * @returns The newly created `XMLModel`.
+ * @throws {TypeError} When a model for this type has already been registered.
+ */
 export declare function createModel<T>(type: Constructor<T>, options: CreateXMLModelOptions<T>): XMLModel<T>;
+/**
+ * Decorator factory that registers an `XMLModel` for the decorated class.
+ *
+ * Provide at minimum a `fromXML` function unless the class inherits from a
+ * parent class that already has a model — the default `fromXML` throws.
+ *
+ * @param options - Optional model creation options.
+ */
 declare function ModelDecoratorFactory<T>(options?: CreateXMLModelOptions<T>): (constructor: Constructor<T>) => void;
 export { getModel } from './registry';
 export { ModelDecoratorFactory as Model };

package/dist/model/index.js

@@ -1,5 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import "../_virtual/Reflect.js";
 import { reflect } from "typescript-rtti";
 import { ToXMLConversionError, PropertyToXMLConversionError, FromXMLConversionError, PropertyFromXMLConversionError } from "../errors.js";
@@ -27,10 +25,8 @@ function* ParentChain(constructor) {
   }
   return;
 }
-__name(ParentChain, "ParentChain");
 function getParentModel(model) {
-  if (model.options.parent)
-    return model.options.parent;
+  if (model.options.parent) return model.options.parent;
   for (const constructor of ParentChain(model.type)) {
     const model2 = findModel(constructor);
     if (model2) {
@@ -39,17 +35,15 @@ function getParentModel(model) {
   }
   return null;
 }
-__name(getParentModel, "getParentModel");
-const _XMLModel = class _XMLModel {
+class XMLModel {
   constructor(type, options) {
     this.type = type;
     const model = this;
     let parent = void 0;
-    const getParent = /* @__PURE__ */ __name(() => {
-      if (typeof parent === "undefined")
-        parent = getParentModel(this);
+    const getParent = () => {
+      if (typeof parent === "undefined") parent = getParentModel(this);
       return parent;
-    }, "getParent");
+    };
     let propertiesLoaded = false;
     const properties = {
       options: /* @__PURE__ */ new Map(),
@@ -116,20 +110,30 @@ const _XMLModel = class _XMLModel {
         ]
       }
     };
-    const loadProperties = /* @__PURE__ */ __name(() => {
-      const props = this.reflectedClass.ownProperties.filter((prop) => typeof prop.host.constructor.prototype[prop.name] !== "function");
+    const loadProperties = () => {
+      const props = this.reflectedClass.ownProperties.filter(
+        (prop) => typeof prop.host.constructor.prototype[prop.name] !== "function"
+      );
       props.forEach((property) => {
-        const options2 = getPropertyConversionOptions(this.type, property.name);
+        const options2 = getPropertyConversionOptions(
+          this.type,
+          property.name
+        );
         if (!options2.ignored) {
+          const type2 = options2.reflected?.type;
+          if (!options2.model && type2?.is("class") && type2.class === Object) {
+            console.warn(
+              `[xml-model] Property '${String(property.name)}' on '${this.type.name}' has type Object at runtime. If its declared type is a class, make sure it is imported as a value and not with 'import type'.`
+            );
+          }
           properties.options.set(property.name, options2);
         }
       });
       propertiesLoaded = true;
-    }, "loadProperties");
+    };
     this.options = {
       get properties() {
-        if (!propertiesLoaded)
-          loadProperties();
+        if (!propertiesLoaded) loadProperties();
         return properties;
       },
       fromXML: {
@@ -148,17 +152,22 @@ const _XMLModel = class _XMLModel {
         return options.tagname || defaults.tagnameFromModel(model);
       }
     };
-    if (options.parent)
-      this.options.parent = options.parent;
+    if (options.parent) this.options.parent = options.parent;
     if (!getParent()) {
       this.options.fromXML.middlewares.push((ctx) => defaults.fromXML(ctx));
       this.options.toXML.middlewares.push((ctx) => defaults.toXML(ctx));
     }
-    if (options.fromXML)
-      this.options.fromXML.middlewares.push(options.fromXML);
-    if (options.toXML)
-      this.options.toXML.middlewares.push(options.toXML);
+    if (options.fromXML) this.options.fromXML.middlewares.push(options.fromXML);
+    if (options.toXML) this.options.toXML.middlewares.push(options.toXML);
   }
+  /**
+   * Converts an XML document (string or parsed `XMLRoot`) into an instance of `T`.
+   *
+   * @param xml - Raw XML string or a pre-parsed `XMLRoot` object.
+   * @returns The converted instance produced by the model's `fromXML` middleware chain.
+   * @throws {FromXMLConversionError} When model-level conversion fails.
+   * @throws {PropertyFromXMLConversionError} When a property-level conversion fails.
+   */
   fromXML(xml) {
     const _xml = typeof xml === "string" ? XML.parse(xml) : xml;
     const model = this;
@@ -175,6 +184,15 @@ const _XMLModel = class _XMLModel {
     };
     return resolve(MiddlewareChain(this.options.fromXML), context);
   }
+  /**
+   * Converts an instance of `T` into an XML document.
+   *
+   * @param instance - An instance of the class this model was created for.
+   * @returns An `XMLRoot` representing the serialised object.
+   * @throws {TypeError} When `instance` is not an instance of the expected type.
+   * @throws {ToXMLConversionError} When model-level conversion fails.
+   * @throws {PropertyToXMLConversionError} When a property-level conversion fails.
+   */
   toXML(instance) {
     const model = this;
     if (instance instanceof this.type || typeof instance !== "undefined" && instance.constructor === this.type) {
@@ -194,28 +212,33 @@ const _XMLModel = class _XMLModel {
       throw new TypeError(`provided object is not an instance of ${this.type.name}`);
     }
   }
+  /** The typescript-rtti reflection metadata for the model's class. */
   get reflectedClass() {
     return reflect(this.type);
   }
+  /**
+   * Returns a merged map of all property options for this model, including inherited properties.
+   * Own properties override parent properties with the same name.
+   */
   resolveAllProperties() {
     const ownProperties = /* @__PURE__ */ new Map();
     const parent = getParentModel(this);
     this.options.properties.options.forEach((options, key) => {
-      ownProperties.set(key, new Proxy(options, {
-        get: /* @__PURE__ */ __name((target, p, reciever) => {
-          if (p === "model")
-            return this;
-          else
-            return Reflect.get(target, p, reciever);
-        }, "get")
-      }));
+      ownProperties.set(
+        key,
+        new Proxy(options, {
+          get: (target, p, reciever) => {
+            if (p === "model") return this;
+            else return Reflect.get(target, p, reciever);
+          }
+        })
+        // FIXME: is typing ok ?
+      );
     });
     const res = parent ? mergeMaps(parent.resolveAllProperties(), ownProperties) : ownProperties;
     return res;
   }
-};
-__name(_XMLModel, "XMLModel");
-let XMLModel = _XMLModel;
+}
 function createModel(type, options) {
   if (findModel(type)) {
     throw new TypeError(`a model for type ${type.name} already exists`);
@@ -224,14 +247,11 @@ function createModel(type, options) {
   registrerModel(model);
   return model;
 }
-__name(createModel, "createModel");
 function ModelDecoratorFactory(options) {
   return function(constructor) {
-    if (!findModel(constructor))
-      createModel(constructor, options || {});
+    if (!findModel(constructor)) createModel(constructor, options || {});
   };
 }
-__name(ModelDecoratorFactory, "ModelDecoratorFactory");
 registerBuiltIns(createModel);
 export {
   ModelDecoratorFactory as Model,

package/dist/model/property.d.ts

@@ -1,6 +1,18 @@
 import { Constructor } from 'typescript-rtti';
 import { XMLModelProperty, XMLModelPropertyOptions, CreateXMLModelPropertyOptions } from './types';
+/**
+ * Returns the resolved conversion options for a property, using stored `@Prop()` options
+ * if available, or falling back to defaults derived from the property's type information.
+ */
 export declare function getPropertyConversionOptions<T>(constructor: Constructor<T>, property: XMLModelProperty<T>): XMLModelPropertyOptions<T>;
+/**
+ * Decorator factory that customises how a class property is converted to and from XML.
+ *
+ * Applied to properties of classes decorated with `@Model()`. All options are optional —
+ * omitting `@Prop()` entirely uses the defaults inferred from the property's TypeScript type.
+ *
+ * @param options - Property conversion options.
+ */
 declare function PropDecoratorFactory<T = any>(options?: CreateXMLModelPropertyOptions<T>): (prototype: any, property: XMLModelProperty<T>) => void;
 export { PropDecoratorFactory as Prop };
 //# sourceMappingURL=property.d.ts.map

package/dist/model/property.js

@@ -1,5 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { reflect } from "typescript-rtti";
 import { defaults } from "../defaults.js";
 import isRegExp from "../util/is-regexp.js";
@@ -15,13 +13,12 @@ function resolvePropertyConversionOptions(options, constructor, property) {
     },
     inline: !!options.inline,
     ignored: !!options.ignore,
-    isSourceElement: /* @__PURE__ */ __name((...args) => defaults.propertySourceElementsFilter(...args), "isSourceElement"),
+    isSourceElement: (...args) => defaults.propertySourceElementsFilter(...args),
     resolveElements: options.resolveElements ? options.resolveElements : (...args) => defaults.propertyResolveSourceElements(...args),
-    fromXML: /* @__PURE__ */ __name((context) => (options.fromXML ?? defaults.propertyFromXML)(context), "fromXML"),
-    toXML: /* @__PURE__ */ __name((context) => (options.toXML ?? defaults.propertyToXML)(context), "toXML")
+    fromXML: (context) => (options.fromXML ?? defaults.propertyFromXML)(context),
+    toXML: (context) => (options.toXML ?? defaults.propertyToXML)(context)
   };
-  if (options?.model)
-    _options.model = options.model;
+  if (options?.model) _options.model = options.model;
   if (options?.sourceElements) {
     const _sourceElements = options.sourceElements;
     if (typeof _sourceElements === "string") {
@@ -34,7 +31,6 @@ function resolvePropertyConversionOptions(options, constructor, property) {
   }
   return _options;
 }
-__name(resolvePropertyConversionOptions, "resolvePropertyConversionOptions");
 const PropertyOptions = /* @__PURE__ */ new Map();
 function storePropertyConversionOptions(constructor, property, options) {
   let map = PropertyOptions.get(constructor);
@@ -44,26 +40,26 @@ function storePropertyConversionOptions(constructor, property, options) {
   }
   map.set(property, options);
 }
-__name(storePropertyConversionOptions, "storePropertyConversionOptions");
 function findPropertyConversionOptions(constructor, property) {
   const options = PropertyOptions.get(constructor);
   if (options) {
     return options.get(property);
   }
 }
-__name(findPropertyConversionOptions, "findPropertyConversionOptions");
 function getPropertyConversionOptions(constructor, property) {
   const options = findPropertyConversionOptions(constructor, property);
   return options ?? resolvePropertyConversionOptions({}, constructor, property);
 }
-__name(getPropertyConversionOptions, "getPropertyConversionOptions");
 function PropDecoratorFactory(options) {
   return function(prototype, property) {
-    const _options = resolvePropertyConversionOptions(options ?? {}, prototype.constructor, property);
+    const _options = resolvePropertyConversionOptions(
+      options ?? {},
+      prototype.constructor,
+      property
+    );
     storePropertyConversionOptions(prototype.constructor, property, _options);
   };
 }
-__name(PropDecoratorFactory, "PropDecoratorFactory");
 export {
   PropDecoratorFactory as Prop,
   getPropertyConversionOptions