xml-model 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/index.js

@@ -2,6 +2,6 @@ import { DATA, isModel, model } from "./model.js";
 import XML, { ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode } from "./xml/xml-js.js";
 import { xml } from "./xml/schema-meta.js";
 import { normalizeCodecOptions, registerDefault } from "./xml/codec.js";
-import { xmlModel } from "./xml/model.js";
+import { XMLBase, XMLBaseWithSource, xmlModel } from "./xml/model.js";
 import "./xml/index.js";
-export { DATA, XML, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, isModel, model, normalizeCodecOptions, registerDefault, xml, xmlModel };
+export { DATA, XML, XMLBase, XMLBaseWithSource, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, isModel, model, normalizeCodecOptions, registerDefault, xml, xmlModel };

package/dist/node_modules/sax/lib/sax.js

@@ -49,6 +49,7 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 			clearBuffers(parser);
 			parser.q = parser.c = "";
 			parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH;
+			parser.encoding = null;
 			parser.opt = opt || {};
 			parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
 			parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
@@ -146,6 +147,19 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 		function createStream(strict, opt) {
 			return new SAXStream(strict, opt);
 		}
+		function determineBufferEncoding(data, isEnd) {
+			if (data.length >= 2) {
+				if (data[0] === 255 && data[1] === 254) return "utf-16le";
+				if (data[0] === 254 && data[1] === 255) return "utf-16be";
+			}
+			if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191) return "utf8";
+			if (data.length >= 4) {
+				if (data[0] === 60 && data[1] === 0 && data[2] === 63 && data[3] === 0) return "utf-16le";
+				if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 63) return "utf-16be";
+				return "utf8";
+			}
+			return isEnd ? "utf8" : null;
+		}
 		function SAXStream(strict, opt) {
 			if (!(this instanceof SAXStream)) return new SAXStream(strict, opt);
 			Stream.apply(this);
@@ -161,6 +175,7 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 				me._parser.error = null;
 			};
 			this._decoder = null;
+			this._decoderBuffer = null;
 			streamWraps.forEach(function(ev) {
 				Object.defineProperty(me, "on" + ev, {
 					get: function() {
@@ -180,10 +195,30 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 			});
 		}
 		SAXStream.prototype = Object.create(Stream.prototype, { constructor: { value: SAXStream } });
+		SAXStream.prototype._decodeBuffer = function(data, isEnd) {
+			if (this._decoderBuffer) {
+				data = Buffer.concat([this._decoderBuffer, data]);
+				this._decoderBuffer = null;
+			}
+			if (!this._decoder) {
+				var encoding = determineBufferEncoding(data, isEnd);
+				if (!encoding) {
+					this._decoderBuffer = data;
+					return "";
+				}
+				this._parser.encoding = encoding;
+				this._decoder = new TextDecoder(encoding);
+			}
+			return this._decoder.decode(data, { stream: !isEnd });
+		};
 		SAXStream.prototype.write = function(data) {
-			if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) {
-				if (!this._decoder) this._decoder = new TextDecoder("utf8");
-				data = this._decoder.decode(data, { stream: true });
+			if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) data = this._decodeBuffer(data, false);
+			else if (this._decoderBuffer) {
+				var remaining = this._decodeBuffer(Buffer.alloc(0), true);
+				if (remaining) {
+					this._parser.write(remaining);
+					this.emit("data", remaining);
+				}
 			}
 			this._parser.write(data.toString());
 			this.emit("data", data);
@@ -191,7 +226,13 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 		};
 		SAXStream.prototype.end = function(chunk) {
 			if (chunk && chunk.length) this.write(chunk);
-			if (this._decoder) {
+			if (this._decoderBuffer) {
+				var finalChunk = this._decodeBuffer(Buffer.alloc(0), true);
+				if (finalChunk) {
+					this._parser.write(finalChunk);
+					this.emit("data", finalChunk);
+				}
+			} else if (this._decoder) {
 				var remaining = this._decoder.decode();
 				if (remaining) {
 					this._parser.write(remaining);
@@ -548,6 +589,26 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 		function emit(parser, event, data) {
 			parser[event] && parser[event](data);
 		}
+		function getDeclaredEncoding(body) {
+			var match = body && body.match(/(?:^|\s)encoding\s*=\s*(['"])([^'"]+)\1/i);
+			return match ? match[2] : null;
+		}
+		function normalizeEncodingName(encoding) {
+			if (!encoding) return null;
+			return encoding.toLowerCase().replace(/[^a-z0-9]/g, "");
+		}
+		function encodingsMatch(detectedEncoding, declaredEncoding) {
+			const detected = normalizeEncodingName(detectedEncoding);
+			const declared = normalizeEncodingName(declaredEncoding);
+			if (!detected || !declared) return true;
+			if (declared === "utf16") return detected === "utf16le" || detected === "utf16be";
+			return detected === declared;
+		}
+		function validateXmlDeclarationEncoding(parser, data) {
+			if (!parser.strict || !parser.encoding || !data || data.name !== "xml") return;
+			var declaredEncoding = getDeclaredEncoding(data.body);
+			if (declaredEncoding && !encodingsMatch(parser.encoding, declaredEncoding)) strictFail(parser, "XML declaration encoding " + declaredEncoding + " does not match detected stream encoding " + parser.encoding.toUpperCase());
+		}
 		function emitNode(parser, nodeType, data) {
 			if (parser.textNode) closeText(parser);
 			emit(parser, nodeType, data);
@@ -1014,10 +1075,12 @@ var require_sax = /* @__PURE__ */ __commonJSMin(((exports) => {
 						continue;
 					case S.PROC_INST_ENDING:
 						if (c === ">") {
-							emitNode(parser, "onprocessinginstruction", {
+							const procInstEndData = {
 								name: parser.procInstName,
 								body: parser.procInstBody
-							});
+							};
+							validateXmlDeclarationEncoding(parser, procInstEndData);
+							emitNode(parser, "onprocessinginstruction", procInstEndData);
 							parser.procInstName = parser.procInstBody = "";
 							parser.state = S.TEXT;
 						} else {

package/dist/util/zod.js

@@ -9,6 +9,8 @@ function getParentSchema(schema) {
 		if (isZodType(schema.def.in)) parent = schema.def.in;
 	} else if (schema instanceof z.ZodOptional) {
 		if (isZodType(schema.def.innerType)) parent = schema.def.innerType;
+	} else if (schema instanceof z.ZodDefault) {
+		if (isZodType(schema.def.innerType)) parent = schema.def.innerType;
 	} else if (schema instanceof z.ZodLazy) {
 		const value = schema.def.getter();
 		if (isZodType(value)) parent = value;

package/dist/xml/codec.d.ts

@@ -32,8 +32,8 @@ export interface CodecOptions<S extends z.ZodType> {
  */
 export type UserCodecOptions<S extends z.ZodType = z.ZodType> = {
     tagname?: string | CodecOptions<S>["tagname"];
-    decode?: CodecOptions<S>["decode"];
-    encode?: CodecOptions<S>["encode"];
+    decode?: (ctx: RootDecodingContext<S>, next: () => z.input<S>) => z.input<S>;
+    encode?: (ctx: RootEncodingContext<S>, next: () => XMLElement) => XMLElement;
     propertyTagname?: string | CodecOptions<S>["propertyTagname"];
     inlineProperty?: boolean;
     propertyMatch?: RegExp | CodecOptions<S>["propertyMatch"];
@@ -71,13 +71,40 @@ export declare function normalizeCodecOptions<S extends z.ZodType>(schema: S, op
 type OrderEntry = string | XMLElement;
 export interface XMLState {
     /** Preserves element ordering and unknown elements across a decode → encode round-trip. */
-    fieldOrder: OrderEntry[];
+    sequence: OrderEntry[];
+    /** Present when xmlStateSchema({ source: true }) is used: the original XMLElement. */
+    source?: XMLElement;
 }
 /**
- * Non-enumerable Symbol attached to decoded data objects (and forwarded to model instances).
- * Groups all XML codec round-trip state under a single key.
+ * String key used to store XML round-trip state on decoded data objects.
+ * Using a string (rather than a Symbol) allows Zod's schema.parse() to
+ * preserve it naturally when the key is included in the schema via xmlStateSchema().
  */
-export declare const XML_STATE: unique symbol;
+export declare const XML_STATE_KEY: "__xml_state";
+/**
+ * Schema for the XML round-trip state field.
+ *
+ * Include in your base model schema under `XML_STATE_KEY` to preserve element ordering
+ * and unknown elements through Zod's `schema.parse()` for nested model instances.
+ *
+ * Pass `{ source: true }` to also record the original `XMLElement` on each instance.
+ *
+ * @example
+ * class XMLBase extends xmlModel(z.object({
+ *   [XML_STATE_KEY]: xmlStateSchema(),
+ * }), { tagname: "base" }) {}
+ *
+ * // With source recording:
+ * class XMLBase extends xmlModel(z.object({
+ *   [XML_STATE_KEY]: xmlStateSchema({ source: true }),
+ * }), { tagname: "base" }) {}
+ */
+export declare function xmlStateSchema(): z.ZodOptional<z.ZodCustom<XMLState>>;
+export declare function xmlStateSchema(options: {
+    source: true;
+}): z.ZodOptional<z.ZodCustom<XMLState & {
+    source: XMLElement;
+}>>;
 export declare function decode<S extends z.ZodType>(schema: S, xml: XMLElement): z.input<S>;
 export declare function encode<S extends z.ZodType>(schema: S, data: z.output<S>): XMLElement;
 type DefaultResolver<S extends z.ZodType = z.ZodType> = (schema: S) => CodecOptions<S> | void;

package/dist/xml/codec.js

@@ -1,6 +1,6 @@
 import XML from "./xml-js.js";
 import { isZodType } from "../util/zod.js";
-import { getUserOptions } from "./schema-meta.js";
+import { getUserOptions, prop } from "./schema-meta.js";
 import { kebabCase } from "../util/kebab-case.js";
 import { z } from "zod";
 //#region src/xml/codec.ts
@@ -28,8 +28,8 @@ function normalizeCodecOptions(schema, options = {}) {
 	const result = {
 		schema,
 		tagname,
-		decode: options.decode ?? defaultOptions().decode,
-		encode: options.encode ?? defaultOptions().encode,
+		decode: options.decode ? (ctx) => options.decode(ctx, () => defaultOptions().decode(ctx)) : (ctx) => defaultOptions().decode(ctx),
+		encode: options.encode ? (ctx) => options.encode(ctx, () => defaultOptions().encode(ctx)) : (ctx) => defaultOptions().encode(ctx),
 		propertyTagname,
 		inlineProperty,
 		propertyMatch,
@@ -51,7 +51,10 @@ function normalizeCodecOptions(schema, options = {}) {
 				data: property.value
 			});
 			if (XML.isEmpty(res)) return;
-			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements);
+			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements.map((el) => el.type === "element" ? {
+				...el,
+				name: property.tagname
+			} : el));
 			else ctx.result.elements.push(res);
 		}
 	};
@@ -66,10 +69,19 @@ function resolveCodecOptions(schema) {
 	return options;
 }
 /**
-* Non-enumerable Symbol attached to decoded data objects (and forwarded to model instances).
-* Groups all XML codec round-trip state under a single key.
+* String key used to store XML round-trip state on decoded data objects.
+* Using a string (rather than a Symbol) allows Zod's schema.parse() to
+* preserve it naturally when the key is included in the schema via xmlStateSchema().
 */
-var XML_STATE = Symbol("xml-model.state");
+var XML_STATE_KEY = "__xml_state";
+function xmlStateSchema(options) {
+	return prop(z.custom().optional(), {
+		decode: options?.source ? (ctx, _next) => {
+			(ctx.result[XML_STATE_KEY] ??= {}).source = ctx.xml;
+		} : () => {},
+		encode: () => {}
+	});
+}
 function resolvePropertiesCodecOptions(schema) {
 	const shape = schema.def.shape;
 	const options = {};
@@ -103,7 +115,10 @@ function resolveDefault(schema) {
 }
 registerDefault((schema) => {
 	if (schema instanceof z.ZodArray) {
-		const elOptions = resolveCodecOptions(schema.def.element);
+		const elSchema = schema.def.element;
+		if (!isZodType(elSchema)) throw new Error(`Expected a ZodType, got ${elSchema}`);
+		const elOptions = resolveCodecOptions(elSchema);
+		const elHasOwnTagname = Boolean(getUserOptions(elSchema).tagname);
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
 				const { xml } = ctx;
@@ -116,12 +131,16 @@ registerDefault((schema) => {
 			encode(ctx) {
 				const values = ctx.data;
 				if (!Array.isArray(values)) throw new Error("expected array");
+				const elOptsForEncode = elHasOwnTagname ? elOptions : {
+					...elOptions,
+					tagname: ctx.options.tagname
+				};
 				return {
 					type: "element",
 					name: ctx.options.tagname(ctx),
 					attributes: {},
-					elements: values.map((v) => elOptions.encode({
-						options: elOptions,
+					elements: values.map((v) => elOptsForEncode.encode({
+						options: elOptsForEncode,
 						data: v
 					}))
 				};
@@ -134,12 +153,18 @@ registerDefault((schema) => {
 		const innerOptions = resolveCodecOptions(inner);
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
-				if (!ctx.xml) return void 0;
+				if (ctx.xml === null) return void 0;
 				else return innerOptions.decode(ctx);
 			},
 			encode(ctx) {
 				if (typeof ctx.data === "undefined") return {};
 				else return innerOptions.encode(ctx);
+			},
+			decodeAsProperty(ctx) {
+				if (ctx.property.xml !== null) innerOptions.decodeAsProperty(ctx);
+			},
+			encodeAsProperty(ctx) {
+				if (typeof ctx.property.value !== "undefined") innerOptions.encodeAsProperty(ctx);
 			}
 		});
 	}
@@ -238,6 +263,7 @@ registerDefault((schema) => {
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
 				const sequence = [];
+				const result = { [XML_STATE_KEY]: { sequence } };
 				const propContexts = Object.fromEntries(Object.entries(options).map(([name, propOpts]) => {
 					return [name, {
 						name,
@@ -274,7 +300,6 @@ registerDefault((schema) => {
 					} else throw new Error(`Same element was matched by multiple properties: ${matches.join(", ")}`);
 				}
 				for (const propName in options) if (!seenProperties.has(propName)) sequence.push(propName);
-				const result = {};
 				for (const prop in options) {
 					const o = options[prop];
 					const propCtx = propContexts[prop];
@@ -293,12 +318,6 @@ registerDefault((schema) => {
 						result
 					});
 				}
-				Object.defineProperty(result, XML_STATE, {
-					value: { fieldOrder: sequence },
-					enumerable: false,
-					writable: true,
-					configurable: true
-				});
 				return result;
 			},
 			encode(ctx) {
@@ -309,7 +328,7 @@ registerDefault((schema) => {
 					attributes: {},
 					elements: []
 				};
-				const sequence = data[XML_STATE]?.fieldOrder ?? Object.keys(options);
+				const sequence = data["__xml_state"]?.sequence ?? Object.keys(options);
 				for (const item of sequence) if (typeof item === "string") {
 					const o = options[item];
 					if (!o) throw new Error(`Failed to resolve property options for sequence item ${item}`);
@@ -334,6 +353,6 @@ registerDefault((schema) => {
 	}
 });
 //#endregion
-export { XML_STATE, decode, encode, normalizeCodecOptions, registerDefault };
+export { XML_STATE_KEY, decode, encode, normalizeCodecOptions, registerDefault, xmlStateSchema };
 
 //# sourceMappingURL=codec.js.map

package/dist/xml/index.d.ts

@@ -1,6 +1,6 @@
 export * from './xml-js';
 export { xml } from './schema-meta';
-export type { UserCodecOptions } from './codec';
+export type { UserCodecOptions, XMLState } from './codec';
 export { registerDefault, normalizeCodecOptions } from './codec';
-export { xmlModel, type XmlModelConstructor } from './model';
+export { xmlModel, XMLBase, XMLBaseWithSource, type XmlModelConstructor } from './model';
 //# sourceMappingURL=index.d.ts.map

package/dist/xml/model.d.ts

@@ -14,5 +14,37 @@ export type XmlModelConstructor<S extends z.ZodObject<any> = z.ZodObject<any>, I
     /** Converts an instance to an XML string. */
     toXMLString(instance: z.infer<S>, options?: StringifyOptions): string;
 };
+/**
+ * Base class for xmlModel classes. Preserves element ordering and unknown elements
+ * through `schema.parse()` for nested model instances.
+ *
+ * @example
+ * class Device extends XMLBase.extend(
+ *   { name: z.string() },
+ *   xml.root({ tagname: "device" }),
+ * ) {}
+ */
+export declare const XMLBase: XmlModelConstructor<z.ZodObject<{
+    __xml_state: z.ZodOptional<z.ZodCustom<import('./codec').XMLState, unknown>>;
+}, z.core.$strip>, {
+    __xml_state?: import('./codec').XMLState;
+}>;
+/**
+ * Like {@link XMLBase}, but also records the original `XMLElement` as `.source`
+ * on each instance's XML state.
+ *
+ * @example
+ * const device = Device.fromXML(`<device>…</device>`);
+ * device[XML_STATE_KEY]?.source; // XMLElement
+ */
+export declare const XMLBaseWithSource: XmlModelConstructor<z.ZodObject<{
+    __xml_state: z.ZodOptional<z.ZodCustom<import('./codec').XMLState & {
+        source: XMLElement;
+    }, unknown>>;
+}, z.core.$strip>, {
+    __xml_state?: import('./codec').XMLState & {
+        source: XMLElement;
+    };
+}>;
 export declare function xmlModel<S extends z.ZodObject<any>>(schema: S, options?: UserCodecOptions<S>): XmlModelConstructor<S>;
 //# sourceMappingURL=model.d.ts.map

package/dist/xml/model.js

@@ -1,9 +1,29 @@
 import { model } from "../model.js";
 import XML from "./xml-js.js";
 import { root } from "./schema-meta.js";
-import { XML_STATE, decode, encode } from "./codec.js";
-import "zod";
+import { XML_STATE_KEY, decode, encode, xmlStateSchema } from "./codec.js";
+import { z } from "zod";
 //#region src/xml/model.ts
+/**
+* Base class for xmlModel classes. Preserves element ordering and unknown elements
+* through `schema.parse()` for nested model instances.
+*
+* @example
+* class Device extends XMLBase.extend(
+*   { name: z.string() },
+*   xml.root({ tagname: "device" }),
+* ) {}
+*/
+var XMLBase = xmlModel(z.object({ [XML_STATE_KEY]: xmlStateSchema() }));
+/**
+* Like {@link XMLBase}, but also records the original `XMLElement` as `.source`
+* on each instance's XML state.
+*
+* @example
+* const device = Device.fromXML(`<device>…</device>`);
+* device[XML_STATE_KEY]?.source; // XMLElement
+*/
+var XMLBaseWithSource = xmlModel(z.object({ [XML_STATE_KEY]: xmlStateSchema({ source: true }) }));
 function xmlModel(schema, options) {
 	const _schema = options ? root(schema, options) : schema;
 	return class extends model(_schema) {
@@ -12,9 +32,9 @@ function xmlModel(schema, options) {
 			if (XML.isRoot(input)) input = XML.elementFromRoot(input);
 			const schema = this.dataSchema;
 			const inputData = decode(this.dataSchema, input);
-			const xmlState = inputData[XML_STATE];
+			const xmlState = inputData[XML_STATE_KEY];
 			const parsed = schema.parse(inputData);
-			parsed[XML_STATE] = xmlState;
+			parsed[XML_STATE_KEY] = xmlState;
 			return this.fromData(parsed);
 		}
 		static toXML(instance) {
@@ -28,6 +48,6 @@ function xmlModel(schema, options) {
 	};
 }
 //#endregion
-export { xmlModel };
+export { XMLBase, XMLBaseWithSource, xmlModel };
 
 //# sourceMappingURL=model.js.map

package/dist/xml/schema-meta.d.ts

@@ -15,8 +15,8 @@ type UserPropOptions = {
     tagname?: string | UserCodecOptions["propertyTagname"];
     inline?: boolean;
     match?: RegExp | ((el: XMLElement) => boolean);
-    decode?: (ctx: PropertyDecodingContext) => Partial<Record<string, unknown>> | undefined;
-    encode?: (ctx: PropertyEncodingContext) => XMLElement | undefined;
+    decode?: (ctx: PropertyDecodingContext, next: () => void) => void;
+    encode?: (ctx: PropertyEncodingContext, next: () => void) => void;
 };
 export declare function root<S extends z.ZodType>(schema: S, options: UserRootOptions<S>): S;
 export declare function root(options: UserRootOptions): z.GlobalMeta;

package/dist/xml/schema-meta.js

@@ -1,3 +1,4 @@
+import XML from "./xml-js.js";
 import { getParentSchema, isZodType } from "../util/zod.js";
 import "zod";
 //#region src/xml/schema-meta.ts
@@ -19,21 +20,40 @@ function normalizePropOptions(options) {
 	if (options.decode !== void 0) {
 		const userDecode = options.decode;
 		partial.decodeAsProperty = function(ctx) {
-			const res = userDecode(ctx);
-			if (typeof res !== "undefined") Object.assign(ctx.result, res);
+			const next = () => {
+				const val = ctx.property.options.decode({
+					options: ctx.property.options,
+					xml: ctx.property.xml
+				});
+				ctx.result[ctx.property.name] = val;
+			};
+			userDecode(ctx, next);
 		};
 	}
 	if (options.encode !== void 0) {
 		const userEncode = options.encode;
 		partial.encodeAsProperty = function(ctx) {
 			const { property } = ctx;
-			const res = userEncode(ctx);
-			if (typeof res === "undefined") return;
-			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements);
-			else {
-				res.name = property.tagname;
-				ctx.result.elements.push(res);
-			}
+			const next = () => {
+				const optsWithTagname = {
+					...property.options,
+					tagname: () => property.tagname
+				};
+				const res = property.options.encode({
+					options: optsWithTagname,
+					data: property.value
+				});
+				if (XML.isEmpty(res)) return;
+				if (property.options.inlineProperty) ctx.result.elements.push(...res.elements.map((el) => el.type === "element" ? {
+					...el,
+					name: property.tagname
+				} : el));
+				else ctx.result.elements.push({
+					...res,
+					name: property.tagname
+				});
+			};
+			userEncode(ctx, next);
 		};
 	}
 	return partial;
@@ -52,7 +72,7 @@ function attr(optionsOrSchema, options) {
 		decodeAsProperty(ctx) {
 			const { name, options: propOptions } = ctx.property;
 			const attrName = opts.name ?? name;
-			const attrValue = ctx.xml?.attributes[attrName];
+			const attrValue = ctx.xml?.attributes?.[attrName];
 			ctx.result[name] = propOptions.schema.parse(attrValue);
 		},
 		encodeAsProperty(ctx) {
@@ -73,16 +93,27 @@ var xml = {
 function getOwnUserOptions(schema) {
 	return schema.meta()?.[metaKey] ?? {};
 }
+var INHERITABLE_KEYS = [
+	"tagname",
+	"propertyTagname",
+	"inlineProperty",
+	"propertyMatch",
+	"decodeAsProperty",
+	"encodeAsProperty"
+];
 function getUserOptions(schema) {
 	const own = getOwnUserOptions(schema);
 	const parentSchema = getParentSchema(schema);
 	if (!parentSchema) return own;
+	const parentOptions = getUserOptions(parentSchema);
+	const inherited = {};
+	for (const key of INHERITABLE_KEYS) if (parentOptions[key] !== void 0 && own[key] === void 0) inherited[key] = parentOptions[key];
 	return {
-		...getUserOptions(parentSchema),
+		...inherited,
 		...own
 	};
 }
 //#endregion
-export { getUserOptions, root, xml };
+export { getUserOptions, prop, root, xml };
 
 //# sourceMappingURL=schema-meta.js.map

package/dist/xml/xml-js.d.ts

@@ -120,21 +120,6 @@ export type ParseOptions = IgnoreOptions & ChangingKeyNames & {
      * @default false
      */
     addParent?: boolean;
-    /**
-     * Whether to always wrap sub-elements in an array, even when there is only one.
-     * Pass an array of element names to restrict this behaviour to those names only.
-     * Only applicable in compact mode.
-     * @default false
-     */
-    alwaysArray?: boolean | Array<string>;
-    /**
-     * Whether to always emit an `elements` array even on empty elements.
-     * `<a></a>` becomes `{ elements: [{ type: "element", name: "a", elements: [] }] }`
-     * instead of `{ elements: [{ type: "element", name: "a" }] }`.
-     * Only applicable in non-compact mode.
-     * @default false
-     */
-    alwaysChildren?: boolean;
     /**
      * Whether to parse the contents of processing instructions as attributes.
      * `<?go to="there"?>` becomes `{ go: { attributes: { to: "there" } } }`
@@ -221,14 +206,8 @@ declare function isEmpty(xml: object): xml is XMLVoid;
  */
 declare function getContent(xml: XMLElement): string;
 /**
- * Creates a minimal element structure wrapping the given text content.
- * When no tag name is provided, returns a fragment with a text child.
- * When a tag name is provided, returns a full element with the given name and optional attributes.
- *
+ * Creates a text-only fragment wrapping the given content.
  * @param content - The text content to wrap (defaults to empty string).
- * @param tag - Optional element tag name.
- * @param attributes - Optional attributes; only valid when `tag` is provided.
- * @throws {TypeError} When `attributes` are provided without a `tag`.
  */
 declare function fromContent(content: string): {
     elements: [{
@@ -236,6 +215,12 @@ declare function fromContent(content: string): {
         text: string;
     }] | [];
 };
+/**
+ * Creates a full element wrapping the given text content.
+ * @param content - The text content to wrap (defaults to empty string).
+ * @param tag - Element tag name.
+ * @param attributes - Optional attributes.
+ */
 declare function fromContent(content: string, tag: string, attributes?: XMLElement["attributes"]): {
     type: "element";
     name: string;

package/dist/xml/xml-js.js

@@ -25,14 +25,22 @@ var ZXMLNode = z.discriminatedUnion("type", [
 ]);
 var ZXMLRoot = z.object({ elements: z.array(ZXMLNode) });
 function parse(xml, options = {}) {
-	const strippedOptions = { ...options };
-	delete strippedOptions["compact"];
-	const res = (0, import_lib.xml2js)(xml, strippedOptions);
+	if ("compact" in options) throw new Error("xml-model always uses non-compact mode (compact is forced to false)");
+	if ("alwaysChildren" in options) throw new Error("xml-model always parses with alwaysChildren: true");
+	const res = (0, import_lib.xml2js)(xml, {
+		...options,
+		compact: false,
+		alwaysChildren: true
+	});
 	if ("elements" in res) return res;
 	throw new Error("Got empty XML");
 }
 function stringify(xml, options = {}) {
-	return (0, import_lib.js2xml)(xml, options);
+	if ("compact" in options) throw new Error("xml-model always uses non-compact mode (compact is forced to false)");
+	return (0, import_lib.js2xml)(xml, {
+		...options,
+		compact: false
+	});
 }
 function isRoot(xml) {
 	return Object.keys(xml).length === 1 && "elements" in xml && Array.isArray(xml.elements);
@@ -51,11 +59,11 @@ function isEmpty(xml) {
 * @throws {TypeError} When the element has multiple or non-text children.
 */
 function getContent(xml) {
-	if (xml.elements?.length === 1) {
+	if (!xml.elements.length) return "";
+	if (xml.elements.length === 1) {
 		const content = xml.elements[0];
 		if (content.type === "text") return content.text;
 	}
-	if (!xml.elements) return "";
 	throw new TypeError(`can't get text from XMLElement: ${JSON.stringify(xml)}`);
 }
 function fromContent(content = "", tag, attributes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-model",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.5",
   "description": "allows transparent XML <-> Object conversion in typescript",
   "license": "MIT",
   "author": "MathisTLD",
@@ -34,10 +34,10 @@
     "fmt:check": "vp fmt --check",
     "prepare": "vp config"
   },
-  "dependencies": {},
   "devDependencies": {
     "@types/node": "^24.10.11",
     "marmotte": "^0.4.4",
+    "oxc-minify": "^0.121.0",
     "typescript": "^5.9.3",
     "vite-plus": "latest",
     "vitepress": "^2.0.0-alpha.16",