@lnpg/pkgn-sol 1.0.0-beta.0

package/dist/types/elements/text/blockquote/index.d.ts

@@ -0,0 +1,153 @@
+/**
+ * pkgn-sol Design Foundation: Blockquote element helpers.
+ *
+ * @remarks
+ * The blockquote element (`<blockquote>`) represents a section that is quoted
+ * from another source.
+ *
+ * Best-practice guidance:
+ * - Use `<blockquote>` for longer, block-level quotations.
+ * - Use `<q>` for short, inline quotations.
+ * - If you provide a citation URL, set the `cite` attribute, but also consider
+ *   providing a visible citation in content (e.g. a link or a `<cite>` element),
+ *   since many user agents do not surface `cite` automatically.
+ * - Avoid presentational attributes. Use CSS for styling.
+ *
+ * Element-specific attributes:
+ * - `cite`: A URL for the source of the quotation (when available).
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create block quotes in vanilla JS/TS without templates
+ * - apply consistent global attributes safely
+ * - use a stable "enhancement" hook if pkgn-sol ever needs runtime behavior
+ *
+ * This module has no side effects and does not mutate the DOM unless you call
+ * its functions.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blockquote
+ *
+ * @module
+ * @category Elements
+ */
+import { type ElementOf, type GlobalAttrs } from '../../../ts/dom';
+/**
+ * Structured ARIA input supported by pkgn-sol element factories.
+ *
+ * @remarks
+ * This is intentionally a small, typed subset that covers common cases and
+ * prevents typo-based ARIA bugs.
+ *
+ * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.
+ *
+ * @category Attributes
+ */
+export type StructuredAria = {
+    /**
+     * Accessible label, mapped to `aria-label`.
+     */
+    label?: string;
+    /**
+     * ID reference to the labelling element(s), mapped to `aria-labelledby`.
+     */
+    labelledby?: string;
+    /**
+     * Decorative/hidden hint, mapped to `aria-hidden`.
+     */
+    hidden?: boolean;
+};
+/**
+ * The semantic tag name for block quotes.
+ *
+ * @category Constants
+ */
+export declare const BLOCKQUOTE_TAG: "blockquote";
+/**
+ * A CSS selector targeting blockquote elements.
+ *
+ * @category Constants
+ */
+export declare const BLOCKQUOTE_SELECTOR = "blockquote";
+/**
+ * Attribute bag for blockquote creation/enhancement.
+ *
+ * @remarks
+ * Blockquote accepts standard HTML global attributes and one element-specific
+ * attribute:
+ * - `cite`: A URL pointing to the quoted source (when available).
+ *
+ * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is
+ * mapped into {@link GlobalAttrs.aria}.
+ *
+ * Security note:
+ * - Inline event handler attributes (e.g. `onclick`) are blocked by `dom.ts`.
+ * - The raw `style` attribute is blocked; use {@link GlobalAttrs.style}.
+ *
+ * @category Attributes
+ */
+export type BlockquoteAttrs = Omit<GlobalAttrs, 'aria'> & {
+    /**
+     * Citation URL for the source of the quote.
+     *
+     * @remarks
+     * This maps to the `cite` attribute. When present, it should be a valid URL.
+     * Consider also including a visible citation in the document content.
+     */
+    cite?: string;
+    /**
+     * Structured ARIA fields mapped into `aria-*` attributes.
+     */
+    aria?: StructuredAria;
+};
+/**
+ * Create a blockquote element with optional text content and attributes.
+ *
+ * @remarks
+ * - Text content is assigned via `textContent` (never `innerHTML`).
+ * - Global attributes are applied via pkgn-sol's shared DOM helper,
+ *   including security guards that block inline event handler attributes
+ *   (e.g. `onclick`) and raw `style` attribute strings.
+ *
+ * Note: `<blockquote>` typically contains flow content (e.g. paragraphs). This
+ * helper supports a simple `text` convenience for cases where plain text is
+ * sufficient; consumers can still append richer child nodes afterwards.
+ *
+ * @param text - Optional text content for the blockquote.
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<blockquote>` element.
+ *
+ * @example
+ * ```ts
+ * import { createBlockquote } from "@lnpg/pkgn-sol/elements/text/blockquote";
+ *
+ * const q = createBlockquote("To be, or not to be...", {
+ *   cite: "https://example.com/source",
+ *   className: "quote",
+ *   aria: { label: "Quotation" }
+ * });
+ *
+ * document.body.appendChild(q);
+ * ```
+ *
+ * @category DOM
+ */
+export declare function createBlockquote(text?: string, attrs?: BlockquoteAttrs): ElementOf<typeof BLOCKQUOTE_TAG>;
+/**
+ * Enhance blockquote elements within a given root.
+ *
+ * @remarks
+ * This is intentionally a no-op in `0.1.0`.
+ *
+ * Why does it exist?
+ * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)
+ * - It allows future progressive enhancements without changing consumer code
+ *
+ * What it will never do:
+ * - It will not inject styles (CSS remains the source of truth)
+ * - It will not introduce framework-specific behavior
+ *
+ * @param root - The node to search within. Defaults to `document`.
+ *
+ * @category Enhancement
+ */
+export declare function enhanceBlockquotes(root?: ParentNode): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/text/blockquote/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/elements/text/blockquote/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAElF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAG,YAAqB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IACxD;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAmCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,eAAe,GACtB,SAAS,CAAC,OAAO,cAAc,CAAC,CAElC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,UAAqB,GAAG,IAAI,CAGpE"}

package/dist/types/elements/text/hr/index.d.ts

@@ -0,0 +1,121 @@
+/**
+ * pkgn-sol Design Foundation: Hr element helpers.
+ *
+ * @remarks
+ * The hr element (`<hr>`) represents a thematic break between paragraph-level
+ * elements (e.g. a shift of topic or scene).
+ *
+ * Best-practice guidance:
+ * - Use `<hr>` for semantic separation of content, not for visual decoration.
+ * - Avoid obsolete presentational attributes (e.g. `align`, `size`, `width`, `noshade`);
+ *   use CSS instead.
+ * - Prefer native semantics. Only set `role` when you have a specific, justified reason.
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create thematic breaks in vanilla JS/TS without templates
+ * - apply consistent global attributes safely
+ * - use a stable "enhancement" hook if pkgn-sol ever needs runtime behavior
+ *
+ * MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/hr
+ *
+ * @module
+ * @category Elements
+ */
+import { type ElementOf, type GlobalAttrs } from '../../../ts/dom';
+/**
+ * Structured ARIA input supported by pkgn-sol element factories.
+ *
+ * @remarks
+ * This is intentionally a small, typed subset that covers common cases and
+ * prevents typo-based ARIA bugs (e.g. `lable`).
+ *
+ * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.
+ *
+ * @category Attributes
+ */
+export type StructuredAria = {
+    /**
+     * Accessible label, mapped to `aria-label`.
+     */
+    label?: string;
+    /**
+     * ID reference to the labelling element(s), mapped to `aria-labelledby`.
+     */
+    labelledby?: string;
+    /**
+     * Decorative/hidden hint, mapped to `aria-hidden`.
+     */
+    hidden?: boolean;
+};
+/**
+ * The semantic tag name for thematic breaks.
+ *
+ * @category Constants
+ */
+export declare const HR_TAG: "hr";
+/**
+ * A CSS selector targeting hr elements.
+ *
+ * @category Constants
+ */
+export declare const HR_SELECTOR = "hr";
+/**
+ * Attribute bag for hr creation/enhancement.
+ *
+ * @remarks
+ * Hr elements accept standard HTML global attributes.
+ *
+ * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is
+ * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.
+ *
+ * @category Attributes
+ */
+export type HrAttrs = Omit<GlobalAttrs, 'aria'> & {
+    /**
+     * Structured ARIA fields mapped into `aria-*` attributes.
+     */
+    aria?: StructuredAria;
+};
+/**
+ * Create an hr element with optional global attributes.
+ *
+ * @remarks
+ * - `<hr>` is a void element and must not carry text content.
+ * - Global attributes are applied via pkgn-sol's shared DOM helper,
+ *   including security guards that block inline event handler attributes
+ *   (e.g. `onclick`) and raw `style` attribute strings.
+ *
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<hr>` element.
+ *
+ * @example
+ * Create and append a thematic break:
+ * ```ts
+ * import { createHr } from "@lnpg/pkgn-sol/elements/text/hr";
+ *
+ * document.body.appendChild(createHr({ className: "divider" }));
+ * ```
+ *
+ * @category DOM
+ */
+export declare function createHr(attrs?: HrAttrs): ElementOf<typeof HR_TAG>;
+/**
+ * Enhance hr elements within a given root.
+ *
+ * @remarks
+ * This is intentionally a no-op in `0.1.0`.
+ *
+ * Why does it exist?
+ * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)
+ * - It allows future progressive enhancements without changing consumer code
+ *
+ * What it will never do:
+ * - It will not inject styles (CSS remains the source of truth)
+ * - It will not introduce framework-specific behavior
+ *
+ * @param root - The node to search within. Defaults to `document`.
+ *
+ * @category Enhancement
+ */
+export declare function enhanceHrs(root?: ParentNode): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/text/hr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/elements/text/hr/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAqB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEtF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAG,IAAa,CAAC;AAEpC;;;;GAIG;AACH,eAAO,MAAM,WAAW,OAAO,CAAC;AAEhC;;;;;;;;;;GAUG;AACH,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IAChD;;OAEG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AA6BF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC,OAAO,MAAM,CAAC,CAElE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,IAAI,GAAE,UAAqB,GAAG,IAAI,CAG5D"}

package/dist/types/elements/text/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Text element factories.
+ *
+ * Provides framework-agnostic factory functions for common text and
+ * text-adjacent grouping elements.
+ *
+ * These factories:
+ * - Create semantic HTML text elements using pkgn-sol's hardened DOM helpers.
+ * - Forward curated global attributes.
+ * - Enforce structured, typed attribute bags.
+ * - Apply sensible fallbacks where required by the HTML specification.
+ * - Prevent unsafe attribute injection.
+ *
+ * @module elements/text
+ * @since 0.1.0
+ */
+/**
+ * `<p>` element factory namespace.
+ *
+ * Represents a paragraph of text (phrasing content).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/p
+ */
+export * as paragraph from './paragraph';
+/**
+ * `<hr>` element factory namespace.
+ *
+ * Represents a thematic break between paragraph-level elements.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/hr
+ */
+export * as hr from './hr';
+/**
+ * `<pre>` element factory namespace.
+ *
+ * Represents preformatted text where whitespace is significant.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/pre
+ */
+export * as pre from './pre';
+/**
+ * `<blockquote>` element factory namespace.
+ *
+ * Represents a section quoted from another source (an extended quotation).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/blockquote
+ */
+export * as blockquote from './blockquote';
+/**
+ * `<address>` element factory namespace.
+ *
+ * Represents contact information for a person, people, or an organization.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/address
+ */
+export * as address from './address';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/elements/text/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;GAMG;AACH,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAE3B;;;;;;GAMG;AACH,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAE7B;;;;;;GAMG;AACH,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAE3C;;;;;;GAMG;AACH,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC"}

package/dist/types/elements/text/paragraph/index.d.ts

@@ -0,0 +1,139 @@
+/**
+ * pkgn-sol Design Foundation: Paragraph (`p`) element helpers.
+ *
+ * @remarks
+ * The paragraph element (`<p>`) represents a paragraph: a structural grouping of
+ * related phrasing content. It is a block-level element in HTML rendering
+ * contexts, but its meaning is semantic, not visual.
+ *
+ * Best-practice guidance:
+ * - Use `<p>` for paragraphs of text (phrasing content).
+ * - Do not use `<p>` as a generic layout container. Prefer semantic grouping
+ *   elements (e.g. `<section>`, `<article>`) or non-semantic `<div>` only when
+ *   semantics do not apply.
+ * - Avoid nesting block-level content inside `<p>`. In HTML parsing, a `<p>`
+ *   element will auto-close when certain elements are encountered.
+ * - Avoid obsolete attributes like `align`; use CSS instead.
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create paragraphs in vanilla JS/TS without templates
+ * - apply consistent global attributes safely
+ * - use a stable "enhancement" hook if pkgn-sol ever needs runtime behavior
+ *
+ * This module has no side effects and does not mutate the DOM unless you call
+ * its functions.
+ *
+ * References:
+ * - MDN: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/p
+ * - WHATWG: https://html.spec.whatwg.org/multipage/grouping-content.html#the-p-element
+ *
+ * @module
+ * @category Elements
+ */
+import { type ElementOf, type GlobalAttrs } from '../../../ts/dom';
+/**
+ * Structured ARIA input supported by pkgn-sol element factories.
+ *
+ * @remarks
+ * This is intentionally a small, typed subset that covers common cases and
+ * prevents typo-based ARIA bugs (e.g. `lable`).
+ *
+ * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.
+ *
+ * @category Attributes
+ */
+export type StructuredAria = {
+    /**
+     * Accessible label, mapped to `aria-label`.
+     *
+     * @remarks
+     * Prefer `labelledby` when a visible labeling element exists.
+     */
+    label?: string;
+    /**
+     * ID reference to the labelling element(s), mapped to `aria-labelledby`.
+     */
+    labelledby?: string;
+    /**
+     * Decorative/hidden hint, mapped to `aria-hidden`.
+     *
+     * @remarks
+     * Generally avoid hiding meaningful text from assistive technology.
+     */
+    hidden?: boolean;
+};
+/**
+ * The semantic tag name for paragraphs.
+ *
+ * @category Constants
+ */
+export declare const P_TAG: "p";
+/**
+ * A CSS selector targeting paragraph elements.
+ *
+ * @category Constants
+ */
+export declare const P_SELECTOR = "p";
+/**
+ * Attribute bag for paragraph creation/enhancement.
+ *
+ * @remarks
+ * Paragraph elements accept standard HTML global attributes.
+ *
+ * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is
+ * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.
+ *
+ * @category Attributes
+ */
+export type PAttrs = Omit<GlobalAttrs, 'aria'> & {
+    /**
+     * Structured ARIA fields mapped into `aria-*` attributes.
+     */
+    aria?: StructuredAria;
+};
+/**
+ * Create a paragraph element with optional text content and global attributes.
+ *
+ * @remarks
+ * - Text content is assigned via `textContent` (never `innerHTML`).
+ * - Global attributes are applied via pkgn-sol's shared DOM helper,
+ *   including security guards that block inline event handler attributes
+ *   (e.g. `onclick`) and raw `style` attribute strings.
+ *
+ * @param text - Optional text content for the paragraph.
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<p>` element.
+ *
+ * @example
+ * Create and append a paragraph:
+ * ```ts
+ * import { createP } from "@lnpg/pkgn-sol/elements/text/p";
+ *
+ * document.body.appendChild(
+ *   createP("Hello.", { className: "lead", id: "intro" })
+ * );
+ * ```
+ *
+ * @category DOM
+ */
+export declare function createP(text?: string, attrs?: PAttrs): ElementOf<typeof P_TAG>;
+/**
+ * Enhance paragraph elements within a given root.
+ *
+ * @remarks
+ * This is intentionally a no-op in `0.1.0`.
+ *
+ * Why does it exist?
+ * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)
+ * - It allows future progressive enhancements without changing consumer code
+ *
+ * What it will never do:
+ * - It will not inject styles (CSS remains the source of truth)
+ * - It will not introduce framework-specific behavior
+ *
+ * @param root - The node to search within. Defaults to `document`.
+ *
+ * @category Enhancement
+ */
+export declare function enhancePs(root?: ParentNode): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/text/paragraph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/elements/text/paragraph/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAElF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK,EAAG,GAAY,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IAC/C;;OAEG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AA6BF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,OAAO,KAAK,CAAC,CAE9E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,IAAI,GAAE,UAAqB,GAAG,IAAI,CAG3D"}

package/dist/types/elements/text/pre/index.d.ts

@@ -0,0 +1,135 @@
+/**
+ * pkgn-sol Design Foundation: Pre element helpers.
+ *
+ * @remarks
+ * The pre element (`<pre>`) represents preformatted text which is intended to be
+ * presented "as written", preserving whitespace and line breaks.
+ *
+ * Best-practice guidance:
+ * - Use `<pre>` for text where whitespace is meaningful (e.g. code blocks, ASCII art,
+ *   logs, configuration snippets). :contentReference[oaicite:3]{index=3}
+ * - For code examples, prefer `<pre><code>...</code></pre>` to provide clearer
+ *   semantics for assistive tech and tooling.
+ * - Avoid obsolete/non-standard attributes historically associated with `<pre>`
+ *   such as `width`, `cols`, or `wrap`; control layout with CSS instead
+ *   (e.g. `white-space: pre-wrap` or overflow rules). :contentReference[oaicite:4]{index=4}
+ *
+ * This module provides small, framework-agnostic helpers so consumers can:
+ * - create preformatted blocks in vanilla JS/TS without templates
+ * - apply consistent global attributes safely
+ * - use a stable "enhancement" hook if pkgn-sol ever needs runtime behavior
+ *
+ * This module has no side effects and does not mutate the DOM unless you call
+ * its functions.
+ *
+ * @module
+ * @category Elements
+ */
+import { type ElementOf, type GlobalAttrs } from '../../../ts/dom';
+/**
+ * Structured ARIA input supported by pkgn-sol element factories.
+ *
+ * @remarks
+ * This is intentionally a small, typed subset that covers common cases and
+ * prevents typo-based ARIA bugs (e.g. `lable`).
+ *
+ * It is mapped into {@link GlobalAttrs.aria} for application by `dom.ts`.
+ *
+ * @category Attributes
+ */
+export type StructuredAria = {
+    /**
+     * Accessible label, mapped to `aria-label`.
+     */
+    label?: string;
+    /**
+     * ID reference to the labelling element(s), mapped to `aria-labelledby`.
+     */
+    labelledby?: string;
+    /**
+     * Decorative/hidden hint, mapped to `aria-hidden`.
+     */
+    hidden?: boolean;
+};
+/**
+ * The semantic tag name for preformatted text blocks.
+ *
+ * @category Constants
+ */
+export declare const PRE_TAG: "pre";
+/**
+ * A CSS selector targeting pre elements.
+ *
+ * @category Constants
+ */
+export declare const PRE_SELECTOR = "pre";
+/**
+ * Attribute bag for pre creation/enhancement.
+ *
+ * @remarks
+ * The `<pre>` element uses standard HTML global attributes.
+ *
+ * pkgn-sol also supports a structured ARIA input for common ARIA fields, which is
+ * mapped into {@link GlobalAttrs.aria} without changing pkgn-sol's core DOM helpers.
+ *
+ * @category Attributes
+ */
+export type PreAttrs = Omit<GlobalAttrs, 'aria'> & {
+    /**
+     * Structured ARIA fields mapped into `aria-*` attributes.
+     */
+    aria?: StructuredAria;
+};
+/**
+ * Create a pre element with optional text content and global attributes.
+ *
+ * @remarks
+ * - Text content is assigned via `textContent` (never `innerHTML`).
+ * - Global attributes are applied via pkgn-sol's shared DOM helper,
+ *   including security guards that block inline event handler attributes
+ *   (e.g. `onclick`) and raw `style` attribute strings.
+ *
+ * Note:
+ * - `<pre>` preserves whitespace by default in browser rendering, but wrapping
+ *   behavior is typically controlled with CSS (e.g. `white-space: pre-wrap`). :contentReference[oaicite:5]{index=5}
+ *
+ * @param text - Optional text content for the pre element.
+ * @param attrs - Optional attributes to apply.
+ * @returns The created `<pre>` element.
+ *
+ * @example
+ * Create a code block:
+ * ```ts
+ * import { createPre } from "@lnpg/pkgn-sol/elements/text/pre";
+ *
+ * const pre = createPre("npm run build\nnpm run test", {
+ *   className: "code-block",
+ *   aria: { label: "Command output" }
+ * });
+ *
+ * document.body.appendChild(pre);
+ * ```
+ *
+ * @category DOM
+ */
+export declare function createPre(text?: string, attrs?: PreAttrs): ElementOf<typeof PRE_TAG>;
+/**
+ * Enhance pre elements within a given root.
+ *
+ * @remarks
+ * This is intentionally a no-op in `0.1.0`.
+ *
+ * Why does it exist?
+ * - It establishes a stable integration pattern for frameworks (Vue/React/etc.)
+ * - It allows future progressive enhancements without changing consumer code
+ *
+ * What it will never do:
+ * - It will not inject styles (CSS remains the source of truth)
+ * - It will not introduce framework-specific behavior
+ *
+ * @param root - The node to search within. Defaults to `document`.
+ *
+ * @category Enhancement
+ */
+export declare function enhancePres(root?: ParentNode): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/elements/text/pre/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/elements/text/pre/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAElF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAG,KAAc,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,YAAY,QAAQ,CAAC;AAElC;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG;IACjD;;OAEG;IACH,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AA6BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC,OAAO,OAAO,CAAC,CAEpF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,IAAI,GAAE,UAAqB,GAAG,IAAI,CAG7D"}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * as elements from './elements';
+export * as tailwind from './ts/adapters/tailwind/v4';
+export declare const solVersion = "0.1.0";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAC;AAEtD,eAAO,MAAM,UAAU,UAAU,CAAC"}

package/dist/types/ts/adapters/tailwind/v4/index.d.ts

@@ -0,0 +1,3 @@
+export { solTailwindPreset } from './preset';
+export { solTailwindPlugin } from './plugin';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ts/adapters/tailwind/v4/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/ts/adapters/tailwind/v4/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/ts/adapters/tailwind/v4/plugin.d.ts

@@ -0,0 +1,11 @@
+export type PluginApi = {
+    addUtilities: (utilities: Record<string, Record<string, string>>) => void;
+    theme: (path: string) => unknown;
+};
+/**
+ * Returns the pkgn-sol Tailwind plugin.
+ *
+ * Note: this is async so Tailwind can remain an optional peer dependency.
+ */
+export declare function solTailwindPlugin(): Promise<unknown>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/types/ts/adapters/tailwind/v4/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../../src/ts/adapters/tailwind/v4/plugin.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC;IAC1E,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAClC,CAAC;AA4BF;;;;GAIG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAU1D"}

package/dist/types/ts/adapters/tailwind/v4/preset.d.ts

@@ -0,0 +1,12 @@
+/**
+ * pkgn-sol Tailwind preset.
+ *
+ * This intentionally:
+ * - does NOT import Tailwind at runtime (so it can be used as a plain object)
+ * - maps pkgn-sol CSS variables to Tailwind theme tokens
+ */
+export type SolTailwindPreset = {
+    theme?: Record<string, unknown>;
+};
+export declare const solTailwindPreset: SolTailwindPreset;
+//# sourceMappingURL=preset.d.ts.map

package/dist/types/ts/adapters/tailwind/v4/preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset.d.ts","sourceRoot":"","sources":["../../../../../../src/ts/adapters/tailwind/v4/preset.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AA0DF,eAAO,MAAM,iBAAiB,EAAE,iBAM/B,CAAC"}