lucide-vesk 0.2.11

package/README.md

@@ -0,0 +1,120 @@
+# lucide-vesk
+
+Lucide icons for [Vesk](https://github.com/emeraldlinks/veskTs) — same props as `lucide-react`, fully typed, covers every Lucide icon, never scoped.
+
+- **Same props as `lucide-react`** — `size`, `color`, `strokeWidth`, `absoluteStrokeWidth`, `class` / `className`, `style`, `aria-*`, `title`, `ref`, plus any SVG attribute.
+- **Fully typed** — `LucideProps`, `IconNode`, `LucideIcon` exported from the same package; every icon is typed.
+- **Covers all icons** — 1594 primary icons plus 205 aliases = 1799 exported names (lucide v0.511.0).
+- **Never scoped** — no `<style>` tag, no Vesk scoped CSS, just an `<svg>` with Lucide defaults.
+
+## Install
+
+```bash
+npm install lucide-vesk
+```
+
+## Usage in Vesk (.vsk)
+
+```vsk
+import { House, Search, Circle } from 'lucide-vesk'
+import { createLucideIcon } from 'lucide-vesk'
+
+component Page {
+  <div>
+    <House size={32} color="red" />
+    <Circle size={16} color="blue" strokeWidth={1} />
+    <Search size={48} absoluteStrokeWidth strokeWidth={2} className="opacity-50" />
+  </div>
+}
+```
+
+Works in both **statement mode** (bare JSX) and **expression mode** (`return <House />`).
+
+```vsk
+// expression mode
+import { House } from 'lucide-vesk'
+export component PageExpr(props: { n: number }) {
+  return <div><House size={props.n} /></div>
+}
+```
+
+## Props parity with lucide-react
+
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `size` | `string \| number` | `24` | Width and height |
+| `color` | `string` | `"currentColor"` | Stroke color |
+| `strokeWidth` | `string \| number` | `2` | Stroke width |
+| `absoluteStrokeWidth` | `boolean` | `false` | Recalculate strokeWidth as `strokeWidth * 24 / size` |
+| `class` / `className` | `string` | `""` | Merged with `lucide` and `lucide-{name}` |
+| `style` | `string` | — | Inline style |
+| `title` | `string` | — | Rendered as `<title>` for a11y |
+| `aria-*`, `role` | — | — | If none present and no title/children, `aria-hidden="true"` is set |
+
+All other SVG attributes (`fill`, `stroke`, `onClick`, etc.) are forwarded. Event handlers (`on*`) are excluded from SSR HTML (Vesk convention) and wired via `addEventListener` on the client.
+
+```vsk
+import { House } from 'lucide-vesk'
+component Demo {
+  <House size={24} color="red" strokeWidth={1.5} absoluteStrokeWidth className="my-class" aria-label="home" onClick={() => console.log("clicked")} />
+}
+```
+
+## Generic Icon and Custom Icons
+
+```ts
+import { Icon, createLucideIcon } from 'lucide-vesk'
+import type { IconNode } from 'lucide-vesk'
+
+const MyIcon = createLucideIcon("my-icon", [["path", { d: "M0 0 L10 10" }]])
+MyIcon({ size: 20, color: "green" }) // -> SVG string (server) or SVGSVGElement (client)
+```
+
+`Icon` is the primitive used by every generated icon — you can also render any `IconNode` directly:
+
+```vsk
+import { Icon } from 'lucide-vesk'
+import { House } from 'lucide-vesk'
+component Demo {
+  // House.__iconNode is the raw IconNode
+  <Icon iconNode={House.__iconNode} size={24} />
+}
+```
+
+## Tree-shaking
+
+Import per-icon via the barrel (tree-shakable) or via subpath:
+
+```ts
+import { House } from 'lucide-vesk'
+import { House } from 'lucide-vesk/icons/House'
+```
+
+## Never Scoped
+
+lucide-vesk never emits `<style>` and never uses Vesk's scoped CSS. Icons are unstyled except for Lucide's `defaultAttributes` (`xmlns`, `viewBox`, `fill="none"`, `stroke="currentColor"`, `stroke-width`, `stroke-linecap`, `stroke-linejoin`). You can style them via `class`/`style` or global CSS.
+
+```ts
+import { House } from 'lucide-vesk'
+// no style tag is emitted — check dist files contain no "<style"
+```
+
+## Coverage
+
+- 1594 primary icons from `lucide@0.511.0`
+- 205 aliases (e.g. `AlarmCheck` for `AlarmClockCheck`, `ArrowDownAz` for `ArrowDownAZ`, `SortDesc` for `ArrowDownWideNarrow`)
+- Total 1799 exported names — run `npx tsx scripts/generate.ts` to regenerate from the installed `lucide` package.
+
+## Types
+
+```ts
+import type { LucideProps, IconNode, LucideIcon } from 'lucide-vesk'
+
+const props: LucideProps = { size: 24, color: "red", absoluteStrokeWidth: true }
+const node: IconNode = [["path", { d: "M0 0" }]]
+const Comp: LucideIcon = createLucideIcon("test", node)
+```
+
+## License
+
+ISC — same as [Lucide](https://github.com/lucide-icons/lucide).

package/dist/Icon.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Core Icon primitive — framework-agnostic SVG renderer for Vesk.
+ * Mirrors lucide-react's Icon.tsx but without React, without ForwardRef, and with Vesk SSR/CSR branching.
+ *
+ * Server (document === undefined): returns HTML string `<svg ...>...</svg>`
+ * Client (document exists): returns an SVGSVGElement (or null when hydration claims an existing node)
+ *   - normal: creates a fresh SVG via createElementNS
+ *   - hydrate: when a HydrateWalker is passed as 3rd arg, reuses the SSR-rendered <svg>
+ *
+ * Never scoped — no style tag, no scoped attribute, just an svg with Lucide defaults.
+ */
+import type { IconNode, LucideProps } from "./types.js";
+type HydrateWalker = {
+    root: Element | null;
+    nextElement(tag?: string): Element;
+    subWalker(el: Element): HydrateWalker;
+} | null | undefined;
+export declare function Icon(props: LucideProps & {
+    iconNode: IconNode;
+}, _registry?: Map<string, unknown>, walker?: HydrateWalker): string | Element | null;
+export default Icon;
+//# sourceMappingURL=Icon.d.ts.map

package/dist/Icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Icon.d.ts","sourceRoot":"","sources":["../src/Icon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAExD,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IACrB,WAAW,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,aAAa,CAAC;CACvC,GAAG,IAAI,GAAG,SAAS,CAAC;AA4GrB,wBAAgB,IAAI,CAClB,KAAK,EAAE,WAAW,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAA;CAAE,EAC3C,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,MAAM,CAAC,EAAE,aAAa,GACrB,MAAM,GAAG,OAAO,GAAG,IAAI,CA0MzB;AAED,eAAe,IAAI,CAAC"}

package/dist/Icon.js

@@ -0,0 +1,328 @@
+/**
+ * Core Icon primitive — framework-agnostic SVG renderer for Vesk.
+ * Mirrors lucide-react's Icon.tsx but without React, without ForwardRef, and with Vesk SSR/CSR branching.
+ *
+ * Server (document === undefined): returns HTML string `<svg ...>...</svg>`
+ * Client (document exists): returns an SVGSVGElement (or null when hydration claims an existing node)
+ *   - normal: creates a fresh SVG via createElementNS
+ *   - hydrate: when a HydrateWalker is passed as 3rd arg, reuses the SSR-rendered <svg>
+ *
+ * Never scoped — no style tag, no scoped attribute, just an svg with Lucide defaults.
+ */
+import { defaultAttributes } from "./defaultAttributes.js";
+import { hasA11yProp, mergeClasses } from "./utils.js";
+function escapeAttr(s) {
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === "&")
+            out += "&amp;";
+        else if (ch === '"')
+            out += "&quot;";
+        else if (ch === "<")
+            out += "&lt;";
+        else if (ch === ">")
+            out += "&gt;";
+        else
+            out += ch;
+    }
+    return out;
+}
+function buildSvgString(iconNode, svgAttrs, title, children) {
+    let html = "<svg";
+    for (const [k, v] of Object.entries(svgAttrs)) {
+        if (v == null || v === false)
+            continue;
+        html += ` ${k}="${escapeAttr(String(v))}"`;
+    }
+    html += ">";
+    if (title)
+        html += `<title>${escapeAttr(title)}</title>`;
+    for (const [tag, attrs] of iconNode) {
+        html += `<${tag}`;
+        for (const [ak, av] of Object.entries(attrs)) {
+            if (ak === "key")
+                continue;
+            html += ` ${ak}="${escapeAttr(String(av))}"`;
+        }
+        html += "/>";
+    }
+    if (children != null) {
+        const arr = Array.isArray(children) ? children : [children];
+        for (const c of arr) {
+            if (c == null || typeof c === "boolean")
+                continue;
+            if (typeof c === "string" || typeof c === "number")
+                html += escapeAttr(String(c));
+            // If children is an Element (client hydrated fragment) we serialise its outerHTML fallback
+            else if (typeof c.outerHTML === "string")
+                html += c.outerHTML;
+            else
+                html += escapeAttr(String(c));
+        }
+    }
+    html += "</svg>";
+    return html;
+}
+function setSvgAttrs(svg, attrs) {
+    for (const [k, v] of Object.entries(attrs)) {
+        if (v == null || v === false)
+            continue;
+        if (v === true)
+            svg.setAttribute(k, "");
+        else
+            svg.setAttribute(k, String(v));
+    }
+}
+function syncIconNode(svg, iconNode) {
+    // For hydrate reuse, we assume SSR node matches iconNode; to be safe we only reconcile if child count differs.
+    // IconNode is append-only static, so we can diff cheaply: remove all existing icon children then re-append.
+    // But to avoid touching custom children, we only replace the iconNode portion.
+    // Simpler: if child count === iconNode.length (+ title), assume it's already correct and return.
+    // Otherwise rebuild.
+    const expected = iconNode.length;
+    // Count non-title, non-custom children: we can't distinguish custom children, so rebuild when mismatch and no custom children detected.
+    // We'll do minimal: if counts differ, clear and rebuild iconNode.
+    // This handles alias swaps where iconNode changes.
+    const currentIconChildren = Array.from(svg.children).filter((el) => el.tagName.toLowerCase() !== "title");
+    if (currentIconChildren.length === expected) {
+        // verify attrs match? Assume ok for perf.
+        return;
+    }
+    // remove existing icon-node children (keep title if present)
+    for (const ch of Array.from(svg.children)) {
+        if (ch.tagName.toLowerCase() === "title")
+            continue;
+        // If it's a custom child inserted by user, we don't have a marker; we preserve if we detect more than expected?
+        // For now remove all non-title and re-append iconNode + preserve custom children appended after?
+        ch.remove();
+    }
+    for (const [tag, attrs] of iconNode) {
+        const el = document.createElementNS("http://www.w3.org/2000/svg", tag);
+        for (const [ak, av] of Object.entries(attrs)) {
+            if (ak === "key")
+                continue;
+            el.setAttribute(ak, String(av));
+        }
+        svg.appendChild(el);
+    }
+}
+function appendChildren(svg, children) {
+    if (children == null)
+        return;
+    const arr = Array.isArray(children) ? children : [children];
+    for (const c of arr) {
+        if (c == null || typeof c === "boolean")
+            continue;
+        if (typeof c === "string" || typeof c === "number") {
+            svg.appendChild(document.createTextNode(String(c)));
+        }
+        else if (c instanceof Node) {
+            svg.appendChild(c);
+        }
+        else if (typeof c.outerHTML === "string") {
+            // fallback for stringified
+            const tmp = document.createElement("div");
+            tmp.innerHTML = String(c);
+            while (tmp.firstChild)
+                svg.appendChild(tmp.firstChild);
+        }
+    }
+}
+export function Icon(props, _registry, walker) {
+    const { iconNode, color = "currentColor", size = 24, strokeWidth = 2, absoluteStrokeWidth, className = "", class: cls, style, children, title, ref, ...rest } = props;
+    // Remove internal keys from rest that shouldn't be forwarded as SVG attrs
+    // (iconNode already destructured, but rest may contain iconNode? no)
+    const classes = mergeClasses("lucide", className, cls, rest.class, rest.className);
+    // Build the SVG attrs — defaultAttributes first, then size/stroke overrides, then rest
+    // Note: defaultAttributes has 'stroke-width' kebab, we normalize to kebab for SSR and setAttribute
+    let calcStrokeWidth = strokeWidth;
+    if (absoluteStrokeWidth) {
+        const nSize = Number(size);
+        const nStroke = Number(strokeWidth);
+        if (!Number.isNaN(nSize) && nSize !== 0 && !Number.isNaN(nStroke)) {
+            calcStrokeWidth = (nStroke * 24) / nSize;
+        }
+    }
+    const svgAttrs = {};
+    // default attrs
+    for (const [k, v] of Object.entries(defaultAttributes)) {
+        svgAttrs[k] = String(v);
+    }
+    // overrides
+    svgAttrs.width = String(size);
+    svgAttrs.height = String(size);
+    svgAttrs.stroke = String(color);
+    svgAttrs["stroke-width"] = String(calcStrokeWidth);
+    // class: merge lucide + user classes, and strip class/className from rest later
+    const mergedClass = mergeClasses("lucide", className, cls);
+    if (mergedClass)
+        svgAttrs.class = mergedClass;
+    else
+        delete svgAttrs.class;
+    if (style != null)
+        svgAttrs.style = String(style);
+    // a11y: if no title/children/aria prop, set aria-hidden true
+    const hasA11y = hasA11yProp(rest) || !!title || !!children;
+    if (!hasA11y)
+        svgAttrs["aria-hidden"] = "true";
+    // forward rest attrs (excluding class/className/style already handled, and internal keys)
+    const skipKeys = new Set(["class", "className", "style", "color", "size", "strokeWidth", "absoluteStrokeWidth", "iconNode", "children", "title", "ref"]);
+    for (const [k, v] of Object.entries(rest)) {
+        if (skipKeys.has(k))
+            continue;
+        if (v == null || v === false)
+            continue;
+        // Event handlers (on*) are excluded from SSR HTML — Vesk's server-utils strips them, and client adds via addEventListener
+        // But for generic icon, we forward them as attributes for client setAttribute? They will be set as attributes, not listeners.
+        // Vesk's client code handles on* via addEventListener, but for icons imported as JS, props spread includes on* that should be wired as listeners, not attrs.
+        // We'll still set them as attributes for now; the compiler's event handling for icons will handle on* via the component's own logic if needed.
+        // To keep parity with lucide-react (which spreads rest onto <svg>), we set them.
+        if (typeof v === "function" && k.startsWith("on")) {
+            // store for later addEventListener
+            continue;
+        }
+        if (v === true)
+            svgAttrs[k] = "";
+        else
+            svgAttrs[k] = String(v);
+    }
+    const isServer = typeof document === "undefined";
+    if (isServer) {
+        return buildSvgString(iconNode, svgAttrs, title, children);
+    }
+    // Client — try hydrate path if walker is provided
+    const anyWalker = walker;
+    let svg = null;
+    let walkerClaimed = false;
+    if (anyWalker) {
+        // Case A: walker.root is already the wrapper div or the svg itself.
+        // The server wrapper (when hydrate) is <!--vsk--><div><svg>...</svg></div>
+        // In that case walker.root should be the div, and we want to reuse its inner svg.
+        // Case B: server without wrapper (<!--vsk--><svg>) — nextElement('svg') returns svg directly.
+        // We try both.
+        try {
+            const root = anyWalker.root;
+            if (root) {
+                const tag = root.tagName.toLowerCase();
+                if (tag === "svg") {
+                    svg = root;
+                    walkerClaimed = true;
+                }
+                else if (tag === "div") {
+                    // wrapper div case — find inner svg
+                    const inner = root.querySelector(":scope > svg") || root.querySelector("svg");
+                    if (inner && inner.tagName.toLowerCase() === "svg") {
+                        svg = inner;
+                        walkerClaimed = true;
+                    }
+                    else {
+                        // create svg inside wrapper
+                        svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+                        root.appendChild(svg);
+                        walkerClaimed = true;
+                    }
+                }
+            }
+            if (!walkerClaimed && typeof anyWalker.nextElement === "function") {
+                const maybe = anyWalker.nextElement("svg");
+                if (maybe && maybe.tagName.toLowerCase() === "svg") {
+                    svg = maybe;
+                    walkerClaimed = true;
+                }
+            }
+        }
+        catch {
+            svg = null;
+            walkerClaimed = false;
+        }
+    }
+    if (walkerClaimed && svg) {
+        // Reuse claimed SVG — sync attrs and iconNode if needed
+        // Clear old attrs that may be stale? Just set new ones.
+        // Remove stale attrs first? We overwrite.
+        setSvgAttrs(svg, svgAttrs);
+        // Ensure title
+        const existingTitle = svg.querySelector(":scope > title");
+        if (title) {
+            if (existingTitle)
+                existingTitle.textContent = String(title);
+            else {
+                const tEl = document.createElementNS("http://www.w3.org/2000/svg", "title");
+                tEl.textContent = String(title);
+                svg.insertBefore(tEl, svg.firstChild);
+            }
+        }
+        else if (existingTitle) {
+            existingTitle.remove();
+        }
+        syncIconNode(svg, iconNode);
+        // Re-append children if provided (custom children)
+        if (children != null) {
+            // For hydrate, children are fragment; we should ensure they are appended after iconNode
+            // Simple: if svg already had custom children appended, we may duplicate; so we only append if not already.
+            // We'll clear non-iconNode children beyond iconNode count? For now just append if no custom children yet.
+            const hasCustom = svg.children.length > iconNode.length + (title ? 1 : 0);
+            if (!hasCustom)
+                appendChildren(svg, children);
+        }
+        // wire events from rest (on*)
+        for (const [k, v] of Object.entries(rest)) {
+            if (typeof v === "function" && k.startsWith("on") && k.length > 2) {
+                const event = k.slice(2).toLowerCase();
+                svg.addEventListener(event, v);
+            }
+        }
+        if (typeof ref === "function") {
+            try {
+                ref(svg);
+            }
+            catch { }
+        }
+        else if (ref && typeof ref.current !== "undefined") {
+            ref.current = svg;
+        }
+        // If walkerClaimed via wrapper div, return the wrapper div so parent doesn't duplicate
+        const root = anyWalker?.root;
+        if (root && root.tagName.toLowerCase() === "div" && svg.parentElement === root) {
+            return root;
+        }
+        return svg;
+    }
+    // Normal client creation — fresh SVG
+    const fresh = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    setSvgAttrs(fresh, svgAttrs);
+    if (title) {
+        const tEl = document.createElementNS("http://www.w3.org/2000/svg", "title");
+        tEl.textContent = String(title);
+        fresh.appendChild(tEl);
+    }
+    for (const [tag, attrs] of iconNode) {
+        const el = document.createElementNS("http://www.w3.org/2000/svg", tag);
+        for (const [ak, av] of Object.entries(attrs)) {
+            if (ak === "key")
+                continue;
+            el.setAttribute(ak, String(av));
+        }
+        fresh.appendChild(el);
+    }
+    appendChildren(fresh, children);
+    // wire events
+    for (const [k, v] of Object.entries(rest)) {
+        if (typeof v === "function" && k.startsWith("on") && k.length > 2) {
+            const event = k.slice(2).toLowerCase();
+            fresh.addEventListener(event, v);
+        }
+    }
+    if (typeof ref === "function") {
+        try {
+            ref(fresh);
+        }
+        catch { }
+    }
+    else if (ref && typeof ref.current !== "undefined") {
+        ref.current = fresh;
+    }
+    return fresh;
+}
+export default Icon;

package/dist/createLucideIcon.d.ts

@@ -0,0 +1,9 @@
+/**
+ * createLucideIcon — mirrors lucide-react's createLucideIcon but for Vesk.
+ * Returns a Vesk-compatible icon component with the same props and class handling.
+ * Never scoped — no style tag.
+ */
+import type { IconNode, LucideIcon } from "./types.js";
+export declare function createLucideIcon(iconName: string, iconNode: IconNode): LucideIcon;
+export default createLucideIcon;
+//# sourceMappingURL=createLucideIcon.d.ts.map

package/dist/createLucideIcon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLucideIcon.d.ts","sourceRoot":"","sources":["../src/createLucideIcon.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAe,MAAM,YAAY,CAAC;AAEpE,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,UAAU,CAqBjF;AAED,eAAe,gBAAgB,CAAC"}

package/dist/createLucideIcon.js

@@ -0,0 +1,25 @@
+/**
+ * createLucideIcon — mirrors lucide-react's createLucideIcon but for Vesk.
+ * Returns a Vesk-compatible icon component with the same props and class handling.
+ * Never scoped — no style tag.
+ */
+import Icon from "./Icon.js";
+import { toKebabCase, toPascalCase, mergeClasses } from "./utils.js";
+export function createLucideIcon(iconName, iconNode) {
+    const Component = ((props = {}, _registry, walker) => {
+        const { className, class: cls, ...rest } = props;
+        const kebab = toKebabCase(iconName);
+        // lucide-react merges `lucide-${kebab}` and `lucide-${iconName}` (original name is already kebab, but keep parity)
+        const nameClasses = mergeClasses(`lucide-${kebab}`, `lucide-${iconName}`);
+        const merged = mergeClasses(nameClasses, className, cls);
+        return Icon({
+            ...rest,
+            className: merged,
+            iconNode,
+        }, _registry, walker);
+    });
+    Component.displayName = toPascalCase(iconName);
+    Component.__iconNode = iconNode;
+    return Component;
+}
+export default createLucideIcon;

package/dist/defaultAttributes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Default SVG attributes for every Lucide icon.
+ * Mirrors lucide-react's defaultAttributes — never scoped, framework agnostic.
+ */
+export declare const defaultAttributes: {
+    readonly xmlns: "http://www.w3.org/2000/svg";
+    readonly width: 24;
+    readonly height: 24;
+    readonly viewBox: "0 0 24 24";
+    readonly fill: "none";
+    readonly stroke: "currentColor";
+    readonly "stroke-width": 2;
+    readonly "stroke-linecap": "round";
+    readonly "stroke-linejoin": "round";
+};
+export type DefaultAttributes = typeof defaultAttributes;
+//# sourceMappingURL=defaultAttributes.d.ts.map

package/dist/defaultAttributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultAttributes.d.ts","sourceRoot":"","sources":["../src/defaultAttributes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;CAUpB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC"}

package/dist/defaultAttributes.js

@@ -0,0 +1,15 @@
+/**
+ * Default SVG attributes for every Lucide icon.
+ * Mirrors lucide-react's defaultAttributes — never scoped, framework agnostic.
+ */
+export const defaultAttributes = {
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 24,
+    height: 24,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": 2,
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+};

package/dist/icons/AArrowDown.d.ts

@@ -0,0 +1,6 @@
+import type { IconNode } from "../types.js";
+export declare const __iconNode: IconNode;
+declare const AArrowDown: import("../types.js").LucideIcon;
+export default AArrowDown;
+export { AArrowDown };
+//# sourceMappingURL=AArrowDown.d.ts.map

package/dist/icons/AArrowDown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AArrowDown.d.ts","sourceRoot":"","sources":["../../src/icons/AArrowDown.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,eAAO,MAAM,UAAU,EAAE,QAyBD,CAAC;AAEzB,QAAA,MAAM,UAAU,kCAA+C,CAAC;AAEhE,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/icons/AArrowDown.js

@@ -0,0 +1,37 @@
+/**
+ * @license lucide-vesk v0.511.0 - ISC
+ * @name a-arrow-down
+ * @see https://lucide.dev/icons/a-arrow-down
+ * Auto-generated — do not edit. Generated from lucide@a-arrow-down.
+ * Never scoped — no style tag.
+ */
+import createLucideIcon from "../createLucideIcon.js";
+export const __iconNode = [
+    [
+        "path",
+        {
+            "d": "M3.5 13h6"
+        }
+    ],
+    [
+        "path",
+        {
+            "d": "m2 16 4.5-9 4.5 9"
+        }
+    ],
+    [
+        "path",
+        {
+            "d": "M18 7v9"
+        }
+    ],
+    [
+        "path",
+        {
+            "d": "m14 12 4 4 4-4"
+        }
+    ]
+];
+const AArrowDown = createLucideIcon("a-arrow-down", __iconNode);
+export default AArrowDown;
+export { AArrowDown };

package/dist/icons/AArrowUp.d.ts

@@ -0,0 +1,6 @@
+import type { IconNode } from "../types.js";
+export declare const __iconNode: IconNode;
+declare const AArrowUp: import("../types.js").LucideIcon;
+export default AArrowUp;
+export { AArrowUp };
+//# sourceMappingURL=AArrowUp.d.ts.map

package/dist/icons/AArrowUp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AArrowUp.d.ts","sourceRoot":"","sources":["../../src/icons/AArrowUp.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,eAAO,MAAM,UAAU,EAAE,QAyBD,CAAC;AAEzB,QAAA,MAAM,QAAQ,kCAA6C,CAAC;AAE5D,eAAe,QAAQ,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/dist/icons/AArrowUp.js

@@ -0,0 +1,37 @@
+/**
+ * @license lucide-vesk v0.511.0 - ISC
+ * @name a-arrow-up
+ * @see https://lucide.dev/icons/a-arrow-up
+ * Auto-generated — do not edit. Generated from lucide@a-arrow-up.
+ * Never scoped — no style tag.
+ */
+import createLucideIcon from "../createLucideIcon.js";
+export const __iconNode = [
+    [
+        "path",
+        {
+            "d": "M3.5 13h6"
+        }
+    ],
+    [
+        "path",
+        {
+            "d": "m2 16 4.5-9 4.5 9"
+        }
+    ],
+    [
+        "path",
+        {
+            "d": "M18 16V7"
+        }
+    ],
+    [
+        "path",
+        {
+            "d": "m14 11 4-4 4 4"
+        }
+    ]
+];
+const AArrowUp = createLucideIcon("a-arrow-up", __iconNode);
+export default AArrowUp;
+export { AArrowUp };

package/dist/icons/ALargeSmall.d.ts

@@ -0,0 +1,6 @@
+import type { IconNode } from "../types.js";
+export declare const __iconNode: IconNode;
+declare const ALargeSmall: import("../types.js").LucideIcon;
+export default ALargeSmall;
+export { ALargeSmall };
+//# sourceMappingURL=ALargeSmall.d.ts.map

package/dist/icons/ALargeSmall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALargeSmall.d.ts","sourceRoot":"","sources":["../../src/icons/ALargeSmall.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,eAAO,MAAM,UAAU,EAAE,QAyBD,CAAC;AAEzB,QAAA,MAAM,WAAW,kCAAgD,CAAC;AAElE,eAAe,WAAW,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,CAAC"}