@stll/folio-core 0.65.0 → 0.66.0

package/dist/docx/streamingXmlParser.js

@@ -1,406 +0,0 @@
-import { EMPTY_NAMESPACE_SCOPE, attachXmlNamespaceContext } from "./xmlNamespaceContext.js";
-import { FOLIO_XML_RESOURCE_LIMITS } from "./xmlResourceLimits.js";
-import { isOoxmlNumericIdAttributeName } from "@stll/docx-core";
-// src/docx/streamingXmlParser.ts
-const sourceRanges = /* @__PURE__ */ new WeakMap();
-/** Exact element source ranges, available only from the opt-in source-range reader. */
-const getXmlSourceRange = (element) => sourceRanges.get(element);
-const BUILT_IN_ENTITIES = {
-	amp: "&",
-	apos: "'",
-	gt: ">",
-	lt: "<",
-	quot: "\""
-};
-const parseStreamingXmlInternal = (options) => {
-	const { xml, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE } = options;
-	const visitOpenTag = options.visitOpenTag;
-	let spanMode = "none";
-	if (visitOpenTag !== void 0) spanMode = options.mode === "tree" ? "identities" : "all";
-	if (options.visitElement !== void 0) spanMode = "all";
-	const openTagOptions = {
-		xml,
-		start: 0,
-		close: 0,
-		spanMode,
-		retainAttribute: options.mode === "attributes" ? options.retainAttribute : void 0
-	};
-	const root = { elements: [] };
-	const stack = [];
-	const replacements = [];
-	let cursor = 0;
-	let mergeAdjacentText = false;
-	const acceptText = (text, merge) => {
-		if (options.mode === "tree") return appendText(text, stack, merge);
-		const decoded = decodeXmlEntities(normalizeLineEndings(text));
-		return decoded !== null && (stack.length > 0 || decoded.trim().length === 0);
-	};
-	while (cursor < xml.length) {
-		const open = xml.indexOf("<", cursor);
-		if (open === -1) {
-			if (!acceptText(xml.slice(cursor), mergeAdjacentText)) return { status: "unsupported" };
-			break;
-		}
-		if (open > cursor && !acceptText(xml.slice(cursor, open), mergeAdjacentText)) return { status: "unsupported" };
-		if (open > cursor) mergeAdjacentText = true;
-		if (xml.startsWith("<!--", open)) {
-			const close = xml.indexOf("-->", open + 4);
-			if (close === -1) return { status: "unsupported" };
-			cursor = close + 3;
-			continue;
-		}
-		if (xml.startsWith("<![CDATA[", open)) {
-			const close = xml.indexOf("]]>", open + 9);
-			const text = normalizeLineEndings(xml.slice(open + 9, close));
-			if (close === -1 || !(options.mode === "tree" ? appendRawText(text, stack) : stack.length > 0 || text.trim().length === 0)) return { status: "unsupported" };
-			cursor = close + 3;
-			mergeAdjacentText = false;
-			continue;
-		}
-		if (xml.startsWith("<?", open)) {
-			const close = xml.indexOf("?>", open + 2);
-			if (close === -1) return { status: "unsupported" };
-			cursor = close + 2;
-			mergeAdjacentText = false;
-			continue;
-		}
-		if (xml.startsWith("<!", open)) return { status: "unsupported" };
-		const close = findTagClose(xml, open + 1);
-		if (close === -1) return { status: "unsupported" };
-		if (xml.charCodeAt(open + 1) === 47) {
-			const name = xml.slice(open + 2, close).trim();
-			const frame = stack.pop();
-			if (!frame || frame.name !== name) return { status: "unsupported" };
-			if (frame.start !== void 0) sourceRanges.set(frame.element, {
-				start: frame.start,
-				end: close + 1
-			});
-			cursor = close + 1;
-			mergeAdjacentText = false;
-			continue;
-		}
-		openTagOptions.start = open + 1;
-		openTagOptions.close = close;
-		const parsedTag = parseOpenTag(openTagOptions);
-		if (parsedTag.status === "unsupported") return parsedTag;
-		const parent = stack.at(-1)?.element;
-		const scope = parent?.namespaceScope ?? inheritedNamespaceScope;
-		if (options.mode === "attributes" && options.retainAttribute !== void 0 && parsedTag.element.attributes === void 0) parsedTag.element.namespaceScope = scope;
-		else attachXmlNamespaceContext(parsedTag.element, scope);
-		options.visitElement?.({
-			element: parsedTag.element,
-			attributeValueSpans: parsedTag.attributeValueSpans ?? /* @__PURE__ */ new Map(),
-			nameEnd: parsedTag.nameEnd,
-			parent
-		});
-		const rewritten = (options.mode === "tree" ? parsedTag.attributeValueSpans !== void 0 : options.retainAttribute === void 0 || parsedTag.element.attributes !== void 0) ? visitOpenTag?.(parsedTag.element, parsedTag.attributeValueSpans ?? /* @__PURE__ */ new Map()) : null;
-		if (rewritten) for (const [attributeName, value] of rewritten) {
-			const span = parsedTag.attributeValueSpans?.get(attributeName);
-			if (!span) return { status: "unsupported" };
-			replacements.push({
-				...span,
-				value
-			});
-		}
-		if (options.mode === "tree") appendElement(parent ?? root, parsedTag.element);
-		if (!parsedTag.selfClosing) {
-			if (stack.length >= FOLIO_XML_RESOURCE_LIMITS.maxDepth) return { status: "unsupported" };
-			stack.push(options.mode === "tree" && options.sourceRanges === "tracked" ? {
-				element: parsedTag.element,
-				name: parsedTag.name,
-				start: open
-			} : {
-				element: parsedTag.element,
-				name: parsedTag.name
-			});
-		} else if (options.mode === "tree" && options.sourceRanges === "tracked") sourceRanges.set(parsedTag.element, {
-			start: open,
-			end: close + 1
-		});
-		cursor = close + 1;
-		mergeAdjacentText = false;
-	}
-	if (stack.length > 0) return { status: "unsupported" };
-	return {
-		status: "parsed",
-		value: root,
-		replacements
-	};
-};
-/**
-* @param inheritedNamespaceScope the bindings in scope around `xml`, for a
-*   fragment captured out of a part whose root declared them.
-*/
-const parseStreamingXml = (xml, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE) => {
-	const parsed = parseStreamingXmlInternal({
-		xml,
-		mode: "tree",
-		inheritedNamespaceScope
-	});
-	return parsed.status === "parsed" ? {
-		status: "parsed",
-		value: parsed.value
-	} : { status: "unsupported" };
-};
-/** Retain source spans for every element without changing the parsed namespace tree. */
-const parseStreamingXmlWithSourceRanges = (xml, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE) => {
-	const parsed = parseStreamingXmlInternal({
-		xml,
-		mode: "tree",
-		inheritedNamespaceScope,
-		sourceRanges: "tracked"
-	});
-	return parsed.status === "parsed" ? {
-		status: "parsed",
-		value: parsed.value
-	} : { status: "unsupported" };
-};
-/** Retain the body tree while collecting identities for import repair. */
-const parseStreamingXmlWithIdentityVisitor = (xml, visitOpenTag) => {
-	const parsed = parseStreamingXmlInternal({
-		xml,
-		mode: "tree",
-		visitOpenTag
-	});
-	return parsed.status === "parsed" ? {
-		status: "parsed",
-		value: parsed.value
-	} : parsed;
-};
-/** Rewrite selected decimal attribute values while preserving every other source byte. */
-const rewriteStreamingXmlDecimalAttributes = (xml, visitOpenTag) => {
-	const parsed = parseStreamingXmlInternal({
-		xml,
-		mode: "attributes",
-		visitOpenTag
-	});
-	if (parsed.status === "unsupported") return parsed;
-	const chunks = [];
-	let cursor = 0;
-	for (const replacement of parsed.replacements.toSorted((left, right) => left.start - right.start)) {
-		if (!/^\d+$/u.test(replacement.value)) return { status: "unsupported" };
-		chunks.push(xml.slice(cursor, replacement.start), replacement.value);
-		cursor = replacement.end;
-	}
-	chunks.push(xml.slice(cursor));
-	return {
-		status: "rewritten",
-		value: chunks.join("")
-	};
-};
-/** Visit identity attributes and namespace bindings without building an XML tree. */
-const scanStreamingXmlNumericIdAttributes = (xml, visitOpenTag) => {
-	const parsed = parseStreamingXmlInternal({
-		xml,
-		mode: "attributes",
-		visitOpenTag,
-		retainAttribute: ({ attributeName, elementName }) => {
-			if (attributeName === "xmlns" || attributeName.startsWith("xmlns:")) return true;
-			return isOoxmlNumericIdAttributeName({
-				elementName,
-				attributeName
-			});
-		}
-	});
-	return parsed.status === "parsed" ? { status: "scanned" } : parsed;
-};
-/** Visit namespace-resolved start tags and source spans without building a tree. */
-const scanStreamingXmlElements = (xml, visitElement) => {
-	const parsed = parseStreamingXmlInternal({
-		xml,
-		mode: "attributes",
-		visitOpenTag: () => null,
-		visitElement
-	});
-	return parsed.status === "parsed" ? { status: "scanned" } : parsed;
-};
-const parseOpenTag = ({ xml, start, close, spanMode, retainAttribute }) => {
-	let cursor = skipWhitespace(xml, start, close);
-	const nameStart = cursor;
-	cursor = scanName(xml, cursor, close);
-	if (cursor === nameStart) return { status: "unsupported" };
-	const name = xml.slice(nameStart, cursor);
-	const nameEnd = cursor;
-	if (isUnsafePropertyName(name)) return { status: "unsupported" };
-	let attributes;
-	let attributeValueSpans;
-	let selfClosing = false;
-	while (cursor < close) {
-		cursor = skipWhitespace(xml, cursor, close);
-		if (cursor >= close) break;
-		if (xml.charCodeAt(cursor) === 47) {
-			selfClosing = true;
-			cursor = skipWhitespace(xml, cursor + 1, close);
-			if (cursor !== close) return { status: "unsupported" };
-			break;
-		}
-		const attributeNameStart = cursor;
-		cursor = scanName(xml, cursor, close);
-		if (cursor === attributeNameStart) return { status: "unsupported" };
-		const attributeName = xml.slice(attributeNameStart, cursor);
-		if (isUnsafePropertyName(attributeName)) return { status: "unsupported" };
-		cursor = skipWhitespace(xml, cursor, close);
-		if (xml.charCodeAt(cursor) !== 61) return { status: "unsupported" };
-		cursor = skipWhitespace(xml, cursor + 1, close);
-		const quote = xml.charCodeAt(cursor);
-		if (quote !== 34 && quote !== 39) return { status: "unsupported" };
-		const valueStart = cursor + 1;
-		cursor = xml.indexOf(quote === 34 ? "\"" : "'", valueStart);
-		if (cursor === -1 || cursor > close) return { status: "unsupported" };
-		const decoded = decodeXmlEntities(normalizeLineEndings(xml.slice(valueStart, cursor)));
-		if (decoded === null) return { status: "unsupported" };
-		if (retainAttribute === void 0 || retainAttribute({
-			attributeName,
-			elementName: name
-		})) {
-			attributes ??= {};
-			attributes[attributeName] = decoded;
-			if (spanMode === "all" || spanMode === "identities" && isOoxmlNumericIdAttributeName({
-				elementName: name,
-				attributeName
-			})) {
-				attributeValueSpans ??= /* @__PURE__ */ new Map();
-				attributeValueSpans.set(attributeName, {
-					start: valueStart,
-					end: cursor
-				});
-			}
-		}
-		cursor += 1;
-	}
-	const element = {
-		type: "element",
-		name
-	};
-	if (attributes) element.attributes = attributes;
-	return {
-		status: "parsed",
-		element,
-		name,
-		nameEnd,
-		selfClosing,
-		attributeValueSpans
-	};
-};
-const appendElement = (parent, child) => {
-	parent.elements ??= [];
-	parent.elements.push(child);
-};
-const appendText = (text, stack, mergeAdjacentText) => {
-	if (text.length === 0) return true;
-	const decoded = decodeXmlEntities(normalizeLineEndings(text));
-	if (decoded === null) return false;
-	const parent = stack.at(-1)?.element;
-	const previous = mergeAdjacentText ? parent?.elements?.at(-1) : void 0;
-	if (previous?.type === "text" && typeof previous.text === "string") {
-		previous.text += decoded;
-		return true;
-	}
-	return appendRawText(decoded, stack);
-};
-const appendRawText = (text, stack) => {
-	const parent = stack.at(-1)?.element;
-	if (!parent) return text.trim().length === 0;
-	appendElement(parent, {
-		type: "text",
-		text
-	});
-	return true;
-};
-const findTagClose = (xml, start) => {
-	let quote = 0;
-	for (let cursor = start; cursor < xml.length; cursor += 1) {
-		const code = xml.charCodeAt(cursor);
-		if (quote !== 0) {
-			if (code === quote) quote = 0;
-			continue;
-		}
-		if (code === 34 || code === 39) {
-			quote = code;
-			continue;
-		}
-		if (code === 62) return cursor;
-	}
-	return -1;
-};
-const skipWhitespace = (xml, start, limit) => {
-	let cursor = start;
-	while (cursor < limit) {
-		const code = xml.charCodeAt(cursor);
-		if (code !== 9 && code !== 10 && code !== 13 && code !== 32) break;
-		cursor += 1;
-	}
-	return cursor;
-};
-const scanName = (xml, start, limit) => {
-	let cursor = start;
-	while (cursor < limit) {
-		const code = xml.charCodeAt(cursor);
-		if (code === 9 || code === 10 || code === 13 || code === 32 || code === 47 || code === 61 || code === 62) break;
-		cursor += 1;
-	}
-	return cursor;
-};
-const decodeXmlEntities = (value) => {
-	const firstEntity = value.indexOf("&");
-	if (firstEntity === -1) return value;
-	const parts = [];
-	let cursor = 0;
-	let entityStart = firstEntity;
-	while (entityStart !== -1) {
-		parts.push(value.slice(cursor, entityStart));
-		const entityEnd = value.indexOf(";", entityStart + 1);
-		if (entityEnd === -1) return null;
-		const entity = value.slice(entityStart + 1, entityEnd);
-		const decoded = decodeXmlEntity(entity);
-		if (decoded === null) return null;
-		parts.push(decoded);
-		cursor = entityEnd + 1;
-		entityStart = value.indexOf("&", cursor);
-	}
-	parts.push(value.slice(cursor));
-	return parts.join("");
-};
-const normalizeLineEndings = (value) => {
-	if (!value.includes("\r")) return value;
-	return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
-};
-const decodeXmlEntity = (entity) => {
-	switch (entity) {
-		case "amp": return BUILT_IN_ENTITIES.amp;
-		case "apos": return BUILT_IN_ENTITIES.apos;
-		case "gt": return BUILT_IN_ENTITIES.gt;
-		case "lt": return BUILT_IN_ENTITIES.lt;
-		case "quot": return BUILT_IN_ENTITIES.quot;
-	}
-	if (entity.charCodeAt(0) !== 35) return null;
-	const hexadecimal = entity.charCodeAt(1) === 120 || entity.charCodeAt(1) === 88;
-	const digits = entity.slice(hexadecimal ? 2 : 1);
-	if (digits.length === 0 || !hasOnlyDigits(digits, hexadecimal)) return null;
-	const codePoint = Number.parseInt(digits, hexadecimal ? 16 : 10);
-	if (!Number.isInteger(codePoint) || codePoint <= 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343) return null;
-	return String.fromCodePoint(codePoint);
-};
-const hasOnlyDigits = (value, hexadecimal) => {
-	for (let index = 0; index < value.length; index += 1) {
-		const code = value.charCodeAt(index);
-		if (!(code >= 48 && code <= 57) && !(hexadecimal && code >= 97 && code <= 102) && !(hexadecimal && code >= 65 && code <= 70)) return false;
-	}
-	return true;
-};
-const isUnsafePropertyName = (name) => {
-	switch (name) {
-		case "__defineGetter__":
-		case "__defineSetter__":
-		case "__lookupGetter__":
-		case "__lookupSetter__":
-		case "__proto__":
-		case "constructor":
-		case "hasOwnProperty":
-		case "prototype":
-		case "toString":
-		case "valueOf": return true;
-		default: return false;
-	}
-};
-export { getXmlSourceRange, parseStreamingXml, parseStreamingXmlWithIdentityVisitor, parseStreamingXmlWithSourceRanges, rewriteStreamingXmlDecimalAttributes, scanStreamingXmlElements, scanStreamingXmlNumericIdAttributes };

package/dist/docx/xmlNamespaceContext.d.ts

@@ -1,6 +0,0 @@
-import { XmlElement, XmlNamespaceScope } from "./xmlParser.js";
-export declare const EMPTY_NAMESPACE_SCOPE: XmlNamespaceScope;
-export declare const XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
-export declare const resolveNamespaceUri: (scope: XmlNamespaceScope | undefined, prefix: string) => string | undefined;
-/** Attach the element's resolved namespace metadata from its in-scope declarations. */
-export declare const attachXmlNamespaceContext: (element: XmlElement, inheritedNamespaceScope?: XmlNamespaceScope) => XmlNamespaceScope;

package/dist/docx/xmlNamespaceContext.js

@@ -1,53 +0,0 @@
-// src/docx/xmlNamespaceContext.ts
-const EMPTY_NAMESPACE_SCOPE = { bindings: /* @__PURE__ */ new Map() };
-/**
-* Reserved by the XML Namespaces recommendation (§3): every document binds
-* this prefix to this URI whether or not it declares `xmlns:xml`, and no
-* document may bind it to anything else. A source that omits the declaration
-* — the overwhelming majority — must still resolve `xml:space`, `xml:lang`
-* and `xml:id` to it, or a reader mistakes the attribute for an unprefixed
-* one and a save drops its prefix.
-*/
-const XML_RESERVED_PREFIX = "xml";
-const XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
-const resolveNamespaceUri = (scope, prefix) => {
-	let current = scope;
-	while (current) {
-		const value = current.bindings.get(prefix);
-		if (value !== void 0) return value;
-		current = current.parent;
-	}
-	return prefix === XML_RESERVED_PREFIX ? XML_NAMESPACE_URI : void 0;
-};
-/** Attach the element's resolved namespace metadata from its in-scope declarations. */
-const attachXmlNamespaceContext = (element, inheritedNamespaceScope = EMPTY_NAMESPACE_SCOPE) => {
-	let localBindings = null;
-	if (element.attributes) for (const [attribute, value] of Object.entries(element.attributes)) {
-		if (typeof value !== "string" || attribute !== "xmlns" && !attribute.startsWith("xmlns:")) continue;
-		localBindings ??= /* @__PURE__ */ new Map();
-		const prefix = attribute === "xmlns" ? "" : attribute.slice(6);
-		localBindings.set(prefix, value);
-	}
-	const namespaceScope = localBindings === null ? inheritedNamespaceScope : {
-		bindings: localBindings,
-		parent: inheritedNamespaceScope
-	};
-	Object.defineProperty(element, "namespaceScope", {
-		configurable: false,
-		enumerable: false,
-		value: namespaceScope,
-		writable: false
-	});
-	const name = element.name ?? "";
-	const colonIndex = name.indexOf(":");
-	const prefix = colonIndex === -1 ? "" : name.slice(0, colonIndex);
-	const namespaceUri = resolveNamespaceUri(namespaceScope, prefix);
-	if (namespaceUri !== void 0) Object.defineProperty(element, "namespaceUri", {
-		configurable: false,
-		enumerable: false,
-		value: namespaceUri,
-		writable: false
-	});
-	return namespaceScope;
-};
-export { EMPTY_NAMESPACE_SCOPE, XML_NAMESPACE_URI, attachXmlNamespaceContext, resolveNamespaceUri };

package/dist/docx/xmlResourceLimits.d.ts

@@ -1,107 +0,0 @@
-import { TaggedErrorClass } from "better-result";
-declare const XmlResourceLimitErrorBase: TaggedErrorClass<"XmlResourceLimitError">;
-/**
- * Shared bounds for XML parts parsed by Folio.
- *
- * `maxBytes` and the package expansion ceiling bound the *markup*; they do not
- * bound what parsing that markup allocates. A parsed element retains far more
- * than the bytes it was written as, so a part that satisfies a byte bound can
- * still cost multiples of it in tree. Measured on this repository's corpus
- * generators (Bun 1.4, arm64, heap retained after a forced GC):
- *
- *   shape                       bytes/element   tree heap / part bytes
- *   `<w:r/>`                          49.5 B            8.3x
- *   `<w:r a=".." x4/>`               105-124 B          2.8-3.3x
- *   `<w:r><w:t>x</w:t></w:r>`        162-171 B         14.1-14.8x
- *
- * An element is therefore the unit a memory bound has to count, because the
- * adversarial shape is the cheap one: `<w:r/>` is 7 bytes of markup and 49.5
- * bytes of tree, so 128 MiB of markup buys ~19M elements and ~950 MB of tree
- * inside a byte budget that never trips.
- *
- * Corpus distribution (5,314 readable packages, every XML and .rels part):
- *
- *   metric                     p50      p90      p99    p99.9        max
- *   elements / part             16      227    1,590   24,719    596,668
- *   elements / package         917    3,230   29,106   71,975    602,212
- *   attributes / part           27      577    1,993   21,037    630,374
- *   attributes / package     1,783    4,711   25,896   91,946    639,110
- *   depth / part                 3        9       15       22     15,005
- *   elements per byte        0.012    0.027    0.036    0.043      0.111
- *
- * The defaults below reject no corpus package that today's bounds accept. The
- * package budget is the one that matters: it caps a whole package at ~2.5M
- * elements and ~3M attributes, which is at most ~425 MB of tree at the densest
- * measured shape and ~124 MB at the cheapest. Before it existed, only
- * `word/document.xml`, `word/styles.xml` and `word/numbering.xml` were counted
- * at all, so a package of many merely-large parts could reach the expansion
- * ceiling of 250 MiB, ~37M elements and well past 1.8 GB of tree while passing
- * every bound. Lower these to trade format reach for a smaller ceiling.
- */
-export declare const FOLIO_XML_RESOURCE_LIMITS: {
-  readonly maxBytes: number;
-  readonly maxDepth: 100;
-  /** 1.68x the corpus maximum (596,668). Unchanged; a shipped bound is not loosened. */
-  readonly maxElementsPerPart: 1000000;
-  /** 3.97x the corpus maximum (630,374). */
-  readonly maxAttributesPerPart: 2500000;
-  /** 4.15x the corpus maximum (602,212). */
-  readonly maxElementsPerPackage: 2500000;
-  /** 4.69x the corpus maximum (639,110). */
-  readonly maxAttributesPerPackage: 3000000;
-};
-export type XmlResourceLimits = {
-  maxBytes: number;
-  maxDepth: number;
-  maxElementsPerPart: number;
-  maxAttributesPerPart: number;
-  maxElementsPerPackage: number;
-  maxAttributesPerPackage: number;
-};
-type XmlResourceLimitKind = "bytes" | "depth" | "elements" | "attributes" | "package-elements" | "package-attributes" | "syntax";
-/** XML input exceeded a parser resource bound or could not be scanned safely. */
-export declare class XmlResourceLimitError extends XmlResourceLimitErrorBase<{
-  message: string;
-  limit: XmlResourceLimitKind;
-  /** The package part being scanned, when the caller named one. */
-  partPath?: string;
-  /** The count reached at the point of refusal, not the count of the whole input. */
-  observed: number;
-  allowed: number;
-}> {}
-/**
- * What a package has spent so far, shared by every part in one package.
- *
- * Per-part bounds alone do not bound a package: a package may hold hundreds of
- * parts, each individually modest. The budget is the accumulator the readers
- * carry across parts so the ceiling is the package's, not each part's.
- */
-export type XmlPackageBudget = {
-  elements: number;
-  attributes: number;
-};
-export declare const createXmlPackageBudget: () => XmlPackageBudget;
-export declare const exceedsUtf8ByteLimit: (value: string, maxBytes: number) => boolean;
-export type XmlResourceScanOptions = {
-  xml: string;
-  limits?: XmlResourceLimits;
-  /** The package path scanned, carried on any refusal so a host can name it. */
-  partPath?: string;
-  /** Charged as the scan proceeds; omit for a part with no package context. */
-  budget?: XmlPackageBudget;
-};
-/** What the preflight counted, for callers that reconcile it against the tree. */
-export type XmlResourceScanResult = {
-  elements: number;
-  attributes: number;
-  maxDepth: number;
-};
-/**
- * Bound XML bytes, element count, attribute count and nesting before building
- * an object tree. The lexical scan is iterative, so deeply nested input cannot
- * consume the JS call stack before the depth limit is enforced, and every
- * bound is checked at the point it is crossed, so the work done before a
- * refusal is proportional to the limit rather than to the input.
- */
-export declare const assertXmlResourceLimits: ({ xml, limits, partPath, budget }: XmlResourceScanOptions) => XmlResourceScanResult;
-export {};