/**
* @license lucide-solid v1.48.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/

// src/Icon.tsx
import { createMemo, For, splitProps, useContext } from "solid-js";
import { Dynamic } from "solid-js/web";

// ../shared/src/build/defaultAttributes.ts
var 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"
};
var defaultAttributes_default = defaultAttributes;

// ../shared/src/utils/mergeClasses.ts
var mergeClasses = (...classes) => classes.filter((className, index, array) => {
  return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
}).join(" ").trim();

// ../shared/src/build/buildLucideIconNode.ts
function isDefined(value) {
  return value !== null && value !== void 0;
}
function buildLucideIconNode(icon, params = {}) {
  const attributeNames = params.attributeNames ?? {};
  const getAttributeName = (attributeName) => attributeNames[attributeName] ?? attributeName;
  const viewBoxWidth = icon.size ?? icon.width ?? defaultAttributes_default["width"];
  const viewBoxHeight = icon.size ?? icon.height ?? defaultAttributes_default["height"];
  const aliasClassNames = icon.aliases?.filter((alias) => typeof alias === "string" && alias.trim() !== "").map((alias) => `lucide-${alias}`) ?? [];
  const iconClassNames = [...icon.name ? [`lucide-${icon.name}`] : [], ...aliasClassNames];
  const classNamesFromClassName = params.className?.split(" ").filter(Boolean) ?? [];
  const className = params.includeDefaultClasses === false ? mergeClasses(...classNamesFromClassName) : mergeClasses("lucide", ...iconClassNames, ...classNamesFromClassName);
  const calculatedStrokeWidth = params.absoluteStrokeWidth ? Number(params.strokeWidth ?? defaultAttributes_default["stroke-width"]) * Number(icon.size ?? icon.width ?? defaultAttributes_default["width"]) / Number(params.size ?? params.width ?? defaultAttributes_default["width"]) : params.strokeWidth ?? defaultAttributes_default["stroke-width"];
  const attributes = {
    ...Object.entries(defaultAttributes_default).reduce((attrs, [attrName, value]) => {
      attrs[getAttributeName(attrName)] = value;
      return attrs;
    }, {}),
    ..."color" in params && params.color && {
      [getAttributeName("stroke")]: params.color
    },
    ..."size" in params && isDefined(params.size) && {
      [getAttributeName("width")]: params.size,
      [getAttributeName("height")]: params.size
    },
    ..."width" in params && isDefined(params.width) && {
      [getAttributeName("width")]: params.width
    },
    ..."height" in params && isDefined(params.height) && {
      [getAttributeName("height")]: params.height
    },
    [getAttributeName("stroke-width")]: calculatedStrokeWidth,
    ...className && {
      [getAttributeName("class")]: className
    },
    [getAttributeName("viewBox")]: `0 0 ${viewBoxWidth} ${viewBoxHeight}`,
    ...params.hasA11yProp === false ? {
      [getAttributeName("aria-hidden")]: "true"
    } : {},
    ..."attributes" in params && params.attributes
  };
  return [
    "svg",
    attributes,
    icon.node.map((child) => {
      const [name, attrs, children] = child;
      const nextAttrs = params.nonScalingStroke ? { [getAttributeName("vector-effect")]: "non-scaling-stroke", ...attrs } : attrs;
      return children ? [name, nextAttrs, children] : [name, nextAttrs];
    })
  ];
}
var buildLucideIconNode_default = buildLucideIconNode;

// ../shared/src/utils/hasA11yProp.ts
var hasA11yProp = (props) => {
  for (const prop in props) {
    if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
      return true;
    }
  }
  return false;
};

// src/Icon.tsx
import { LucideContext } from "./context";
var Icon = (props) => {
  const [localProps, rest] = splitProps(props, [
    "color",
    "size",
    "width",
    "height",
    "strokeWidth",
    "children",
    "class",
    "icon",
    "iconNode",
    "absoluteStrokeWidth",
    "nonScalingStroke"
  ]);
  const globalProps = useContext(LucideContext);
  const icon = createMemo(
    () => localProps.icon ?? {
      node: localProps.iconNode ?? [],
      size: 24,
      aliases: []
    }
  );
  const builtIcon = createMemo(
    () => buildLucideIconNode_default(icon(), {
      color: localProps.color ?? globalProps.color,
      width: localProps.width ?? localProps.size ?? globalProps.size,
      height: localProps.height ?? localProps.size ?? globalProps.size,
      strokeWidth: localProps.strokeWidth ?? globalProps.strokeWidth,
      absoluteStrokeWidth: localProps.absoluteStrokeWidth ?? globalProps.absoluteStrokeWidth,
      nonScalingStroke: localProps.nonScalingStroke ?? globalProps.nonScalingStroke,
      className: mergeClasses("lucide-icon", globalProps.class, localProps.class),
      hasA11yProp: Boolean(localProps.children) || hasA11yProp(rest),
      attributes: rest
    })
  );
  return <svg {...builtIcon()[1]}>
      <For each={builtIcon()[2] ?? []}>
        {([elementName, attrs]) => {
    return <Dynamic
      component={elementName}
      {...attrs}
    />;
  }}
      </For>
    </svg>;
};
var Icon_default = Icon;
export {
  Icon_default as default
};
//# sourceMappingURL=Icon.jsx.map