import { formatSemanticTreeText, observeSemanticTree } from "./browser";

import { extract as extractStatic, type StaticSemanticTreeOptions } from "./static";

import type { ExtractorScriptOptions, ObserverScriptOptions, SemanticNode, SemanticTreeOptions } from "./types";

export type {

AgentContract,

AgentContractFeature,

AgentAction,

AgentActionTargetChoice,

AgentAnswerPlan,

AgentBrowserHtmlCapture,

AgentCitation,

AgentContinuationMode,

AgentExpectedOutcome,

AgentExpectedOutcomeKind,

AgentExecutorStep,

AgentExecutionMode,

AgentFindMatch,

AgentFindSummary,

AgentFormChoice,

AgentFormField,

AgentFormHiddenField,

AgentHandoff,

AgentJsonEnvelope,

AgentLoopDecision,

AgentLoopDirective,

AgentNext,

AgentPageAction,

AgentPageAppHint,

AgentPageAuthorLink,

AgentPageBarrier,

AgentPageBreadcrumb,

AgentPageBreadcrumbItem,

AgentPageCitation,

AgentPageCheck,

AgentPageCodeBlock,

AgentPageApiEndpoint,

AgentPageClientState,

AgentPageConfig,

AgentPageContactPoint,

AgentPageDataTable,

AgentPageDataset,

AgentPageEvidence,

AgentPageEmbed,

AgentPageFaq,

AgentPageForm,

AgentPageHydration,

AgentPageHttpPolicy,

AgentPageIdentity,

AgentPageKeyValue,

AgentPageMedia,

AgentPageMetaFact,

AgentPageMetadata,

AgentPageMobileHint,

AgentPageOffer,

AgentPageDecision,

AgentPagePagination,

AgentPageProvenance,

AgentPageResource,

AgentPageSchemaFact,

AgentPageSchemaFactValue,

AgentPageRuntime,

AgentPageSection,

AgentPageTimeline,

AgentPageToc,

AgentPageTocItem,

AgentPageTopic,

AgentPageTranscript,

AgentQualityGate,

AgentQualityGateKind,

AgentReadTarget,

AgentReadValue,

AgentReadValueInline,

AgentReadValueKind,

AgentReadValuePayload,

AgentReadValueReference,

AgentReadValueScalar,

AgentResultChoice,

AgentRoutingIntent,

AgentSearchDecision,

AgentSemanticSummary,

AgentSignal,

AgentSignalKind,

AgentSignalSeverity,

AgentSourceChoice,

AgentSourceSearch,

AgentSourceSearchResult,

AgentStatus,

AgentSummary,

AgentTarget,

AgentVerification,

ExtractMode,

ExtractorScriptOptions,

OutputFormat,

ObserverScriptOptions,

SemanticNode,

SemanticNodeBounds,

SemanticNodeState,

SemanticTreeChange,

SemanticTreeObserverOptions,

SemanticTreeOptions,

} from "./types";

export type { StaticSemanticTreeOptions } from "./static";

export { formatSemanticTreeText, observeSemanticTree };

export function extract(html: string, options?: StaticSemanticTreeOptions): SemanticNode {

return extractStatic(html, options);

}

export function createExtractorScript(options: ExtractorScriptOptions = {}): string {

const serializedOptions = JSON.stringify(options);

return `(() => {

${browserBundleSource()}

const options = ${serializedOptions};

const tree = __AX_LITE__.extractSemanticTree(options);

return options.format === "text" ? __AX_LITE__.formatSemanticTreeText(tree) : tree;

})()`;

}

export function createObserverScript(options: ObserverScriptOptions = {}): string {

const { globalName = "__AX_LITE_OBSERVER__", ...observerOptions } = options;

const serializedOptions = JSON.stringify(observerOptions);

const serializedGlobalName = JSON.stringify(globalName);

return `(() => {

${browserBundleSource()}

const globalName = ${serializedGlobalName};

const observer = __AX_LITE__.observeSemanticTree((change) => {

window.dispatchEvent(new CustomEvent(globalName + ":change", { detail: change }));

}, ${serializedOptions});

window[globalName] = observer;

return observer.snapshot();

})()`;

}

export function flattenSemanticTree(node: SemanticNode): SemanticNode[] {

const nodes: SemanticNode[] = [];

const stack = [node];

while (stack.length > 0) {

const current = stack.shift();

if (!current) continue;

nodes.push(current);

stack.unshift(...current.children);

}

return nodes;

}

export function summarizeSemanticTree(node: SemanticNode): {

nodeCount: number;

interactiveCount: number;

roles: Record<string, number>;

namedRoles: string[];

} {

const flat = flattenSemanticTree(node);

const roles: Record<string, number> = {};

const namedRoles: string[] = [];

for (const item of flat) {

const role = item.role ?? item.tag;

roles[role] = (roles[role] ?? 0) + 1;

if (item.role && item.name) namedRoles.push(`${item.role}:${item.name}`);

}

return {

nodeCount: flat.length,

interactiveCount: flat.filter((item) => item.interactive).length,

roles,

namedRoles,

};

}

export function normalizeOptions(options: SemanticTreeOptions = {}): SemanticTreeOptions {

return {

mode: "compact",

includeBounds: true,

includeAttributes: true,

includeTextNodes: true,

includeHidden: false,

includeSelectOptions: true,

excludeLikelyAds: false,

excludeLikelyBoilerplate: false,

pruneCustomElementWrappers: true,

pruneCollapsedSubtrees: true,

pruneLikelyClosedOverlays: false,

summarizeLargeSubtrees: false,

summarizeLikelyLinkFarms: false,

summarizeRepeatedSubtrees: false,

maxChildrenPerNode: 80,

maxLinkFarmChildren: 24,

maxRepeatedSubtreeInstances: 3,

...options,

};

}

function browserBundleSource(): string {

return String.raw`

const __AX_LITE__ = (() => {

const defaultOptions = {

mode: "compact",

includeBounds: true,

includeAttributes: true,

includeTextNodes: true,

includeHidden: false,

includeSelectOptions: true,

excludeLikelyAds: false,

excludeLikelyBoilerplate: false,

pruneCustomElementWrappers: true,

pruneCollapsedSubtrees: true,

pruneLikelyClosedOverlays: false,

summarizeLargeSubtrees: false,

summarizeLikelyLinkFarms: false,

summarizeRepeatedSubtrees: false,

maxChildrenPerNode: 80,

maxLinkFarmChildren: 24,

maxRepeatedSubtreeInstances: 3,

maxTextLength: 240,

};

const interactiveRoles = new Set(["button","checkbox","combobox","link","listbox","menuitem","menuitemcheckbox","menuitemradio","option","radio","searchbox","slider","spinbutton","switch","tab","textbox","treeitem"]);

const landmarkTags = { article: "article", aside: "complementary", footer: "contentinfo", form: "form", header: "banner", main: "main", nav: "navigation", section: "region" };

const rolesNamedFromContents = new Set(["button","cell","checkbox","columnheader","heading","link","menuitem","menuitemcheckbox","menuitemradio","option","radio","rowheader","switch","tab","treeitem"]);

function extractSemanticTree(options = {}) {

const rootDocument = document;

const context = { options: { ...defaultOptions, ...options }, nextId: 1, rootDocument };

return walkElement(rootDocument.body || rootDocument.documentElement, context) || unavailableNode(context, "document", "Document has no inspectable body");

}

function formatSemanticTreeText(node) {

const lines = [];

function visit(current, depth) {

const prefix = " ".repeat(depth);

const role = current.role || current.tag;

const marker = current.interactive ? "[i] " : "";

const name = current.name ? " '" + current.name + "'" : "";

const state = formatState(current.state);

const unavailable = current.unavailableReason ? " (" + current.unavailableReason + ")" : "";

lines.push(prefix + marker + role + name + state + unavailable);

for (const child of current.children) visit(child, depth + 1);

}

visit(node, 0);

return lines.join("\n");

}

function observeSemanticTree(onChange, options = {}) {

const root = document.documentElement;

const debounceMs = options.debounceMs ?? 50;

let mutationCount = 0;

let timeoutId;

function snapshot() { return extractSemanticTree(options); }

function emit() {

timeoutId = undefined;

onChange({ tree: snapshot(), changedAt: Date.now(), mutationCount });

mutationCount = 0;

}

const observer = new MutationObserver((mutations) => {

mutationCount += mutations.length;

if (timeoutId !== undefined) window.clearTimeout(timeoutId);

timeoutId = window.setTimeout(emit, debounceMs);

});

observer.observe(root, { attributes: true, characterData: true, childList: true, subtree: true });

return {

disconnect() {

if (timeoutId !== undefined) window.clearTimeout(timeoutId);

observer.disconnect();

},

snapshot,

};

}

function walkElement(element, context) {

if (!context.options.includeHidden && isHidden(element)) return null;

if (context.options.excludeLikelyAds && isLikelyAd(element)) return null;

const role = getRole(element);

const state = getState(element, context);

const focusable = isFocusable(element);

const interactive = isInteractive(element, role, focusable);

const name = role ? computeName(element, role, context) : "";

const description = computeDescription(element, context);

const tag = element.tagName.toLowerCase();

const children = collectChildren(element, context);

if (context.options.mode === "interactive" && !interactive) return children.length > 0 ? containerNode(context, tag, children) : null;

if (shouldPrune(element, role, name, interactive, children, context)) return children.length === 1 ? children[0] || null : containerNode(context, tag, children);

const node = { id: nextId(context), tag, role, name, interactive, focusable, children };

if (description) node.description = description;

const text = getDirectText(element, context.options.maxTextLength);

if (text) node.text = text;

const value = getValue(element);

if (value) node.value = value;

if (Object.keys(state).length > 0) node.state = state;

node.selector = getCssPath(element);

node.xpath = getXPath(element);

if (context.options.includeBounds) node.bounds = getBounds(element);

if (context.options.includeAttributes) node.attributes = getAttributes(element);

appendSpecialChildren(element, node, context);

appendShadowChildren(element, node, context);

appendFrameChildren(element, node, context);

return node;

}

function collectChildren(element, context) {

const children = [];

for (const child of Array.from(element.childNodes)) {

if (child.nodeType === Node.ELEMENT_NODE) {

if (!context.options.includeSelectOptions && element instanceof HTMLSelectElement) continue;

const semanticChild = walkElement(child, context);

if (semanticChild) children.push(semanticChild);

} else if (context.options.includeTextNodes && child.nodeType === Node.TEXT_NODE) {

const text = normalizeText(child.textContent || "", context.options.maxTextLength);

if (text) children.push({ id: nextId(context), tag: "#text", role: "text", name: text, text, interactive: false, focusable: false, children: [] });

}

}

return children;

}

function shouldPrune(element, role, name, interactive, children, context) {

if (context.options.mode === "full") return false;

if (role === "none" || role === "presentation") return true;

if (interactive) return false;

if (context.options.pruneCustomElementWrappers && isCustomElement(element)) return children.length > 0;

if (role && role !== "generic") return false;

if (name) return false;

if (element.id || element.getAttribute("aria-label") || element.getAttribute("aria-labelledby")) return false;

return children.length > 0;

}

function getRole(element) {

const explicit = firstToken(element.getAttribute("role"));

if (explicit) return explicit;

const tag = element.tagName.toLowerCase();

if (tag === "section" && !hasExplicitNameSource(element)) return null;

if (tag === "form" && !hasExplicitNameSource(element)) return null;

if (tag in landmarkTags) return landmarkTags[tag] || null;

if (/^h[1-6]$/.test(tag)) return "heading";

if (tag === "a" || tag === "area") return element.hasAttribute("href") ? "link" : null;

if (tag === "button") return "button";

if (tag === "details") return "group";

if (tag === "dialog") return "dialog";

if (tag === "fieldset") return "group";

if (tag === "figure") return "figure";

if (tag === "iframe") return "iframe";

if (tag === "img") return hasEmptyAlt(element) ? "presentation" : "img";

if (tag === "li") return "listitem";

if (tag === "ol" || tag === "ul") return "list";

if (tag === "optgroup") return "group";

if (tag === "option") return "option";

if (tag === "output") return "status";

if (tag === "progress") return "progressbar";

if (tag === "select") return element.hasAttribute("multiple") ? "listbox" : "combobox";

if (tag === "summary") return "button";

if (tag === "table") return "table";

if (tag === "caption") return "caption";

if (tag === "tbody" || tag === "tfoot" || tag === "thead") return "rowgroup";

if (tag === "td") return "cell";

if (tag === "textarea") return "textbox";

if (tag === "th") return element.getAttribute("scope") === "row" ? "rowheader" : "columnheader";

if (tag === "tr") return "row";

if (tag === "input") return inputRole(element);

return null;

}

function inputRole(input) {

const type = (input.getAttribute("type") || "text").toLowerCase();

if (type === "button" || type === "image" || type === "reset" || type === "submit") return "button";

if (type === "checkbox") return "checkbox";

if (type === "email" || type === "tel" || type === "text" || type === "url") return "textbox";

if (type === "number") return "spinbutton";

if (type === "radio") return "radio";

if (type === "range") return "slider";

if (type === "search") return "searchbox";

if (type === "hidden") return null;

return "textbox";

}

function computeName(element, role, context) {

if (element.getAttribute("aria-labelledby")) {

const labelled = textFromIds(element.getAttribute("aria-labelledby") || "", context.rootDocument);

if (labelled) return labelled;

}

const ariaLabel = element.getAttribute("aria-label");

if (ariaLabel) return normalizeText(ariaLabel, context.options.maxTextLength);

if (element instanceof HTMLInputElement && isButtonLikeInput(element)) return normalizeText(element.value || element.getAttribute("value") || inputFallbackName(element), context.options.maxTextLength);

if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) {

const label = labelText(element, context);

if (label) return label;

const placeholder = element.getAttribute("placeholder");

if (placeholder) return normalizeText(placeholder, context.options.maxTextLength);

}

if (element instanceof HTMLImageElement) return normalizeText(element.alt || element.getAttribute("title") || "", context.options.maxTextLength);

if (element instanceof HTMLFieldSetElement) {

const legend = element.querySelector(":scope > legend");

if (legend) return getVisibleText(legend, context.options.maxTextLength);

}

if (rolesNamedFromContents.has(role)) {

const ownText = getVisibleText(element, context.options.maxTextLength);

if (ownText) return ownText;

}

return normalizeText(element.getAttribute("title") || "", context.options.maxTextLength);

}

function computeDescription(element, context) {

const describedBy = element.getAttribute("aria-describedby");

if (describedBy) return textFromIds(describedBy, context.rootDocument);

return normalizeText(element.getAttribute("title") || "", context.options.maxTextLength);

}

function labelText(element, context) {

if (element.labels && element.labels.length > 0) return normalizeText(Array.from(element.labels).map((label) => getVisibleText(label, context.options.maxTextLength)).join(" "), context.options.maxTextLength);

return "";

}

function getState(element, context) {

const state = {};

if (isHidden(element)) state.hidden = true;

if (isDisabled(element)) state.disabled = true;

const busy = ariaBoolean(element.getAttribute("aria-busy"));

if (busy !== undefined) state.busy = busy;

const multiselectable = ariaBoolean(element.getAttribute("aria-multiselectable"));

if (multiselectable !== undefined) state.multiselectable = multiselectable;

const sort = element.getAttribute("aria-sort");

if (sort) state.sort = normalizeText(sort, 40);

const grabbed = ariaBoolean(element.getAttribute("aria-grabbed"));

if (grabbed !== undefined) state.grabbed = grabbed;

const dropEffect = element.getAttribute("aria-dropeffect");

if (dropEffect) state.dropEffect = normalizeText(dropEffect, 80);

if (element === document.activeElement) state.focused = true;

const checked = ariaBooleanOrMixed(element.getAttribute("aria-checked"));

if (checked !== undefined) state.checked = checked;

else if (element instanceof HTMLInputElement && (element.type === "checkbox" || element.type === "radio")) state.checked = element.checked;

const selected = ariaBoolean(element.getAttribute("aria-selected"));

if (selected !== undefined) state.selected = selected;

else if (element instanceof HTMLOptionElement) state.selected = element.selected;

const expanded = ariaBoolean(element.getAttribute("aria-expanded"));

if (expanded !== undefined) state.expanded = expanded;

const pressed = ariaBooleanOrMixed(element.getAttribute("aria-pressed"));

if (pressed !== undefined) state.pressed = pressed;

const required = ariaBoolean(element.getAttribute("aria-required"));

if (required !== undefined) state.required = required;

else if ("required" in element && Boolean(element.required)) state.required = true;

const invalid = element.getAttribute("aria-invalid");

if (invalid && invalid !== "false") state.invalid = invalid === "true" ? true : invalid;

if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) if (element.readOnly) state.readonly = true;

const current = element.getAttribute("aria-current");

if (current && current !== "false") state.current = current === "true" ? true : current;

const haspopup = element.getAttribute("aria-haspopup");

if (haspopup && haspopup !== "false") state.haspopup = haspopup === "true" ? true : haspopup;

const controls = element.getAttribute("aria-controls");

if (controls) state.controls = normalizeText(controls, context.options.maxTextLength);

const live = element.getAttribute("aria-live");

if (live) state.live = normalizeText(live, context.options.maxTextLength);

if (element.getAttribute("aria-modal") === "true") state.modal = true;

const orientation = element.getAttribute("aria-orientation");

if (orientation) state.orientation = normalizeText(orientation, 40);

const valueMin = ariaNumber(element.getAttribute("aria-valuemin"));

if (typeof valueMin === "number") state.valueMin = valueMin;

const valueMax = ariaNumber(element.getAttribute("aria-valuemax"));

if (typeof valueMax === "number") state.valueMax = valueMax;

const valueNow = ariaNumber(element.getAttribute("aria-valuenow"));

if (typeof valueNow === "number") state.valueNow = valueNow;

const valueText = element.getAttribute("aria-valuetext");

if (valueText) state.valueText = normalizeText(valueText, context.options.maxTextLength);

return state;

}

function isHidden(element) {

if (element.hasAttribute("hidden")) return true;

if (element.getAttribute("aria-hidden") === "true") return true;

const style = getComputedStyle(element);

if (style.display === "none" || style.visibility === "hidden" || style.contentVisibility === "hidden") return true;

if (Number(style.opacity) === 0) return true;

return false;

}

function isLikelyAd(element) { const haystack = [element.id, element.getAttribute("class"), element.getAttribute("aria-label"), element.getAttribute("data-testid"), element.getAttribute("data-test-id"), element.getAttribute("data-name")].filter(Boolean).join(" ").toLowerCase(); if (/\b(ad|ads|advert|advertisement|sponsor|sponsored|placement)\b/.test(haystack)) return true; if (element instanceof HTMLAnchorElement && normalizeText(element.textContent || "", 80).toLowerCase() === "ad") return true; return false; }

function isDisabled(element) { return element.getAttribute("aria-disabled") === "true" || ("disabled" in element && Boolean(element.disabled)); }

function isFocusable(element) {

if (isDisabled(element) || isHidden(element)) return false;

const tabindex = element.getAttribute("tabindex");

if (tabindex !== null) return Number(tabindex) >= 0;

return element.matches("a[href],area[href],button,input,select,textarea,summary,iframe,[contenteditable=''],[contenteditable='true']");

}

function isInteractive(element, role, focusable) {

if (role && interactiveRoles.has(role)) return true;

if (element.matches("a[href],button,input,select,textarea,summary,option")) return true;

if (element.hasAttribute("onclick")) return true;

return focusable && Boolean(role);

}

function appendSpecialChildren(element, node, context) {

if (!context.options.includeSelectOptions) return;

if (element instanceof HTMLSelectElement) {

for (const option of Array.from(element.options)) node.children.push({ id: nextId(context), tag: "option", role: "option", name: normalizeText(option.textContent || "", context.options.maxTextLength), value: option.value, state: { selected: option.selected, disabled: option.disabled }, interactive: false, focusable: false, selector: getCssPath(option), xpath: getXPath(option), children: [] });

}

}

function isCustomElement(element) { return element.tagName.includes("-"); }

function appendShadowChildren(element, node, context) {

const shadowRoot = element.shadowRoot;

if (!shadowRoot) return;

for (const child of Array.from(shadowRoot.children)) {

const semanticChild = walkElement(child, context);

if (semanticChild) node.children.push(semanticChild);

}

}

function appendFrameChildren(element, node, context) {

if (!(element instanceof HTMLIFrameElement)) return;

try {

const frameDocument = element.contentDocument;

if (!frameDocument || !frameDocument.body) {

node.children.push(unavailableNode(context, "iframe", "iframe document unavailable"));

return;

}

const previousDocument = context.rootDocument;

context.rootDocument = frameDocument;

const child = walkElement(frameDocument.body, context);

context.rootDocument = previousDocument;

if (child) node.children.push(child);

} catch {

node.children.push(unavailableNode(context, "iframe", "cross-origin iframe"));

}

}

function unavailableNode(context, tag, reason) { return { id: nextId(context), tag, role: null, name: "", interactive: false, focusable: false, unavailableReason: reason, children: [] }; }

function containerNode(context, tag, children) { return { id: nextId(context), tag, role: null, name: "", interactive: false, focusable: false, children }; }

function getValue(element) { if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) return element.value; return normalizeText(element.getAttribute("aria-valuetext") || element.getAttribute("aria-valuenow") || "", 80); }

function getDirectText(element, maxLength) { return normalizeText(Array.from(element.childNodes).filter((node) => node.nodeType === Node.TEXT_NODE).map((node) => node.textContent || "").join(" "), maxLength); }

function getVisibleText(element, maxLength) { const parts = []; function visit(node) { if (node.nodeType === Node.TEXT_NODE) { parts.push(node.textContent || ""); return; } if (node.nodeType !== Node.ELEMENT_NODE) return; const childElement = node; if (isHidden(childElement)) return; for (const child of Array.from(childElement.childNodes)) visit(child); } visit(element); return normalizeText(parts.join(" "), maxLength); }

function getAttributes(element) { const attributes = {}; for (const attribute of Array.from(element.attributes)) if (attribute.name === "id" || attribute.name === "href" || attribute.name === "type" || attribute.name === "role" || attribute.name === "alt" || attribute.name === "title" || attribute.name.startsWith("aria-") || attribute.name.startsWith("data-")) attributes[attribute.name] = attribute.value; return attributes; }

function getBounds(element) { const rect = element.getBoundingClientRect(); return { x: round(rect.x), y: round(rect.y), width: round(rect.width), height: round(rect.height) }; }

function getCssPath(element) { if (element.id) return "#" + cssEscape(element.id); const segments = []; let current = element; while (current && current.nodeType === Node.ELEMENT_NODE && current !== document.documentElement) { const tag = current.tagName.toLowerCase(); const parent = current.parentElement; if (!parent) { segments.unshift(tag); break; } const siblings = Array.from(parent.children).filter((child) => child.tagName === current.tagName); const index = siblings.indexOf(current) + 1; segments.unshift(siblings.length > 1 ? tag + ":nth-of-type(" + index + ")" : tag); current = parent; } return segments.join(" > "); }

function getXPath(element) { const segments = []; let current = element; while (current && current.nodeType === Node.ELEMENT_NODE) { const tag = current.tagName.toLowerCase(); const parent = current.parentElement; if (!parent) { segments.unshift("/" + tag + "[1]"); break; } const sameTag = Array.from(parent.children).filter((child) => child.tagName === current.tagName); segments.unshift("/" + tag + "[" + (sameTag.indexOf(current) + 1) + "]"); current = parent; } return segments.join(""); }

function textFromIds(ids, rootDocument) { return normalizeText(ids.split(/\s+/).map((id) => { const element = rootDocument.getElementById(id); return element ? getVisibleText(element, 240) : ""; }).filter(Boolean).join(" "), 240); }

function normalizeText(value, maxLength) { const normalized = value.replace(/\s+/g, " ").trim(); return normalized.length > maxLength ? normalized.slice(0, maxLength - 1) + "…" : normalized; }

function firstToken(value) { return (value && value.trim().split(/\s+/)[0]) || null; }

function hasExplicitNameSource(element) { return Boolean(element.getAttribute("aria-label") || element.getAttribute("aria-labelledby") || element.getAttribute("title")); }

function hasEmptyAlt(element) { return element.hasAttribute("alt") && element.getAttribute("alt") === ""; }

function isButtonLikeInput(input) { return ["button", "image", "reset", "submit"].includes((input.getAttribute("type") || "").toLowerCase()); }

function inputFallbackName(input) { const type = (input.getAttribute("type") || "").toLowerCase(); if (type === "submit") return "Submit"; if (type === "reset") return "Reset"; return ""; }

function ariaBoolean(value) { if (value === "true") return true; if (value === "false") return false; return undefined; }

function ariaBooleanOrMixed(value) { if (value === "mixed") return "mixed"; return ariaBoolean(value); }

function ariaNumber(value) {

if (value === null || value.trim() === "") return undefined;

const parsed = Number(value);

return Number.isFinite(parsed) ? parsed : undefined;

}

function formatState(state) { if (!state) return ""; const entries = Object.entries(state).filter(([, value]) => value !== undefined); return entries.length > 0 ? " [" + entries.map(([key, value]) => key + "=" + String(value)).join(" ") + "]" : ""; }

function nextId(context) { const id = "n" + context.nextId; context.nextId += 1; return id; }

function round(value) { return Math.round(value * 100) / 100; }

function cssEscape(value) { if (typeof CSS !== "undefined" && typeof CSS.escape === "function") return CSS.escape(value); return value.replace(/[^a-zA-Z0-9_-]/g, (char) => "\\" + char); }

return { extractSemanticTree, formatSemanticTreeText, observeSemanticTree };

})();

`;

}