persona-dsl 26.1.20.8__py3-none-any.whl

persona_dsl/runtime/dist/persona_bundle.js

@@ -0,0 +1,1077 @@
+"use strict";
+(() => {
+  // src/utils/hash.ts
+  function hashString(str) {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+      hash = (hash << 5) + hash + str.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(36);
+  }
+
+  // src/core/IdGenerator.ts
+  var IdGenerator = class {
+    /**
+     * Generates a deterministic ID for an element based on its context.
+     * Includes siblingIndex to ensure uniqueness for identical siblings.
+     */
+    generate(parentId, role, element, siblingIndex) {
+      const tag = element.tagName.toLowerCase();
+      const idAttr = element.getAttribute("id") || "";
+      const testId = element.getAttribute("data-test-id") || element.getAttribute("data-testid") || "";
+      const href = element.getAttribute("href") || "";
+      const accessibleName = (element.getAttribute("aria-label") || "").slice(0, 40);
+      const safeName = accessibleName.replace(/\s+/g, "_");
+      const localSignature = [
+        tag,
+        role || "",
+        idAttr,
+        testId,
+        href,
+        safeName,
+        siblingIndex
+        // Critical for uniqueness
+      ].join("|");
+      const raw = `${parentId}:${localSignature}`;
+      return hashString(raw);
+    }
+  };
+
+  // src/utils/dom.ts
+  var cacheStyle;
+  var cacheStyleBefore;
+  var cacheStyleAfter;
+  var domCachesCounter = 0;
+  function beginDOMCaches() {
+    ++domCachesCounter;
+    cacheStyle || (cacheStyle = /* @__PURE__ */ new Map());
+    cacheStyleBefore || (cacheStyleBefore = /* @__PURE__ */ new Map());
+    cacheStyleAfter || (cacheStyleAfter = /* @__PURE__ */ new Map());
+  }
+  function endDOMCaches() {
+    if (!--domCachesCounter) {
+      cacheStyle = void 0;
+      cacheStyleBefore = void 0;
+      cacheStyleAfter = void 0;
+    }
+  }
+  function getElementComputedStyle(element, pseudo) {
+    const cache = pseudo === "::before" ? cacheStyleBefore : pseudo === "::after" ? cacheStyleAfter : cacheStyle;
+    if (cache && cache.has(element))
+      return cache.get(element);
+    const style = element.ownerDocument && element.ownerDocument.defaultView ? element.ownerDocument.defaultView.getComputedStyle(element, pseudo) : void 0;
+    cache && style && cache.set(element, style);
+    return style;
+  }
+  function isElementStyleVisibilityVisible(element, style) {
+    style = style || getElementComputedStyle(element);
+    if (!style)
+      return true;
+    if (Element.prototype.checkVisibility) {
+      if (!element.checkVisibility())
+        return false;
+    } else {
+      const detailsOrSummary = element.closest("details,summary");
+      if (detailsOrSummary !== element && detailsOrSummary && detailsOrSummary.nodeName === "DETAILS" && !detailsOrSummary.open)
+        return false;
+    }
+    if (style.visibility !== "visible")
+      return false;
+    return true;
+  }
+  function isVisibleTextNode(node) {
+    if (node.nodeType !== Node.TEXT_NODE)
+      return false;
+    const range = node.ownerDocument.createRange();
+    range.selectNode(node);
+    const rect = range.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0;
+  }
+  function elementSafeTagName(element) {
+    const tagName = element.tagName;
+    if (typeof tagName === "string")
+      return tagName.toUpperCase();
+    if (element instanceof HTMLFormElement)
+      return "FORM";
+    return element.tagName.toUpperCase();
+  }
+  function parentElementOrShadowHost(element) {
+    if (element.parentElement)
+      return element.parentElement;
+    if (!element.parentNode)
+      return void 0;
+    if (element.parentNode.nodeType === 11 && element.parentNode.host)
+      return element.parentNode.host;
+    return void 0;
+  }
+  function enclosingShadowRootOrDocument(element) {
+    let node = element;
+    while (node && node.parentNode)
+      node = node.parentNode;
+    if (node && (node.nodeType === 11 || node.nodeType === 9))
+      return node;
+    return void 0;
+  }
+
+  // src/utils/aria.ts
+  function hasExplicitAccessibleName(e) {
+    return e.hasAttribute("aria-label") || e.hasAttribute("aria-labelledby");
+  }
+  var kAncestorPreventingLandmark = "article:not([role]), aside:not([role]), main:not([role]), nav:not([role]), section:not([role]), [role=article], [role=complementary], [role=main], [role=navigation], [role=region]";
+  var kGlobalAriaAttributes = [
+    ["aria-atomic", void 0],
+    ["aria-busy", void 0],
+    ["aria-controls", void 0],
+    ["aria-current", void 0],
+    ["aria-describedby", void 0],
+    ["aria-details", void 0],
+    ["aria-dropeffect", void 0],
+    ["aria-flowto", void 0],
+    ["aria-grabbed", void 0],
+    ["aria-hidden", void 0],
+    ["aria-keyshortcuts", void 0],
+    ["aria-label", ["caption", "code", "deletion", "emphasis", "generic", "insertion", "paragraph", "presentation", "strong", "subscript", "superscript"]],
+    ["aria-labelledby", ["caption", "code", "deletion", "emphasis", "generic", "insertion", "paragraph", "presentation", "strong", "subscript", "superscript"]],
+    ["aria-live", void 0],
+    ["aria-owns", void 0],
+    ["aria-relevant", void 0],
+    ["aria-roledescription", ["generic"]]
+  ];
+  function hasGlobalAriaAttribute(element, forRole) {
+    return kGlobalAriaAttributes.some(([attr, prohibited]) => {
+      return !(prohibited || []).includes(forRole || "") && element.hasAttribute(attr);
+    });
+  }
+  function hasTabIndex(element) {
+    return !Number.isNaN(Number(String(element.getAttribute("tabindex"))));
+  }
+  function isNativelyDisabled(element) {
+    const tag = elementSafeTagName(element);
+    const isNativeFormControl = ["BUTTON", "INPUT", "SELECT", "TEXTAREA", "OPTION", "OPTGROUP"].includes(tag);
+    if (!isNativeFormControl)
+      return false;
+    if (element.hasAttribute("disabled"))
+      return true;
+    if (tag === "OPTION" && element.closest("OPTGROUP[DISABLED]"))
+      return true;
+    const fieldSetElement = element.closest("FIELDSET[DISABLED]");
+    if (!fieldSetElement)
+      return false;
+    const legendElement = fieldSetElement.querySelector(":scope > LEGEND");
+    return !legendElement || !legendElement.contains(element);
+  }
+  function isFocusable(element) {
+    const tagName = elementSafeTagName(element);
+    const nativelyFocusable = ["BUTTON", "DETAILS", "SELECT", "TEXTAREA"].includes(tagName) || (tagName === "A" || tagName === "AREA") && element.hasAttribute("href") || tagName === "INPUT" && !element.hidden;
+    return !isNativelyDisabled(element) && (nativelyFocusable || hasTabIndex(element));
+  }
+  var kImplicitRoleByTagName = {
+    "A": (e) => e.hasAttribute("href") ? "link" : null,
+    "AREA": (e) => e.hasAttribute("href") ? "link" : null,
+    "ARTICLE": () => "article",
+    "ASIDE": () => "complementary",
+    "BLOCKQUOTE": () => "blockquote",
+    "BUTTON": () => "button",
+    "CAPTION": () => "caption",
+    "CODE": () => "code",
+    "DATALIST": () => "listbox",
+    "DEL": () => "deletion",
+    "DETAILS": () => "group",
+    "DFN": () => "term",
+    "DIALOG": () => "dialog",
+    "DT": () => "term",
+    "EM": () => "emphasis",
+    "FIELDSET": () => "group",
+    "FIGURE": () => "figure",
+    "FOOTER": (e) => e.closest(kAncestorPreventingLandmark) ? null : "contentinfo",
+    "FORM": (e) => hasExplicitAccessibleName(e) ? "form" : null,
+    "H1": () => "heading",
+    "H2": () => "heading",
+    "H3": () => "heading",
+    "H4": () => "heading",
+    "H5": () => "heading",
+    "H6": () => "heading",
+    "HEADER": (e) => e.closest(kAncestorPreventingLandmark) ? null : "banner",
+    "HR": () => "separator",
+    "HTML": () => "document",
+    "IMG": (e) => e.getAttribute("alt") === "" && !e.getAttribute("title") && !hasGlobalAriaAttribute(e) && !hasTabIndex(e) ? "presentation" : "img",
+    "INPUT": (e) => {
+      const type = e.type.toLowerCase();
+      if (type === "search")
+        return e.hasAttribute("list") ? "combobox" : "searchbox";
+      if (["email", "tel", "text", "url", ""].includes(type)) {
+        const listId = e.getAttribute("list");
+        const root = enclosingShadowRootOrDocument(e);
+        const list = listId && root ? root.querySelector("#" + CSS.escape(listId)) : null;
+        return list && elementSafeTagName(list) === "DATALIST" ? "combobox" : "textbox";
+      }
+      if (type === "hidden")
+        return null;
+      if (type === "file")
+        return "button";
+      const inputTypeToRole = {
+        "button": "button",
+        "checkbox": "checkbox",
+        "image": "button",
+        "number": "spinbutton",
+        "radio": "radio",
+        "range": "slider",
+        "reset": "button",
+        "submit": "button"
+      };
+      return inputTypeToRole[type] || "textbox";
+    },
+    "INS": () => "insertion",
+    "LI": () => "listitem",
+    "MAIN": () => "main",
+    "MARK": () => "mark",
+    "MATH": () => "math",
+    "MENU": () => "list",
+    "METER": () => "meter",
+    "NAV": () => "navigation",
+    "OL": () => "list",
+    "OPTGROUP": () => "group",
+    "OPTION": () => "option",
+    "OUTPUT": () => "status",
+    "P": () => "paragraph",
+    "PROGRESS": () => "progressbar",
+    "SEARCH": () => "search",
+    "SECTION": (e) => hasExplicitAccessibleName(e) ? "region" : null,
+    "SELECT": (e) => e.hasAttribute("multiple") || e.size > 1 ? "listbox" : "combobox",
+    "STRONG": () => "strong",
+    "SUB": () => "subscript",
+    "SUP": () => "superscript",
+    "SVG": () => "img",
+    "TABLE": () => "table",
+    "TBODY": () => "rowgroup",
+    "TD": (e) => {
+      const table = e.closest("table");
+      const role = table ? getExplicitAriaRole(table) : "";
+      return role === "grid" || role === "treegrid" ? "gridcell" : "cell";
+    },
+    "TEXTAREA": () => "textbox",
+    "TFOOT": () => "rowgroup",
+    "TH": (e) => {
+      const scope = e.getAttribute("scope");
+      if (scope === "col" || scope === "colgroup")
+        return "columnheader";
+      if (scope === "row" || scope === "rowgroup")
+        return "rowheader";
+      return "columnheader";
+    },
+    "THEAD": () => "rowgroup",
+    "TIME": () => "time",
+    "TR": () => "row",
+    "UL": () => "list"
+  };
+  var validRoles = [
+    "alert",
+    "alertdialog",
+    "application",
+    "article",
+    "banner",
+    "blockquote",
+    "button",
+    "caption",
+    "cell",
+    "checkbox",
+    "code",
+    "columnheader",
+    "combobox",
+    "complementary",
+    "contentinfo",
+    "definition",
+    "deletion",
+    "dialog",
+    "directory",
+    "document",
+    "emphasis",
+    "feed",
+    "figure",
+    "form",
+    "generic",
+    "grid",
+    "gridcell",
+    "group",
+    "heading",
+    "img",
+    "insertion",
+    "link",
+    "list",
+    "listbox",
+    "listitem",
+    "log",
+    "main",
+    "mark",
+    "marquee",
+    "math",
+    "meter",
+    "menu",
+    "menubar",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "navigation",
+    "none",
+    "note",
+    "option",
+    "paragraph",
+    "presentation",
+    "progressbar",
+    "radio",
+    "radiogroup",
+    "region",
+    "row",
+    "rowgroup",
+    "rowheader",
+    "scrollbar",
+    "search",
+    "searchbox",
+    "separator",
+    "slider",
+    "spinbutton",
+    "status",
+    "strong",
+    "subscript",
+    "superscript",
+    "switch",
+    "tab",
+    "table",
+    "tablist",
+    "tabpanel",
+    "term",
+    "textbox",
+    "time",
+    "timer",
+    "toolbar",
+    "tooltip",
+    "tree",
+    "treegrid",
+    "treeitem"
+  ];
+  function getExplicitAriaRole(element) {
+    const roles = (element.getAttribute("role") || "").split(" ").map((r) => r.trim());
+    return roles.find((role) => validRoles.includes(role)) || null;
+  }
+  var kPresentationInheritanceParents = {
+    "DD": ["DL", "DIV"],
+    "DIV": ["DL"],
+    "DT": ["DL", "DIV"],
+    "LI": ["OL", "UL"],
+    "TBODY": ["TABLE"],
+    "TD": ["TR"],
+    "TFOOT": ["TABLE"],
+    "TH": ["TR"],
+    "THEAD": ["TABLE"],
+    "TR": ["THEAD", "TBODY", "TFOOT", "TABLE"]
+  };
+  function getImplicitAriaRole(element) {
+    const implicit = (kImplicitRoleByTagName[elementSafeTagName(element)] || (() => null))(element) || "";
+    if (!implicit)
+      return null;
+    let ancestor = element;
+    while (ancestor) {
+      const parent = parentElementOrShadowHost(ancestor);
+      if (!parent)
+        break;
+      const parents = kPresentationInheritanceParents[elementSafeTagName(ancestor)];
+      if (!parents || !parents.includes(elementSafeTagName(parent)))
+        break;
+      const parentExplicitRole = getExplicitAriaRole(parent);
+      if ((parentExplicitRole === "none" || parentExplicitRole === "presentation") && hasPresentationConflictResolution(parent, parentExplicitRole))
+        return parentExplicitRole;
+      ancestor = parent;
+    }
+    return implicit;
+  }
+  function hasPresentationConflictResolution(element, role) {
+    return hasGlobalAriaAttribute(element, role) || isFocusable(element);
+  }
+  function getAriaRole(element) {
+    const explicitRole = getExplicitAriaRole(element);
+    if (!explicitRole)
+      return getImplicitAriaRole(element);
+    if (explicitRole === "none" || explicitRole === "presentation") {
+      const implicitRole = getImplicitAriaRole(element);
+      if (implicitRole && hasPresentationConflictResolution(element, implicitRole))
+        return implicitRole;
+    }
+    return explicitRole;
+  }
+  function getAriaBoolean(attr) {
+    return attr === null ? void 0 : attr.toLowerCase() === "true";
+  }
+  function isElementIgnoredForAria(element) {
+    const tag = elementSafeTagName(element);
+    return ["STYLE", "SCRIPT", "NOSCRIPT", "TEMPLATE"].includes(tag);
+  }
+  var cacheIsHidden;
+  function belongsToDisplayNoneOrAriaHiddenOrNonSlotted(element) {
+    let hidden = cacheIsHidden && cacheIsHidden.get(element);
+    if (hidden === void 0) {
+      hidden = false;
+      if (element.parentElement && element.parentElement.shadowRoot && !element.slot)
+        hidden = true;
+      if (!hidden) {
+        const style = getElementComputedStyle(element);
+        hidden = !style || style.display === "none" || getAriaBoolean(element.getAttribute("aria-hidden")) === true;
+      }
+      if (!hidden) {
+        const parent = parentElementOrShadowHost(element);
+        if (parent)
+          hidden = belongsToDisplayNoneOrAriaHiddenOrNonSlotted(parent);
+      }
+      cacheIsHidden && cacheIsHidden.set(element, hidden);
+    }
+    return hidden;
+  }
+  function isElementHiddenForAria(element) {
+    if (element === (element.ownerDocument && element.ownerDocument.body))
+      return false;
+    if (isElementIgnoredForAria(element))
+      return true;
+    const style = getElementComputedStyle(element);
+    const isSlot = element.nodeName === "SLOT";
+    if (style && style.display === "contents" && !isSlot) {
+      for (let child = element.firstChild; child; child = child.nextSibling) {
+        if (child.nodeType === 1 && !isElementHiddenForAria(child))
+          return false;
+        if (child.nodeType === 3 && isVisibleTextNode(child))
+          return false;
+      }
+      return true;
+    }
+    const isOptionInsideSelect = element.nodeName === "OPTION" && !!element.closest("select");
+    if (!isOptionInsideSelect && !isSlot && !isElementStyleVisibilityVisible(element, style))
+      return true;
+    return belongsToDisplayNoneOrAriaHiddenOrNonSlotted(element);
+  }
+  function getIdRefs(element, ref) {
+    if (!ref)
+      return [];
+    const root = enclosingShadowRootOrDocument(element);
+    if (!root)
+      return [];
+    try {
+      const ids = ref.split(" ").filter((id) => !!id);
+      const result = [];
+      for (const id of ids) {
+        const el = root.querySelector("#" + CSS.escape(id));
+        if (el && !result.includes(el))
+          result.push(el);
+      }
+      return result;
+    } catch (e) {
+      return [];
+    }
+  }
+  var cacheAccessibleName;
+  var cacheAccessibleNameHidden;
+  function beginAriaCaches() {
+    cacheAccessibleName = /* @__PURE__ */ new Map();
+    cacheAccessibleNameHidden = /* @__PURE__ */ new Map();
+    cacheIsHidden = /* @__PURE__ */ new Map();
+  }
+  function endAriaCaches() {
+    cacheAccessibleName = void 0;
+    cacheAccessibleNameHidden = void 0;
+    cacheIsHidden = void 0;
+  }
+  function asFlatString(s) {
+    return s.split("\xA0").map((chunk) => chunk.replace(/\r\n/g, "\n").replace(/[\u200b\u00ad]/g, "").replace(/\s\s*/g, " ")).join("\xA0").trim();
+  }
+  var kRolesAllowNameFromContent = /* @__PURE__ */ new Set([
+    // Interactive + "meaningful" roles where name-from-content is expected even with nested markup.
+    "button",
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "checkbox",
+    "radio",
+    "switch",
+    "tab",
+    "option",
+    "textbox",
+    "searchbox",
+    "combobox",
+    "heading",
+    // Common structural leaves.
+    "cell",
+    "gridcell",
+    "rowheader",
+    "columnheader"
+  ]);
+  function getCSSContent(element, pseudo) {
+    const style = getElementComputedStyle(element, pseudo);
+    if (!style)
+      return void 0;
+    const raw = style.getPropertyValue("content");
+    const content = (raw || "").trim();
+    if (!content || content === "none" || content === "normal")
+      return void 0;
+    if (content.startsWith('"') && content.endsWith('"') || content.startsWith("'") && content.endsWith("'")) {
+      return content.slice(1, -1);
+    }
+    return void 0;
+  }
+  function getElementAccessibleName(element, includeHidden) {
+    const cache = includeHidden ? cacheAccessibleNameHidden : cacheAccessibleName;
+    if (cache && cache.has(element))
+      return cache.get(element);
+    const role = getAriaRole(element) || "generic";
+    const elementProhibitsNaming = [
+      "caption",
+      "code",
+      "definition",
+      "deletion",
+      "emphasis",
+      // важно: НЕ блокируем generic/paragraph/mark/etc. — текст этих контейнеров нужен как имя,
+      // если у них нет дочерних ELEMENT_NODE. Поэтому сюда не добавляем 'generic', 'paragraph', и т.п.
+      "presentation",
+      "strong",
+      "subscript",
+      "suggestion",
+      "superscript",
+      "term",
+      "time",
+      "menu",
+      "menubar"
+    ];
+    const hasExplicitName = hasExplicitAccessibleName(element);
+    const hasElementChildren = !!element.firstElementChild || !!(element.shadowRoot && element.shadowRoot.firstElementChild);
+    if (!hasExplicitName && hasElementChildren) {
+      const isNonSemantic = role === "generic" || role === "paragraph";
+      if (isNonSemantic || !kRolesAllowNameFromContent.has(role)) {
+        cache && cache.set(element, "");
+        return "";
+      }
+    }
+    if (elementProhibitsNaming.includes(role)) {
+      cache && cache.set(element, "");
+      return "";
+    }
+    const name = asFlatString(
+      getTextAlternativeInternal(element, {
+        includeHidden,
+        visitedElements: /* @__PURE__ */ new Set(),
+        embeddedInTargetElement: "self"
+      })
+    );
+    cache && cache.set(element, name);
+    return name;
+  }
+  function innerAccumulatedElementText(element, options) {
+    const tokens = [];
+    function visit(node, skipSlotted) {
+      if (skipSlotted && node.assignedSlot)
+        return;
+      if (node.nodeType === 1) {
+        const display = (getElementComputedStyle(node) || {}).display || "inline";
+        let token = getTextAlternativeInternal(node, options);
+        if (display !== "inline" || node.nodeName === "BR")
+          token = " " + token + " ";
+        tokens.push(token);
+      } else if (node.nodeType === 3) {
+        tokens.push(node.textContent || "");
+      }
+    }
+    tokens.push(getCSSContent(element, "::before") || "");
+    const content = getCSSContent(element);
+    if (content !== void 0) {
+      tokens.push(content);
+    } else {
+      const assignedNodes = element.nodeName === "SLOT" ? element.assignedNodes() : [];
+      if (assignedNodes.length) {
+        for (const child of assignedNodes)
+          visit(child, false);
+      } else {
+        for (let child = element.firstChild; child; child = child.nextSibling)
+          visit(child, true);
+        if (element.shadowRoot) {
+          for (let child = element.shadowRoot.firstChild; child; child = child.nextSibling)
+            visit(child, true);
+        }
+        for (const owned of getIdRefs(element, element.getAttribute("aria-owns")))
+          visit(owned, true);
+      }
+    }
+    tokens.push(getCSSContent(element, "::after") || "");
+    return tokens.join("");
+  }
+  function getAriaLabelledByElements(element) {
+    const ref = element.getAttribute("aria-labelledby");
+    if (ref === null)
+      return null;
+    const refs = getIdRefs(element, ref);
+    return refs.length ? refs : null;
+  }
+  function getLabelElementsForControl(element) {
+    const labels = [];
+    const id = element.getAttribute("id");
+    if (id) {
+      const root = enclosingShadowRootOrDocument(element);
+      if (root) {
+        try {
+          const byFor = root.querySelectorAll('label[for="' + CSS.escape(id) + '"]');
+          byFor && byFor.forEach((n) => {
+            if (!labels.includes(n))
+              labels.push(n);
+          });
+        } catch (e) {
+        }
+      }
+    }
+    let parent = element.parentElement;
+    while (parent) {
+      if (parent.tagName.toUpperCase() === "LABEL") {
+        if (!labels.includes(parent))
+          labels.push(parent);
+        break;
+      }
+      parent = parentElementOrShadowHost(parent) || parent.parentElement;
+    }
+    return labels;
+  }
+  function getTextAlternativeInternal(element, options) {
+    if (options.visitedElements.has(element))
+      return "";
+    options.visitedElements.add(element);
+    const childOptions = {
+      ...options,
+      embeddedInTargetElement: options.embeddedInTargetElement === "self" ? "descendant" : options.embeddedInTargetElement
+    };
+    if (!options.includeHidden) {
+      const hiddenRefTraversal = !!(options.embeddedInLabelledBy && options.embeddedInLabelledBy.hidden) || !!(options.embeddedInDescribedBy && options.embeddedInDescribedBy.hidden) || !!(options.embeddedInNativeTextAlternative && options.embeddedInNativeTextAlternative.hidden) || !!(options.embeddedInLabel && options.embeddedInLabel.hidden);
+      if (isElementIgnoredForAria(element) || !hiddenRefTraversal && isElementHiddenForAria(element)) {
+        return "";
+      }
+    }
+    const labelledBy = getAriaLabelledByElements(element);
+    if (!options.embeddedInLabelledBy && labelledBy) {
+      const accessibleName = labelledBy.map(
+        (ref) => getTextAlternativeInternal(ref, {
+          ...options,
+          embeddedInLabelledBy: { element: ref, hidden: isElementHiddenForAria(ref) },
+          embeddedInDescribedBy: void 0,
+          embeddedInTargetElement: void 0,
+          embeddedInLabel: void 0,
+          embeddedInNativeTextAlternative: void 0
+        })
+      ).join(" ");
+      if (accessibleName)
+        return accessibleName;
+    }
+    const ariaLabel = element.getAttribute("aria-label") || "";
+    if (ariaLabel.trim()) {
+      return ariaLabel;
+    }
+    const tagName = elementSafeTagName(element);
+    if (tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT") {
+      const labels = getLabelElementsForControl(element);
+      if (labels.length) {
+        const labelsText = labels.map(
+          (labelEl) => innerAccumulatedElementText(labelEl, {
+            ...options,
+            embeddedInLabel: { element: labelEl, hidden: isElementHiddenForAria(labelEl) }
+          })
+        ).join(" ").trim();
+        if (labelsText) {
+          return labelsText;
+        }
+      }
+    }
+    return innerAccumulatedElementText(element, childOptions);
+  }
+
+  // src/core/TreeWalker.ts
+  var TreeWalker = class {
+    constructor() {
+      this.idGenerator = new IdGenerator();
+      this.visited = /* @__PURE__ */ new Set();
+    }
+    snapshot(root) {
+      beginDOMCaches();
+      beginAriaCaches();
+      this.visited.clear();
+      try {
+        const raw = this.processNode(root, "root", 0, true);
+        if (!raw)
+          return null;
+        return this.normalizeTree(raw);
+      } finally {
+        endAriaCaches();
+        endDOMCaches();
+        this.visited.clear();
+      }
+    }
+    /**
+     * Упрощает дерево, убирая пустые generic-обёртки без собственного содержимого.
+     *
+     * Правила:
+     * - Узлы с role="generic" и пустым name, без props/статусов и с одним дочерним AriaNode
+     *   схлопываются: возвращается их единственный ребёнок.
+     * - Всё остальное сохраняется как есть.
+     */
+    normalizeTree(node) {
+      const simplify = (n) => {
+        const normalizedChildren = [];
+        for (const child of n.children) {
+          if (typeof child === "string")
+            continue;
+          normalizedChildren.push(simplify(child));
+        }
+        n.children = normalizedChildren;
+        const isPlainGeneric = n.role === "generic" && !n.name && (!n.props || Object.keys(n.props).length === 0) && !n.disabled && !n.checked && !n.expanded && !n.selected && !n.pressed && !n.level && n.children.length === 1;
+        if (isPlainGeneric) {
+          return n.children[0];
+        }
+        return n;
+      };
+      return simplify(node);
+    }
+    processNode(element, parentId, index, forceVisible = false) {
+      if (this.visited.has(element))
+        return null;
+      this.visited.add(element);
+      const hidden = isElementHiddenForAria(element);
+      const tagName = element.tagName.toUpperCase();
+      const semanticRoles = ["A", "BUTTON", "INPUT", "SELECT", "TEXTAREA", "OPTION", "LI"];
+      if (!forceVisible && hidden && !semanticRoles.includes(tagName))
+        return null;
+      const role = getAriaRole(element) || "";
+      let name = getElementAccessibleName(element, false);
+      if (role === "none" || role === "presentation") {
+        name = "";
+      }
+      let finalRole = role || "generic";
+      let linkWrapperInfo = null;
+      if (finalRole === "menuitem" && tagName === "LI") {
+        const anchor = element.querySelector("a[href]");
+        const text = anchor ? (anchor.textContent || "").trim() : "";
+        if (anchor && text && text.toLowerCase() !== "ellipsis") {
+          finalRole = "generic";
+          name = "";
+          linkWrapperInfo = { anchor, text };
+        }
+      }
+      const id = this.idGenerator.generate(parentId, finalRole, element, index);
+      element.setAttribute("data-persona-id", id);
+      const node = {
+        role: finalRole,
+        name,
+        ref: id,
+        children: [],
+        element,
+        props: {}
+      };
+      if (linkWrapperInfo) {
+        const href = linkWrapperInfo.anchor.getAttribute("href") || "";
+        const linkId = this.idGenerator.generate(id, "link", linkWrapperInfo.anchor, 0);
+        linkWrapperInfo.anchor.setAttribute("data-persona-id", linkId);
+        const linkNode = {
+          role: "link",
+          name: linkWrapperInfo.text,
+          ref: linkId,
+          children: [],
+          element: linkWrapperInfo.anchor,
+          props: {}
+        };
+        if (href)
+          linkNode.props.url = href;
+        if (hidden) {
+          linkNode.hidden = true;
+        }
+        node.children.push(linkNode);
+        this.visited.add(linkWrapperInfo.anchor);
+      }
+      const ariaHiddenAttr = element.getAttribute("aria-hidden");
+      const isHiddenAria = ariaHiddenAttr === "true";
+      const isHiddenVisual = isElementHiddenForAria(element);
+      if (isHiddenAria || isHiddenVisual) {
+        node.hidden = true;
+      }
+      if (element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true") {
+        node.disabled = true;
+      }
+      if (finalRole === "checkbox" || finalRole === "radio" || finalRole === "menuitemcheckbox" || finalRole === "menuitemradio") {
+        const checked = element.getAttribute("aria-checked") || element.checked;
+        if (checked === "true" || checked === true)
+          node.checked = true;
+        else if (checked === "mixed")
+          node.checked = "mixed";
+      }
+      if (element.hasAttribute("aria-expanded")) {
+        node.expanded = element.getAttribute("aria-expanded") === "true";
+      }
+      if (element.hasAttribute("aria-selected")) {
+        node.selected = element.getAttribute("aria-selected") === "true";
+      }
+      if (element.hasAttribute("aria-pressed")) {
+        const pressed = element.getAttribute("aria-pressed");
+        if (pressed === "true")
+          node.pressed = true;
+        else if (pressed === "mixed")
+          node.pressed = "mixed";
+      }
+      if (element.hasAttribute("aria-level")) {
+        const lvl = parseInt(element.getAttribute("aria-level") || "");
+        if (!isNaN(lvl))
+          node.level = lvl;
+      }
+      if (finalRole === "link" && element.hasAttribute("href")) {
+        node.props.url = element.getAttribute("href") || "";
+      }
+      if (finalRole === "menuitem") {
+        const anchor = element.querySelector("a[href]");
+        if (anchor) {
+          const href = anchor.getAttribute("href") || "";
+          const label = (anchor.textContent || "").trim();
+          const linkId = this.idGenerator.generate(id, "link", anchor, 0);
+          anchor.setAttribute("data-persona-id", linkId);
+          const linkNode = {
+            role: "link",
+            name: label,
+            ref: linkId,
+            children: [],
+            element: anchor,
+            props: {}
+          };
+          if (href)
+            linkNode.props.url = href;
+          if (hidden) {
+            linkNode.hidden = true;
+          }
+          node.children.push(linkNode);
+        }
+      }
+      if ((finalRole === "textbox" || finalRole === "searchbox" || finalRole === "combobox") && element instanceof HTMLInputElement) {
+        if (element.value)
+          node.props.value = element.value;
+      }
+      if (element.hasAttribute("placeholder")) {
+        node.props.placeholder = element.getAttribute("placeholder") || "";
+      }
+      const testIdAttr = ["data-test-id", "data-testid", "data-test"].find((attr) => element.hasAttribute(attr));
+      if (testIdAttr) {
+        node.props.testId = element.getAttribute(testIdAttr) || "";
+      }
+      this.processChildren(element, node);
+      return node;
+    }
+    processChildren(element, parentNode) {
+      if (element.shadowRoot) {
+        let idx2 = 0;
+        for (let child = element.shadowRoot.firstElementChild; child; child = child.nextElementSibling) {
+          if (this.processChildNode(child, parentNode, idx2))
+            idx2++;
+        }
+        return;
+      }
+      let idx = 0;
+      for (let child = element.firstElementChild; child; child = child.nextElementSibling) {
+        if (this.processChildNode(child, parentNode, idx))
+          idx++;
+      }
+      if (element.tagName === "IFRAME") {
+        try {
+          const iframeDoc = element.contentDocument;
+          if (iframeDoc && iframeDoc.body) {
+            const childNode = this.processNode(iframeDoc.body, parentNode.ref, 0, true);
+            if (childNode)
+              parentNode.children.push(childNode);
+          }
+        } catch (e) {
+        }
+      }
+    }
+    processChildNode(node, parentNode, index) {
+      if (node.nodeType === Node.ELEMENT_NODE) {
+        const childEl = node;
+        const childNode = this.processNode(childEl, parentNode.ref, index, false);
+        if (childNode) {
+          parentNode.children.push(childNode);
+          return true;
+        }
+        return true;
+      }
+      return false;
+    }
+  };
+
+  // src/core/Observer.ts
+  var Observer = class {
+    constructor(root, treeWalker) {
+      this.updateScheduled = false;
+      this.root = root;
+      this.treeWalker = treeWalker;
+      this.observer = new MutationObserver(() => {
+        this.scheduleUpdate();
+      });
+    }
+    start() {
+      this.observer.observe(this.root, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: [
+          "role",
+          "aria-label",
+          "aria-labelledby",
+          "aria-hidden",
+          "hidden",
+          "style",
+          "class",
+          "type",
+          "placeholder",
+          "title",
+          "alt",
+          "href",
+          "value"
+        ]
+      });
+      this.scheduleUpdate();
+    }
+    stop() {
+      this.observer.disconnect();
+    }
+    scheduleUpdate() {
+      if (this.updateScheduled)
+        return;
+      this.updateScheduled = true;
+      requestAnimationFrame(() => {
+        this.update();
+        this.updateScheduled = false;
+      });
+    }
+    update() {
+      const start = performance.now();
+      this.treeWalker.snapshot(this.root);
+      const end = performance.now();
+      if (end - start > 50) {
+        console.warn(`Persona: DOM snapshot took ${Math.round(end - start)}ms`);
+      }
+    }
+  };
+
+  // src/index.ts
+  var Runtime = class {
+    constructor() {
+      // Ref -> Parent AriaNode
+      this.rootNode = null;
+      this.version = "1.0.0";
+      this.treeWalker = new TreeWalker();
+      this.elementMap = /* @__PURE__ */ new Map();
+      this.nodeMap = /* @__PURE__ */ new Map();
+      this.parentMap = /* @__PURE__ */ new Map();
+      const root = document.body;
+      if (root) {
+        this.observer = new Observer(root, this.treeWalker);
+        this.observer.start();
+      }
+      this.refresh();
+      console.log(`[Persona] Runtime v${this.version} initialized`);
+    }
+    refresh() {
+      const root = document.body;
+      if (root) {
+        this.rootNode = this.treeWalker.snapshot(root);
+        this.rebuildMaps(this.rootNode);
+      }
+    }
+    rebuildMaps(root) {
+      this.elementMap.clear();
+      this.nodeMap.clear();
+      this.parentMap.clear();
+      if (!root)
+        return;
+      const visit = (node, parent) => {
+        this.elementMap.set(node.ref, node.element);
+        this.nodeMap.set(node.ref, node);
+        if (parent) {
+          this.parentMap.set(node.ref, parent);
+        }
+        for (const child of node.children) {
+          if (typeof child === "object" && child) {
+            visit(child, node);
+          }
+        }
+      };
+      visit(root, null);
+    }
+    getTreeForTransport() {
+      this.refresh();
+      if (!this.rootNode)
+        return null;
+      const clean = (node) => {
+        const { element, children, ...rest } = node;
+        const cleanedChildren = (Array.isArray(children) ? children : []).map((c) => {
+          if (typeof c === "string")
+            return c;
+          return clean(c);
+        });
+        return { ...rest, children: cleanedChildren };
+      };
+      try {
+        return clean(this.rootNode);
+      } catch (e) {
+        console.error("[Persona] Error building transport tree", e);
+        return null;
+      }
+    }
+    find(ref) {
+      if (this.elementMap.has(ref)) {
+        const el2 = this.elementMap.get(ref);
+        if (el2.isConnected)
+          return el2;
+      }
+      const el = document.querySelector(`[data-persona-id="${ref}"]`);
+      return el || null;
+    }
+    getSnapshot() {
+      this.refresh();
+      return this.rootNode;
+    }
+    navigate(ref, direction, index) {
+      if (!this.nodeMap.has(ref)) {
+        this.refresh();
+        if (!this.nodeMap.has(ref))
+          return null;
+      }
+      const node = this.nodeMap.get(ref);
+      const parent = this.parentMap.get(ref);
+      if (direction === "parent") {
+        return parent ? parent.element : null;
+      }
+      if (direction === "child") {
+        if (typeof index !== "number")
+          return null;
+        const idx = index < 0 ? node.children.length + index : index;
+        if (idx >= 0 && idx < node.children.length) {
+          const child = node.children[idx];
+          return typeof child === "object" && child ? child.element : null;
+        }
+        return null;
+      }
+      if (direction === "next" || direction === "prev") {
+        if (!parent)
+          return null;
+        const siblings = parent.children.filter((c) => typeof c === "object");
+        const idx = siblings.indexOf(node);
+        if (idx === -1)
+          return null;
+        if (direction === "next") {
+          return idx + 1 < siblings.length ? siblings[idx + 1].element : null;
+        }
+        if (direction === "prev") {
+          return idx - 1 >= 0 ? siblings[idx - 1].element : null;
+        }
+      }
+      return null;
+    }
+  };
+  if (typeof window !== "undefined") {
+    window.__PERSONA__ = new Runtime();
+  }
+})();
+//# sourceMappingURL=persona_bundle.js.map