@lnpg/pkgn-sol 1.0.0-beta.0

package/dist/cjs/elements/inline/b/b.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"b.cjs","names":[],"sources":["../../../../../src/elements/inline/b/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: B element helpers.\n *\n * @remarks\n * The b element (`<b>`) represents a span of text to which attention is being\n * drawn for utilitarian purposes, without conveying extra importance.\n *\n * Best-practice guidance:\n * - Use `<b>` to draw attention without implying importance.\n * - Use `<strong>` for strong importance and `<em>` for stress emphasis.\n * - Do not use `<b>` purely for styling. Prefer CSS (e.g. `font-weight`) when the\n *   goal is visual bolding rather than semantics.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create inline attention spans in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol ever needs runtime behavior\n *\n * MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/b\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 pkgn-sol 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 \"bring attention to\" spans.\n *\n * @category Constants\n */\nexport const B_TAG = 'b' as const;\n\n/**\n * A CSS selector targeting b elements.\n *\n * @category Constants\n */\nexport const B_SELECTOR = 'b';\n\n/**\n * Attribute bag for b creation/enhancement.\n *\n * @remarks\n * B elements accept standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type BAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link BAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The b attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: BAttrs): 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 b 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 pkgn-sol'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 b element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<b>` element.\n *\n * @example\n * ```ts\n * import { createB } from \"@lnpg/pkgn-sol/elements/inline/b\";\n *\n * document.body.appendChild(createB(\"Keyword\", { className: \"keyword\" }));\n * ```\n *\n * @category DOM\n */\nexport function createB(text?: string, attrs?: BAttrs): ElementOf<typeof B_TAG> {\n  return createElement(B_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance b elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceBs(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for b.\n  void root;\n}\n"],"mappings":"0LA2Da,EAAQ,IAOR,EAAa,IA4B1B,SAAS,EAAc,EAAyC,CAC9D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EAyBrD,SAAgB,EAAQ,EAAe,EAAyC,CAC9E,OAAO,EAAA,EAAA,IAAqB,EAAc,EAAM,CAAE,EAAK,CAqBzD,SAAgB,EAAU,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/cite/cite.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({CITE_SELECTOR:()=>r,CITE_TAG:()=>n,createCite:()=>a,enhanceCites:()=>o}),n=`cite`,r=`cite`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.CITE_SELECTOR=r,exports.CITE_TAG=n,exports.createCite=a,exports.enhanceCites=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=cite.cjs.map

package/dist/cjs/elements/inline/cite/cite.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cite.cjs","names":[],"sources":["../../../../../src/elements/inline/cite/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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. (pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for cite.\n  void root;\n}\n"],"mappings":"kMA6Da,EAAW,OAOX,EAAgB,OA4B7B,SAAS,EAAc,EAA4C,CACjE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA2BrD,SAAgB,EAAW,EAAe,EAA+C,CACvF,OAAO,EAAA,EAAc,EAAU,EAAc,EAAM,CAAE,EAAK,CAqB5D,SAAgB,EAAa,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/code/code.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({CODE_SELECTOR:()=>r,CODE_TAG:()=>n,createCode:()=>a,enhanceCodes:()=>o}),n=`code`,r=`code`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.CODE_SELECTOR=r,exports.CODE_TAG=n,exports.createCode=a,exports.enhanceCodes=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=code.cjs.map

package/dist/cjs/elements/inline/code/code.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"code.cjs","names":[],"sources":["../../../../../src/elements/inline/code/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for code.\n  void root;\n}\n"],"mappings":"kMAkEa,EAAW,OAOX,EAAgB,OAgC7B,SAAS,EAAc,EAA4C,CACjE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CAQvD,OANI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA8BrD,SAAgB,EAAW,EAAe,EAA+C,CACvF,OAAO,EAAA,EAAc,EAAU,EAAc,EAAM,CAAE,EAAK,CAqB5D,SAAgB,EAAa,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/data/data.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({DATA_SELECTOR:()=>r,DATA_TAG:()=>n,createData:()=>a,enhanceDatas:()=>o}),n=`data`,r=`data`;function i(e,t){if(!e)return;let{aria:n,value:r,...i}=e,a=i,o={...a.attrs??{}},s=typeof r==`string`||typeof r==`number`?r:typeof t==`string`?t:void 0;if((typeof s==`string`||typeof s==`number`)&&(o.value=s),Object.keys(o).length>0&&(a.attrs=o),!n)return a;let c={};return typeof n.label==`string`&&(c.label=n.label),typeof n.labelledby==`string`&&(c.labelledby=n.labelledby),typeof n.hidden==`boolean`&&(c.hidden=n.hidden),Object.keys(c).length>0?{...a,aria:c}:a}function a(t,r){return e.n(n,i(r,t),t)}function o(e=document){}exports.DATA_SELECTOR=r,exports.DATA_TAG=n,exports.createData=a,exports.enhanceDatas=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=data.cjs.map

package/dist/cjs/elements/inline/data/data.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.cjs","names":[],"sources":["../../../../../src/elements/inline/data/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 * pkgn-sol applies a sensible fallback:\n * - If `attrs.value` is omitted and `text` is provided, pkgn-sol sets `value` to `text`.\n *\n * Security notes:\n * - pkgn-sol blocks unsafe attribute *names* (e.g. `onclick`, raw `style`).\n * - pkgn-sol 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 pkgn-sol 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. pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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, pkgn-sol 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 pkgn-sol'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, pkgn-sol 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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for data.\n  void root;\n}\n"],"mappings":"kMAwEa,EAAW,OAOX,EAAgB,OAsC7B,SAAS,EAAc,EAAmB,EAAwC,CAChF,GAAI,CAAC,EAGH,OAGF,GAAM,CAAE,OAAM,QAAO,GAAG,GAAS,EAE3B,EAAmB,EAEnB,EAA8C,CAAE,GAAI,EAAI,OAAS,EAAE,CAAG,CAGtE,EACJ,OAAO,GAAU,UAAY,OAAO,GAAU,SAC1C,EACA,OAAO,GAAS,SACd,EACA,IAAA,GAQR,IANI,OAAO,GAAmB,UAAY,OAAO,GAAmB,YAClE,EAAS,MAAQ,GAGf,OAAO,KAAK,EAAS,CAAC,OAAS,IAAG,EAAI,MAAQ,GAE9C,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CAQvD,OANI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAK,KAAM,EAAY,CAAG,EA4BpD,SAAgB,EAAW,EAAe,EAA+C,CACvF,OAAO,EAAA,EAAc,EAAU,EAAc,EAAO,EAAK,CAAE,EAAK,CAqBlE,SAAgB,EAAa,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/dfn/dfn.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({DFN_SELECTOR:()=>`dfn`,DFN_TAG:()=>`dfn`,createDfn:()=>a,enhanceDfns:()=>o}),n=`dfn`,r=`dfn`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`dfn`,i(n),t)}function o(e=document){}exports.DFN_SELECTOR=r,exports.DFN_TAG=n,exports.createDfn=a,exports.enhanceDfns=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=dfn.cjs.map

package/dist/cjs/elements/inline/dfn/dfn.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dfn.cjs","names":[],"sources":["../../../../../src/elements/inline/dfn/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for dfn.\n  void root;\n}\n"],"mappings":"sMA4Da,EAAU,MAOV,EAAe,MA4B5B,SAAS,EAAc,EAA2C,CAChE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA2BrD,SAAgB,EAAU,EAAe,EAA6C,CACpF,OAAO,EAAA,EAAA,MAAuB,EAAc,EAAM,CAAE,EAAK,CAqB3D,SAAgB,EAAY,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/em/em.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({EM_SELECTOR:()=>`em`,EM_TAG:()=>`em`,createEm:()=>a,enhanceEms:()=>o}),n=`em`,r=`em`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`em`,i(n),t)}function o(e=document){}exports.EM_SELECTOR=r,exports.EM_TAG=n,exports.createEm=a,exports.enhanceEms=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=em.cjs.map

package/dist/cjs/elements/inline/em/em.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"em.cjs","names":[],"sources":["../../../../../src/elements/inline/em/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for em.\n  void root;\n}\n"],"mappings":"gMA4Da,EAAS,KAOT,EAAc,KA4B3B,SAAS,EAAc,EAA0C,CAC/D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA2BrD,SAAgB,EAAS,EAAe,EAA2C,CACjF,OAAO,EAAA,EAAA,KAAsB,EAAc,EAAM,CAAE,EAAK,CAqB1D,SAAgB,EAAW,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/i/i.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({I_SELECTOR:()=>`i`,I_TAG:()=>`i`,createI:()=>a,enhanceIs:()=>o}),n=`i`,r=`i`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`i`,i(n),t)}function o(e=document){}exports.I_SELECTOR=r,exports.I_TAG=n,exports.createI=a,exports.enhanceIs=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=i.cjs.map

package/dist/cjs/elements/inline/i/i.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"i.cjs","names":[],"sources":["../../../../../src/elements/inline/i/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for i.\n  void root;\n}\n"],"mappings":"0LAwEa,EAAQ,IAOR,EAAa,IAgC1B,SAAS,EAAc,EAAyC,CAC9D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CAQvD,OANI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA8BrD,SAAgB,EAAQ,EAAe,EAAyC,CAC9E,OAAO,EAAA,EAAA,IAAqB,EAAc,EAAM,CAAE,EAAK,CAqBzD,SAAgB,EAAU,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/inline.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./a/a.cjs`),t=require(`./abbr/abbr.cjs`),n=require(`./b/b.cjs`),r=require(`./small/small.cjs`),i=require(`./strong/strong.cjs`),a=require(`./cite/cite.cjs`),o=require(`./code/code.cjs`),s=require(`./data/data.cjs`),c=require(`./dfn/dfn.cjs`),l=require(`./em/em.cjs`),u=require(`./i/i.cjs`),d=require(`./kbd/kbd.cjs`),f=require(`./mark/mark.cjs`),p=require(`./q/q.cjs`),m=require(`./rb/rb.cjs`),h=require(`../../chunks/inline.cjs`),g=require(`./rt/rt.cjs`),_=require(`./rtc/rtc.cjs`),v=require(`./ruby/ruby.cjs`),y=require(`./s/s.cjs`),b=require(`./samp/samp.cjs`),x=require(`./sub/sub.cjs`),S=require(`./sup/sup.cjs`),C=require(`./time/time.cjs`),w=require(`./u/u.cjs`),T=require(`./var/var.cjs`);Object.defineProperty(exports,`abbr`,{enumerable:!0,get:function(){return t.t}}),Object.defineProperty(exports,`anchor`,{enumerable:!0,get:function(){return e.t}}),Object.defineProperty(exports,`b`,{enumerable:!0,get:function(){return n.t}}),Object.defineProperty(exports,`cite`,{enumerable:!0,get:function(){return a.t}}),Object.defineProperty(exports,`code`,{enumerable:!0,get:function(){return o.t}}),Object.defineProperty(exports,`data`,{enumerable:!0,get:function(){return s.t}}),Object.defineProperty(exports,`dfn`,{enumerable:!0,get:function(){return c.t}}),Object.defineProperty(exports,`em`,{enumerable:!0,get:function(){return l.t}}),Object.defineProperty(exports,`italic`,{enumerable:!0,get:function(){return u.t}}),Object.defineProperty(exports,`kbd`,{enumerable:!0,get:function(){return d.t}}),Object.defineProperty(exports,`mark`,{enumerable:!0,get:function(){return f.t}}),Object.defineProperty(exports,`q`,{enumerable:!0,get:function(){return p.t}}),Object.defineProperty(exports,`rb`,{enumerable:!0,get:function(){return m.t}}),Object.defineProperty(exports,`rp`,{enumerable:!0,get:function(){return h.n}}),Object.defineProperty(exports,`rt`,{enumerable:!0,get:function(){return g.t}}),Object.defineProperty(exports,`rtc`,{enumerable:!0,get:function(){return _.t}}),Object.defineProperty(exports,`ruby`,{enumerable:!0,get:function(){return v.t}}),Object.defineProperty(exports,`s`,{enumerable:!0,get:function(){return y.t}}),Object.defineProperty(exports,`samp`,{enumerable:!0,get:function(){return b.t}}),Object.defineProperty(exports,`small`,{enumerable:!0,get:function(){return r.t}}),Object.defineProperty(exports,`strong`,{enumerable:!0,get:function(){return i.t}}),Object.defineProperty(exports,`sub`,{enumerable:!0,get:function(){return x.t}}),Object.defineProperty(exports,`sup`,{enumerable:!0,get:function(){return S.t}}),Object.defineProperty(exports,`time`,{enumerable:!0,get:function(){return C.t}}),Object.defineProperty(exports,`u`,{enumerable:!0,get:function(){return w.t}}),Object.defineProperty(exports,`var`,{enumerable:!0,get:function(){return T.t}});

package/dist/cjs/elements/inline/kbd/kbd.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({KBD_SELECTOR:()=>`kbd`,KBD_TAG:()=>`kbd`,createKbd:()=>a,enhanceKbds:()=>o}),n=`kbd`,r=`kbd`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`kbd`,i(n),t)}function o(e=document){}exports.KBD_SELECTOR=r,exports.KBD_TAG=n,exports.createKbd=a,exports.enhanceKbds=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=kbd.cjs.map

package/dist/cjs/elements/inline/kbd/kbd.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kbd.cjs","names":[],"sources":["../../../../../src/elements/inline/kbd/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 * - pkgn-sol blocks unsafe attribute *names* (e.g. `onclick`, raw `style`) via `dom.ts`.\n * - pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for kbd.\n  void root;\n}\n"],"mappings":"sMA4Da,EAAU,MAOV,EAAe,MA4B5B,SAAS,EAAc,EAA2C,CAChE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA0BrD,SAAgB,EAAU,EAAe,EAA6C,CACpF,OAAO,EAAA,EAAA,MAAuB,EAAc,EAAM,CAAE,EAAK,CAqB3D,SAAgB,EAAY,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/mark/mark.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({MARK_SELECTOR:()=>r,MARK_TAG:()=>n,createMark:()=>a,enhanceMarks:()=>o}),n=`mark`,r=`mark`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.MARK_SELECTOR=r,exports.MARK_TAG=n,exports.createMark=a,exports.enhanceMarks=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=mark.cjs.map

package/dist/cjs/elements/inline/mark/mark.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark.cjs","names":[],"sources":["../../../../../src/elements/inline/mark/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for mark.\n  void root;\n}\n"],"mappings":"kMA8Da,EAAW,OAOX,EAAgB,OA4B7B,SAAS,EAAc,EAA4C,CACjE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA0BrD,SAAgB,EAAW,EAAe,EAA+C,CACvF,OAAO,EAAA,EAAc,EAAU,EAAc,EAAM,CAAE,EAAK,CAqB5D,SAAgB,EAAa,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/q/q.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({Q_SELECTOR:()=>`q`,Q_TAG:()=>`q`,createQ:()=>o,enhanceQs:()=>s}),n=`q`,r=`q`;function i(e,t,n){e[t]===void 0&&(e[t]=n)}function a(e){if(!e)return;let{aria:t,cite:n,...r}=e,a={...r};if(typeof n==`string`&&n.length>0){let e={...a.attrs??{}};i(e,`cite`,n),a.attrs=e}if(!t)return a;let o={};return typeof t.label==`string`&&(o.label=t.label),typeof t.labelledby==`string`&&(o.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(o.hidden=t.hidden),Object.keys(o).length>0?{...a,aria:o}:a}function o(t,n){return e.n(`q`,a(n),t)}function s(e=document){}exports.Q_SELECTOR=r,exports.Q_TAG=n,exports.createQ=o,exports.enhanceQs=s,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=q.cjs.map

package/dist/cjs/elements/inline/q/q.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"q.cjs","names":[],"sources":["../../../../../src/elements/inline/q/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 * - pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol 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 pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for q.\n  void root;\n}\n"],"mappings":"0LAoEa,EAAQ,IAOR,EAAa,IAuC1B,SAAS,EACP,EACA,EACA,EACM,CACK,EAAI,KAAS,SAAa,EAAI,GAAO,GAWlD,SAAS,EAAc,EAAyC,CAC9D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,OAAM,GAAG,GAAS,EAG1B,EAAmB,CAAE,GAAG,EAAM,CAGpC,GAAI,OAAO,GAAS,UAAY,EAAK,OAAS,EAAG,CAC/C,IAAM,EAAyC,CAAE,GAAI,EAAI,OAAS,EAAE,CAAG,CACvE,EAAW,EAAK,OAAQ,EAAK,CAC7B,EAAI,MAAQ,EAId,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CAQvD,OANI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAK,KAAM,EAAY,CAAG,EAgCpD,SAAgB,EAAQ,EAAe,EAAyC,CAC9E,OAAO,EAAA,EAAA,IAAqB,EAAc,EAAM,CAAE,EAAK,CAazD,SAAgB,EAAU,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/rb/rb.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({RB_SELECTOR:()=>`rb`,RB_TAG:()=>`rb`,createRb:()=>a,enhanceRbs:()=>o}),n=`rb`,r=`rb`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`rb`,i(n),t)}function o(e=document){}exports.RB_SELECTOR=r,exports.RB_TAG=n,exports.createRb=a,exports.enhanceRbs=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=rb.cjs.map

package/dist/cjs/elements/inline/rb/rb.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rb.cjs","names":[],"sources":["../../../../../src/elements/inline/rb/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for rb.\n  void root;\n}\n"],"mappings":"gMAyEa,EAAS,KAOT,EAAc,KAgC3B,SAAS,EAAc,EAA0C,CAC/D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CAQvD,OANI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA6BrD,SAAgB,EAAS,EAAe,EAA8B,CACpE,OAAO,EAAA,EAAA,KAEL,EAAc,EAAM,CACpB,EACD,CAqBH,SAAgB,EAAW,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/rt/rt.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({RT_SELECTOR:()=>`rt`,RT_TAG:()=>`rt`,createRt:()=>a,enhanceRts:()=>o}),n=`rt`,r=`rt`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`rt`,i(n),t)}function o(e=document){}exports.RT_SELECTOR=r,exports.RT_TAG=n,exports.createRt=a,exports.enhanceRts=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=rt.cjs.map

package/dist/cjs/elements/inline/rt/rt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rt.cjs","names":[],"sources":["../../../../../src/elements/inline/rt/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 (pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for rt.\n  void root;\n}\n"],"mappings":"gMA6Da,EAAS,KAOT,EAAc,KA4B3B,SAAS,EAAc,EAA0C,CAC/D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA0BrD,SAAgB,EAAS,EAAe,EAA2C,CACjF,OAAO,EAAA,EAAA,KAAsB,EAAc,EAAM,CAAE,EAAK,CAqB1D,SAAgB,EAAW,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/rtc/rtc.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({RTC_SELECTOR:()=>`rtc`,RTC_TAG:()=>`rtc`,createRtc:()=>a,enhanceRtcs:()=>o}),n=`rtc`,r=`rtc`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){let r=document.createElement(`rtc`);return e.t(r,i(n)),typeof t==`string`&&(r.textContent=t),r}function o(e=document){}exports.RTC_SELECTOR=r,exports.RTC_TAG=n,exports.createRtc=a,exports.enhanceRtcs=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=rtc.cjs.map

package/dist/cjs/elements/inline/rtc/rtc.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtc.cjs","names":[],"sources":["../../../../../src/elements/inline/rtc/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Rtc element helpers.\n *\n * @remarks\n * The rtc element (`<rtc>`) is a ruby text container used within `<ruby>` to\n * group ruby annotation text components, typically for semantic annotations.\n *\n * Best-practice guidance:\n * - Use `<rtc>` only as part of `<ruby>` markup.\n * - `<rtc>` has no element-specific attributes; it accepts global attributes.\n *\n * Note on DOM typing:\n * - `<rtc>` is not part of {@link HTMLElementTagNameMap} in TypeScript's DOM\n *   typings, so pkgn-sol creates it via `document.createElement(\"rtc\")` and returns\n *   an {@link HTMLElement}.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create rtc elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol 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 { applyGlobalAttrs, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by pkgn-sol 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 containers.\n *\n * @category Constants\n */\nexport const RTC_TAG = 'rtc' as const;\n\n/**\n * A CSS selector targeting rtc elements.\n *\n * @category Constants\n */\nexport const RTC_SELECTOR = 'rtc';\n\n/**\n * Attribute bag for rtc creation/enhancement.\n *\n * @remarks\n * The `<rtc>` element uses standard HTML global attributes and has no\n * element-specific attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type RtcAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link RtcAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The rtc attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: RtcAttrs): 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 rtc 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 pkgn-sol'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: `<rtc>` is not part of {@link HTMLElementTagNameMap}, so pkgn-sol creates it\n * via `document.createElement(\"rtc\")` and returns {@link HTMLElement}.\n *\n * @param text - Optional text content for the rtc element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<rtc>` element.\n *\n * @category DOM\n */\nexport function createRtc(text?: string, attrs?: RtcAttrs): HTMLElement {\n  const el = document.createElement(RTC_TAG);\n\n  applyGlobalAttrs(el, toGlobalAttrs(attrs));\n\n  if (typeof text === 'string') el.textContent = text;\n\n  return el;\n}\n\n/**\n * Enhance rtc elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceRtcs(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for rtc.\n  void root;\n}\n"],"mappings":"sMA+Da,EAAU,MAOV,EAAe,MA6B5B,SAAS,EAAc,EAA2C,CAChE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EAqBrD,SAAgB,EAAU,EAAe,EAA+B,CACtE,IAAM,EAAK,SAAS,cAAA,MAAsB,CAM1C,OAJA,EAAA,EAAiB,EAAI,EAAc,EAAM,CAAC,CAEtC,OAAO,GAAS,WAAU,EAAG,YAAc,GAExC,EAqBT,SAAgB,EAAY,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/ruby/ruby.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({RUBY_SELECTOR:()=>r,RUBY_TAG:()=>n,createRuby:()=>a,enhanceRubies:()=>o}),n=`ruby`,r=`ruby`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.RUBY_SELECTOR=r,exports.RUBY_TAG=n,exports.createRuby=a,exports.enhanceRubies=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=ruby.cjs.map

package/dist/cjs/elements/inline/ruby/ruby.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ruby.cjs","names":[],"sources":["../../../../../src/elements/inline/ruby/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: ruby element helpers.\n *\n * @remarks\n * The ruby element (`<ruby>`) represents ruby annotations: small annotation text\n * rendered above, below, or next to base text (commonly used for pronunciation,\n * transliteration, or translation in East Asian typography).\n *\n * Best-practice guidance:\n * - Prefer correct ruby structure: base text followed by `<rt>` for annotation text.\n * - Use `<rp>` to provide fallback parentheses for user agents that do not support\n *   ruby rendering. Modern browsers generally ignore `<rp>` when ruby is supported,\n *   but it improves graceful degradation.\n * - For complex ruby (multiple base segments / multiple annotations), consider\n *   using `<rb>` to delimit base segments and `<rtc>` for semantic annotation groupings.\n * - Avoid using `innerHTML` for untrusted content. pkgn-sol assigns text via `textContent`.\n *\n * Attributes:\n * - `<ruby>` 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 `<ruby>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol 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/ruby\n * @see https://html.spec.whatwg.org/multipage/text-level-semantics.html#the-ruby-element\n * @see https://www.w3.org/TR/ruby-use-cases/\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 pkgn-sol 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 annotation containers.\n *\n * @category Constants\n */\nexport const RUBY_TAG = 'ruby' as const;\n\n/**\n * A CSS selector targeting ruby elements.\n *\n * @category Constants\n */\nexport const RUBY_SELECTOR = 'ruby';\n\n/**\n * Attribute bag for ruby creation/enhancement.\n *\n * @remarks\n * `<ruby>` accepts standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 RubyAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link RubyAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The ruby attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: RubyAttrs): 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 ruby 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 pkgn-sol'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:\n * - `<ruby>` typically contains mixed children (`<rt>`, `<rp>`, `<rb>`, etc.).\n *   The `text` argument is a convenience for simple cases; consumers can append\n *   richer child nodes afterwards.\n *\n * @param text - Optional text content for the ruby element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<ruby>` element.\n *\n * @example\n * ```ts\n * import { createRuby } from \"@lnpg/pkgn-sol/elements/inline/ruby\";\n *\n * const ruby = createRuby();\n * ruby.append(\n *   document.createTextNode(\"漢\"),\n *   document.createElement(\"rt\")\n * );\n * ```\n *\n * @category DOM\n */\nexport function createRuby(text?: string, attrs?: RubyAttrs): ElementOf<typeof RUBY_TAG> {\n  return createElement(RUBY_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance ruby elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceRubies(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for ruby.\n  void root;\n}\n"],"mappings":"mMAwEa,EAAW,OAOX,EAAgB,OAgC7B,SAAS,EAAc,EAA4C,CACjE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CAQvD,OANI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EAkCrD,SAAgB,EAAW,EAAe,EAA+C,CACvF,OAAO,EAAA,EAAc,EAAU,EAAc,EAAM,CAAE,EAAK,CAqB5D,SAAgB,EAAc,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/s/s.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({S_SELECTOR:()=>`s`,S_TAG:()=>`s`,createS:()=>a,enhanceSs:()=>o}),n=`s`,r=`s`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`s`,i(n),t)}function o(e=document){}exports.S_SELECTOR=r,exports.S_TAG=n,exports.createS=a,exports.enhanceSs=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=s.cjs.map

package/dist/cjs/elements/inline/s/s.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"s.cjs","names":[],"sources":["../../../../../src/elements/inline/s/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: S (strikethrough) element helpers.\n *\n * @remarks\n * The s element (`<s>`) represents content that is no longer accurate or no\n * longer relevant. It is a presentational indicator of \"this isn't current\"\n * rather than an edit-tracking semantic.\n *\n * Best-practice guidance:\n * - Use `<s>` for \"no longer relevant/accurate\" text (e.g. outdated pricing).\n * - Use `<del>` when you mean \"this was removed\" (edit history / document diff semantics).\n * - Do not use `<s>` as a substitute for emphasis; use appropriate semantics and CSS.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create `<s>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol 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/Element/s\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 pkgn-sol 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 s elements.\n *\n * @category Constants\n */\nexport const S_TAG = 's' as const;\n\n/**\n * A CSS selector targeting s elements.\n *\n * @category Constants\n */\nexport const S_SELECTOR = 's';\n\n/**\n * Attribute bag for s creation/enhancement.\n *\n * @remarks\n * The `<s>` element accepts standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type SAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link SAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The s attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: SAttrs): 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 s 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 pkgn-sol'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 element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<s>` element.\n *\n * @example\n * ```ts\n * import { createS } from \"@lnpg/pkgn-sol/elements/inline/s\";\n *\n * const el = createS(\"£199\", { className: \"old-price\" });\n * document.body.appendChild(el);\n * ```\n *\n * @category DOM\n */\nexport function createS(text?: string, attrs?: SAttrs): ElementOf<typeof S_TAG> {\n  return createElement(S_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance s elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceSs(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for s.\n  void root;\n}\n"],"mappings":"0LA8Da,EAAQ,IAOR,EAAa,IA4B1B,SAAS,EAAc,EAAyC,CAC9D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA0BrD,SAAgB,EAAQ,EAAe,EAAyC,CAC9E,OAAO,EAAA,EAAA,IAAqB,EAAc,EAAM,CAAE,EAAK,CAqBzD,SAAgB,EAAU,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/samp/samp.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({SAMP_SELECTOR:()=>r,SAMP_TAG:()=>n,createSamp:()=>a,enhanceSamps:()=>o}),n=`samp`,r=`samp`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.SAMP_SELECTOR=r,exports.SAMP_TAG=n,exports.createSamp=a,exports.enhanceSamps=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=samp.cjs.map

package/dist/cjs/elements/inline/samp/samp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"samp.cjs","names":[],"sources":["../../../../../src/elements/inline/samp/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Samp element helpers.\n *\n * @remarks\n * The samp element (`<samp>`) represents sample (or quoted) output from another\n * program or computing system.\n *\n * Best-practice guidance:\n * - Use `<samp>` for *output* (what the computer/system printed).\n * - Use `<kbd>` for user input (what the user typed/pressed).\n * - Use `<code>` for code fragments (source code).\n * - Use CSS for presentation; semantics should match meaning.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create samp nodes in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol ever needs runtime behavior\n *\n * MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/samp\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 pkgn-sol 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 sample output.\n *\n * @category Constants\n */\nexport const SAMP_TAG = 'samp' as const;\n\n/**\n * A CSS selector targeting samp elements.\n *\n * @category Constants\n */\nexport const SAMP_SELECTOR = 'samp';\n\n/**\n * Attribute bag for samp creation/enhancement.\n *\n * @remarks\n * Samp elements accept standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type SampAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link SampAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The samp attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: SampAttrs): 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 samp 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 pkgn-sol'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 samp element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<samp>` element.\n *\n * @example\n * ```ts\n * import { createSamp } from \"@lnpg/pkgn-sol/elements/inline/samp\";\n *\n * // Sample output:\n * const out = createSamp(\"Everything up-to-date\");\n * ```\n *\n * @category DOM\n */\nexport function createSamp(text?: string, attrs?: SampAttrs): ElementOf<typeof SAMP_TAG> {\n  return createElement(SAMP_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance samp elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceSamps(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for samp.\n  void root;\n}\n"],"mappings":"kMA2Da,EAAW,OAOX,EAAgB,OA4B7B,SAAS,EAAc,EAA4C,CACjE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA0BrD,SAAgB,EAAW,EAAe,EAA+C,CACvF,OAAO,EAAA,EAAc,EAAU,EAAc,EAAM,CAAE,EAAK,CAqB5D,SAAgB,EAAa,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/small/small.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({SMALL_SELECTOR:()=>r,SMALL_TAG:()=>n,createSmall:()=>a,enhanceSmalls:()=>o}),n=`small`,r=`small`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.SMALL_SELECTOR=r,exports.SMALL_TAG=n,exports.createSmall=a,exports.enhanceSmalls=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=small.cjs.map

package/dist/cjs/elements/inline/small/small.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"small.cjs","names":[],"sources":["../../../../../src/elements/inline/small/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Small element helpers.\n *\n * @remarks\n * The small element (`<small>`) represents side comments and small print.\n *\n * Best-practice guidance:\n * - Use `<small>` for side notes, disclaimers, legal restrictions, copyright,\n *   attribution, or licensing text.\n * - Do not use `<small>` purely to make text visually smaller. Use CSS when the\n *   intent is presentational rather than semantic.\n * - Keep accessible meaning intact: if the content is important, it should be\n *   readable and not \"hidden\" behind styling choices.\n *\n * Attributes:\n * - `<small>` 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 `<small>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol 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/Element/small\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 pkgn-sol 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 small element.\n *\n * @category Constants\n */\nexport const SMALL_TAG = 'small' as const;\n\n/**\n * A CSS selector targeting small elements.\n *\n * @category Constants\n */\nexport const SMALL_SELECTOR = 'small';\n\n/**\n * Attribute bag for small creation/enhancement.\n *\n * @remarks\n * `<small>` accepts standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 SmallAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link SmallAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The small attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: SmallAttrs): 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 small 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 pkgn-sol'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: `<small>` 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 small element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<small>` element.\n *\n * @example\n * ```ts\n * import { createSmall } from \"@lnpg/pkgn-sol/elements/inline/small\";\n *\n * const legal = createSmall(\"Terms apply.\", { className: \"legal\" });\n * document.body.appendChild(legal);\n * ```\n *\n * @category DOM\n */\nexport function createSmall(text?: string, attrs?: SmallAttrs): ElementOf<typeof SMALL_TAG> {\n  return createElement(SMALL_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance small elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceSmalls(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for small.\n  void root;\n}\n"],"mappings":"sMAmEa,EAAY,QAOZ,EAAiB,QAgC9B,SAAS,EAAc,EAA6C,CAClE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CAQvD,OANI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA8BrD,SAAgB,EAAY,EAAe,EAAiD,CAC1F,OAAO,EAAA,EAAc,EAAW,EAAc,EAAM,CAAE,EAAK,CAqB7D,SAAgB,EAAc,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/strong/strong.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({STRONG_SELECTOR:()=>r,STRONG_TAG:()=>n,createStrong:()=>a,enhanceStrongs:()=>o}),n=`strong`,r=`strong`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.STRONG_SELECTOR=r,exports.STRONG_TAG=n,exports.createStrong=a,exports.enhanceStrongs=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=strong.cjs.map

package/dist/cjs/elements/inline/strong/strong.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong.cjs","names":[],"sources":["../../../../../src/elements/inline/strong/index.ts"],"sourcesContent":["/**\n * pkgn-sol 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 pkgn-sol 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 pkgn-sol 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 * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol'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 pkgn-sol'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 \"@lnpg/pkgn-sol/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 `0.1.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  // v0.1.0: no runtime behavior for strong.\n  void root;\n}\n"],"mappings":"0MA8Da,EAAa,SAOb,EAAkB,SA4B/B,SAAS,EAAc,EAA8C,CACnE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA2BrD,SAAgB,EAAa,EAAe,EAAmD,CAC7F,OAAO,EAAA,EAAc,EAAY,EAAc,EAAM,CAAE,EAAK,CAqB9D,SAAgB,EAAe,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/sub/sub.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({SUB_SELECTOR:()=>`sub`,SUB_TAG:()=>`sub`,createSub:()=>a,enhanceSubs:()=>o}),n=`sub`,r=`sub`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`sub`,i(n),t)}function o(e=document){}exports.SUB_SELECTOR=r,exports.SUB_TAG=n,exports.createSub=a,exports.enhanceSubs=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=sub.cjs.map

package/dist/cjs/elements/inline/sub/sub.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sub.cjs","names":[],"sources":["../../../../../src/elements/inline/sub/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Sub element helpers.\n *\n * @remarks\n * The sub element (`<sub>`) represents subscript text.\n *\n * Best-practice guidance:\n * - Use `<sub>` for typographical conventions (e.g. chemical formulas like H₂O,\n *   mathematical indices in plain text, footnote markers) where subscript is\n *   semantically appropriate.\n * - Do not use `<sub>` purely for presentation. Use CSS for visual styling.\n *\n * The `<sub>` element has no element-specific attributes. It supports standard\n * HTML global attributes.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create sub elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol 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 * MDN:\n * - https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/sub\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 pkgn-sol 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 subscript text.\n *\n * @category Constants\n */\nexport const SUB_TAG = 'sub' as const;\n\n/**\n * A CSS selector targeting sub elements.\n *\n * @category Constants\n */\nexport const SUB_SELECTOR = 'sub';\n\n/**\n * Attribute bag for sub creation/enhancement.\n *\n * @remarks\n * The `<sub>` element accepts standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type SubAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link SubAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The sub attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: SubAttrs): 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 sub 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 pkgn-sol'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 sub element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<sub>` element.\n *\n * @example\n * ```ts\n * import { createSub } from \"@lnpg/pkgn-sol/elements/inline/sub\";\n *\n * const formula = document.createElement(\"span\");\n * formula.append(\"H\");\n * formula.appendChild(createSub(\"2\"));\n * formula.append(\"O\");\n * ```\n *\n * @category DOM\n */\nexport function createSub(text?: string, attrs?: SubAttrs): ElementOf<typeof SUB_TAG> {\n  return createElement(SUB_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance sub elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceSubs(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for sub.\n  void root;\n}\n"],"mappings":"sMAiEa,EAAU,MAOV,EAAe,MA4B5B,SAAS,EAAc,EAA2C,CAChE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA4BrD,SAAgB,EAAU,EAAe,EAA6C,CACpF,OAAO,EAAA,EAAA,MAAuB,EAAc,EAAM,CAAE,EAAK,CAqB3D,SAAgB,EAAY,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/sup/sup.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({SUP_SELECTOR:()=>`sup`,SUP_TAG:()=>`sup`,createSup:()=>a,enhanceSups:()=>o}),n=`sup`,r=`sup`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`sup`,i(n),t)}function o(e=document){}exports.SUP_SELECTOR=r,exports.SUP_TAG=n,exports.createSup=a,exports.enhanceSups=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=sup.cjs.map

package/dist/cjs/elements/inline/sup/sup.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sup.cjs","names":[],"sources":["../../../../../src/elements/inline/sup/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Sup element helpers.\n *\n * @remarks\n * The sup element (`<sup>`) represents superscript text.\n *\n * Best-practice guidance:\n * - Use `<sup>` for semantic superscripts such as footnote markers, ordinal indicators,\n *   and mathematical exponents.\n * - Avoid using `<sup>` purely for visual styling; prefer CSS when semantics are not intended.\n * - For footnotes, consider pairing markers with accessible labelling (e.g. via `aria-label`)\n *   and appropriate linking patterns.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create superscript nodes in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol 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/Element/sup\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 pkgn-sol 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 superscript elements.\n *\n * @category Constants\n */\nexport const SUP_TAG = 'sup' as const;\n\n/**\n * A CSS selector targeting sup elements.\n *\n * @category Constants\n */\nexport const SUP_SELECTOR = 'sup';\n\n/**\n * Attribute bag for sup creation/enhancement.\n *\n * @remarks\n * Sup elements accept standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type SupAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link SupAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The sup attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: SupAttrs): 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 sup 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 pkgn-sol'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 sup.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<sup>` element.\n *\n * @example\n * Create a footnote marker:\n * ```ts\n * import { createSup } from \"@lnpg/pkgn-sol/elements/inline/sup\";\n *\n * const marker = createSup(\"1\", { aria: { label: \"Footnote 1\" } });\n * ```\n *\n * @category DOM\n */\nexport function createSup(text?: string, attrs?: SupAttrs): ElementOf<typeof SUP_TAG> {\n  return createElement(SUP_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance sup elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceSups(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for sup.\n  void root;\n}\n"],"mappings":"sMA8Da,EAAU,MAOV,EAAe,MA4B5B,SAAS,EAAc,EAA2C,CAChE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA0BrD,SAAgB,EAAU,EAAe,EAA6C,CACpF,OAAO,EAAA,EAAA,MAAuB,EAAc,EAAM,CAAE,EAAK,CAqB3D,SAAgB,EAAY,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/time/time.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({TIME_SELECTOR:()=>r,TIME_TAG:()=>n,createTime:()=>a,enhanceTimes:()=>o}),n=`time`,r=`time`;function i(e){if(!e)return;let{aria:t,datetime:n,dateTime:r,attrs:i,...a}=e,o={...a};if(t){let e={};typeof t.label==`string`&&(e.label=t.label),typeof t.labelledby==`string`&&(e.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(e.hidden=t.hidden),Object.keys(e).length>0&&(o.aria=e)}let s=n??r,c={...i??{}};return typeof s==`string`?s.length>0&&(c.datetime=s):s instanceof Date&&(c.datetime=s.toISOString()),Object.keys(c).length>0&&(o.attrs=c),o}function a(t,r){return e.n(n,i(r),t)}function o(e=document){}exports.TIME_SELECTOR=r,exports.TIME_TAG=n,exports.createTime=a,exports.enhanceTimes=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=time.cjs.map

package/dist/cjs/elements/inline/time/time.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.cjs","names":[],"sources":["../../../../../src/elements/inline/time/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Time element helpers.\n *\n * @remarks\n * The time element (`<time>`) represents a specific period in time.\n *\n * Best-practice guidance (summary):\n * - Provide a machine-readable `datetime` value when possible.\n * - Keep visible text human-friendly (e.g. \"Tomorrow\", \"12 Feb 2026\").\n * - Avoid using `<time>` purely for styling.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create `<time>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - supply a typed `datetime`/`dateTime` field mapped to the `datetime` attribute\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 pkgn-sol 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 time.\n *\n * @category Constants\n */\nexport const TIME_TAG = 'time' as const;\n\n/**\n * A CSS selector targeting time elements.\n *\n * @category Constants\n */\nexport const TIME_SELECTOR = 'time';\n\n/**\n * Attribute bag for time creation/enhancement.\n *\n * @remarks\n * In addition to global attributes, `<time>` commonly uses the `datetime`\n * attribute to provide a machine-readable value.\n *\n * pkgn-sol supports:\n * - `datetime` (preferred, aligns with the HTML attribute name)\n * - `dateTime` (alias for ergonomic camelCase usage)\n *\n * @category Attributes\n */\nexport type TimeAttrs = Omit<GlobalAttrs, 'aria' | 'attrs'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n\n  /**\n   * Machine-readable time value, mapped to the `datetime` attribute.\n   *\n   * @remarks\n   * Examples:\n   * - `2026-02-25`\n   * - `2026-02-25T16:30:00Z`\n   * - `PT2H`\n   *\n   * If a {@link Date} is provided, it is converted via `toISOString()`.\n   */\n  datetime?: string | Date;\n\n  /**\n   * Alias of {@link TimeAttrs.datetime}.\n   *\n   * @remarks\n   * Supported for ergonomic camelCase input. If both are provided, `datetime`\n   * takes precedence.\n   */\n  dateTime?: string | Date;\n\n  /**\n   * Additional attributes not modeled above.\n   *\n   * @remarks\n   * This exists as an escape hatch while still allowing pkgn-sol to apply its\n   * attribute safety rules via `dom.ts`.\n   */\n  attrs?: GlobalAttrs['attrs'];\n};\n\n/**\n * Normalize {@link TimeAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The time attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: TimeAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, datetime, dateTime, attrs: extraAttrs, ...rest } = attrs;\n\n  const mapped: GlobalAttrs = { ...rest };\n\n  // Map structured aria.\n  if (aria) {\n    const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\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    if (Object.keys(mappedAria).length > 0) mapped.aria = mappedAria;\n  }\n\n  // Map datetime/dateTime -> datetime attribute, while preserving any provided attrs.\n  const v = datetime ?? dateTime;\n\n  const mergedAttrs: NonNullable<GlobalAttrs['attrs']> = { ...(extraAttrs ?? {}) };\n\n  if (typeof v === 'string') {\n    if (v.length > 0) mergedAttrs.datetime = v;\n  } else if (v instanceof Date) {\n    mergedAttrs.datetime = v.toISOString();\n  }\n\n  if (Object.keys(mergedAttrs).length > 0) mapped.attrs = mergedAttrs;\n\n  return mapped;\n}\n\n/**\n * Create a time 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 pkgn-sol'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 time element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<time>` element.\n *\n * @example\n * ```ts\n * import { createTime } from \"@lnpg/pkgn-sol/elements/inline/time\";\n *\n * const t = createTime(\"25 Feb 2026\", { datetime: \"2026-02-25\" });\n * document.body.appendChild(t);\n * ```\n *\n * @example\n * Using the `dateTime` alias:\n * ```ts\n * const t = createTime(\"25 Feb 2026\", { dateTime: \"2026-02-25\" });\n * ```\n *\n * @category DOM\n */\nexport function createTime(text?: string, attrs?: TimeAttrs): ElementOf<typeof TIME_TAG> {\n  return createElement(TIME_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance time elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.0`.\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceTimes(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for time.\n  void root;\n}\n"],"mappings":"kMA0Da,EAAW,OAOX,EAAgB,OA6D7B,SAAS,EAAc,EAA4C,CACjE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,WAAU,WAAU,MAAO,EAAY,GAAG,GAAS,EAE3D,EAAsB,CAAE,GAAG,EAAM,CAGvC,GAAI,EAAM,CACR,IAAM,EAA+C,EAAE,CACnD,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE3D,OAAO,KAAK,EAAW,CAAC,OAAS,IAAG,EAAO,KAAO,GAIxD,IAAM,EAAI,GAAY,EAEhB,EAAiD,CAAE,GAAI,GAAc,EAAE,CAAG,CAUhF,OARI,OAAO,GAAM,SACX,EAAE,OAAS,IAAG,EAAY,SAAW,GAChC,aAAa,OACtB,EAAY,SAAW,EAAE,aAAa,EAGpC,OAAO,KAAK,EAAY,CAAC,OAAS,IAAG,EAAO,MAAQ,GAEjD,EAgCT,SAAgB,EAAW,EAAe,EAA+C,CACvF,OAAO,EAAA,EAAc,EAAU,EAAc,EAAM,CAAE,EAAK,CAa5D,SAAgB,EAAa,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/u/u.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({U_SELECTOR:()=>`u`,U_TAG:()=>`u`,createU:()=>a,enhanceUs:()=>o}),n=`u`,r=`u`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`u`,i(n),t)}function o(e=document){}exports.U_SELECTOR=r,exports.U_TAG=n,exports.createU=a,exports.enhanceUs=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=u.cjs.map

package/dist/cjs/elements/inline/u/u.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"u.cjs","names":[],"sources":["../../../../../src/elements/inline/u/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: U element helpers.\n *\n * @remarks\n * The u element (`<u>`) represents a span of text with an unarticulated,\n * explicitly rendered non-textual annotation.\n *\n * Best-practice guidance:\n * - Do not use `<u>` purely for underlining text. Use CSS (`text-decoration`) for\n *   presentation.\n * - Use `<u>` only when the semantics are appropriate (e.g. marking misspellings\n *   or other non-textual annotations).\n * - Avoid usage where it could be confused with a hyperlink.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create u elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol ever needs runtime behavior\n *\n * MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/u\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 pkgn-sol 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 unarticulated annotation spans.\n *\n * @category Constants\n */\nexport const U_TAG = 'u' as const;\n\n/**\n * A CSS selector targeting u elements.\n *\n * @category Constants\n */\nexport const U_SELECTOR = 'u';\n\n/**\n * Attribute bag for u creation/enhancement.\n *\n * @remarks\n * U elements accept standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type UAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link UAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The u attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: UAttrs): 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 u 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 pkgn-sol'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 u element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<u>` element.\n *\n * @example\n * ```ts\n * import { createU } from \"@lnpg/pkgn-sol/elements/inline/u\";\n *\n * const misspelt = createU(\"teh\", { aria: { label: \"Misspelt word\" } });\n * ```\n *\n * @category DOM\n */\nexport function createU(text?: string, attrs?: UAttrs): ElementOf<typeof U_TAG> {\n  return createElement(U_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance u elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceUs(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for u.\n  void root;\n}\n"],"mappings":"0LA4Da,EAAQ,IAOR,EAAa,IA4B1B,SAAS,EAAc,EAAyC,CAC9D,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EAyBrD,SAAgB,EAAQ,EAAe,EAAyC,CAC9E,OAAO,EAAA,EAAA,IAAqB,EAAc,EAAM,CAAE,EAAK,CAqBzD,SAAgB,EAAU,EAAmB,SAAgB"}

package/dist/cjs/elements/inline/var/var.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({VAR_SELECTOR:()=>`var`,VAR_TAG:()=>`var`,createVar:()=>a,enhanceVars:()=>o}),n=`var`,r=`var`;function i(e){if(!e)return;let{aria:t,...n}=e;if(!t)return n;let r={};return typeof t.label==`string`&&(r.label=t.label),typeof t.labelledby==`string`&&(r.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(r.hidden=t.hidden),Object.keys(r).length>0?{...n,aria:r}:n}function a(t,n){return e.n(`var`,i(n),t)}function o(e=document){}exports.VAR_SELECTOR=r,exports.VAR_TAG=n,exports.createVar=a,exports.enhanceVars=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=var.cjs.map

package/dist/cjs/elements/inline/var/var.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"var.cjs","names":[],"sources":["../../../../../src/elements/inline/var/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Var element helpers.\n *\n * @remarks\n * The var element (`<var>`) represents a variable name in a mathematical\n * expression or programming context. Browsers typically render it in italics\n * by default, but presentation should be handled via CSS.\n *\n * Best-practice guidance:\n * - Use `<var>` specifically for variables (e.g. `x`, `y`, `n`, `userId`).\n * - Use `<code>` for code fragments, `<kbd>` for user input, and `<samp>` for\n *   sample output, rather than overloading `<var>`.\n * - Keep semantics clean: `<var>` is inline and should not be used as a generic\n *   styling hook.\n *\n * pkgn-sol provides small, framework-agnostic helpers so consumers can:\n * - create `<var>` elements in vanilla JS/TS without templates\n * - apply consistent global attributes safely\n * - use a stable \"enhancement\" hook if pkgn-sol 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/Element/var\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 pkgn-sol 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 var elements.\n *\n * @category Constants\n */\nexport const VAR_TAG = 'var' as const;\n\n/**\n * A CSS selector targeting var elements.\n *\n * @category Constants\n */\nexport const VAR_SELECTOR = 'var';\n\n/**\n * Attribute bag for var creation/enhancement.\n *\n * @remarks\n * The `<var>` element accepts standard HTML global attributes.\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is\n * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.\n *\n * @category Attributes\n */\nexport type VarAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link VarAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The var attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: VarAttrs): 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 var 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 pkgn-sol'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 var element.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<var>` element.\n *\n * @example\n * ```ts\n * import { createVar } from \"@lnpg/pkgn-sol/elements/inline/var\";\n *\n * const v = createVar(\"n\", { className: \"symbol\" });\n * document.body.appendChild(v);\n * ```\n *\n * @category DOM\n */\nexport function createVar(text?: string, attrs?: VarAttrs): ElementOf<typeof VAR_TAG> {\n  return createElement(VAR_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance var elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.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 enhanceVars(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for var.\n  void root;\n}\n"],"mappings":"sMAgEa,EAAU,MAOV,EAAe,MA4B5B,SAAS,EAAc,EAA2C,CAChE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,GAAG,GAAS,EAE1B,GAAI,CAAC,EAAM,OAAO,EAElB,IAAM,EAA+C,EAAE,CASvD,OAPI,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAG7C,OAAO,KAAK,EAAW,CAAC,OAAS,EAEhC,CAAE,GAAG,EAAM,KAAM,EAAY,CAAG,EA0BrD,SAAgB,EAAU,EAAe,EAA6C,CACpF,OAAO,EAAA,EAAA,MAAuB,EAAc,EAAM,CAAE,EAAK,CAqB3D,SAAgB,EAAY,EAAmB,SAAgB"}

package/dist/cjs/elements/interactive/details/details.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../../../chunks/dom.cjs`);var t=e.i({DETAILS_SELECTOR:()=>r,DETAILS_TAG:()=>n,createDetails:()=>a,enhanceDetails:()=>o}),n=`details`,r=`details`;function i(e){if(!e)return;let{aria:t,open:n,name:r,...i}=e,a={...i.attrs??{}},o=(e,t)=>{t!==void 0&&(Object.prototype.hasOwnProperty.call(a,e)||(a[e]=t))};o(`name`,r),n===!0&&o(`open`,``);let s={...i};if(Object.keys(a).length>0&&(s.attrs=a),t){let e={};typeof t.label==`string`&&(e.label=t.label),typeof t.labelledby==`string`&&(e.labelledby=t.labelledby),typeof t.hidden==`boolean`&&(e.hidden=t.hidden),Object.keys(e).length>0&&(s.aria=e)}return s}function a(t){return e.n(n,i(t))}function o(e=document){}exports.DETAILS_SELECTOR=r,exports.DETAILS_TAG=n,exports.createDetails=a,exports.enhanceDetails=o,Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return t}});
+//# sourceMappingURL=details.cjs.map

package/dist/cjs/elements/interactive/details/details.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"details.cjs","names":[],"sources":["../../../../../src/elements/interactive/details/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Details element helpers.\n *\n * @remarks\n * The details element (`<details>`) creates a disclosure widget where content is\n * shown/hidden by toggling the element open/closed. (MDN) :contentReference[oaicite:3]{index=3}\n *\n * Best-practice guidance:\n * - Provide a visible label using a child `<summary>` element; it acts as the\n *   interactive control for toggling the parent `<details>`. (MDN) :contentReference[oaicite:4]{index=4}\n * - Use the `open` attribute to render expanded by default. (MDN) :contentReference[oaicite:5]{index=5}\n * - If using the `name` attribute to create a mutually-exclusive group, authors\n *   must avoid markup where more than one element in the same name group has\n *   `open` present. User agents may enforce exclusivity by changing `open`.\n *   (WHATWG) :contentReference[oaicite:6]{index=6}\n *\n * pkgn-sol-specific conventions:\n * - Applies global attributes via pkgn-sol's hardened DOM helpers (`dom.ts`), which\n *   block inline event handler attributes (e.g. `onclick`) and the raw `style`\n *   attribute string.\n * - Supports a small structured ARIA input to reduce typo-based ARIA bugs.\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 AttrValue, type ElementOf, type GlobalAttrs } from '../../../ts/dom';\n\n/**\n * Structured ARIA input supported by pkgn-sol element factories.\n *\n * @remarks\n * This is intentionally a small, typed subset mapped into {@link GlobalAttrs.aria}.\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(s) to 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 details disclosure widgets.\n *\n * @category Constants\n */\nexport const DETAILS_TAG = 'details' as const;\n\n/**\n * A CSS selector targeting details elements.\n *\n * @category Constants\n */\nexport const DETAILS_SELECTOR = 'details';\n\n/**\n * Attribute bag for details creation/enhancement.\n *\n * @remarks\n * `<details>` accepts global attributes plus:\n * - `open` (boolean attribute)\n * - `name` (creates a mutually-exclusive details name group, per spec)\n *\n * `name` grouping behavior is specified by HTML; pkgn-sol does not enforce group\n * constraints at runtime. (WHATWG) :contentReference[oaicite:7]{index=7}\n *\n * pkgn-sol also supports a structured ARIA input for common ARIA fields, mapped into\n * {@link GlobalAttrs.aria}.\n *\n * @category Attributes\n */\nexport type DetailsAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n\n  /**\n   * Whether the details is open (expanded) by default.\n   *\n   * @remarks\n   * This maps to the boolean `open` attribute. (MDN) :contentReference[oaicite:8]{index=8}\n   */\n  open?: boolean;\n\n  /**\n   * Name of a mutually-exclusive details group.\n   *\n   * @remarks\n   * Details with the same `name` may form an exclusive group where at most one\n   * is open at a time. (WHATWG) :contentReference[oaicite:9]{index=9}\n   */\n  name?: string;\n};\n\n/**\n * Normalize {@link DetailsAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @remarks\n * Pattern:\n * - Start with any caller-provided raw attrs escape hatch.\n * - Apply typed attributes without overriding explicit raw attributes.\n * - Map structured ARIA into {@link GlobalAttrs.aria}.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: DetailsAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, open, name, ...rest } = attrs;\n\n  const mergedAttrs: Record<string, AttrValue> = { ...(rest.attrs ?? {}) };\n\n  const setIfUnset = (key: string, v: AttrValue | undefined): void => {\n    if (v === undefined) return;\n    if (Object.prototype.hasOwnProperty.call(mergedAttrs, key)) return;\n    mergedAttrs[key] = v;\n  };\n\n  setIfUnset('name', name);\n\n  // Boolean attribute by presence when true.\n  if (open === true) setIfUnset('open', '');\n\n  const mapped: GlobalAttrs = { ...rest };\n\n  if (Object.keys(mergedAttrs).length > 0) {\n    mapped.attrs = mergedAttrs;\n  }\n\n  if (aria) {\n    const mappedAria: NonNullable<GlobalAttrs['aria']> = {};\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    if (Object.keys(mappedAria).length > 0) {\n      mapped.aria = mappedAria;\n    }\n  }\n\n  return mapped;\n}\n\n/**\n * Create a details element with optional attributes.\n *\n * @remarks\n * - Provide a child `<summary>` for the visible label/toggle control. (MDN) :contentReference[oaicite:10]{index=10}\n * - Global attributes are applied via pkgn-sol's shared DOM helper, including security\n *   guards that block inline event handler attributes (e.g. `onclick`) and raw\n *   `style` attribute strings.\n *\n * @param attrs - Optional attributes to apply.\n * @returns The created `<details>` element.\n *\n * @example\n * ```ts\n * import { createDetails } from \"@lnpg/pkgn-sol/elements/interactive/details\";\n *\n * const d = createDetails({ open: true });\n * ```\n *\n * @category DOM\n */\nexport function createDetails(attrs?: DetailsAttrs): ElementOf<typeof DETAILS_TAG> {\n  return createElement(DETAILS_TAG, toGlobalAttrs(attrs));\n}\n\n/**\n * Enhance details elements within a given root.\n *\n * @remarks\n * This is intentionally a no-op in `0.1.0`.\n *\n * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceDetails(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for details.\n  void root;\n}\n"],"mappings":"6MA6Da,EAAc,UAOd,EAAmB,UAqDhC,SAAS,EAAc,EAA+C,CACpE,GAAI,CAAC,EAAO,OAEZ,GAAM,CAAE,OAAM,OAAM,OAAM,GAAG,GAAS,EAEhC,EAAyC,CAAE,GAAI,EAAK,OAAS,EAAE,CAAG,CAElE,GAAc,EAAa,IAAmC,CAC9D,IAAM,IAAA,KACN,OAAO,UAAU,eAAe,KAAK,EAAa,EAAI,GAC1D,EAAY,GAAO,KAGrB,EAAW,OAAQ,EAAK,CAGpB,IAAS,IAAM,EAAW,OAAQ,GAAG,CAEzC,IAAM,EAAsB,CAAE,GAAG,EAAM,CAMvC,GAJI,OAAO,KAAK,EAAY,CAAC,OAAS,IACpC,EAAO,MAAQ,GAGb,EAAM,CACR,IAAM,EAA+C,EAAE,CACnD,OAAO,EAAK,OAAU,WAAU,EAAW,MAAQ,EAAK,OACxD,OAAO,EAAK,YAAe,WAAU,EAAW,WAAa,EAAK,YAClE,OAAO,EAAK,QAAW,YAAW,EAAW,OAAS,EAAK,QAE3D,OAAO,KAAK,EAAW,CAAC,OAAS,IACnC,EAAO,KAAO,GAIlB,OAAO,EAwBT,SAAgB,EAAc,EAAqD,CACjF,OAAO,EAAA,EAAc,EAAa,EAAc,EAAM,CAAC,CAazD,SAAgB,EAAe,EAAmB,SAAgB"}