@endevops/effect-codec-xml 0.0.1

package/dist/render.d.ts

@@ -0,0 +1,99 @@
+import { XmlVersion } from "./naming.js";
+import { XmlRenderError } from "./errors.js";
+import { NameMode } from "./conventions.js";
+import { XmlValue } from "./xml-value.js";
+import { Effect } from "effect";
+//#region src/render.d.ts
+/**
+ * @description Options for {@link renderXml}.
+ */
+export interface XmlRenderOptions {
+  /**
+   * @description Name of the root element.
+   *
+   * @default 'root'\
+   * A codec passes the name it took from the schema's `identifier` annotation when the caller did not set one.
+   */
+  readonly rootName?: string | undefined;
+  /**
+   * @description Element name used for the members of a document whose root value is an array.
+   *
+   * @default 'item'
+   */
+  readonly itemName?: string | undefined;
+  /**
+   * @description Indent nested elements on their own lines.
+   *
+   * @default false
+   */
+  readonly format?: boolean | undefined;
+  /**
+   * @description The string one indent level is made of. Defaults to two spaces.
+   */
+  readonly indent?: string | undefined;
+  /**
+   * @description Write an element with no attributes, text or children as `<a/>` rather than `<a></a>`.
+   *
+   * @default true
+   */
+  readonly suppressEmptyNode?: boolean | undefined;
+  /**
+   * @description Sort an element's keys so the same value always renders to the same bytes.
+   *
+   * @default false\
+   * Which keeps declaration order.\ Worth turning on for snapshot tests, where key order is otherwise the only thing that can make two equal values differ.
+   */
+  readonly sortKeys?: boolean | undefined;
+  /**
+   * @description What to do with a field name that is not a legal XML name.
+   *
+   * @default 'repair'.
+   */
+  readonly name?: NameMode | undefined;
+  /**
+   * @description XML version to validate names against.
+   *
+   * @default '1.0'
+   */
+  readonly xmlVersion?: XmlVersion | undefined;
+  /**
+   * @description How deep to nest before giving up. Guards against a value that nests without end taking the stack with it.
+   *
+   * @default 256
+   */
+  readonly maxDepth?: number | undefined;
+}
+/**
+ * @description Escapes a value for use as character data.
+ *
+ * @param value - The text to escape.
+ *
+ * @returns The text with the XML-unsafe characters replaced by predefined entities, or the very same string when there is nothing to escape.
+ */
+export declare const escapeText: (value: string) => string;
+/**
+ * @description Escapes a value for use inside a double-quoted attribute.
+ *
+ * @param value - The text to escape.
+ *
+ * @returns The escaped text, with the whitespace that XML would otherwise normalize spelled as character references.
+ */
+export declare const escapeAttribute: (value: string) => string;
+/**
+ * @description Renders an {@link XmlValue} as an XML document.\
+ * A record becomes an element:
+ *
+ * - `@`-prefixed keys become attributes, the reserved `#text` key becomes character data, and every other key becomes a child element.
+ * - An array repeats its name — a document whose root value is an array wraps it in the root element and names each member `itemName`.
+ * - A string is character data. The walk is synchronous, and what can go wrong is reported by throwing an {@link XmlRenderError}; {@link renderXml}
+ *   folds that into the effect's typed error channel. A caller not already in an `Effect` runs it with `Effect.runSync`, which throws the failure it
+ *   produced.
+ *
+ * @param value - The value to render.
+ * @param options - Root name, formatting, empty-element and name-resolution settings.
+ *
+ * @returns An effect producing the XML document as a string.
+ */
+export declare const renderXml: (value: XmlValue, options?: XmlRenderOptions) => Effect.Effect<string, XmlRenderError>;
+//#endregion
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","names":[],"sources":["../src/render.ts"],"mappings":";;;;;;;;;iBA+EiB;;;;;;;WAON;;;;;;WAOA;;;;;;WAOA;;;;WAKA;;;;;;WAOA;;;;;;;WAQA;;;;;;WAOA,OAAO;;;;;;WAOP,aAAa;;;;;;WAOb;;;;;;;;;qBAiHE,aAAU;;;;;;;;qBASV,kBAAe;;;;;;;;;;;;;;;;qBAmDf,YAAS,OAAW,UAAQ,UAAW,qBAAwB,OAAO,eAAe"}

package/dist/render.js

@@ -0,0 +1,509 @@
+import { XmlRenderError } from "./errors.js";
+import { TEXT_KEY, attributeName, isAttributeKey, isTextKey, resolveNameSync } from "./conventions.js";
+import { Effect, Predicate, Result } from "effect";
+//#region src/render.ts
+/**
+* @description The five characters XML predefines an entity for, and the names to write for them. Written out rather than referenced from the entity decoder
+* because the table is indexed by character code below.
+*/
+const XML_PREDEFINED = {
+	34: """,
+	38: "&",
+	39: "'",
+	60: "<",
+	62: ">"
+};
+/**
+* @description The character references for the whitespace XML normalizes inside an attribute value. A parser replaces a literal newline, carriage return or tab
+* in an attribute with a space, so a value that has to survive a round trip has to spell them as references. They are in the attribute table and not
+* the text one: in character data they are content, and only an attribute value is normalized.
+*/
+const ATTRIBUTE_WHITESPACE = {
+	9: "	",
+	10: "
",
+	13: "
"
+};
+/**
+* @description The replacement for each ASCII character that needs one, and `undefined` for the ones that do not. Indexed by character code and 128 long, so the
+* check is one comparison and one array read with no string search in it.
+*
+* @param extra - Characters to escape in addition to the five predefines.
+*
+* @returns The lookup table.
+*/
+const buildTable = (extra) => {
+	const table = Array.from({ length: 128 }).fill(void 0);
+	for (const [code, entity] of Object.entries({
+		...XML_PREDEFINED,
+		...extra
+	})) table[Number(code)] = entity;
+	return table;
+};
+const TEXT_TABLE = buildTable({});
+const ATTRIBUTE_TABLE = buildTable(ATTRIBUTE_WHITESPACE);
+/**
+* @description The characters each table escapes, as a pattern rather than as a set of replacement passes. Finding the first one with a pattern is what makes
+* clean text cheap: V8 compiles a single character class into a scan that is several times faster than a JavaScript loop reading the same string a
+* code unit at a time, and clean text is most text. `render 20k of clean text` in `bench/codec.bench.ts` is the row that says so — a hand-written
+* loop over the same twenty thousand characters is roughly two and a half times slower. Neither pattern is global, so `exec` ignores `lastIndex` and
+* always starts at the beginning. One module-level instance of each is therefore safe to reuse, and nothing has to be reset between calls.
+*/
+const TEXT_UNSAFE = /[<>&"']/;
+const ATTRIBUTE_UNSAFE = /[<>&"'\n\r\t]/;
+/**
+* @description Builds the name resolver for one render. Every element and every attribute name goes through here, and a document repeats names: a thousand
+* `<item>` elements, or the same `id` on every row. A validator that runs a regex per occurrence pays that cost a thousand times for one answer, so
+* the first result is remembered and the rest are lookups. It also keeps the mode and version in one place, which is what stops a caller from
+* resolving a name with different settings than the render it is part of. A cache miss calls {@link resolveNameSync}, which throws an
+* {@link XmlParseError} in `'error'` mode; {@link renderXml} catches it and reports it as an {@link XmlRenderError}.
+*
+* @param options - Resolved render options.
+*
+* @returns A function from field name to the legal XML name.
+*/
+const makeNamer = (options) => {
+	const cache = /* @__PURE__ */ new Map();
+	return (name) => {
+		const hit = cache.get(name);
+		if (hit !== void 0) return hit;
+		const resolved = resolveNameSync(name, {
+			mode: options.name,
+			xmlVersion: options.xmlVersion
+		});
+		cache.set(name, resolved);
+		return resolved;
+	};
+};
+/**
+* @description A boolean option's value, with an absent one read as the default. The three boolean options are spelled through here rather than through a `??` of
+* their own, so the table below reads as a list of what each option _is_ instead of a list of nine separate decisions about what an omitted option
+* means — and so a reader looking for "which options are on by default" finds three words rather than three mixes of `?? true` and `?? false` to
+* read.
+*
+* @param value - The option as the caller wrote it, or `undefined` when the caller left it out.
+* @param fallback - The value to use when the caller left it out.
+*
+* @returns The option's value.
+*/
+const flag = (value, fallback) => value ?? fallback;
+/**
+* @description The indent for a given depth, built the first time a render reaches that depth and kept. A document of a few thousand elements on several lines
+* each would otherwise call `repeat` once per line and allocate the same handful of strings thousands of times over.
+*
+* @param indent - The string one level of indentation is made of.
+*
+* @returns A function from depth to the indent for that depth.
+*/
+const makeLineAt = (indent) => {
+	const lines = [""];
+	return (depth) => {
+		const line = lines[depth];
+		if (line !== void 0) return line;
+		const built = indent.repeat(depth);
+		lines[depth] = built;
+		return built;
+	};
+};
+/**
+* @description Applies the defaults to one call's options, and builds the two things a render needs that are not options: the memoized name resolver and the
+* memoized indent lines.
+*
+* @param options - The options as the caller wrote them.
+*
+* @returns Every option a render reads, defaulted, with the resolver and the indent lines attached.
+*/
+const resolveOptions = (options) => {
+	const resolved = {
+		rootName: options.rootName ?? "root",
+		itemName: options.itemName ?? "item",
+		format: flag(options.format, false),
+		indent: options.indent ?? "  ",
+		suppressEmptyNode: flag(options.suppressEmptyNode, true),
+		sortKeys: flag(options.sortKeys, false),
+		name: options.name ?? "repair",
+		xmlVersion: options.xmlVersion ?? "1.0",
+		maxDepth: options.maxDepth ?? 256
+	};
+	return {
+		...resolved,
+		namer: makeNamer(resolved),
+		lineAt: makeLineAt(resolved.indent)
+	};
+};
+/**
+* @description Escapes a value for use as character data.
+*
+* @param value - The text to escape.
+*
+* @returns The text with the XML-unsafe characters replaced by predefined entities, or the very same string when there is nothing to escape.
+*/
+const escapeText = (value) => escape(value, TEXT_UNSAFE, TEXT_TABLE);
+/**
+* @description Escapes a value for use inside a double-quoted attribute.
+*
+* @param value - The text to escape.
+*
+* @returns The escaped text, with the whitespace that XML would otherwise normalize spelled as character references.
+*/
+const escapeAttribute = (value) => escape(value, ATTRIBUTE_UNSAFE, ATTRIBUTE_TABLE);
+/**
+* @description Replaces every character the table has an entry for, in one pass over the string. The pattern finds the first character that needs replacing, and a
+* string with none is handed straight back — which is the common case, and the one the pattern is there to make fast. From there the rest of the
+* string is copied in runs between the replacements rather than a character at a time, so the cost is one pattern scan, one copy, and one
+* concatenation per replacement, rather than a whole pass per character class. Only ASCII is looked up. XML carries every other character natively,
+* and a code unit above 127 has no entity an XML parser is required to know.
+*
+* @param value - The text to escape.
+* @param pattern - Matches the first character that needs replacing.
+* @param table - The replacement for each ASCII character that needs one.
+*
+* @returns The escaped text, or `value` itself when there is nothing to escape.
+*/
+const escape = (value, pattern, table) => {
+	const found = pattern.exec(value);
+	if (found === null) return value;
+	const length = value.length;
+	const start = found.index;
+	let out = value.slice(0, start);
+	let copied = start;
+	for (let index = start; index < length; index++) {
+		const code = value.charCodeAt(index);
+		const entity = code < 128 ? table[code] : void 0;
+		if (entity !== void 0) {
+			out += value.slice(copied, index) + entity;
+			copied = index + 1;
+		}
+	}
+	return copied === length ? out : out + value.slice(copied);
+};
+/**
+* @description Renders an {@link XmlValue} as an XML document.\
+* A record becomes an element:
+*
+* - `@`-prefixed keys become attributes, the reserved `#text` key becomes character data, and every other key becomes a child element.
+* - An array repeats its name — a document whose root value is an array wraps it in the root element and names each member `itemName`.
+* - A string is character data. The walk is synchronous, and what can go wrong is reported by throwing an {@link XmlRenderError}; {@link renderXml}
+*   folds that into the effect's typed error channel. A caller not already in an `Effect` runs it with `Effect.runSync`, which throws the failure it
+*   produced.
+*
+* @param value - The value to render.
+* @param options - Root name, formatting, empty-element and name-resolution settings.
+*
+* @returns An effect producing the XML document as a string.
+*/
+const renderXml = (value, options = {}) => Effect.suspend(() => Effect.fromResult(renderResult(value, options)));
+/**
+* @description Runs the synchronous walk and folds the one failure it reports into a {@link Result}, which {@link renderXml} turns back into an `Effect`. Kept
+* separate so the walk itself can throw without the public API ever throwing.
+*
+* @param value - The value to render.
+* @param options - The options as the caller wrote them.
+*
+* @returns The document, or the failure to report.
+*/
+const renderResult = (value, options) => {
+	try {
+		return Result.succeed(render(value, options));
+	} catch (cause) {
+		return Result.fail(toRenderError(cause));
+	}
+};
+/**
+* @description Reports a failure the synchronous walk threw in the render's own error type. The walk only throws an {@link XmlRenderError} of its own or an
+* {@link XmlParseError} from the name resolver; the latter carries the message the spec asserts on, so it is carried across rather than replaced.
+*
+* @param cause - Whatever was thrown.
+*
+* @returns The failure to report.
+*/
+const toRenderError = (cause) => {
+	if (cause instanceof XmlRenderError) return cause;
+	if (Predicate.isError(cause)) return new XmlRenderError({ message: cause.message });
+	return new XmlRenderError({ message: String(cause) });
+};
+/**
+* @description The synchronous walk behind {@link renderXml}.
+*
+* @param value - The value to render.
+* @param options - The options as the caller wrote them.
+*
+* @returns The XML document as a string.
+*
+* @throws {XmlRenderError} When the value nests past `maxDepth`, or the name resolver refuses a field name.
+*/
+const render = (value, options) => {
+	const resolved = resolveOptions(options);
+	const out = [];
+	if (Array.isArray(value)) {
+		const tag = resolved.namer(resolved.rootName);
+		out.push("<", tag, ">");
+		for (const member of value) renderElement(out, resolved.itemName, member, 1, resolved);
+		if (resolved.format) out.push("\n");
+		out.push("</", tag, ">");
+	} else renderElement(out, resolved.rootName, value, 0, resolved);
+	if (resolved.format) out.push("\n");
+	return out.join("");
+};
+/**
+* @description Renders one named element and its subtree. The value an {@link XmlValue} holds decides which of the four shapes below it takes — a repeated run of
+* children, character data, an absent field, or a record — and each of those is written by a function of its own, so this one is the dispatch rather
+* than the document.
+*
+* @param out - The chunk buffer to append to.
+* @param name - The element name, not yet resolved.
+* @param value - The element's value.
+* @param depth - Current nesting depth, for indentation and the depth cap.
+* @param options - Resolved render options.
+*/
+const renderElement = (out, name, value, depth, options) => {
+	assertWithinDepth(depth, options);
+	if (Array.isArray(value)) {
+		renderRepeated(out, name, value, depth, options);
+		return;
+	}
+	if (options.format && depth > 0) openLine(out, depth, options);
+	const tag = options.namer(name);
+	if (Predicate.isString(value) || Predicate.isUndefined(value)) {
+		renderLeaf(out, tag, value, options);
+		return;
+	}
+	if (!Predicate.isObject(value)) return;
+	renderRecord(out, tag, value, depth, options);
+};
+/**
+* @description Refuses to walk deeper than the render allows. A value can nest without end, and every one of those levels costs a stack frame here, so the cap is
+* checked on the way down rather than trusted to the caller.
+*
+* @param depth - The depth about to be written.
+* @param options - Resolved render options.
+*
+* @throws {XmlRenderError} When the depth is past the cap.
+*/
+const assertWithinDepth = (depth, options) => {
+	if (depth > options.maxDepth) throw new XmlRenderError({ message: `XML nesting exceeded maxDepth (${options.maxDepth}). Raise the limit if the document is legitimately this deep.` });
+};
+/**
+* @description Renders a repeated run of children under one name: `tags: ['a', 'b']` renders `<tags>a</tags><tags>b</tags>`, not one element wrapping both. The
+* name is already the element's own, so a name only has to be supplied where no name is available. Checked before the line break and the name are
+* taken, because the array itself is not an element: opening a line for it as well as for each of its members would leave a blank line where the
+* array was.
+*
+* @param out - The chunk buffer to append to.
+* @param name - The element name, not yet resolved.
+* @param members - The children to write, one after another.
+* @param depth - The depth the run sits at.
+* @param options - Resolved render options.
+*/
+const renderRepeated = (out, name, members, depth, options) => {
+	if (members.length === 0) {
+		if (options.format && depth > 0) openLine(out, depth, options);
+		writeEmpty(out, options.namer(name), options);
+		return;
+	}
+	for (const member of members) renderElement(out, name, member, depth, options);
+};
+/**
+* @description Renders an element whose value is character data, or nothing. An empty string is character data that happens to be empty, and an element holding
+* none of it is the same element as one holding nothing at all — as is an `undefined` element, which is an absent one. The renderer is handed values
+* that never went through the schema — a caller building a document by hand — so the absent case is reachable, and an empty element is the honest
+* rendering of both.
+*
+* @param out - The chunk buffer to append to.
+* @param tag - The element's name, already resolved.
+* @param value - The element's character data, or `undefined` for an absent element.
+* @param options - Resolved render options.
+*/
+const renderLeaf = (out, tag, value, options) => {
+	if (Predicate.isUndefined(value) || value === "") {
+		writeEmpty(out, tag, options);
+		return;
+	}
+	out.push("<", tag, ">", escapeText(value), "</", tag, ">");
+};
+/**
+* @description Renders an element holding a record: the attributes gathered from its `@` keys, the character data from its `#text` key, and its remaining keys as
+* child elements.
+*
+* @param out - The chunk buffer to append to.
+* @param tag - The element's name, already resolved.
+* @param record - The element's value.
+* @param depth - The depth the element sits at.
+* @param options - Resolved render options.
+*/
+const renderRecord = (out, tag, record, depth, options) => {
+	const fields = collectFields(record, options);
+	const text = textOf(record);
+	const children = fields.children;
+	if (children === void 0 && text === "") {
+		writeEmpty(out, tag, options, fields.attributes);
+		return;
+	}
+	out.push("<", tag, fields.attributes, ">");
+	if (text !== "") {
+		if (children !== void 0 && options.format) openLine(out, depth + 1, options);
+		out.push(escapeText(text));
+	}
+	if (children !== void 0) {
+		writeChildren(out, record, children, depth, options);
+		if (options.format) openLine(out, depth, options);
+	}
+	out.push("</", tag, ">");
+};
+/**
+* @description One pass over a record's keys, collecting all three roles at once: the attributes are rendered as they are found, the child names are set aside for
+* the pass that writes them, and the text key is left to {@link textOf}. A pass for the attributes, a pass for the children and an index for the text
+* instead walks the keys three times and allocates the key array twice, which on a document of a few thousand elements is thousands of allocations
+* for nothing. Sorting is off by default, and the default path is the one that matters, so the attributes are built as they are found and there is
+* nothing to sort. When it is on, the attribute keys are collected instead and rendered afterwards in sorted order, which costs an array per element
+* and buys output that does not depend on the order the fields happened to be declared in.
+*
+* @param record - The element's value.
+* @param options - Resolved render options.
+*
+* @returns The element's rendered attributes and its child names.
+*/
+const collectFields = (record, options) => {
+	const keys = Object.keys(record);
+	let attributes = "";
+	let children;
+	const sortAttributes = options.sortKeys ? [] : void 0;
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const child = record[key];
+		if (child === void 0) continue;
+		if (isAttributeKey(key)) {
+			if (sortAttributes === void 0) attributes += renderAttribute(key, child, options);
+			else sortAttributes.push(key);
+			continue;
+		}
+		if (!isTextKey(key)) (children ??= []).push(key);
+	}
+	if (sortAttributes !== void 0) {
+		sortAttributes.sort();
+		attributes += sortedAttributes(sortAttributes, record, options);
+		children?.sort();
+	}
+	return {
+		attributes,
+		children
+	};
+};
+/**
+* @description The attributes named by `keys`, rendered in the order given. Only reached when the render was asked to sort keys, where the names are collected
+* during the key pass and written here so their order does not follow the order the fields were declared in.
+*
+* @param keys - The attribute keys to write, in the order to write them.
+* @param record - The element's value, to read the attribute values out of.
+* @param options - Resolved render options.
+*
+* @returns The rendered attributes, each with its leading space.
+*/
+const sortedAttributes = (keys, record, options) => {
+	let attributes = "";
+	for (const key of keys) attributes += renderAttribute(key, record[key], options);
+	return attributes;
+};
+/**
+* @description One attribute, written whole. The leading space is part of it so the caller can concatenate attributes and the opening tag without a separator of
+* its own.
+*
+* @param key - The attribute's key, with or without its `@` prefix.
+* @param value - The attribute's value.
+* @param options - Resolved render options.
+*
+* @returns The attribute, ready to write inside the opening tag.
+*/
+const renderAttribute = (key, value, options) => {
+	return " " + options.namer(attributeName(key)) + "=\"" + escapeAttribute(attributeText(value)) + "\"";
+};
+/**
+* @description Writes an element's children, by name and in the order their keys were found. The names are what the key pass kept; the values are read back out of
+* the record here, because keeping both would mean a second array per element.
+*
+* @param out - The chunk buffer to append to.
+* @param record - The element's value.
+* @param children - The child names, in the order to write them.
+* @param depth - The depth the parent sits at; its children are one deeper.
+* @param options - Resolved render options.
+*/
+const writeChildren = (out, record, children, depth, options) => {
+	for (let i = 0; i < children.length; i++) {
+		const key = children[i];
+		const child = record[key];
+		if (child === void 0) continue;
+		renderElement(out, key, child, depth + 1, options);
+	}
+};
+/**
+* @description Starts a new line at the given depth, when pretty-printing.
+*
+* @param out - The chunk buffer to append to.
+* @param depth - The depth the line sits at.
+* @param options - Resolved render options.
+*/
+const openLine = (out, depth, options) => {
+	out.push("\n");
+	out.push(options.lineAt(depth));
+};
+/**
+* @description Writes an element with no content, in whichever of the two forms the options ask for. Every path that produces an element with nothing in it goes
+* through here, so the self-closing decision is made in exactly one place. That matters because "nothing in it" arrives four different ways — an
+* empty string, an absent value, an empty array, and a record whose fields are all absent — and four separate decisions are four chances for one of
+* them to write the long form by accident.
+*
+* @param out - The chunk buffer to append to.
+* @param tag - The element's name, already resolved.
+* @param options - Resolved render options.
+* @param attributes - The element's rendered attributes, if it has any. Defaults to none.
+*/
+const writeEmpty = (out, tag, options, attributes = "") => {
+	if (options.suppressEmptyNode) out.push("<", tag, attributes, "/>");
+	else out.push("<", tag, attributes, "></", tag, ">");
+};
+/**
+* @description An element's character data, with the reserved text key read off its value.
+*
+* @param record - The element's value.
+*
+* @returns The text to write between the tags, or `''` when the element has none.
+*/
+const textOf = (record) => {
+	const text = record[TEXT_KEY];
+	if (Predicate.isUndefined(text)) return "";
+	return Predicate.isString(text) ? text : renderScalar(text);
+};
+/**
+* @description An attribute value as the character data it is written as. A bare string is the only sensible shape, since an attribute holds nothing else. A
+* non-string is stringified rather than rejected: the schema is what enforces the field's type, and rejecting here would duplicate that check with a
+* different error and a message that names neither the field nor the document.
+*
+* @param value - The attribute's value.
+*
+* @returns The text to escape and write between the quotes.
+*/
+const attributeText = (value) => {
+	if (Predicate.isString(value)) return value;
+	if (Predicate.isUndefined(value)) return "";
+	return renderScalar(value);
+};
+/**
+* @description Renders a leaf that is not a string as the character data an XML document can hold. A schema-derived value never reaches here —
+* `Schema.toCodecStringTree` has already turned every scalar into a string — so this is for values a caller built by hand. A value with no sensible
+* text form is rendered as nothing rather than as `[object Object]`, which would silently write a document that parses back to something else.
+*
+* @param value - The leaf to render.
+*
+* @returns The leaf's textual form.
+*/
+const renderScalar = (value) => {
+	if (Predicate.isNull(value)) return "null";
+	try {
+		return JSON.stringify(value) ?? "";
+	} catch {
+		return "";
+	}
+};
+//#endregion
+export { escapeAttribute, escapeText, renderXml };
+
+//# sourceMappingURL=render.js.map