@vastare/fundatio 0.1.0

package/dist/esm/chunks/index53.js

@@ -0,0 +1,29 @@
+import { c as r } from "./dom.js";
+const a = "strong", l = "strong";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...o } = t;
+  if (!e) return o;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...o, aria: n } : o;
+}
+function s(t, e) {
+  return r(a, i(e), t);
+}
+function c(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  STRONG_SELECTOR: l,
+  STRONG_TAG: a,
+  createStrong: s,
+  enhanceStrongs: c
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  l as S,
+  a,
+  s as c,
+  c as e,
+  f as i
+};
+//# sourceMappingURL=index53.js.map

package/dist/esm/chunks/index53.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index53.js","sources":["../../../src/elements/inline/strong/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Strong element helpers.\n *\n * @remarks\n * The strong element (`<strong>`) indicates that its contents have strong\n * importance, seriousness, or urgency. Browsers typically render it as bold,\n * but the semantic meaning is what matters. :contentReference[oaicite:3]{index=3}\n *\n * Best-practice guidance:\n * - Use `<strong>` for genuinely important text (e.g. warnings, urgent notes).\n * - Do not use `<strong>` purely for visual styling; use CSS for presentation.\n * - Do not confuse `<strong>` with `<b>`:\n *   - `<strong>` conveys importance/seriousness/urgency.\n *   - `<b>` draws attention without adding semantic importance. :contentReference[oaicite:4]{index=4}\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create strong text nodes in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * This module has no side effects and does not mutate the DOM unless you call\n * its functions.\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for strong importance.\n *\n * @category Constants\n */\nexport const STRONG_TAG = 'strong' as const;\n\n/**\n * A CSS selector targeting strong elements.\n *\n * @category Constants\n */\nexport const STRONG_SELECTOR = 'strong';\n\n/**\n * Attribute bag for strong creation/enhancement.\n *\n * @remarks\n * The `<strong>` element uses standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type StrongAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link StrongAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The strong attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: StrongAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  // Only attach `aria` if something was actually defined.\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create a strong element with optional text content and global attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * @param text - Optional text content for the strong element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<strong>` element.\n *\n * @example\n * Emphasize a warning:\n * ```ts\n * import { createStrong } from \"@Vastare/Fundatio/elements/inline/strong\";\n *\n * const warning = createStrong(\"Warning:\", { className: \"warning-label\" });\n * document.body.appendChild(warning);\n * ```\n *\n * @category DOM\n */\nexport function createStrong(text?: string, attrs?: StrongAttrs): ElementOf<typeof STRONG_TAG> {\n  return createElement(STRONG_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance strong elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceStrongs(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for strong.\n  void root;\n}\n"],"names":["STRONG_TAG","STRONG_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createStrong","text","createElement","enhanceStrongs","root"],"mappings":";AA8DO,MAAMA,IAAa,UAObC,IAAkB;AA4B/B,SAASC,EAAcC,GAA8C;AACnE,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAG7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AA0BO,SAASE,EAAaC,GAAeL,GAAmD;AAC7F,SAAOM,EAAcT,GAAYE,EAAcC,CAAK,GAAGK,CAAI;AAC7D;AAoBO,SAASE,EAAeC,IAAmB,UAAgB;AAGlE;;;;;;;;"}

package/dist/esm/chunks/index54.js

@@ -0,0 +1,29 @@
+import { c as i } from "./dom.js";
+const o = "cite", l = "cite";
+function r(t) {
+  if (!t) return;
+  const { aria: e, ...a } = t;
+  if (!e) return a;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...a, aria: n } : a;
+}
+function c(t, e) {
+  return i(o, r(e), t);
+}
+function s(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  CITE_SELECTOR: l,
+  CITE_TAG: o,
+  createCite: c,
+  enhanceCites: s
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  l as C,
+  o as a,
+  c,
+  s as e,
+  f as i
+};
+//# sourceMappingURL=index54.js.map

package/dist/esm/chunks/index54.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index54.js","sources":["../../../src/elements/inline/cite/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Cite element helpers.\n *\n * @remarks\n * The cite element (`<cite>`) represents the title of a creative work (e.g. a book,\n * paper, essay, poem, song, film, TV show, game, sculpture, painting, etc.). :contentReference[oaicite:2]{index=2}\n *\n * Best-practice guidance:\n * - Use `<cite>` for the title of the work being referenced, not the author's name\n *   and not purely for styling. :contentReference[oaicite:3]{index=3}\n * - If you want a visible link to a source, use an `<a>` element (and/or surrounding\n *   citation patterns) rather than relying on hidden metadata. (Fundatio intentionally\n *   does not invent citation-specific behaviors here.)\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create cite inline nodes in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * This module has no side effects and does not mutate the DOM unless you call\n * its functions.\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for cite.\n *\n * @category Constants\n */\nexport const CITE_TAG = 'cite' as const;\n\n/**\n * A CSS selector targeting cite elements.\n *\n * @category Constants\n */\nexport const CITE_SELECTOR = 'cite';\n\n/**\n * Attribute bag for cite creation/enhancement.\n *\n * @remarks\n * The `<cite>` element uses standard HTML global attributes. :contentReference[oaicite:4]{index=4}\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type CiteAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link CiteAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The cite attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: CiteAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  // Only attach `aria` if something was actually defined.\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create a cite element with optional text content and global attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * @param text - Optional text content for the cite element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<cite>` element.\n *\n * @example\n * Cite a work title:\n * ```ts\n * import { createCite } from \"@Vastare/Fundatio/elements/inline/cite\";\n *\n * const c = createCite(\"The Scream\", { className: \"work-title\" });\n * document.body.appendChild(c);\n * ```\n *\n * @category DOM\n */\nexport function createCite(text?: string, attrs?: CiteAttrs): ElementOf<typeof CITE_TAG> {\n  return createElement(CITE_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance cite elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceCites(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for cite.\n  void root;\n}\n"],"names":["CITE_TAG","CITE_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createCite","text","createElement","enhanceCites","root"],"mappings":";AA6DO,MAAMA,IAAW,QAOXC,IAAgB;AA4B7B,SAASC,EAAcC,GAA4C;AACjE,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAG7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AA0BO,SAASE,EAAWC,GAAeL,GAA+C;AACvF,SAAOM,EAAcT,GAAUE,EAAcC,CAAK,GAAGK,CAAI;AAC3D;AAoBO,SAASE,EAAaC,IAAmB,UAAgB;AAGhE;;;;;;;;"}

package/dist/esm/chunks/index55.js

@@ -0,0 +1,29 @@
+import { c as l } from "./dom.js";
+const a = "code", r = "code";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...n } = t;
+  if (!e) return n;
+  const o = {};
+  return typeof e.label == "string" && (o.label = e.label), typeof e.labelledby == "string" && (o.labelledby = e.labelledby), typeof e.hidden == "boolean" && (o.hidden = e.hidden), Object.keys(o).length > 0 ? { ...n, aria: o } : n;
+}
+function d(t, e) {
+  return l(a, i(e), t);
+}
+function c(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  CODE_SELECTOR: r,
+  CODE_TAG: a,
+  createCode: d,
+  enhanceCodes: c
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  r as C,
+  a,
+  d as c,
+  c as e,
+  f as i
+};
+//# sourceMappingURL=index55.js.map

package/dist/esm/chunks/index55.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index55.js","sources":["../../../src/elements/inline/code/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Code element helpers.\n *\n * @remarks\n * The code element (`<code>`) represents a fragment of computer code.\n *\n * Best-practice guidance:\n * - Use `<code>` for inline code fragments inside text.\n * - For code blocks, pair `<code>` with `<pre>` (e.g. `<pre><code>...</code></pre>`).\n * - Do not use `<code>` purely for visual styling. If the intent is presentational\n *   (monospace text), use CSS instead.\n *\n * Attributes:\n * - `<code>` has no element-specific attributes in HTML. It accepts global\n *   attributes only.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create `<code>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * This module has no side effects and does not mutate the DOM unless you call\n * its functions.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/code\n * @see https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-code-element\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs.\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for the code element.\n *\n * @category Constants\n */\nexport const CODE_TAG = 'code' as const;\n\n/**\n * A CSS selector targeting code elements.\n *\n * @category Constants\n */\nexport const CODE_SELECTOR = 'code';\n\n/**\n * Attribute bag for code creation/enhancement.\n *\n * @remarks\n * `<code>` accepts standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * Security note:\n * - Inline event handler attributes (e.g. `onclick`) are blocked by `dom.ts`.\n * - The raw `style` attribute is blocked; use {@link GlobalAttrs.style}.\n *\n * @category Attributes\n */\nexport type CodeAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link CodeAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The code attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: CodeAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create a code element with optional text content and attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * Note: `<code>` is phrasing content. This helper supports a simple `text`\n * convenience for cases where plain text is sufficient; consumers can still\n * append richer child nodes afterwards.\n *\n * @param text - Optional text content for the code element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<code>` element.\n *\n * @example\n * ```ts\n * import { createCode } from \"@Vastare/Fundatio/elements/inline/code\";\n *\n * const snippet = createCode(\"npm run build\", { className: \"cmd\" });\n * document.body.appendChild(snippet);\n * ```\n *\n * @category DOM\n */\nexport function createCode(text?: string, attrs?: CodeAttrs): ElementOf<typeof CODE_TAG> {\n  return createElement(CODE_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance code elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceCodes(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for code.\n  void root;\n}\n"],"names":["CODE_TAG","CODE_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createCode","text","createElement","enhanceCodes","root"],"mappings":";AAkEO,MAAMA,IAAW,QAOXC,IAAgB;AAgC7B,SAASC,EAAcC,GAA4C;AACjE,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAE7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AA6BO,SAASE,EAAWC,GAAeL,GAA+C;AACvF,SAAOM,EAAcT,GAAUE,EAAcC,CAAK,GAAGK,CAAI;AAC3D;AAoBO,SAASE,EAAaC,IAAmB,UAAgB;AAGhE;;;;;;;;"}

package/dist/esm/chunks/index56.js

@@ -0,0 +1,30 @@
+import { c as f } from "./dom.js";
+const s = "data", d = "data";
+function b(t, o) {
+  if (!t)
+    return;
+  const { aria: e, value: r, ...c } = t, a = c, i = { ...a.attrs ?? {} }, l = typeof r == "string" || typeof r == "number" ? r : typeof o == "string" ? o : void 0;
+  if ((typeof l == "string" || typeof l == "number") && (i.value = l), Object.keys(i).length > 0 && (a.attrs = i), !e) return a;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...a, aria: n } : a;
+}
+function p(t, o) {
+  return f(s, b(o, t), t);
+}
+function u(t = document) {
+}
+const h = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DATA_SELECTOR: d,
+  DATA_TAG: s,
+  createData: p,
+  enhanceDatas: u
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  d as D,
+  s as a,
+  p as c,
+  u as e,
+  h as i
+};
+//# sourceMappingURL=index56.js.map

package/dist/esm/chunks/index56.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index56.js","sources":["../../../src/elements/inline/data/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Data (`data`) element helpers.\n *\n * @remarks\n * The data element (`<data>`) links human-readable content to a machine-readable\n * value via the `value` attribute.\n *\n * Best-practice guidance:\n * - Use `value` for canonical/machine-readable values (IDs, codes, normalized forms).\n * - Keep visible text human-friendly.\n * - Prefer explicit `value` when the machine value differs from the displayed text.\n *\n * Fundatio applies a sensible fallback:\n * - If `attrs.value` is omitted and `text` is provided, Fundatio sets `value` to `text`.\n *\n * Security notes:\n * - Fundatio blocks unsafe attribute *names* (e.g. `onclick`, raw `style`).\n * - Fundatio does not sanitize attribute *values*. Treat untrusted inputs accordingly.\n *\n * References:\n * - MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/data\n * - WHATWG: https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-data-element\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * Allowed value types for the `value` attribute on `<data>`.\n *\n * @remarks\n * HTML treats attributes as strings. Fundatio allows string/number and coerces to string.\n *\n * @category Attributes\n */\nexport type DataValue = string | number;\n\n/**\n * The semantic tag name for data elements.\n *\n * @category Constants\n */\nexport const DATA_TAG = 'data' as const;\n\n/**\n * A CSS selector targeting data elements.\n *\n * @category Constants\n */\nexport const DATA_SELECTOR = 'data';\n\n/**\n * Attribute bag for data element creation/enhancement.\n *\n * @remarks\n * Data elements accept standard HTML global attributes, plus:\n * - `value`: machine-readable translation of the element's content.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type DataAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Machine-readable value for the data.\n   *\n   * @remarks\n   * If omitted and `text` is provided, Fundatio falls back to using `text` as `value`.\n   */\n  value?: DataValue;\n\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link DataAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The data element attributes.\n * @param text - Optional text content used for the `value` fallback.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: DataAttrs, text?: string): GlobalAttrs | undefined {\n  if (!attrs) {\n    // Even when attrs are omitted, we may still want to apply the value fallback.\n    // However, without an attrs bag there's nowhere to attach `attrs.value`.\n    return undefined;\n  }\n\n  const { aria, value, ...rest } = attrs;\n\n  const out: GlobalAttrs = rest;\n\n  const rawAttrs: NonNullable<GlobalAttrs['attrs']> = { ...(out.attrs ?? {}) };\n\n  // Prefer explicit `value`. Otherwise, fall back to `text` (if provided).\n  const effectiveValue =\n    typeof value === 'string' || typeof value === 'number'\n      ? value\n      : typeof text === 'string'\n        ? text\n        : undefined;\n\n  if (typeof effectiveValue === 'string' || typeof effectiveValue === 'number') {\n    rawAttrs.value = effectiveValue;\n  }\n\n  if (Object.keys(rawAttrs).length > 0) out.attrs = rawAttrs;\n\n  if (!aria) return out;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...out, aria: mappedAria } : out;\n}\n\n/**\n * Create a data element with optional text content and attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n * - If `attrs.value` is omitted and `text` is provided, Fundatio sets `value` to `text`.\n *\n * @param text - Optional human-readable content for the data element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<data>` element.\n *\n * @example\n * ```ts\n * import { createData } from \"@Vastare/Fundatio/elements/inline/data\";\n *\n * document.body.appendChild(\n *   createData(\"Mini Ketchup\", { value: 398 })\n * );\n * ```\n *\n * @category DOM\n */\nexport function createData(text?: string, attrs?: DataAttrs): ElementOf<typeof DATA_TAG> {\n  return createElement(DATA_TAG, toGlobalAttrs(attrs, text), text);\n}\n\n/**\n * Enhance data elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceDatas(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for data.\n  void root;\n}\n"],"names":["DATA_TAG","DATA_SELECTOR","toGlobalAttrs","attrs","text","aria","value","rest","out","rawAttrs","effectiveValue","mappedAria","createData","createElement","enhanceDatas","root"],"mappings":";AAwEO,MAAMA,IAAW,QAOXC,IAAgB;AAsC7B,SAASC,EAAcC,GAAmBC,GAAwC;AAChF,MAAI,CAACD;AAGH;AAGF,QAAM,EAAE,MAAAE,GAAM,OAAAC,GAAO,GAAGC,MAASJ,GAE3BK,IAAmBD,GAEnBE,IAA8C,EAAE,GAAID,EAAI,SAAS,CAAA,EAAC,GAGlEE,IACJ,OAAOJ,KAAU,YAAY,OAAOA,KAAU,WAC1CA,IACA,OAAOF,KAAS,WACdA,IACA;AAQR,OANI,OAAOM,KAAmB,YAAY,OAAOA,KAAmB,cAClED,EAAS,QAAQC,IAGf,OAAO,KAAKD,CAAQ,EAAE,SAAS,QAAO,QAAQA,IAE9C,CAACJ,EAAM,QAAOG;AAElB,QAAMG,IAA+C,CAAA;AAErD,SAAI,OAAON,EAAK,SAAU,aAAUM,EAAW,QAAQN,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUM,EAAW,aAAaN,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWM,EAAW,SAASN,EAAK,SAE7C,OAAO,KAAKM,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGH,GAAK,MAAMG,MAAeH;AACpD;AA2BO,SAASI,EAAWR,GAAeD,GAA+C;AACvF,SAAOU,EAAcb,GAAUE,EAAcC,GAAOC,CAAI,GAAGA,CAAI;AACjE;AAoBO,SAASU,EAAaC,IAAmB,UAAgB;AAGhE;;;;;;;;"}

package/dist/esm/chunks/index57.js

@@ -0,0 +1,29 @@
+import { c as l } from "./dom.js";
+const o = "dfn", r = "dfn";
+function i(n) {
+  if (!n) return;
+  const { aria: e, ...a } = n;
+  if (!e) return a;
+  const t = {};
+  return typeof e.label == "string" && (t.label = e.label), typeof e.labelledby == "string" && (t.labelledby = e.labelledby), typeof e.hidden == "boolean" && (t.hidden = e.hidden), Object.keys(t).length > 0 ? { ...a, aria: t } : a;
+}
+function d(n, e) {
+  return l(o, i(e), n);
+}
+function s(n = document) {
+}
+const b = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DFN_SELECTOR: r,
+  DFN_TAG: o,
+  createDfn: d,
+  enhanceDfns: s
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  r as D,
+  o as a,
+  d as c,
+  s as e,
+  b as i
+};
+//# sourceMappingURL=index57.js.map

package/dist/esm/chunks/index57.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index57.js","sources":["../../../src/elements/inline/dfn/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Dfn element helpers.\n *\n * @remarks\n * The dfn element (`<dfn>`) indicates the defining instance of a term.\n * The nearest containing phrasing context (often a paragraph, list item, or\n * section) should include the term's definition.\n *\n * Best-practice guidance:\n * - Use `<dfn>` for the defining instance of a term, not for general emphasis.\n * - Avoid nesting `<dfn>` inside another `<dfn>`.\n * - If you use the `title` attribute on `<dfn>`, it should contain only the term\n *   being defined (useful when the displayed text differs from the term).\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create definition-term markers in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dfn\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for defining instances of terms.\n *\n * @category Constants\n */\nexport const DFN_TAG = 'dfn' as const;\n\n/**\n * A CSS selector targeting dfn elements.\n *\n * @category Constants\n */\nexport const DFN_SELECTOR = 'dfn';\n\n/**\n * Attribute bag for dfn creation/enhancement.\n *\n * @remarks\n * Dfn elements accept standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type DfnAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link DfnAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The dfn attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: DfnAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  // Only attach `aria` if something was actually defined.\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create a dfn element with optional text content and global attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * @param text - Optional text content for the dfn element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<dfn>` element.\n *\n * @example\n * ```ts\n * import { createDfn } from \"@Vastare/Fundatio/elements/inline/dfn\";\n *\n * document.body.appendChild(\n *   createDfn(\"validator\", { id: \"term-validator\" })\n * );\n * ```\n *\n * @category DOM\n */\nexport function createDfn(text?: string, attrs?: DfnAttrs): ElementOf<typeof DFN_TAG> {\n  return createElement(DFN_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance dfn elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceDfns(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for dfn.\n  void root;\n}\n"],"names":["DFN_TAG","DFN_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createDfn","text","createElement","enhanceDfns","root"],"mappings":";AA4DO,MAAMA,IAAU,OAOVC,IAAe;AA4B5B,SAASC,EAAcC,GAA2C;AAChE,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAG7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AA0BO,SAASE,EAAUC,GAAeL,GAA6C;AACpF,SAAOM,EAAcT,GAASE,EAAcC,CAAK,GAAGK,CAAI;AAC1D;AAoBO,SAASE,EAAYC,IAAmB,UAAgB;AAG/D;;;;;;;;"}

package/dist/esm/chunks/index58.js

@@ -0,0 +1,29 @@
+import { c as l } from "./dom.js";
+const o = "em", r = "em";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...a } = t;
+  if (!e) return a;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...a, aria: n } : a;
+}
+function s(t, e) {
+  return l(o, i(e), t);
+}
+function c(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  EM_SELECTOR: r,
+  EM_TAG: o,
+  createEm: s,
+  enhanceEms: c
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  r as E,
+  o as a,
+  s as c,
+  c as e,
+  f as i
+};
+//# sourceMappingURL=index58.js.map

package/dist/esm/chunks/index58.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index58.js","sources":["../../../src/elements/inline/em/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Em element helpers.\n *\n * @remarks\n * The em element (`<em>`) marks text that has stress emphasis. Stress emphasis is\n * semantic: it can change the meaning of a sentence, and nested `<em>` elements\n * indicate a greater degree of emphasis. :contentReference[oaicite:2]{index=2}\n *\n * Best-practice guidance:\n * - Use `<em>` when you would change vocal stress if speaking the sentence.\n * - Avoid using `<em>` purely for visual styling (e.g. italics); use CSS instead.\n * - Nested `<em>` increases emphasis; do not nest for decoration. :contentReference[oaicite:3]{index=3}\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create emphasis nodes in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * This module has no side effects and does not mutate the DOM unless you call\n * its functions.\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for stress emphasis.\n *\n * @category Constants\n */\nexport const EM_TAG = 'em' as const;\n\n/**\n * A CSS selector targeting em elements.\n *\n * @category Constants\n */\nexport const EM_SELECTOR = 'em';\n\n/**\n * Attribute bag for em creation/enhancement.\n *\n * @remarks\n * The `<em>` element uses standard HTML global attributes. :contentReference[oaicite:4]{index=4}\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type EmAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link EmAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The em attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: EmAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  // Only attach `aria` if something was actually defined.\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create an em element with optional text content and global attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * @param text - Optional text content for the em element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<em>` element.\n *\n * @example\n * Stress emphasis:\n * ```ts\n * import { createEm } from \"@Vastare/Fundatio/elements/inline/em\";\n *\n * const e = createEm(\"really\", { className: \"stress\" });\n * document.body.appendChild(e);\n * ```\n *\n * @category DOM\n */\nexport function createEm(text?: string, attrs?: EmAttrs): ElementOf<typeof EM_TAG> {\n  return createElement(EM_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance em elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceEms(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for em.\n  void root;\n}\n"],"names":["EM_TAG","EM_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createEm","text","createElement","enhanceEms","root"],"mappings":";AA4DO,MAAMA,IAAS,MAOTC,IAAc;AA4B3B,SAASC,EAAcC,GAA0C;AAC/D,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAG7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AA0BO,SAASE,EAASC,GAAeL,GAA2C;AACjF,SAAOM,EAAcT,GAAQE,EAAcC,CAAK,GAAGK,CAAI;AACzD;AAoBO,SAASE,EAAWC,IAAmB,UAAgB;AAG9D;;;;;;;;"}

package/dist/esm/chunks/index59.js

@@ -0,0 +1,29 @@
+import { c as l } from "./dom.js";
+const o = "i", r = "i";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...a } = t;
+  if (!e) return a;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...a, aria: n } : a;
+}
+function s(t, e) {
+  return l(o, i(e), t);
+}
+function c(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  I_SELECTOR: r,
+  I_TAG: o,
+  createI: s,
+  enhanceIs: c
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  r as I,
+  o as a,
+  s as c,
+  c as e,
+  f as i
+};
+//# sourceMappingURL=index59.js.map

package/dist/esm/chunks/index59.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index59.js","sources":["../../../src/elements/inline/i/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: i element helpers.\n *\n * @remarks\n * The i element (`<i>`) represents a range of text set off from the normal prose\n * for some reason, such as:\n * - idiomatic text / alternate voice or mood\n * - technical terms\n * - taxonomical designations\n * - transliterations\n *\n * Best-practice guidance:\n * - Do not use `<i>` purely for visual italics. Use CSS when the intent is\n *   presentational rather than semantic.\n * - If you mean emphasis (stress), use `<em>`.\n * - If you mean importance, use `<strong>`.\n * - If you mean the title of a work, use `<cite>`.\n *\n * Attributes:\n * - `<i>` has no element-specific attributes in HTML. It accepts global\n *   attributes only.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create `<i>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * This module has no side effects and does not mutate the DOM unless you call\n * its functions.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/i\n * @see https://html.spec.whatwg.org/multipage/text-level-semantics.html\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs.\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for the i element.\n *\n * @category Constants\n */\nexport const I_TAG = 'i' as const;\n\n/**\n * A CSS selector targeting i elements.\n *\n * @category Constants\n */\nexport const I_SELECTOR = 'i';\n\n/**\n * Attribute bag for i creation/enhancement.\n *\n * @remarks\n * `<i>` accepts standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * Security note:\n * - Inline event handler attributes (e.g. `onclick`) are blocked by `dom.ts`.\n * - The raw `style` attribute is blocked; use {@link GlobalAttrs.style}.\n *\n * @category Attributes\n */\nexport type IAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link IAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The i attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: IAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create an i element with optional text content and attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * Note: `<i>` is phrasing content. This helper supports a simple `text`\n * convenience for cases where plain text is sufficient; consumers can still\n * append richer child nodes afterwards.\n *\n * @param text - Optional text content for the i element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<i>` element.\n *\n * @example\n * ```ts\n * import { createI } from \"@Vastare/Fundatio/elements/inline/i\";\n *\n * const term = createI(\"Homo sapiens\", { className: \"taxonomy\" });\n * document.body.appendChild(term);\n * ```\n *\n * @category DOM\n */\nexport function createI(text?: string, attrs?: IAttrs): ElementOf<typeof I_TAG> {\n  return createElement(I_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance i elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceIs(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for i.\n  void root;\n}\n"],"names":["I_TAG","I_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createI","text","createElement","enhanceIs","root"],"mappings":";AAwEO,MAAMA,IAAQ,KAORC,IAAa;AAgC1B,SAASC,EAAcC,GAAyC;AAC9D,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAE7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AA6BO,SAASE,EAAQC,GAAeL,GAAyC;AAC9E,SAAOM,EAAcT,GAAOE,EAAcC,CAAK,GAAGK,CAAI;AACxD;AAoBO,SAASE,EAAUC,IAAmB,UAAgB;AAG7D;;;;;;;;"}

package/dist/esm/chunks/index6.js

@@ -0,0 +1,19 @@
+import { i } from "./index38.js";
+import { i as o } from "./index39.js";
+import { i as e } from "./index40.js";
+import { i as r } from "./index41.js";
+import { i as t } from "./index42.js";
+import { i as m } from "./index43.js";
+const x = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  h1: i,
+  h2: o,
+  h3: e,
+  h4: r,
+  h5: t,
+  h6: m
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  x as i
+};
+//# sourceMappingURL=index6.js.map

package/dist/esm/chunks/index6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}

package/dist/esm/chunks/index60.js

@@ -0,0 +1,29 @@
+import { c as l } from "./dom.js";
+const o = "kbd", r = "kbd";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...a } = t;
+  if (!e) return a;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...a, aria: n } : a;
+}
+function d(t, e) {
+  return l(o, i(e), t);
+}
+function b(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  KBD_SELECTOR: r,
+  KBD_TAG: o,
+  createKbd: d,
+  enhanceKbds: b
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  r as K,
+  o as a,
+  d as c,
+  b as e,
+  f as i
+};
+//# sourceMappingURL=index60.js.map

package/dist/esm/chunks/index60.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index60.js","sources":["../../../src/elements/inline/kbd/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Kbd (`kbd`) element helpers.\n *\n * @remarks\n * The kbd element (`<kbd>`) represents user input, typically keyboard input,\n * but it may also represent input via other mechanisms (e.g. voice commands).\n *\n * Best-practice guidance:\n * - Use `<kbd>` for inline, human-readable input instructions (keys, shortcuts, commands).\n * - For key combinations, it is common to wrap the whole sequence in an outer `<kbd>`\n *   and each individual key as inner `<kbd>` elements (e.g. `<kbd><kbd>Ctrl</kbd>+<kbd>S</kbd></kbd>`).\n * - Do not rely on default styling; apply CSS for consistent presentation.\n *\n * Security notes:\n * - Fundatio blocks unsafe attribute *names* (e.g. `onclick`, raw `style`) via `dom.ts`.\n * - Fundatio does not sanitize attribute *values*. Treat untrusted inputs accordingly.\n *\n * References:\n * - MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/kbd\n * - WHATWG: https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-kbd-element\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for kbd elements.\n *\n * @category Constants\n */\nexport const KBD_TAG = 'kbd' as const;\n\n/**\n * A CSS selector targeting kbd elements.\n *\n * @category Constants\n */\nexport const KBD_SELECTOR = 'kbd';\n\n/**\n * Attribute bag for kbd creation/enhancement.\n *\n * @remarks\n * Kbd elements accept standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type KbdAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link KbdAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The kbd attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: KbdAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  // Only attach `aria` if something was actually defined.\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create a kbd element with optional text content and global attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * @param text - Optional text content for the kbd element (e.g. \"Ctrl\", \"⌘\", \"F3\").\n * @param attrs - Optional attributes to apply.\n * @returns The created `<kbd>` element.\n *\n * @example\n * ```ts\n * import { createKbd } from \"@Vastare/Fundatio/elements/inline/kbd\";\n *\n * const shortcut = createKbd(undefined, { className: \"keys\" });\n * shortcut.append(createKbd(\"Ctrl\"), document.createTextNode(\"+\"), createKbd(\"S\"));\n * ```\n *\n * @category DOM\n */\nexport function createKbd(text?: string, attrs?: KbdAttrs): ElementOf<typeof KBD_TAG> {\n  return createElement(KBD_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance kbd elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceKbds(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for kbd.\n  void root;\n}\n"],"names":["KBD_TAG","KBD_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createKbd","text","createElement","enhanceKbds","root"],"mappings":";AA4DO,MAAMA,IAAU,OAOVC,IAAe;AA4B5B,SAASC,EAAcC,GAA2C;AAChE,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAG7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AAyBO,SAASE,EAAUC,GAAeL,GAA6C;AACpF,SAAOM,EAAcT,GAASE,EAAcC,CAAK,GAAGK,CAAI;AAC1D;AAoBO,SAASE,EAAYC,IAAmB,UAAgB;AAG/D;;;;;;;;"}

package/dist/esm/chunks/index61.js

@@ -0,0 +1,29 @@
+import { c as r } from "./dom.js";
+const o = "mark", l = "mark";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...n } = t;
+  if (!e) return n;
+  const a = {};
+  return typeof e.label == "string" && (a.label = e.label), typeof e.labelledby == "string" && (a.labelledby = e.labelledby), typeof e.hidden == "boolean" && (a.hidden = e.hidden), Object.keys(a).length > 0 ? { ...n, aria: a } : n;
+}
+function s(t, e) {
+  return r(o, i(e), t);
+}
+function c(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MARK_SELECTOR: l,
+  MARK_TAG: o,
+  createMark: s,
+  enhanceMarks: c
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  l as M,
+  o as a,
+  s as c,
+  c as e,
+  f as i
+};
+//# sourceMappingURL=index61.js.map

package/dist/esm/chunks/index61.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index61.js","sources":["../../../src/elements/inline/mark/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Mark element helpers.\n *\n * @remarks\n * The mark element (`<mark>`) represents text that is marked or highlighted for\n * reference or notation because it is relevant in the current context.\n *\n * Common, semantic uses:\n * - Highlighting search matches within results or a document.\n * - Marking passages being referenced elsewhere (e.g. annotated excerpts).\n *\n * Best-practice guidance:\n * - Use `<mark>` when the highlight communicates contextual relevance, not merely\n *   a visual style.\n * - Prefer CSS for purely presentational highlighting.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create marked text spans in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/mark\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for marked/highlighted text.\n *\n * @category Constants\n */\nexport const MARK_TAG = 'mark' as const;\n\n/**\n * A CSS selector targeting mark elements.\n *\n * @category Constants\n */\nexport const MARK_SELECTOR = 'mark';\n\n/**\n * Attribute bag for mark creation/enhancement.\n *\n * @remarks\n * Mark elements accept standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type MarkAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link MarkAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The mark attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: MarkAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  // Only attach `aria` if something was actually defined.\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create a mark element with optional text content and global attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * @param text - Optional text content for the mark element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<mark>` element.\n *\n * @example\n * ```ts\n * import { createMark } from \"@Vastare/Fundatio/elements/inline/mark\";\n *\n * // Highlight a search match:\n * document.body.appendChild(createMark(\"kitchen\", { className: \"match\" }));\n * ```\n *\n * @category DOM\n */\nexport function createMark(text?: string, attrs?: MarkAttrs): ElementOf<typeof MARK_TAG> {\n  return createElement(MARK_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance mark elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceMarks(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for mark.\n  void root;\n}\n"],"names":["MARK_TAG","MARK_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createMark","text","createElement","enhanceMarks","root"],"mappings":";AA8DO,MAAMA,IAAW,QAOXC,IAAgB;AA4B7B,SAASC,EAAcC,GAA4C;AACjE,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAG7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AAyBO,SAASE,EAAWC,GAAeL,GAA+C;AACvF,SAAOM,EAAcT,GAAUE,EAAcC,CAAK,GAAGK,CAAI;AAC3D;AAoBO,SAASE,EAAaC,IAAmB,UAAgB;AAGhE;;;;;;;;"}

package/dist/esm/chunks/index62.js

@@ -0,0 +1,36 @@
+import { c as s } from "./dom.js";
+const r = "q", c = "q";
+function f(t, e, n) {
+  typeof t[e] > "u" && (t[e] = n);
+}
+function d(t) {
+  if (!t) return;
+  const { aria: e, cite: n, ...l } = t, o = { ...l };
+  if (typeof n == "string" && n.length > 0) {
+    const i = { ...o.attrs ?? {} };
+    f(i, "cite", n), o.attrs = i;
+  }
+  if (!e) return o;
+  const a = {};
+  return typeof e.label == "string" && (a.label = e.label), typeof e.labelledby == "string" && (a.labelledby = e.labelledby), typeof e.hidden == "boolean" && (a.hidden = e.hidden), Object.keys(a).length > 0 ? { ...o, aria: a } : o;
+}
+function b(t, e) {
+  return s(r, d(e), t);
+}
+function p(t = document) {
+}
+const h = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Q_SELECTOR: c,
+  Q_TAG: r,
+  createQ: b,
+  enhanceQs: p
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  c as Q,
+  r as a,
+  b as c,
+  p as e,
+  h as i
+};
+//# sourceMappingURL=index62.js.map

package/dist/esm/chunks/index62.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index62.js","sources":["../../../src/elements/inline/q/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Q element helpers.\n *\n * @remarks\n * The q element (`<q>`) indicates that the enclosed text is a short inline\n * quotation. Most modern browsers render it with quotation punctuation. This\n * element is intended for quotations that do not require paragraph breaks; for\n * longer quotations, use `<blockquote>`. :contentReference[oaicite:3]{index=3}\n *\n * Best-practice guidance:\n * - Use `<q>` for short inline quotations; use `<blockquote>` for longer quotes.\n * - Do not manually insert quotation punctuation immediately around `<q>`; user\n *   agents may insert punctuation as part of rendering. :contentReference[oaicite:4]{index=4}\n * - If you want a visible, user-facing citation link, use an `<a>` element.\n *   The optional `cite` attribute on `<q>` is a URL for the quotation source and\n *   is often treated as metadata. :contentReference[oaicite:5]{index=5}\n *\n * Security note:\n * - Fundatio does not attempt to validate or sanitize URLs. If `cite` is derived from\n *   untrusted input, validate it at the application boundary.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create inline quotations in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * This module has no side effects and does not mutate the DOM unless you call\n * its functions.\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for inline quotations.\n *\n * @category Constants\n */\nexport const Q_TAG = 'q' as const;\n\n/**\n * A CSS selector targeting q elements.\n *\n * @category Constants\n */\nexport const Q_SELECTOR = 'q';\n\n/**\n * Attribute bag for q creation/enhancement.\n *\n * @remarks\n * The `<q>` element uses standard HTML global attributes and supports an\n * optional `cite` attribute, which provides a URL for the quotation source. :contentReference[oaicite:6]{index=6}\n *\n * Fundatio supports structured ARIA for common ARIA fields, mapped into\n * {@link GlobalAttrs.aria}.\n *\n * @category Attributes\n */\nexport type QAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * A URL for the source of the quotation.\n   *\n   * @remarks\n   * This reflects the `cite` attribute used by `<q>` (and `<blockquote>`).\n   * User agents may expose it, but it is often treated as metadata. :contentReference[oaicite:7]{index=7}\n   */\n  cite?: string;\n\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Set an attribute value only if that key is currently unset.\n *\n * @remarks\n * This supports Fundatio's \"escape hatch\" convention where `attrs.attrs` can override\n * any element-specific mappings.\n *\n * @category Internal\n */\nfunction setIfUnset(\n  bag: Record<string, import('../../../ts/dom').AttrValue>,\n  key: string,\n  value: import('../../../ts/dom').AttrValue,\n): void {\n  if (typeof bag[key] === 'undefined') bag[key] = value;\n}\n\n/**\n * Normalize {@link QAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The q attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: QAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, cite, ...rest } = attrs;\n\n  // Start with global attrs.\n  const out: GlobalAttrs = { ...rest };\n\n  // Map element-specific attributes into the escape hatch bag.\n  if (typeof cite === 'string' && cite.length > 0) {\n    const bag: NonNullable<GlobalAttrs['attrs']> = { ...(out.attrs ?? {}) };\n    setIfUnset(bag, 'cite', cite);\n    out.attrs = bag;\n  }\n\n  // Map structured ARIA.\n  if (!aria) return out;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...out, aria: mappedAria } : out;\n}\n\n/**\n * Create a q element with optional text content and attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n * - The optional `cite` attribute is applied via the `attrs` escape hatch. :contentReference[oaicite:8]{index=8}\n *\n * @param text - Optional text content for the q element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<q>` element.\n *\n * @example\n * Inline quotation with source metadata:\n * ```ts\n * import { createQ } from \"@Vastare/Fundatio/elements/inline/q\";\n *\n * const q = createQ(\"We choose to go to the Moon.\", {\n *   cite: \"https://example.com/speech\",\n *   aria: { label: \"Inline quotation\" }\n * });\n *\n * document.body.appendChild(q);\n * ```\n *\n * @category DOM\n */\nexport function createQ(text?: string, attrs?: QAttrs): ElementOf<typeof Q_TAG> {\n  return createElement(Q_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance q elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceQs(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for q.\n  void root;\n}\n"],"names":["Q_TAG","Q_SELECTOR","setIfUnset","bag","key","value","toGlobalAttrs","attrs","aria","cite","rest","out","mappedAria","createQ","text","createElement","enhanceQs","root"],"mappings":";AAoEO,MAAMA,IAAQ,KAORC,IAAa;AAuC1B,SAASC,EACPC,GACAC,GACAC,GACM;AACN,EAAI,OAAOF,EAAIC,CAAG,IAAM,QAAaD,EAAIC,CAAG,IAAIC;AAClD;AAUA,SAASC,EAAcC,GAAyC;AAC9D,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,MAAAC,GAAM,GAAGC,MAASH,GAG1BI,IAAmB,EAAE,GAAGD,EAAA;AAG9B,MAAI,OAAOD,KAAS,YAAYA,EAAK,SAAS,GAAG;AAC/C,UAAMN,IAAyC,EAAE,GAAIQ,EAAI,SAAS,CAAA,EAAC;AACnE,IAAAT,EAAWC,GAAK,QAAQM,CAAI,GAC5BE,EAAI,QAAQR;AAAA,EACd;AAGA,MAAI,CAACK,EAAM,QAAOG;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOJ,EAAK,SAAU,aAAUI,EAAW,QAAQJ,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUI,EAAW,aAAaJ,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWI,EAAW,SAASJ,EAAK,SAE7C,OAAO,KAAKI,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAK,MAAMC,MAAeD;AACpD;AA+BO,SAASE,EAAQC,GAAeP,GAAyC;AAC9E,SAAOQ,EAAcf,GAAOM,EAAcC,CAAK,GAAGO,CAAI;AACxD;AAYO,SAASE,EAAUC,IAAmB,UAAgB;AAG7D;;;;;;;;"}

package/dist/esm/chunks/index63.js

@@ -0,0 +1,33 @@
+import { c as r } from "./dom.js";
+const o = "rb", l = "rb";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...a } = t;
+  if (!e) return a;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...a, aria: n } : a;
+}
+function b(t, e) {
+  return r(
+    o,
+    i(e),
+    t
+  );
+}
+function s(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  RB_SELECTOR: l,
+  RB_TAG: o,
+  createRb: b,
+  enhanceRbs: s
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  l as R,
+  o as a,
+  b as c,
+  s as e,
+  f as i
+};
+//# sourceMappingURL=index63.js.map

package/dist/esm/chunks/index63.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index63.js","sources":["../../../src/elements/inline/rb/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: rb element helpers.\n *\n * @remarks\n * The rb element (`<rb>`) represents the ruby base text: the text being\n * annotated within a `<ruby>` element.\n *\n * Best-practice guidance:\n * - Use `<rb>` to wrap each atomic segment of base text when authoring complex\n *   ruby annotations (e.g. multiple base units with paired `<rt>` annotations).\n * - For simple ruby, the base text can be implicit (`<ruby>base<rt>anno</rt></ruby>`),\n *   but using `<rb>` can improve clarity and pairing in complex markup.\n * - `<rb>` is intended to be used within `<ruby>` (or within `<rtc>` in extended\n *   ruby models), alongside `<rt>` / `<rp>` / `<rtc>` where applicable.\n *\n * Attributes:\n * - `<rb>` has no element-specific attributes in HTML. It accepts global\n *   attributes only.\n *\n * Implementation note:\n * - In HTML source, `</rb>` may be omitted in certain sequences, but Fundatio creates\n *   DOM nodes, so it always creates a concrete `<rb>` element.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create `<rb>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * This module has no side effects and does not mutate the DOM unless you call\n * its functions.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/rb\n * @see https://www.w3.org/TR/html-ruby-extensions/\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs.\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for ruby base units.\n *\n * @category Constants\n */\nexport const RB_TAG = 'rb' as const;\n\n/**\n * A CSS selector targeting rb elements.\n *\n * @category Constants\n */\nexport const RB_SELECTOR = 'rb';\n\n/**\n * Attribute bag for rb creation/enhancement.\n *\n * @remarks\n * `<rb>` accepts standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * Security note:\n * - Inline event handler attributes (e.g. `onclick`) are blocked by `dom.ts`.\n * - The raw `style` attribute is blocked; use {@link GlobalAttrs.style}.\n *\n * @category Attributes\n */\nexport type RbAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link RbAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The rb attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: RbAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create an rb element with optional text content and attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * Note: `<rb>` is phrasing content. This helper supports a simple `text`\n * convenience for cases where plain text is sufficient; consumers can still\n * append richer child nodes afterwards.\n *\n * @param text - Optional text content for the rb element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<rb>` element.\n *\n * @example\n * ```ts\n * import { createRb } from \"@Vastare/Fundatio/elements/inline/rb\";\n *\n * const rb = createRb(\"漢\", { className: \"ruby-base\" });\n * ```\n *\n * @category DOM\n */\nexport function createRb(text?: string, attrs?: RbAttrs): HTMLElement {\n  return createElement(\n    RB_TAG as unknown as keyof HTMLElementTagNameMap,\n    toGlobalAttrs(attrs),\n    text,\n  ) as unknown as HTMLElement;\n}\n\n/**\n * Enhance rb elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceRbs(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for rb.\n  void root;\n}\n"],"names":["RB_TAG","RB_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createRb","text","createElement","enhanceRbs","root"],"mappings":";AAyEO,MAAMA,IAAS,MAOTC,IAAc;AAgC3B,SAASC,EAAcC,GAA0C;AAC/D,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAE7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AA4BO,SAASE,EAASC,GAAeL,GAA8B;AACpE,SAAOM;AAAA,IACLT;AAAA,IACAE,EAAcC,CAAK;AAAA,IACnBK;AAAA,EAAA;AAEJ;AAoBO,SAASE,EAAWC,IAAmB,UAAgB;AAG9D;;;;;;;;"}

package/dist/esm/chunks/index64.js

@@ -0,0 +1,29 @@
+import { c as r } from "./dom.js";
+const o = "rt", l = "rt";
+function i(t) {
+  if (!t) return;
+  const { aria: e, ...a } = t;
+  if (!e) return a;
+  const n = {};
+  return typeof e.label == "string" && (n.label = e.label), typeof e.labelledby == "string" && (n.labelledby = e.labelledby), typeof e.hidden == "boolean" && (n.hidden = e.hidden), Object.keys(n).length > 0 ? { ...a, aria: n } : a;
+}
+function s(t, e) {
+  return r(o, i(e), t);
+}
+function c(t = document) {
+}
+const f = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  RT_SELECTOR: l,
+  RT_TAG: o,
+  createRt: s,
+  enhanceRts: c
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  l as R,
+  o as a,
+  s as c,
+  c as e,
+  f as i
+};
+//# sourceMappingURL=index64.js.map

package/dist/esm/chunks/index64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index64.js","sources":["../../../src/elements/inline/rt/index.ts"],"sourcesContent":["/**\n * Fundatio Design Foundation: Rt element helpers.\n *\n * @remarks\n * The rt element (`<rt>`) provides the ruby text component of a ruby annotation.\n * Ruby annotations are commonly used to supply pronunciation, translation, or\n * transliteration information (often in East Asian typography).\n *\n * Best-practice guidance:\n * - `<rt>` must be used within a `<ruby>` element.\n * - Use ruby for semantic annotation (pronunciation/reading aids), not for\n *   purely presentational styling.\n * - Prefer plain text via `textContent` for annotation content (Fundatio enforces\n *   this by using `textContent`, never `innerHTML`).\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create `<rt>` nodes in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if Fundatio ever needs runtime behavior\n *\n * MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/rt\n *\n * @module\n * @category Elements\n */\n\nimport { createElement, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by Fundatio element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset that covers common cases and\n * prevents typo-based ARIA bugs (e.g. `lable`).\n *\n * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.\n *\n * @category Attributes\n */\nexport type StructuredAria = {\n  /**\n   * Accessible label, mapped to `aria-label`.\n   */\n  label?: string;\n\n  /**\n   * ID reference to the labelling element(s), mapped to `aria-labelledby`.\n   */\n  labelledby?: string;\n\n  /**\n   * Decorative/hidden hint, mapped to `aria-hidden`.\n   */\n  hidden?: boolean;\n};\n\n/**\n * The semantic tag name for ruby text annotations.\n *\n * @category Constants\n */\nexport const RT_TAG = 'rt' as const;\n\n/**\n * A CSS selector targeting rt elements.\n *\n * @category Constants\n */\nexport const RT_SELECTOR = 'rt';\n\n/**\n * Attribute bag for rt creation/enhancement.\n *\n * @remarks\n * Rt elements include only standard HTML global attributes.\n *\n * Fundatio also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing Fundatio's core DOM helpers.\n *\n * @category Attributes\n */\nexport type RtAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link RtAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The rt attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: RtAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, ...rest } = attrs;\n\n  if (!aria) return rest;\n\n  const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\n\n  if (typeof aria.label === 'string') mappedAria.label = aria.label;\n  if (typeof aria.labelledby === 'string') mappedAria.labelledby = aria.labelledby;\n  if (typeof aria.hidden === 'boolean') mappedAria.hidden = aria.hidden;\n\n  // Only attach `aria` if something was actually defined.\n  const hasMapped = Object.keys(mappedAria).length > 0;\n\n  return hasMapped ? { ...rest, aria: mappedAria } : rest;\n}\n\n/**\n * Create an rt element with optional text content and global attributes.\n *\n * @remarks\n * - Text content is assigned via `textContent` (never `innerHTML`).\n * - Global attributes are applied via Fundatio's shared DOM helper,\n *   including security guards that block inline event handler attributes\n *   (e.g. `onclick`) and raw `style` attribute strings.\n *\n * @param text - Optional text content for the rt element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<rt>` element.\n *\n * @example\n * ```ts\n * import { createRt } from \"@Vastare/Fundatio/elements/inline/rt\";\n *\n * // Intended usage: inside <ruby>\n * const rt = createRt(\"kan\");\n * ```\n *\n * @category DOM\n */\nexport function createRt(text?: string, attrs?: RtAttrs): ElementOf<typeof RT_TAG> {\n  return createElement(RT_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance rt elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `1.0.0`.\n *\n * Why does it exist?\n * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)\n * - It allows future progressive enhancements without changing consumer code\n *\n * What it will never do:\n * - It will not inject styles (CSS remains the source of truth)\n * - It will not introduce framework-specific behavior\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceRts(root: ParentNode = document): void {\n  // v1.0.0: no runtime behavior for rt.\n  void root;\n}\n"],"names":["RT_TAG","RT_SELECTOR","toGlobalAttrs","attrs","aria","rest","mappedAria","createRt","text","createElement","enhanceRts","root"],"mappings":";AA6DO,MAAMA,IAAS,MAOTC,IAAc;AA4B3B,SAASC,EAAcC,GAA0C;AAC/D,MAAI,CAACA,EAAO;AAEZ,QAAM,EAAE,MAAAC,GAAM,GAAGC,EAAA,IAASF;AAE1B,MAAI,CAACC,EAAM,QAAOC;AAElB,QAAMC,IAA+C,CAAA;AAErD,SAAI,OAAOF,EAAK,SAAU,aAAUE,EAAW,QAAQF,EAAK,QACxD,OAAOA,EAAK,cAAe,aAAUE,EAAW,aAAaF,EAAK,aAClE,OAAOA,EAAK,UAAW,cAAWE,EAAW,SAASF,EAAK,SAG7C,OAAO,KAAKE,CAAU,EAAE,SAAS,IAEhC,EAAE,GAAGD,GAAM,MAAMC,MAAeD;AACrD;AAyBO,SAASE,EAASC,GAAeL,GAA2C;AACjF,SAAOM,EAAcT,GAAQE,EAAcC,CAAK,GAAGK,CAAI;AACzD;AAoBO,SAASE,EAAWC,IAAmB,UAAgB;AAG9D;;;;;;;;"}