praxis-kit 3.1.1 → 4.0.1

package/dist/contract/index.js

@@ -1,1056 +1,174 @@
-// ../core/dist/chunk-KKSHJDE7.js
-function assertNever(value) {
-  throw new Error(`Unexpected value: ${String(value)}`);
-}
-function isNull(value) {
-  return value === null;
-}
-function isObject(value) {
-  return !isNull(value) && typeof value === "object";
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isNumber(value) {
-  return typeof value === "number";
-}
-var KNOWN_ARIA_ROLES = [
-  "alert",
-  "alertdialog",
-  "application",
-  "article",
-  "banner",
-  "blockquote",
-  "button",
-  "caption",
-  "cell",
-  "checkbox",
-  "code",
-  "columnheader",
-  "combobox",
-  "complementary",
-  "contentinfo",
-  "definition",
-  "deletion",
-  "dialog",
-  "document",
-  "emphasis",
-  "feed",
-  "figure",
-  "form",
-  "generic",
-  "grid",
-  "gridcell",
-  "group",
-  "heading",
-  "img",
-  "insertion",
-  "link",
-  "list",
-  "listbox",
-  "listitem",
-  "log",
-  "main",
-  "marquee",
-  "math",
-  "menu",
-  "menubar",
-  "menuitem",
-  "menuitemcheckbox",
-  "menuitemradio",
-  "meter",
-  "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"
-];
-var KNOWN_ARIA_ROLES_SET = new Set(KNOWN_ARIA_ROLES);
-var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
-  "aria-atomic",
-  "aria-busy",
-  "aria-controls",
-  "aria-current",
-  "aria-describedby",
-  "aria-details",
-  "aria-disabled",
-  "aria-errormessage",
-  "aria-flowto",
-  "aria-hidden",
-  "aria-keyshortcuts",
-  "aria-label",
-  "aria-labelledby",
-  "aria-live",
-  "aria-owns",
-  "aria-relevant",
-  "aria-roledescription"
-]);
-var IMPLICIT_ROLE_RECORD = {
-  article: "article",
-  aside: "complementary",
-  footer: "contentinfo",
-  header: "banner",
-  main: "main",
-  nav: "navigation",
-  button: "button",
-  a: "link",
-  select: "listbox",
-  h1: "heading",
-  h2: "heading",
-  h3: "heading",
-  h4: "heading",
-  h5: "heading",
-  h6: "heading",
-  ul: "list",
-  ol: "list",
-  li: "listitem",
-  table: "table",
-  tr: "row",
-  td: "cell",
-  th: "columnheader"
-};
-var STRONG_ROLES = [
-  "main",
-  "navigation",
-  "complementary",
-  "contentinfo",
-  "banner"
-];
-var STANDALONE_ROLES = ["article"];
-var STRONG_ROLES_SET = new Set(STRONG_ROLES);
-var STANDALONE_ROLES_SET = new Set(STANDALONE_ROLES);
-var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
-  [
-    "aria-activedescendant",
-    /* @__PURE__ */ new Set([
-      "application",
-      "combobox",
-      "grid",
-      "group",
-      "listbox",
-      "menu",
-      "menubar",
-      "radiogroup",
-      "spinbutton",
-      "tablist",
-      "toolbar",
-      "textbox",
-      "tree",
-      "treegrid"
-    ])
-  ],
-  ["aria-autocomplete", /* @__PURE__ */ new Set(["combobox", "searchbox", "textbox"])],
-  [
-    "aria-checked",
-    /* @__PURE__ */ new Set(["checkbox", "menuitemcheckbox", "option", "radio", "switch", "treeitem"])
-  ],
-  ["aria-colcount", /* @__PURE__ */ new Set(["grid", "table", "treegrid"])],
-  ["aria-colindex", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "row", "rowheader"])],
-  ["aria-colspan", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "rowheader"])],
-  [
-    "aria-expanded",
-    /* @__PURE__ */ new Set([
-      "button",
-      "combobox",
-      "gridcell",
-      "listbox",
-      "menuitem",
-      "menuitemcheckbox",
-      "menuitemradio",
-      "row",
-      "rowheader",
-      "tab",
-      "treeitem"
-    ])
-  ],
-  [
-    "aria-haspopup",
-    /* @__PURE__ */ new Set([
-      "button",
-      "combobox",
-      "gridcell",
-      "listbox",
-      "menuitem",
-      "menuitemcheckbox",
-      "menuitemradio",
-      "tab",
-      "treeitem"
-    ])
-  ],
-  ["aria-level", /* @__PURE__ */ new Set(["heading", "listitem", "row", "treeitem"])],
-  ["aria-modal", /* @__PURE__ */ new Set(["alertdialog", "dialog"])],
-  ["aria-multiline", /* @__PURE__ */ new Set(["textbox"])],
-  ["aria-multiselectable", /* @__PURE__ */ new Set(["grid", "listbox", "tablist", "tree", "treegrid"])],
-  [
-    "aria-orientation",
-    /* @__PURE__ */ new Set(["scrollbar", "select", "separator", "slider", "tablist", "toolbar", "tree"])
-  ],
-  ["aria-placeholder", /* @__PURE__ */ new Set(["searchbox", "textbox"])],
-  [
-    "aria-posinset",
-    /* @__PURE__ */ new Set([
-      "article",
-      "listitem",
-      "menuitem",
-      "menuitemcheckbox",
-      "menuitemradio",
-      "option",
-      "radio",
-      "row",
-      "tab"
-    ])
-  ],
-  ["aria-pressed", /* @__PURE__ */ new Set(["button"])],
-  [
-    "aria-readonly",
-    /* @__PURE__ */ new Set([
-      "combobox",
-      "grid",
-      "gridcell",
-      "listbox",
-      "radiogroup",
-      "slider",
-      "spinbutton",
-      "textbox",
-      "tree",
-      "treegrid"
-    ])
-  ],
-  [
-    "aria-required",
-    /* @__PURE__ */ new Set([
-      "combobox",
-      "gridcell",
-      "listbox",
-      "radiogroup",
-      "spinbutton",
-      "textbox",
-      "tree",
-      "treegrid"
-    ])
-  ],
-  ["aria-rowcount", /* @__PURE__ */ new Set(["grid", "table", "treegrid"])],
-  ["aria-rowindex", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "row", "rowheader"])],
-  ["aria-rowspan", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "rowheader"])],
-  [
-    "aria-selected",
-    /* @__PURE__ */ new Set(["columnheader", "gridcell", "option", "row", "rowheader", "tab", "treeitem"])
-  ],
-  [
-    "aria-setsize",
-    /* @__PURE__ */ new Set([
-      "article",
-      "listitem",
-      "menuitem",
-      "menuitemcheckbox",
-      "menuitemradio",
-      "option",
-      "radio",
-      "row",
-      "tab"
-    ])
-  ],
-  ["aria-sort", /* @__PURE__ */ new Set(["columnheader", "rowheader"])],
-  [
-    "aria-valuemax",
-    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
-  ],
-  [
-    "aria-valuemin",
-    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
-  ],
-  [
-    "aria-valuenow",
-    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
-  ],
-  [
-    "aria-valuetext",
-    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
-  ]
-]);
-function isUndefined(value) {
-  return value === void 0;
-}
-function isGlobalAriaAttribute(attr) {
-  return GLOBAL_ARIA_ATTRIBUTES.has(attr);
-}
-function isAriaAttributeValidForRole(attr, role) {
-  const allowedRoles = ROLE_RESTRICTED_ATTRIBUTES.get(attr);
-  if (isUndefined(allowedRoles)) return true;
-  if (isUndefined(role)) return false;
-  return allowedRoles.has(role);
-}
-function isStrongImplicitRole(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STRONG_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
-}
-function isStandaloneTag(tag) {
-  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
-  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
-}
-
-// ../core/dist/chunk-2NJ5XLOA.js
-var IMPLICIT_ROLE_RECORD2 = {
-  article: "article",
-  aside: "complementary",
-  footer: "contentinfo",
-  header: "banner",
-  main: "main",
-  nav: "navigation",
-  button: "button",
-  a: "link",
-  select: "listbox",
-  h1: "heading",
-  h2: "heading",
-  h3: "heading",
-  h4: "heading",
-  h5: "heading",
-  h6: "heading",
-  ul: "list",
-  ol: "list",
-  li: "listitem",
-  table: "table",
-  tr: "row",
-  td: "cell",
-  th: "columnheader"
-};
-function getImplicitRole(tag) {
-  if (tag in IMPLICIT_ROLE_RECORD2) return IMPLICIT_ROLE_RECORD2[tag];
-  return void 0;
-}
-var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
-function getAsProp(child) {
-  if (!isObject(child) || !("props" in child)) return void 0;
-  const props = child.props;
-  if (!isObject(props)) return void 0;
-  const as = props.as;
-  return isString(as) && as !== "" ? as : void 0;
-}
-function getTag(child) {
-  if (!isObject(child) || !("type" in child)) return void 0;
-  const t = child.type;
-  if (isString(t)) return t;
-  if (typeof t === "function" || isObject(t)) {
-    const defaultTag = t[COMPONENT_DEFAULT_TAG];
-    if (!isString(defaultTag)) return void 0;
-    return getAsProp(child) ?? defaultTag;
-  }
-  return void 0;
-}
-function isTag(...args) {
-  if (isString(args[0])) {
-    const set2 = new Set(args);
-    return (child2) => {
-      const tag2 = getTag(child2);
-      return tag2 !== void 0 && set2.has(tag2);
-    };
-  }
-  const [child, ...tags] = args;
-  const set = new Set(tags);
-  const tag = getTag(child);
-  return tag !== void 0 && set.has(tag);
-}
-var pendingAsyncWarns = /* @__PURE__ */ new Set();
-var asyncWarnScheduled = false;
-function flushAsyncWarns() {
-  asyncWarnScheduled = false;
-  const messages = [...pendingAsyncWarns];
-  pendingAsyncWarns.clear();
-  for (const msg of messages) {
-    console.warn(msg);
+// ../../lib/primitive/src/utils/iterate.ts
+function find(iterable, callback) {
+  for (const value of iterable) {
+    const result = callback(value);
+    if (result != null) {
+      return result;
+    }
   }
+  return null;
 }
-function scheduleAsyncWarn(message) {
-  if (pendingAsyncWarns.has(message)) return;
-  pendingAsyncWarns.add(message);
-  if (!asyncWarnScheduled) {
-    asyncWarnScheduled = true;
-    queueMicrotask(flushAsyncWarns);
+function some(iterable, predicate) {
+  for (const value of iterable) {
+    if (predicate(value)) return true;
   }
+  return false;
 }
-var StrictBase = class {
-  strict;
-  constructor(strict) {
-    this.strict = strict;
-  }
-  violate(message) {
-    if (this.strict === true || this.strict === "throw") {
-      throw new Error(message);
+function every(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (!predicate(value, index++)) {
+      return false;
     }
-    this.warn(message);
   }
-  // Always caps at console.warn — never throws. ARIA 'warning' violations route here
-  // so they surface even in strict='throw' mode without aborting a render.
-  warn(message) {
-    if (!this.strict) return;
-    if (this.strict === "async-warn") {
-      scheduleAsyncWarn(message);
-      return;
-    }
-    console.warn(message);
-  }
-  invariant(condition, message) {
-    if (!condition) {
-      this.violate(message);
-    }
-  }
-};
-function isNull2(value) {
-  return value === null;
-}
-var VALID = [{ valid: true }];
-function isIntrinsicTag(tag) {
-  return isString(tag);
-}
-function omitProp(obj, key) {
-  const { [key]: _, ...rest } = obj;
-  return rest;
+  return true;
 }
-var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
-  #extraRules;
-  #planCache = /* @__PURE__ */ new Map();
-  static #MAX_CACHE = 100;
-  // Memoized AriaFix objects keyed by attribute name — the ARIA attribute set is
-  // finite so this Map is bounded and avoids recreating closures on every cache miss.
-  static #removeAttributeFixCache = /* @__PURE__ */ new Map();
-  constructor(strict = "warn", options) {
-    super(strict);
-    this.#extraRules = options?.rules ?? [];
-  }
-  static #normalizeEmptyRole(tag, props) {
-    if (props.role !== "") return { normalized: false };
-    return {
-      normalized: true,
-      result: {
-        props: omitProp(props, "role"),
-        violations: [
-          {
-            message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`,
-            tag,
-            role: "",
-            attribute: void 0,
-            severity: "warning",
-            phase: "evaluate"
-          }
-        ]
-      }
-    };
-  }
-  static #deriveContext(tag, props) {
-    if (!isIntrinsicTag(tag)) return { proceed: false, result: { props, violations: [] } };
-    const implicitRole = getImplicitRole(tag);
-    const hasExplicitLiveRole = !implicitRole && _AriaPolicyEngine.#LIVE_REGION_ROLES.has(props.role ?? "");
-    if (!implicitRole && !hasExplicitLiveRole)
-      return { proceed: false, result: { props, violations: [] } };
-    const normalized = _AriaPolicyEngine.#normalizeEmptyRole(tag, props);
-    if (normalized.normalized) return { proceed: false, result: normalized.result };
-    const effectiveRole = props.role ?? implicitRole;
-    return {
-      proceed: true,
-      tag,
-      implicitRole,
-      effectiveRole,
-      context: { tag, props, implicitRole, effectiveRole }
-    };
-  }
-  static #runRules(rules, context) {
-    const violations = [];
-    const fixes = [];
-    for (const rule of rules) {
-      for (const result of rule(context)) {
-        if (!result.valid) {
-          violations.push({
-            message: result.message ?? `Invalid role "${context.props.role}" on <${context.tag}>`,
-            tag: context.tag,
-            role: context.props.role,
-            attribute: result.attribute,
-            severity: result.severity,
-            phase: "evaluate"
-          });
-          if (result.fixable) fixes.push(result.fix);
-        }
-      }
-    }
-    return { violations, fixes };
-  }
-  static #getRules(context) {
-    return _AriaPolicyEngine.#hasRole(context.props) ? _AriaPolicyEngine.#pipeline : [_AriaPolicyEngine.#checkInvalidAriaAttributes];
-  }
-  static evaluate(tag, props) {
-    const derived = _AriaPolicyEngine.#deriveContext(tag, props);
-    if (!derived.proceed) return derived.result;
-    const { tag: narrowedTag, implicitRole, context } = derived;
-    const { violations, fixes } = _AriaPolicyEngine.#runRules(
-      _AriaPolicyEngine.#getRules(context),
-      context
-    );
-    const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, props, fixes);
-    return { props: next, violations };
-  }
-  static #evaluateWithRules(tag, props, extraRules) {
-    const derived = _AriaPolicyEngine.#deriveContext(tag, props);
-    if (!derived.proceed) return derived.result;
-    const { tag: narrowedTag, implicitRole, context } = derived;
-    const { violations, fixes } = _AriaPolicyEngine.#runRules(
-      [..._AriaPolicyEngine.#getRules(context), ...extraRules],
-      context
-    );
-    const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, props, fixes);
-    return { props: next, violations };
-  }
-  report(violations) {
-    for (const v of violations) {
-      if (v.severity === "error") this.violate(v.message);
-      else this.warn(v.message);
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const value of iterable) {
+    if (predicate(value, index++)) {
+      yield value;
     }
   }
-  // Cache key covers only the aria-relevant subset of props (tag + role + aria-* attrs).
-  // Non-aria props (className, onClick, etc.) do not affect ARIA decisions and are excluded
-  // so cache hits survive re-renders that only change non-aria props.
-  // Note: #extraRules are NOT included in the key — each engine instance has its own Map,
-  // so two engines with different rules never share cache entries. If caching ever becomes
-  // static/shared, rule identity would need to be folded into the key.
-  static #createPlanKey(tag, props) {
-    if (!isIntrinsicTag(tag)) return null;
-    const parts = [tag];
-    if (typeof props.role === "string") parts.push(`role:${props.role}`);
-    const ariaEntries = [];
-    for (const k in props) {
-      if (!Object.hasOwn(props, k) || !k.startsWith("aria-")) continue;
-      const v = props[k];
-      if (!isString(v) && !isNumber(v) && typeof v !== "boolean") continue;
-      ariaEntries.push(`${k}:${String(v)}`);
-    }
-    if (ariaEntries.length > 0) parts.push(...ariaEntries.sort());
-    return parts.join("|");
+}
+function* map(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    yield callback(value, index++);
   }
-  static #computePlan(inputProps, resultProps) {
-    const removals = /* @__PURE__ */ new Set();
-    const updates = {};
-    for (const key in inputProps) {
-      if (Object.hasOwn(inputProps, key) && !(key in resultProps)) removals.add(key);
-    }
-    for (const key in resultProps) {
-      if (!Object.hasOwn(resultProps, key)) continue;
-      const resultVal = resultProps[key];
-      if (inputProps[key] !== resultVal) updates[key] = resultVal;
-    }
-    return { removals, updates };
+}
+function forEach(iterable, callback) {
+  let index = 0;
+  for (const value of iterable) {
+    callback(value, index++);
   }
-  static #applyPlan(props, removals, updates) {
-    const hasRemovals = removals.size > 0;
-    const hasUpdates = Object.keys(updates).length > 0;
-    if (!hasRemovals && !hasUpdates) return props;
-    const next = {};
-    for (const k in props) {
-      if (Object.hasOwn(props, k) && !removals.has(k)) next[k] = props[k];
-    }
-    Object.assign(next, updates);
-    return next;
+}
+function reduce(iterable, initial, callback) {
+  let accumulator = initial;
+  let index = 0;
+  for (const value of iterable) {
+    accumulator = callback(accumulator, value, index++);
   }
-  validate(tag, props) {
-    const key = _AriaPolicyEngine.#createPlanKey(tag, props);
-    if (!isNull2(key)) {
-      const cached = this.#planCache.get(key);
-      if (cached !== void 0) {
-        this.#planCache.delete(key);
-        this.#planCache.set(key, cached);
-        if (cached.violations.length > 0) this.report(cached.violations);
-        return {
-          props: _AriaPolicyEngine.#applyPlan(props, cached.removals, cached.updates),
-          violations: cached.violations
-        };
-      }
-    }
-    const result = this.#extraRules.length ? _AriaPolicyEngine.#evaluateWithRules(tag, props, this.#extraRules) : _AriaPolicyEngine.evaluate(tag, props);
-    if (result.violations.length > 0) this.report(result.violations);
-    if (!isNull2(key)) {
-      const { removals, updates } = _AriaPolicyEngine.#computePlan(
-        props,
-        result.props
-      );
-      const plan = { removals, updates, violations: result.violations };
-      this.#planCache.set(key, plan);
-      if (this.#planCache.size > _AriaPolicyEngine.#MAX_CACHE) {
-        const lru = this.#planCache.keys().next().value;
-        if (lru !== void 0) this.#planCache.delete(lru);
-      }
+  return accumulator;
+}
+function collect(iterable, callback) {
+  const result = {};
+  let index = 0;
+  for (const value of iterable) {
+    const entry = callback(value, index++);
+    if (entry === null) {
+      return null;
     }
-    return result;
+    result[entry[0]] = entry[1];
   }
-  static #hasRole(props) {
-    return isString(props.role) && props.role.length > 0;
-  }
-  static #applyFixes(tag, implicitRole, props, fixes) {
-    if (fixes.length === 0) return props;
-    const sorted = [...fixes].sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity));
-    let next = props;
-    for (const { apply } of sorted) {
-      const effectiveRole = next.role ?? implicitRole;
-      const fixContext = { tag, implicitRole, effectiveRole, props: next };
-      const fixResult = apply(fixContext);
-      if (fixResult.applied) next = fixResult.next;
+  return result;
+}
+function findLast(value, callback) {
+  for (let index = value.length - 1; index >= 0; index--) {
+    const result = callback(value[index], index);
+    if (result != null) {
+      return result;
     }
-    return next;
   }
-  static #removeRole = {
-    kind: "removeRole",
-    apply: ({ props }) => {
-      if (!("role" in props)) return { applied: false, next: props };
-      return { applied: true, next: omitProp(props, "role"), previous: props };
+  return null;
+}
+function* items(collection) {
+  for (let i = 0; i < collection.length; i++) {
+    const item = collection.item(i);
+    if (item !== null) {
+      yield item;
     }
-  };
-  static #makeRemoveAttributeFix(attr) {
-    const cached = _AriaPolicyEngine.#removeAttributeFixCache.get(attr);
-    if (cached) return cached;
-    const fix = {
-      kind: `removeAttribute:${attr}`,
-      apply: ({ props }) => {
-        if (!(attr in props)) return { applied: false, next: props };
-        return { applied: true, next: omitProp(props, attr), previous: props };
-      }
-    };
-    _AriaPolicyEngine.#removeAttributeFixCache.set(attr, fix);
-    return fix;
   }
-  // Snapshot diagnostic model: all rules evaluate against the same (tag, props, implicitRole) snapshot.
-  static #pipeline = [
-    _AriaPolicyEngine.#checkInvalidRoleOverride,
-    _AriaPolicyEngine.#checkRedundantRole,
-    _AriaPolicyEngine.#checkStandaloneRegion,
-    _AriaPolicyEngine.#checkInvalidAriaAttributes,
-    _AriaPolicyEngine.#checkMissingLiveRegion,
-    _AriaPolicyEngine.#checkMissingAtomic,
-    _AriaPolicyEngine.#checkInvalidAriaRelevant
-  ];
-  static #checkInvalidRoleOverride({
-    tag,
-    props,
-    implicitRole
-  }) {
-    const role = props.role;
-    if (!implicitRole || !role || role === implicitRole) return VALID;
-    if (isStrongImplicitRole(tag) && role === "region") {
-      return [
-        {
-          valid: false,
-          fixable: true,
-          severity: "error",
-          fix: _AriaPolicyEngine.#removeRole,
-          message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+}
+function nodeList(list) {
+  return {
+    *[Symbol.iterator]() {
+      for (let i = 0; i < list.length; i++) {
+        const node = list.item(i);
+        if (node !== null) {
+          yield node;
         }
-      ];
-    }
-    return VALID;
-  }
-  static #checkRedundantRole({ tag, props, implicitRole }) {
-    const role = props.role;
-    if (!implicitRole || !role || role !== implicitRole) return VALID;
-    return [
-      {
-        valid: false,
-        fixable: true,
-        severity: "warning",
-        fix: _AriaPolicyEngine.#removeRole,
-        message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
-      }
-    ];
-  }
-  static #checkStandaloneRegion({ tag, props, implicitRole }) {
-    const role = props.role;
-    if (role !== "region") return VALID;
-    if (!isStandaloneTag(tag)) return VALID;
-    return [
-      {
-        valid: false,
-        fixable: true,
-        severity: "error",
-        fix: _AriaPolicyEngine.#removeRole,
-        message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
       }
-    ];
-  }
-  static #checkInvalidAriaAttributes({
-    tag,
-    props,
-    effectiveRole
-  }) {
-    const results = [];
-    for (const key in props) {
-      if (!Object.hasOwn(props, key)) continue;
-      if (!key.startsWith("aria-")) continue;
-      if (isGlobalAriaAttribute(key)) continue;
-      if (isAriaAttributeValidForRole(key, effectiveRole)) continue;
-      results.push({
-        valid: false,
-        severity: "warning",
-        fixable: true,
-        attribute: key,
-        message: `"${key}" is not valid on role="${effectiveRole ?? tag}". It will be removed.`,
-        fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
-      });
     }
-    return results;
-  }
-  // WAI-ARIA live region roles and their implied aria-live politeness values.
-  static #LIVE_REGION_ROLES = /* @__PURE__ */ new Map([
-    ["alert", "assertive"],
-    ["status", "polite"],
-    ["log", "polite"],
-    ["timer", "off"]
-  ]);
-  static #checkMissingLiveRegion({ effectiveRole, props }) {
-    if (!effectiveRole) return VALID;
-    const impliedLive = _AriaPolicyEngine.#LIVE_REGION_ROLES.get(effectiveRole);
-    if (!impliedLive) return VALID;
-    if ("aria-live" in props) return VALID;
-    const injectLive = {
-      kind: `injectLive:${effectiveRole}`,
-      apply: (ctx) => ({
-        applied: true,
-        next: { ...ctx.props, "aria-live": impliedLive },
-        previous: ctx.props
-      })
-    };
-    return [
-      {
-        valid: false,
-        fixable: true,
-        severity: "warning",
-        fix: injectLive,
-        message: `role="${effectiveRole}" implies aria-live="${impliedLive}" but it is missing. It has been injected.`
-      }
-    ];
-  }
-  static #checkMissingAtomic({ effectiveRole, props }) {
-    if (!effectiveRole || !_AriaPolicyEngine.#LIVE_REGION_ROLES.has(effectiveRole)) return VALID;
-    if ("aria-atomic" in props) return VALID;
-    return [
-      {
-        valid: false,
-        fixable: false,
-        severity: "warning",
-        message: `role="${effectiveRole}" is a live region. Consider setting aria-atomic="true" if the full region should be announced as a unit, or aria-atomic="false" if only changed nodes should be read.`
-      }
-    ];
-  }
-  static #VALID_RELEVANT_TOKENS = /* @__PURE__ */ new Set(["additions", "removals", "text", "all"]);
-  // Custom fix rules passed via `options.rules` must be pure functions of (tag, props) — the cache
-  // replays stored fixes against new prop objects, so fixes that close over external state will
-  // produce inconsistent results on cache hits.
-  static #normalizeRelevantAllFix = {
-    kind: "normalizeRelevantAll",
-    apply: ({ props: p }) => ({
-      applied: true,
-      next: { ...p, "aria-relevant": "all" },
-      previous: p
-    })
   };
-  static #checkInvalidAriaRelevant({ props }) {
-    const relevant = props["aria-relevant"];
-    if (relevant === void 0) return VALID;
-    if (typeof relevant !== "string") return VALID;
-    const tokens = relevant.trim().split(/\s+/);
-    const invalid = tokens.filter((t) => !_AriaPolicyEngine.#VALID_RELEVANT_TOKENS.has(t));
-    if (invalid.length > 0) {
-      return [
-        {
-          valid: false,
-          fixable: true,
-          severity: "warning",
-          attribute: "aria-relevant",
-          message: `aria-relevant contains invalid token(s): ${invalid.map((t) => `"${t}"`).join(", ")}. Valid tokens are: additions, removals, text, all.`,
-          fix: _AriaPolicyEngine.#makeRemoveAttributeFix("aria-relevant")
-        }
-      ];
-    }
-    if (tokens.includes("all") && tokens.length > 1) {
-      return [
-        {
-          valid: false,
-          fixable: true,
-          severity: "warning",
-          attribute: "aria-relevant",
-          message: `aria-relevant includes "all" alongside other tokens. "all" supersedes additions, removals, and text \u2014 use aria-relevant="all" alone.`,
-          fix: _AriaPolicyEngine.#normalizeRelevantAllFix
-        }
-      ];
-    }
-    return VALID;
-  }
-};
-function getTypeName(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const primitive = typeof value;
-  if (primitive !== "object") {
-    return primitive;
-  }
-  const name = value.constructor?.name;
-  return typeof name === "string" && name !== "Object" ? name : "object";
 }
-var MatchValidationErrorBuilder = class {
-  #prefix;
-  constructor(ctx = "") {
-    this.#prefix = ctx ? `${ctx}:
-` : "";
-  }
-  #template(typeName, index, prefix = "", suffix = "") {
-    const leadingStr = prefix ? `${prefix} ` : "";
-    const followingStr = suffix ? ` ${suffix}` : "";
-    return `${leadingStr}child "${typeName}" at index ${index}${followingStr}.`;
-  }
-  unexpectedChild(typeName, index) {
-    return this.#template(typeName, index, "unexpected");
-  }
-  multipleMatches(typeName, index, ruleNames) {
-    const quoted = ruleNames.map((n) => `"${n}"`);
-    return this.#template(
-      typeName,
-      index,
-      "",
-      `matches multiple child rules: ${quoted.join(" and ")}`
-    );
-  }
-  #format(errors) {
-    return this.#prefix + errors.join("\n");
-  }
-  toError(errors) {
-    if (errors.length === 0) {
-      return new Error(this.#prefix + "Unknown validation error.");
-    }
-    return new Error(this.#format(errors));
-  }
-};
-function normalizeCardinality(input, impliesSingleton) {
-  const min = input?.min ?? 0;
-  const max = input?.max ?? (impliesSingleton ? 1 : Infinity);
-  if (min === 0 && max === Infinity) {
-    return { kind: "unbounded" };
-  }
-  if (min > max) {
-    throw new RangeError(`normalizeChildRule: min (${min}) cannot exceed max (${max})`);
-  }
-  return {
-    kind: "bounded",
-    min,
-    max
-  };
+function mapEntries(m) {
+  return m.entries();
 }
-function normalizeChildRule(rule) {
-  const position = rule.position ?? "any";
-  const impliesSingleton = position === "first" || position === "last";
-  return {
-    ...rule,
-    position,
-    cardinality: normalizeCardinality(rule.cardinality, impliesSingleton)
-  };
+function set(s) {
+  return s.values();
 }
-function getChildType(child) {
-  if (!isObject(child) || !("type" in child)) return void 0;
-  return child.type;
+function hasOwn(object, key) {
+  return Object.hasOwn(object, key);
 }
-function buildPartialIndex(rules) {
-  const typeIndex = /* @__PURE__ */ new Map();
-  const duplicateTypes = /* @__PURE__ */ new Set();
-  const untypedIndices = [];
-  for (let ri = 0; ri < rules.length; ri++) {
-    const t = rules[ri].type;
-    if (t === void 0) {
-      untypedIndices.push(ri);
-    } else if (typeIndex.has(t)) {
-      duplicateTypes.add(t);
-    } else {
-      typeIndex.set(t, ri);
-    }
+function* entries(object) {
+  for (const key in object) {
+    if (!hasOwn(object, key)) continue;
+    yield [key, object[key]];
   }
-  if (duplicateTypes.size > 0) {
-    for (const t of duplicateTypes) typeIndex.delete(t);
-    for (let ri = 0; ri < rules.length; ri++) {
-      if (duplicateTypes.has(rules[ri].type)) untypedIndices.push(ri);
-    }
-  }
-  return { typeIndex, untypedIndices };
 }
-var RuleMatcher = class {
-  #rules;
-  #typeIndex;
-  #untypedIndices;
-  constructor(rules) {
-    this.#rules = rules;
-    const { typeIndex, untypedIndices } = buildPartialIndex(rules);
-    this.#typeIndex = typeIndex;
-    this.#untypedIndices = untypedIndices;
+function* keys(object) {
+  for (const [key] of entries(object)) {
+    yield key;
   }
-  match(children) {
-    const forward = /* @__PURE__ */ new Map();
-    const reverse = /* @__PURE__ */ new Map();
-    const unexpectedIndices = /* @__PURE__ */ new Set();
-    const ambiguousIndices = /* @__PURE__ */ new Set();
-    for (let ri = 0; ri < this.#rules.length; ri++) {
-      reverse.set(ri, /* @__PURE__ */ new Set());
-    }
-    for (const [ci, child] of children.entries()) {
-      const t = getChildType(child);
-      if (t !== void 0) {
-        const ri = this.#typeIndex.get(t);
-        if (ri !== void 0) {
-          let childEntry = forward.get(ci);
-          if (!childEntry) {
-            childEntry = /* @__PURE__ */ new Set();
-            forward.set(ci, childEntry);
-          }
-          childEntry.add(ri);
-          reverse.get(ri).add(ci);
-        }
-      }
-      for (const ri of this.#untypedIndices) {
-        if (!this.#rules[ri].match(child)) continue;
-        let childEntry = forward.get(ci);
-        if (!childEntry) {
-          childEntry = /* @__PURE__ */ new Set();
-          forward.set(ci, childEntry);
-        }
-        childEntry.add(ri);
-        reverse.get(ri).add(ci);
-      }
-      const entry = forward.get(ci);
-      if (!entry) {
-        unexpectedIndices.add(ci);
-      } else if (entry.size > 1) {
-        ambiguousIndices.add(ci);
-      }
-    }
-    return { matrix: { childToRules: { forward, reverse } }, unexpectedIndices, ambiguousIndices };
-  }
-};
-var RuleValidator = class _RuleValidator extends StrictBase {
-  #context;
-  constructor(context, strict) {
-    super(strict);
-    this.#context = context;
-  }
-  validate(rules, matrix, childCount) {
-    const firstIndex = 0;
-    const lastIndex = childCount - 1;
-    for (const [ri, rule] of rules.entries()) {
-      const matches = matrix.childToRules.reverse.get(ri);
-      const matchCount = matches.size;
-      this.#validateCardinality(rule, matchCount);
-      if (matchCount === 0) continue;
-      this.#validatePositions(rule, matches, firstIndex, lastIndex);
-    }
+}
+function* values(object) {
+  for (const [, value] of entries(object)) {
+    yield value;
   }
-  #validateCardinality(rule, matchCount) {
-    const { cardinality, name } = rule;
-    if (cardinality.kind !== "bounded") {
-      return;
-    }
-    const { min, max } = cardinality;
-    if (matchCount < min) {
-      this.violate(`${this.#context}: "${name}" requires at least ${min}.`);
-      return;
-    }
-    if (matchCount > max) {
-      this.violate(`${this.#context}: "${name}" allows at most ${max}.`);
-    }
+}
+function mapValues(object, callback) {
+  const result = {};
+  for (const [key, value] of entries(object)) {
+    result[key] = callback(value, key);
   }
-  #validatePositions(rule, matches, firstIndex, lastIndex) {
-    const { name, position } = rule;
-    for (const index of matches) {
-      if (_RuleValidator.#isValidPosition(index, position, firstIndex, lastIndex)) {
-        continue;
-      }
-      this.violate(`${this.#context}: "${name}" must be ${position}, got index ${index}`);
-    }
+  return result;
+}
+function forEachEntry(object, callback) {
+  for (const [key, value] of entries(object)) {
+    callback(key, value);
   }
-  static #isValidPosition(matchIndex, position, firstIndex, lastIndex) {
-    switch (position) {
-      case "first":
-        return matchIndex === firstIndex;
-      case "last":
-        return matchIndex === lastIndex;
-      case "any":
-        return true;
-      default:
-        return assertNever(position);
-    }
+}
+function forEachKey(object, callback) {
+  for (const key of keys(object)) {
+    callback(key);
   }
-};
-var ChildrenEvaluator = class extends StrictBase {
-  #rules;
-  #ruleNames;
-  #matcher;
-  #ruleValidator;
-  #matchBuilder;
-  constructor(rules, strict = "warn", context = "Component") {
-    super(strict);
-    this.#rules = rules.map((r) => normalizeChildRule(r));
-    this.#ruleNames = this.#rules.map((r) => r.name);
-    for (const rule of this.#rules) {
-      const { name, position, cardinality } = rule;
-      if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
-        throw new RangeError(
-          `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
-        );
-      }
-    }
-    this.#matcher = new RuleMatcher(this.#rules);
-    this.#ruleValidator = new RuleValidator(context, strict);
-    this.#matchBuilder = new MatchValidationErrorBuilder(context);
+}
+function forEachValue(object, callback) {
+  for (const value of values(object)) {
+    callback(value);
   }
-  evaluate(children) {
-    if (!this.strict) return;
-    const { matrix, unexpectedIndices, ambiguousIndices } = this.#matcher.match(children);
-    this.#ruleValidator.validate(this.#rules, matrix, children.length);
-    if (unexpectedIndices.size === 0 && ambiguousIndices.size === 0) return;
-    const errors = [];
-    const violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
-    for (const ci of violating) {
-      const typeName = getTypeName(children[ci]);
-      if (unexpectedIndices.has(ci)) {
-        errors.push(this.#matchBuilder.unexpectedChild(typeName, ci));
-      } else {
-        const matches = matrix.childToRules.forward.get(ci);
-        const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
-        errors.push(this.#matchBuilder.multipleMatches(typeName, ci, names));
-      }
-    }
-    this.invariant(errors.length === 0, this.#matchBuilder.toError(errors).message);
+}
+function forEachSet(s, callback) {
+  for (const value of s) {
+    callback(value);
   }
-};
+}
+var iterate = Object.freeze({
+  entries,
+  filter,
+  find,
+  findLast,
+  forEach,
+  forEachEntry,
+  forEachKey,
+  forEachSet,
+  forEachValue,
+  items,
+  keys,
+  map,
+  mapEntries,
+  mapValues,
+  nodeList,
+  reduce,
+  collect,
+  set,
+  some,
+  every,
+  values
+});
+
+// ../../lib/contract/src/props/get-active-props.ts
 var activeProps = ({
   active,
   "aria-current": ariaCurrent,
@@ -1066,6 +184,8 @@ var activeProps = ({
     }
   };
 };
+
+// ../../lib/contract/src/props/get-disabled-props.ts
 var disabledProps = ({
   disabled,
   "aria-disabled": ariaDisabled,
@@ -1077,6 +197,8 @@ var disabledProps = ({
     ...dataDisabled === void 0 && { "data-disabled": "" }
   };
 };
+
+// ../../lib/contract/src/props/get-expanded-props.ts
 var expandedProps = ({
   expanded,
   "aria-expanded": ariaExpanded,
@@ -1092,6 +214,8 @@ var expandedProps = ({
     }
   };
 };
+
+// ../../lib/contract/src/props/get-invalid-props.ts
 var invalidProps = ({
   invalid,
   "aria-invalid": ariaInvalid,
@@ -1103,6 +227,8 @@ var invalidProps = ({
     ...dataInvalid === void 0 && { "data-invalid": "" }
   };
 };
+
+// ../../lib/contract/src/props/get-loading-props.ts
 var loadingProps = ({
   loading,
   "aria-busy": ariaBusy,
@@ -1118,6 +244,8 @@ var loadingProps = ({
     }
   };
 };
+
+// ../../lib/contract/src/props/get-pressed-props.ts
 var pressedProps = ({
   pressed,
   "aria-pressed": ariaPressed,
@@ -1133,6 +261,8 @@ var pressedProps = ({
     }
   };
 };
+
+// ../../lib/contract/src/props/get-readonly-props.ts
 var readonlyProps = ({
   readOnly,
   "aria-readonly": ariaReadonly,
@@ -1148,6 +278,8 @@ var readonlyProps = ({
     }
   };
 };
+
+// ../../lib/contract/src/props/get-selected-props.ts
 var selectedProps = ({
   selected,
   "aria-selected": ariaSelected,
@@ -1163,174 +295,8 @@ var selectedProps = ({
     }
   };
 };
-var LANDMARK_TAG_SET = /* @__PURE__ */ new Set(["article", "aside", "footer", "header", "main", "nav"]);
-var removeLandmarkRoleOverride = {
-  kind: "removeRole",
-  apply: ({ props }) => {
-    if (!("role" in props)) return { applied: false, next: props };
-    const { role: _r, ...rest } = props;
-    return { applied: true, next: rest, previous: props };
-  }
-};
-function landmarkRoleRule({ tag, props, implicitRole }) {
-  if (!LANDMARK_TAG_SET.has(tag) || !implicitRole) return [];
-  const role = props.role;
-  if (!role || role === implicitRole) return [];
-  return [
-    {
-      valid: false,
-      fixable: true,
-      severity: "error",
-      fix: removeLandmarkRoleOverride,
-      message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
-    }
-  ];
-}
-function isOpenContent(...blockedTags) {
-  const set = new Set(blockedTags);
-  return (child) => isObject(child) && "type" in child && (!isString(child.type) || !set.has(child.type));
-}
-var METADATA_TAGS = ["script", "template"];
-var metadataMatch = isTag(...METADATA_TAGS);
-function metadata(name = "metadata") {
-  return { name, match: metadataMatch };
-}
-function firstOptional(name, tag) {
-  return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
-}
-function contract(children) {
-  return { strict: "warn", children };
-}
-function ariaContract(aria) {
-  return { strict: "warn", aria };
-}
-function firstChildContract(name, tag) {
-  return contract([firstOptional(name, tag), { name: "content", match: isOpenContent(tag) }]);
-}
-var VOID_TAGS = [
-  "area",
-  "base",
-  "br",
-  "col",
-  "embed",
-  "hr",
-  "img",
-  "input",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-];
-var TEXT_ONLY_TAGS = ["option", "script", "style", "textarea", "title"];
-var LANDMARK_TAGS = ["article", "aside", "footer", "header", "main", "nav"];
-var listContract = contract([{ name: "list-item", match: isTag("li", ...METADATA_TAGS) }]);
-var tableContract = contract([
-  firstOptional("caption", "caption"),
-  { name: "colgroup", match: isTag("colgroup") },
-  { name: "thead", match: isTag("thead"), cardinality: { max: 1 } },
-  { name: "tbody", match: isTag("tbody") },
-  { name: "tfoot", match: isTag("tfoot"), cardinality: { max: 1 } },
-  { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
-]);
-var tableBodyContract = contract([
-  { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
-]);
-var tableRowContract = contract([
-  { name: "table-cell", match: isTag("td", "th", ...METADATA_TAGS) }
-]);
-var colgroupContract = contract([{ name: "column", match: isTag("col", "template") }]);
-var dlContract = contract([
-  { name: "term", match: isTag("dt") },
-  { name: "description", match: isTag("dd") },
-  { name: "group", match: isTag("div") },
-  metadata()
-]);
-var selectContract = contract([
-  { name: "option", match: isTag("option", "optgroup", "hr", ...METADATA_TAGS) }
-]);
-var optgroupContract = contract([
-  { name: "option", match: isTag("option", ...METADATA_TAGS) }
-]);
-var datalistContract = contract([
-  { name: "option", match: isTag("option", ...METADATA_TAGS) }
-]);
-var pictureContract = contract([
-  { name: "source", match: isTag("source", ...METADATA_TAGS) },
-  { name: "image", match: isTag("img"), cardinality: { min: 1, max: 1 }, position: "last" }
-]);
-var figureContract = contract([
-  { name: "caption", match: isTag("figcaption"), cardinality: { max: 1 } },
-  { name: "content", match: isOpenContent("figcaption") }
-]);
-var detailsContract = firstChildContract("summary", "summary");
-var fieldsetContract = firstChildContract("legend", "legend");
-var mediaContract = contract([
-  { name: "source", match: isTag("source") },
-  { name: "track", match: isTag("track") },
-  metadata(),
-  { name: "content", match: isOpenContent("source", "track", ...METADATA_TAGS) }
-]);
-var headContract = contract([
-  {
-    name: "metadata",
-    match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
-  }
-]);
-var htmlContract = contract([
-  { name: "head", match: isTag("head"), cardinality: { min: 1, max: 1 }, position: "first" },
-  { name: "body", match: isTag("body"), cardinality: { min: 1, max: 1 } }
-]);
-var voidContract = contract([]);
-var textOnlyContract = contract([
-  {
-    name: "text",
-    match: (child) => isString(child) || isNumber(child)
-  }
-]);
-var landmarkContract = ariaContract([landmarkRoleRule]);
-var CONTRACT_GROUPS = [
-  [VOID_TAGS, voidContract],
-  [TEXT_ONLY_TAGS, textOnlyContract],
-  [LANDMARK_TAGS, landmarkContract],
-  [["ul", "ol", "menu"], listContract],
-  [["audio", "video"], mediaContract],
-  [["thead", "tbody", "tfoot"], tableBodyContract]
-];
-function contractMap(groups) {
-  return Object.fromEntries(
-    groups.flatMap(([tags, enforcement]) => tags.map((tag) => [tag, enforcement]))
-  );
-}
-var htmlContracts = {
-  ...contractMap(CONTRACT_GROUPS),
-  table: tableContract,
-  tr: tableRowContract,
-  colgroup: colgroupContract,
-  dl: dlContract,
-  select: selectContract,
-  optgroup: optgroupContract,
-  datalist: datalistContract,
-  picture: pictureContract,
-  figure: figureContract,
-  details: detailsContract,
-  fieldset: fieldsetContract,
-  head: headContract,
-  html: htmlContract
-};
-function buildEvaluatorMap() {
-  const map = /* @__PURE__ */ new Map();
-  for (const [tag, { children }] of Object.entries(htmlContracts)) {
-    if (children?.length) {
-      map.set(tag, new ChildrenEvaluator(children, "warn", `<${tag}>`));
-    }
-  }
-  return map;
-}
-var HTML_EVALUATORS = buildEvaluatorMap();
 
-// ../core/dist/contract.js
+// ../core/src/state/contracts.ts
 function stateContract(props) {
   return { props };
 }
@@ -1342,21 +308,23 @@ var loadingContract = stateContract([loadingProps]);
 var pressedContract = stateContract([pressedProps]);
 var readonlyContract = stateContract([readonlyProps]);
 var selectedContract = stateContract([selectedProps]);
+
+// ../core/src/state/merge-contracts.ts
 function mergeContracts(...contracts) {
   const props = contracts.flatMap((c) => c.props ?? []);
   const aria = contracts.flatMap((c) => c.aria ?? []);
   const children = contracts.flatMap((c) => c.children ?? []);
-  let strict;
+  let diagnostics;
   let allowedAs;
-  for (const c of contracts) {
-    if (c.strict !== void 0) strict = c.strict;
+  iterate.forEach(contracts, (c) => {
+    if (c.diagnostics !== void 0) diagnostics = c.diagnostics;
     if (c.allowedAs !== void 0) allowedAs = c.allowedAs;
-  }
+  });
   return {
     ...props.length > 0 && { props },
     ...aria.length > 0 && { aria },
     ...children.length > 0 && { children },
-    ...strict !== void 0 && { strict },
+    ...diagnostics !== void 0 && { diagnostics },
     ...allowedAs !== void 0 && { allowedAs }
   };
 }