@lnpg/pkgn-sol 1.0.0-beta.0

package/dist/esm/elements/inline/s/s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"s.js","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":";;;;;;;IA8Da,IAAQ,KAOR,IAAa;AA4B1B,SAAS,EAAc,GAAyC;CAC9D,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA0BrD,SAAgB,EAAQ,GAAe,GAAyC;CAC9E,OAAO,EAAA,KAAqB,EAAc,EAAM,EAAE,EAAK;;AAqBzD,SAAgB,EAAU,IAAmB,UAAgB"}

package/dist/esm/elements/inline/samp/samp.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/samp/index.ts
+var n = /* @__PURE__ */ e({
+	SAMP_SELECTOR: () => i,
+	SAMP_TAG: () => r,
+	createSamp: () => o,
+	enhanceSamps: () => s
+}), r = "samp", i = "samp";
+function a(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 o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as SAMP_SELECTOR, r as SAMP_TAG, o as createSamp, s as enhanceSamps, n as t };
+
+//# sourceMappingURL=samp.js.map

package/dist/esm/elements/inline/samp/samp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"samp.js","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":";;;;;;;IA2Da,IAAW,QAOX,IAAgB;AA4B7B,SAAS,EAAc,GAA4C;CACjE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA0BrD,SAAgB,EAAW,GAAe,GAA+C;CACvF,OAAO,EAAc,GAAU,EAAc,EAAM,EAAE,EAAK;;AAqB5D,SAAgB,EAAa,IAAmB,UAAgB"}

package/dist/esm/elements/inline/small/small.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/small/index.ts
+var n = /* @__PURE__ */ e({
+	SMALL_SELECTOR: () => i,
+	SMALL_TAG: () => r,
+	createSmall: () => o,
+	enhanceSmalls: () => s
+}), r = "small", i = "small";
+function a(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 o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as SMALL_SELECTOR, r as SMALL_TAG, o as createSmall, s as enhanceSmalls, n as t };
+
+//# sourceMappingURL=small.js.map

package/dist/esm/elements/inline/small/small.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"small.js","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":";;;;;;;IAmEa,IAAY,SAOZ,IAAiB;AAgC9B,SAAS,EAAc,GAA6C;CAClE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CAQvD,OANI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAE7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA8BrD,SAAgB,EAAY,GAAe,GAAiD;CAC1F,OAAO,EAAc,GAAW,EAAc,EAAM,EAAE,EAAK;;AAqB7D,SAAgB,EAAc,IAAmB,UAAgB"}

package/dist/esm/elements/inline/strong/strong.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/strong/index.ts
+var n = /* @__PURE__ */ e({
+	STRONG_SELECTOR: () => i,
+	STRONG_TAG: () => r,
+	createStrong: () => o,
+	enhanceStrongs: () => s
+}), r = "strong", i = "strong";
+function a(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 o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as STRONG_SELECTOR, r as STRONG_TAG, o as createStrong, s as enhanceStrongs, n as t };
+
+//# sourceMappingURL=strong.js.map

package/dist/esm/elements/inline/strong/strong.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong.js","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":";;;;;;;IA8Da,IAAa,UAOb,IAAkB;AA4B/B,SAAS,EAAc,GAA8C;CACnE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA2BrD,SAAgB,EAAa,GAAe,GAAmD;CAC7F,OAAO,EAAc,GAAY,EAAc,EAAM,EAAE,EAAK;;AAqB9D,SAAgB,EAAe,IAAmB,UAAgB"}

package/dist/esm/elements/inline/sub/sub.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/sub/index.ts
+var n = /* @__PURE__ */ e({
+	SUB_SELECTOR: () => "sub",
+	SUB_TAG: () => "sub",
+	createSub: () => o,
+	enhanceSubs: () => s
+}), r = "sub", i = "sub";
+function a(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 o(e, n) {
+	return t("sub", a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as SUB_SELECTOR, r as SUB_TAG, o as createSub, s as enhanceSubs, n as t };
+
+//# sourceMappingURL=sub.js.map

package/dist/esm/elements/inline/sub/sub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sub.js","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":";;;;;;;IAiEa,IAAU,OAOV,IAAe;AA4B5B,SAAS,EAAc,GAA2C;CAChE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA4BrD,SAAgB,EAAU,GAAe,GAA6C;CACpF,OAAO,EAAA,OAAuB,EAAc,EAAM,EAAE,EAAK;;AAqB3D,SAAgB,EAAY,IAAmB,UAAgB"}

package/dist/esm/elements/inline/sup/sup.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/sup/index.ts
+var n = /* @__PURE__ */ e({
+	SUP_SELECTOR: () => "sup",
+	SUP_TAG: () => "sup",
+	createSup: () => o,
+	enhanceSups: () => s
+}), r = "sup", i = "sup";
+function a(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 o(e, n) {
+	return t("sup", a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as SUP_SELECTOR, r as SUP_TAG, o as createSup, s as enhanceSups, n as t };
+
+//# sourceMappingURL=sup.js.map

package/dist/esm/elements/inline/sup/sup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sup.js","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":";;;;;;;IA8Da,IAAU,OAOV,IAAe;AA4B5B,SAAS,EAAc,GAA2C;CAChE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA0BrD,SAAgB,EAAU,GAAe,GAA6C;CACpF,OAAO,EAAA,OAAuB,EAAc,EAAM,EAAE,EAAK;;AAqB3D,SAAgB,EAAY,IAAmB,UAAgB"}

package/dist/esm/elements/inline/time/time.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/time/index.ts
+var n = /* @__PURE__ */ e({
+	TIME_SELECTOR: () => i,
+	TIME_TAG: () => r,
+	createTime: () => o,
+	enhanceTimes: () => s
+}), r = "time", i = "time";
+function a(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 o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as TIME_SELECTOR, r as TIME_TAG, o as createTime, s as enhanceTimes, n as t };
+
+//# sourceMappingURL=time.js.map

package/dist/esm/elements/inline/time/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","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":";;;;;;;IA0Da,IAAW,QAOX,IAAgB;AA6D7B,SAAS,EAAc,GAA4C;CACjE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,aAAU,aAAU,OAAO,GAAY,GAAG,MAAS,GAE3D,IAAsB,EAAE,GAAG,GAAM;CAGvC,IAAI,GAAM;EACR,IAAM,IAA+C,EAAE;EAKvD,AAJI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAE3D,OAAO,KAAK,EAAW,CAAC,SAAS,MAAG,EAAO,OAAO;;CAIxD,IAAM,IAAI,KAAY,GAEhB,IAAiD,EAAE,GAAI,KAAc,EAAE,EAAG;CAUhF,OARI,OAAO,KAAM,WACX,EAAE,SAAS,MAAG,EAAY,WAAW,KAChC,aAAa,SACtB,EAAY,WAAW,EAAE,aAAa,GAGpC,OAAO,KAAK,EAAY,CAAC,SAAS,MAAG,EAAO,QAAQ,IAEjD;;AAgCT,SAAgB,EAAW,GAAe,GAA+C;CACvF,OAAO,EAAc,GAAU,EAAc,EAAM,EAAE,EAAK;;AAa5D,SAAgB,EAAa,IAAmB,UAAgB"}

package/dist/esm/elements/inline/u/u.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/u/index.ts
+var n = /* @__PURE__ */ e({
+	U_SELECTOR: () => "u",
+	U_TAG: () => "u",
+	createU: () => o,
+	enhanceUs: () => s
+}), r = "u", i = "u";
+function a(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 o(e, n) {
+	return t("u", a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as U_SELECTOR, r as U_TAG, o as createU, s as enhanceUs, n as t };
+
+//# sourceMappingURL=u.js.map

package/dist/esm/elements/inline/u/u.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"u.js","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":";;;;;;;IA4Da,IAAQ,KAOR,IAAa;AA4B1B,SAAS,EAAc,GAAyC;CAC9D,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AAyBrD,SAAgB,EAAQ,GAAe,GAAyC;CAC9E,OAAO,EAAA,KAAqB,EAAc,EAAM,EAAE,EAAK;;AAqBzD,SAAgB,EAAU,IAAmB,UAAgB"}

package/dist/esm/elements/inline/var/var.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/inline/var/index.ts
+var n = /* @__PURE__ */ e({
+	VAR_SELECTOR: () => "var",
+	VAR_TAG: () => "var",
+	createVar: () => o,
+	enhanceVars: () => s
+}), r = "var", i = "var";
+function a(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 o(e, n) {
+	return t("var", a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as VAR_SELECTOR, r as VAR_TAG, o as createVar, s as enhanceVars, n as t };
+
+//# sourceMappingURL=var.js.map

package/dist/esm/elements/inline/var/var.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"var.js","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":";;;;;;;IAgEa,IAAU,OAOV,IAAe;AA4B5B,SAAS,EAAc,GAA2C;CAChE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA0BrD,SAAgB,EAAU,GAAe,GAA6C;CACpF,OAAO,EAAA,OAAuB,EAAc,EAAM,EAAE,EAAK;;AAqB3D,SAAgB,EAAY,IAAmB,UAAgB"}

package/dist/esm/elements/interactive/details/details.js

@@ -0,0 +1,29 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/interactive/details/index.ts
+var n = /* @__PURE__ */ e({
+	DETAILS_SELECTOR: () => i,
+	DETAILS_TAG: () => r,
+	createDetails: () => o,
+	enhanceDetails: () => s
+}), r = "details", i = "details";
+function a(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 o(e) {
+	return t(r, a(e));
+}
+function s(e = document) {}
+//#endregion
+export { i as DETAILS_SELECTOR, r as DETAILS_TAG, o as createDetails, s as enhanceDetails, n as t };
+
+//# sourceMappingURL=details.js.map

package/dist/esm/elements/interactive/details/details.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"details.js","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":";;;;;;;IA6Da,IAAc,WAOd,IAAmB;AAqDhC,SAAS,EAAc,GAA+C;CACpE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,SAAM,SAAM,GAAG,MAAS,GAEhC,IAAyC,EAAE,GAAI,EAAK,SAAS,EAAE,EAAG,EAElE,KAAc,GAAa,MAAmC;EAC9D,MAAM,KAAA,MACN,OAAO,UAAU,eAAe,KAAK,GAAa,EAAI,KAC1D,EAAY,KAAO;;CAMrB,AAHA,EAAW,QAAQ,EAAK,EAGpB,MAAS,MAAM,EAAW,QAAQ,GAAG;CAEzC,IAAM,IAAsB,EAAE,GAAG,GAAM;CAMvC,IAJI,OAAO,KAAK,EAAY,CAAC,SAAS,MACpC,EAAO,QAAQ,IAGb,GAAM;EACR,IAAM,IAA+C,EAAE;EAKvD,AAJI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAE3D,OAAO,KAAK,EAAW,CAAC,SAAS,MACnC,EAAO,OAAO;;CAIlB,OAAO;;AAwBT,SAAgB,EAAc,GAAqD;CACjF,OAAO,EAAc,GAAa,EAAc,EAAM,CAAC;;AAazD,SAAgB,EAAe,IAAmB,UAAgB"}

package/dist/esm/elements/interactive/dialog/dialog.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/interactive/dialog/index.ts
+var n = /* @__PURE__ */ e({
+	DIALOG_SELECTOR: () => i,
+	DIALOG_TAG: () => r,
+	createDialog: () => o,
+	enhanceDialogs: () => s
+}), r = "dialog", i = "dialog";
+function a(e) {
+	if (!e) return;
+	let { aria: t, open: n, closedBy: r, ...i } = e, a = { ...i }, o = { ...a.attrs ?? {} };
+	if (n === !0 && (o.open = !0), (r === "any" || r === "closerequest" || r === "none") && (o.closedby = r), Object.keys(o).length > 0 && (a.attrs = o), !t) return a;
+	let s = {};
+	return typeof t.label == "string" && (s.label = t.label), typeof t.labelledby == "string" && (s.labelledby = t.labelledby), typeof t.hidden == "boolean" && (s.hidden = t.hidden), Object.keys(s).length > 0 ? {
+		...a,
+		aria: s
+	} : a;
+}
+function o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as DIALOG_SELECTOR, r as DIALOG_TAG, o as createDialog, s as enhanceDialogs, n as t };
+
+//# sourceMappingURL=dialog.js.map

package/dist/esm/elements/interactive/dialog/dialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.js","names":[],"sources":["../../../../../src/elements/interactive/dialog/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Dialog element helpers.\n *\n * @remarks\n * The dialog element (`<dialog>`) represents a modal or non-modal dialog box\n * (e.g. a confirm prompt, inspector, or subwindow).\n *\n * Best-practice guidance:\n * - Prefer using the platform APIs:\n *   - `dialog.showModal()` for modal dialogs\n *   - `dialog.show()` for non-modal dialogs\n *   - `dialog.close()` to close, optionally supplying a return value\n * - Provide an accessible name for the dialog content (e.g. heading + `aria-labelledby`\n *   or `aria-label` when appropriate).\n * - Ensure the dialog contains an obvious close mechanism.\n * - Avoid relying solely on adding/removing `open`; prefer the element's methods\n *   for correct focus and modal behavior.\n *\n * Attributes (element-specific):\n * - `open` (boolean): when present, the dialog is active and available for interaction.\n * - `closedBy` (enumerated): maps to the `closedby` content attribute (spec-defined).\n *\n * Security:\n * - Global attribute escape hatches are guarded by pkgn-sol's `dom.ts` helpers which\n *   block inline event handler attributes (e.g. `onclick`) and raw `style`\n *   attribute injection (use the `style` object field instead).\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/dialog\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 dialog.\n *\n * @category Constants\n */\nexport const DIALOG_TAG = 'dialog' as const;\n\n/**\n * A CSS selector targeting dialog elements.\n *\n * @category Constants\n */\nexport const DIALOG_SELECTOR = 'dialog';\n\n/**\n * Values supported by the `closedby` content attribute.\n *\n * @remarks\n * This is a newer platform feature that specifies which user actions can close\n * the dialog automatically.\n *\n * - `any`: close requests or clicks outside close the dialog.\n * - `closerequest`: close requests close the dialog.\n * - `none`: no user actions automatically close the dialog.\n *\n * @category Types\n */\nexport type DialogClosedBy = 'any' | 'closerequest' | 'none';\n\n/**\n * Attribute bag for dialog creation/enhancement.\n *\n * @remarks\n * Dialog elements accept standard HTML global attributes plus a small set of\n * dialog-specific content 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 DialogAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n\n  /**\n   * Whether the dialog is open (active).\n   *\n   * @remarks\n   * Maps to the `open` boolean attribute.\n   *\n   * Prefer controlling visibility via the native methods (`showModal`, `show`,\n   * `close`) when possible.\n   */\n  open?: boolean;\n\n  /**\n   * Control user actions that can close the dialog.\n   *\n   * @remarks\n   * Maps to the `closedby` content attribute.\n   */\n  closedBy?: DialogClosedBy;\n};\n\n/**\n * Normalize {@link DialogAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The dialog attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: DialogAttrs): GlobalAttrs | undefined {\n  if (!attrs) return undefined;\n\n  const { aria, open, closedBy, ...rest } = attrs;\n\n  const mapped: GlobalAttrs = { ...rest };\n\n  const extra: NonNullable<GlobalAttrs['attrs']> = { ...(mapped.attrs ?? {}) };\n\n  if (open === true) extra.open = true;\n\n  if (closedBy === 'any' || closedBy === 'closerequest' || closedBy === 'none') {\n    extra.closedby = closedBy;\n  }\n\n  if (Object.keys(extra).length > 0) {\n    mapped.attrs = extra;\n  }\n\n  if (!aria) return mapped;\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 hasMappedAria = Object.keys(mappedAria).length > 0;\n\n  return hasMappedAria ? { ...mapped, aria: mappedAria } : mapped;\n}\n\n/**\n * Create a dialog 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 dialog.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<dialog>` element.\n *\n * @example\n * ```ts\n * import { createDialog } from \"@lnpg/pkgn-sol/elements/interactive/dialog\";\n *\n * const d = createDialog(\"Hello\", { open: true });\n * ```\n *\n * @category DOM\n */\nexport function createDialog(text?: string, attrs?: DialogAttrs): ElementOf<typeof DIALOG_TAG> {\n  return createElement(DIALOG_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance dialog 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 enhanceDialogs(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for dialog.\n  void root;\n}\n"],"mappings":";;;;;;;IAoEa,IAAa,UAOb,IAAkB;AA+D/B,SAAS,EAAc,GAA8C;CACnE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,SAAM,aAAU,GAAG,MAAS,GAEpC,IAAsB,EAAE,GAAG,GAAM,EAEjC,IAA2C,EAAE,GAAI,EAAO,SAAS,EAAE,EAAG;CAY5E,IAVI,MAAS,OAAM,EAAM,OAAO,MAE5B,MAAa,SAAS,MAAa,kBAAkB,MAAa,YACpE,EAAM,WAAW,IAGf,OAAO,KAAK,EAAM,CAAC,SAAS,MAC9B,EAAO,QAAQ,IAGb,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAGzC,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAQ,MAAM;EAAY,GAAG;;AAyB3D,SAAgB,EAAa,GAAe,GAAmD;CAC7F,OAAO,EAAc,GAAY,EAAc,EAAM,EAAE,EAAK;;AAqB9D,SAAgB,EAAe,IAAmB,UAAgB"}

package/dist/esm/elements/interactive/interactive.js

@@ -0,0 +1,14 @@
+import { i as e } from "../../chunks/dom.js";
+import { t } from "./details/details.js";
+import { t as n } from "./dialog/dialog.js";
+import { t as r } from "./summary/summary.js";
+//#region src/elements/interactive/index.ts
+var i = /* @__PURE__ */ e({
+	details: () => t,
+	dialog: () => n,
+	summary: () => r
+});
+//#endregion
+export { t as details, n as dialog, r as summary, i as t };
+
+//# sourceMappingURL=interactive.js.map

package/dist/esm/elements/interactive/interactive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive.js","names":[],"sources":["../../../../src/elements/interactive/index.ts"],"sourcesContent":["/**\n * Interactive element factories.\n *\n * Provides framework-agnostic factory functions for interactive HTML elements\n * that expose built-in browser behaviors such as disclosure widgets and modal\n * dialogs.\n *\n * These factories:\n * - Create semantic interactive structures using pkgn-sol's hardened DOM helpers.\n * - Forward curated global attributes.\n * - Enforce structured, typed attribute bags.\n * - Preserve correct accessibility semantics and relationships.\n * - Prevent unsafe attribute injection.\n *\n * The elements in this module provide native interactivity that browsers\n * understand without requiring JavaScript frameworks.\n *\n * @module elements/interactive\n * @since 0.1.0\n */\n\n/**\n * `<details>` element factory namespace.\n *\n * Represents a disclosure widget that users can open and close to reveal\n * additional information.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details\n */\nexport * as details from './details';\n\n/**\n * `<dialog>` element factory namespace.\n *\n * Represents a dialog box or interactive component such as a modal window,\n * alert, or confirmation interface.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog\n */\nexport * as dialog from './dialog';\n\n/**\n * `<summary>` element factory namespace.\n *\n * Represents the summary or visible heading for a `<details>` disclosure\n * widget. Clicking the summary toggles the details content.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/summary\n */\nexport * as summary from './summary';\n"],"mappings":""}

package/dist/esm/elements/interactive/summary/summary.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/interactive/summary/index.ts
+var n = /* @__PURE__ */ e({
+	SUMMARY_SELECTOR: () => i,
+	SUMMARY_TAG: () => r,
+	createSummary: () => o,
+	enhanceSummaries: () => s
+}), r = "summary", i = "summary";
+function a(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 o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as SUMMARY_SELECTOR, r as SUMMARY_TAG, o as createSummary, s as enhanceSummaries, n as t };
+
+//# sourceMappingURL=summary.js.map

package/dist/esm/elements/interactive/summary/summary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.js","names":[],"sources":["../../../../../src/elements/interactive/summary/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Summary element helpers.\n *\n * @remarks\n * The summary element (`<summary>`) provides the visible label for a parent\n * `<details>` disclosure widget. Activating (clicking / pressing Enter) on the\n * `<summary>` toggles the open state of the parent `<details>` element.\n *\n * Best-practice guidance:\n * - Use `<summary>` only as the first child of a `<details>` element.\n * - Use clear, concise text so the disclosure purpose is obvious.\n * - Prefer semantic content inside `<summary>`; avoid overly complex interactive\n *   children inside the summary label.\n *\n * pkgn-sol notes:\n * - This module is framework-agnostic and has no side effects.\n * - Global attributes are applied via pkgn-sol's shared DOM helper, which blocks:\n *   - inline event handler attributes (e.g. `onclick`)\n *   - raw `style` attribute injection (use the `style` object instead)\n * - Text passed to factories is assigned via `textContent` (never `innerHTML`).\n *\n * References:\n * - MDN: `<summary>` element\n * - WHATWG HTML: `<details>` content model and summary semantics\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 summary.\n *\n * @category Constants\n */\nexport const SUMMARY_TAG = 'summary' as const;\n\n/**\n * A CSS selector targeting summary elements.\n *\n * @category Constants\n */\nexport const SUMMARY_SELECTOR = 'summary';\n\n/**\n * Attribute bag for summary creation/enhancement.\n *\n * @remarks\n * `<summary>` supports 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 SummaryAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link SummaryAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The summary attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: SummaryAttrs): 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 summary 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 summary.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<summary>` element.\n *\n * @example\n * ```ts\n * import { createSummary } from \"@lnpg/pkgn-sol/elements/interactive/summary\";\n *\n * const s = createSummary(\"More details\");\n * ```\n *\n * @category DOM\n */\nexport function createSummary(text?: string, attrs?: SummaryAttrs): ElementOf<typeof SUMMARY_TAG> {\n  return createElement(SUMMARY_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance summary 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 * @param root - The node to search within. Defaults to `document`.\n *\n * @category Enhancement\n */\nexport function enhanceSummaries(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for summary.\n  void root;\n}\n"],"mappings":";;;;;;;IAgEa,IAAc,WAOd,IAAmB;AA4BhC,SAAS,EAAc,GAA+C;CACpE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CAQvD,OANI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAE7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AAyBrD,SAAgB,EAAc,GAAe,GAAqD;CAChG,OAAO,EAAc,GAAa,EAAc,EAAM,EAAE,EAAK;;AAiB/D,SAAgB,EAAiB,IAAmB,UAAgB"}

package/dist/esm/elements/layout/article/article.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/layout/article/index.ts
+var n = /* @__PURE__ */ e({
+	ARTICLE_SELECTOR: () => i,
+	ARTICLE_TAG: () => r,
+	createArticle: () => o,
+	enhanceArticles: () => s
+}), r = "article", i = "article";
+function a(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 o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as ARTICLE_SELECTOR, r as ARTICLE_TAG, o as createArticle, s as enhanceArticles, n as t };
+
+//# sourceMappingURL=article.js.map

package/dist/esm/elements/layout/article/article.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"article.js","names":[],"sources":["../../../../../src/elements/layout/article/index.ts"],"sourcesContent":["/**\n * pkgn-sol Design Foundation: Article element helpers.\n *\n * @remarks\n * The article element (`<article>`) represents a self-contained composition in a\n * document, page, application, or site that is intended to be independently\n * distributable or reusable (e.g. syndication).\n *\n * Best-practice guidance:\n * - Use `<article>` for content that makes sense on its own (blog post, news item,\n *   forum post, comment, product card, etc.).\n * - Prefer `<section>` for thematic grouping that is not independently distributable.\n * - Articles commonly include a heading (h1-h6) in their content, but this module\n *   does not enforce structure at runtime.\n *\n * This module provides small, framework-agnostic helpers so consumers can:\n * - create article sections 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/article\n * @see https://html.spec.whatwg.org/multipage/sections.html#the-article-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 article.\n *\n * @category Constants\n */\nexport const ARTICLE_TAG = 'article' as const;\n\n/**\n * A CSS selector targeting article elements.\n *\n * @category Constants\n */\nexport const ARTICLE_SELECTOR = 'article';\n\n/**\n * Attribute bag for article creation/enhancement.\n *\n * @remarks\n * Article 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 ArticleAttrs = Omit<GlobalAttrs, 'aria'> & {\n  /**\n   * Structured ARIA fields mapped into `aria-*` attributes.\n   */\n  aria?: StructuredAria;\n};\n\n/**\n * Normalize {@link ArticleAttrs} into {@link GlobalAttrs} for `dom.ts`.\n *\n * @param attrs - The article attributes.\n * @returns A {@link GlobalAttrs} object, or `undefined` if no attrs were provided.\n *\n * @category Internal\n */\nfunction toGlobalAttrs(attrs?: ArticleAttrs): 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 article 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 article.\n * @param attrs - Optional attributes to apply.\n * @returns The created `<article>` element.\n *\n * @example\n * ```ts\n * import { createArticle } from \"@lnpg/pkgn-sol/elements/layout/article\";\n *\n * document.body.appendChild(\n *   createArticle(undefined, { className: \"post\", aria: { label: \"Blog post\" } })\n * );\n * ```\n *\n * @category DOM\n */\nexport function createArticle(text?: string, attrs?: ArticleAttrs): ElementOf<typeof ARTICLE_TAG> {\n  return createElement(ARTICLE_TAG, toGlobalAttrs(attrs), text);\n}\n\n/**\n * Enhance article 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 enhanceArticles(root: ParentNode = document): void {\n  // v0.1.0: no runtime behavior for article.\n  void root;\n}\n"],"mappings":";;;;;;;IAiEa,IAAc,WAOd,IAAmB;AA4BhC,SAAS,EAAc,GAA+C;CACpE,IAAI,CAAC,GAAO;CAEZ,IAAM,EAAE,SAAM,GAAG,MAAS;CAE1B,IAAI,CAAC,GAAM,OAAO;CAElB,IAAM,IAA+C,EAAE;CASvD,OAPI,OAAO,EAAK,SAAU,aAAU,EAAW,QAAQ,EAAK,QACxD,OAAO,EAAK,cAAe,aAAU,EAAW,aAAa,EAAK,aAClE,OAAO,EAAK,UAAW,cAAW,EAAW,SAAS,EAAK,SAG7C,OAAO,KAAK,EAAW,CAAC,SAAS,IAEhC;EAAE,GAAG;EAAM,MAAM;EAAY,GAAG;;AA2BrD,SAAgB,EAAc,GAAe,GAAqD;CAChG,OAAO,EAAc,GAAa,EAAc,EAAM,EAAE,EAAK;;AAqB/D,SAAgB,EAAgB,IAAmB,UAAgB"}

package/dist/esm/elements/layout/aside/aside.js

@@ -0,0 +1,26 @@
+import { i as e, n as t } from "../../../chunks/dom.js";
+//#region src/elements/layout/aside/index.ts
+var n = /* @__PURE__ */ e({
+	ASIDE_SELECTOR: () => i,
+	ASIDE_TAG: () => r,
+	createAside: () => o,
+	enhanceAsides: () => s
+}), r = "aside", i = "aside";
+function a(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 o(e, n) {
+	return t(r, a(n), e);
+}
+function s(e = document) {}
+//#endregion
+export { i as ASIDE_SELECTOR, r as ASIDE_TAG, o as createAside, s as enhanceAsides, n as t };
+
+//# sourceMappingURL=aside.js.map