From 093383a73abac733f6fbff13face21c97d1a52c9 Mon Sep 17 00:00:00 2001 From: Max Veytsman Date: Wed, 31 Aug 2022 16:41:05 -0400 Subject: [PATCH] Pregenerate the icons with a mix task --- lib/heroicons.ex | 67 - lib/heroicons/generator.ex | 91 - lib/heroicons/mini.ex | 11871 +++++++++++++++ lib/heroicons/outline.ex | 11716 +++++++++++++++ lib/heroicons/solid.ex | 11874 ++++++++++++++++ lib/mix/heroicons/generator_helpers.ex | 19 + lib/{ => mix}/heroicons/svg_processor.ex | 6 +- .../heroicons/svg_processor/handler.ex | 57 +- lib/mix/tasks/heroicons/generate.ex | 85 + mix.exs | 2 +- priv/templates/icon_set.ex | 58 + test/heroicons_test.exs | 32 +- 12 files changed, 35681 insertions(+), 197 deletions(-) delete mode 100644 lib/heroicons/generator.ex create mode 100644 lib/heroicons/mini.ex create mode 100644 lib/heroicons/outline.ex create mode 100644 lib/heroicons/solid.ex create mode 100644 lib/mix/heroicons/generator_helpers.ex rename lib/{ => mix}/heroicons/svg_processor.ex (77%) rename lib/{ => mix}/heroicons/svg_processor/handler.ex (57%) create mode 100644 lib/mix/tasks/heroicons/generate.ex create mode 100644 priv/templates/icon_set.ex diff --git a/lib/heroicons.ex b/lib/heroicons.ex index 9087ae6..d766cba 100644 --- a/lib/heroicons.ex +++ b/lib/heroicons.ex @@ -16,71 +16,4 @@ defmodule Heroicons do Heroicons are designed by [Steve Schoger](https://twitter.com/steveschoger) """ - - defmodule Outline do - @moduledoc """ - Outline style icons drawn with a stroke, packaged as Phoenix Components. - - For primary navigation and marketing sections, with an outlined appearance, - designed to be rendered at 24x24. - """ - - use Heroicons.Generator, - icon_dir: "outline/", - # Following https://github.com/tailwindlabs/heroicons/blob/b933d51df1f27c35414389fea185e9bac0097481/svgo.24.outline.yaml - svg_opts: [ - remove_dimensions: true, - sort_attributes: true, - remove_attributes: ["stroke", "path:stroke-width"], - add_attributes: [ - {"stroke-widt", "1.5"}, - {"stroke", "currentColor"}, - {"aria-hidden", "true"} - ] - ] - end - - defmodule Solid do - @moduledoc """ - Solid style icons drawn with fills, packaged as Phoenix Components. - - For primary navigation and marketing sections, with a filled appearance, - designed to be rendered at 24x24. - """ - - use Heroicons.Generator, - icon_dir: "solid/", - # Following https://github.com/tailwindlabs/heroicons/blob/b933d51df1f27c35414389fea185e9bac0097481/svgo.24.solid.yaml - svg_opts: [ - remove_dimensions: true, - sort_attributes: true, - remove_attributes: ["fill"], - add_attributes: [ - {"fill", "currentColor"}, - {"aria-hidden", "true"} - ] - ] - end - - defmodule Mini do - @moduledoc """ - Solid style icons drawn with fills, packaged as Phoenix Components. - - For smaller elements like buttons, form elements, and to support text, - designed to be rendered at 20x20. - """ - - use Heroicons.Generator, - icon_dir: "mini/", - # Following https://github.com/tailwindlabs/heroicons/blob/b933d51df1f27c35414389fea185e9bac0097481/svgo.20.solid.yaml - svg_opts: [ - remove_dimensions: true, - sort_attributes: true, - remove_attributes: ["fill"], - add_attributes: [ - {"fill", "currentColor"}, - {"aria-hidden", "true"} - ] - ] - end end diff --git a/lib/heroicons/generator.ex b/lib/heroicons/generator.ex deleted file mode 100644 index 4ab5dec..0000000 --- a/lib/heroicons/generator.ex +++ /dev/null @@ -1,91 +0,0 @@ -defmodule Heroicons.Generator do - alias Heroicons.SvgProcessor - - defmacro __using__(icon_dir: icon_dir, svg_opts: svg_opts) do - icon_paths = - Path.absname(icon_dir, :code.priv_dir(:heroicons)) - |> Path.join("*.svg") - |> Path.wildcard() - - require Phoenix.Component - - if function_exported?(Phoenix.Component, :assigns_to_attributes, 2) do - Module.put_attribute(__CALLER__.module, :assign_mod, Phoenix.Component) - Module.put_attribute(__CALLER__.module, :assigns_to_attrs_mod, Phoenix.Component) - else - Module.put_attribute(__CALLER__.module, :assign_mod, Phoenix.LiveView) - Module.put_attribute(__CALLER__.module, :assigns_to_attrs_mod, Phoenix.LiveView.Helpers) - end - - for path <- icon_paths do - generate(path, svg_opts) - end - end - - @doc false - def generate(path, svg_opts) do - name = - Path.basename(path, ".svg") - |> String.replace("-", "_") - |> String.to_atom() - - icon = - File.read!(path) - |> SvgProcessor.process(svg_opts) - - <<"> = icon - head = " - - <.#{name} class="h-6 w-6 text-gray-500" /> - - or as a function - - <%= #{name}() %> - - <%= #{name}(class: "h-6 w-6 text-gray-500") %> - """ - - quote do - @doc unquote(doc) - def unquote(name)(assigns_or_opts \\ []) - - def unquote(name)(var!(assigns)) when is_map(var!(assigns)) do - var!(attrs) = @assigns_to_attrs_mod.assigns_to_attributes(var!(assigns)) - var!(assigns) = @assign_mod.assign(var!(assigns), :attrs, var!(attrs)) - - unquote( - EEx.compile_string(head <> "{@attrs}" <> body, - engine: Phoenix.LiveView.HTMLEngine, - file: __ENV__.file, - line: __ENV__.line + 1, - module: __ENV__.module, - indentation: 0 - ) - ) - end - - def unquote(name)(opts) when is_list(opts) do - attrs = - for {k, v} <- opts do - safe_k = - k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() - - safe_v = v |> Phoenix.HTML.Safe.to_iodata() - - {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} - end - - {:safe, [unquote(head), Phoenix.HTML.Safe.to_iodata(attrs), unquote(body)]} - end - end - end -end diff --git a/lib/heroicons/mini.ex b/lib/heroicons/mini.ex new file mode 100644 index 0000000..59d8705 --- /dev/null +++ b/lib/heroicons/mini.ex @@ -0,0 +1,11871 @@ +defmodule Heroicons.Mini do + @moduledoc """ + Solid style icons drawn with fills, packaged as Phoenix Components. + + For smaller elements like buttons, form elements, and to support text, + designed to be rendered at 20x20. + """ + + use Phoenix.Component + + if function_exported?(Phoenix.Component, :assigns_to_attributes, 2) do + @assign_mod Phoenix.Component + @assigns_to_attrs_mod Phoenix.Component + else + @assign_mod Phoenix.LiveView + @assigns_to_attrs_mod Phoenix.LiveView.Helpers + end + + @doc """ + ![](assets/icons/mini/academic-cap.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.academic_cap /> + + <.academic_cap class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= academic_cap() %> + + <%= academic_cap(class: "h-6 w-6 text-gray-500") %> + """ + def academic_cap(assigns_or_opts \\ []) + + def academic_cap(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def academic_cap(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/adjustments-horizontal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.adjustments_horizontal /> + + <.adjustments_horizontal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= adjustments_horizontal() %> + + <%= adjustments_horizontal(class: "h-6 w-6 text-gray-500") %> + """ + def adjustments_horizontal(assigns_or_opts \\ []) + + def adjustments_horizontal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def adjustments_horizontal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/adjustments-vertical.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.adjustments_vertical /> + + <.adjustments_vertical class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= adjustments_vertical() %> + + <%= adjustments_vertical(class: "h-6 w-6 text-gray-500") %> + """ + def adjustments_vertical(assigns_or_opts \\ []) + + def adjustments_vertical(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def adjustments_vertical(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/archive-box-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box_arrow_down /> + + <.archive_box_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box_arrow_down() %> + + <%= archive_box_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box_arrow_down(assigns_or_opts \\ []) + + def archive_box_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/archive-box-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box_x_mark /> + + <.archive_box_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box_x_mark() %> + + <%= archive_box_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box_x_mark(assigns_or_opts \\ []) + + def archive_box_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/archive-box.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box /> + + <.archive_box class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box() %> + + <%= archive_box(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box(assigns_or_opts \\ []) + + def archive_box(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-down-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_circle /> + + <.arrow_down_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_circle() %> + + <%= arrow_down_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_circle(assigns_or_opts \\ []) + + def arrow_down_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-down-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_left /> + + <.arrow_down_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_left() %> + + <%= arrow_down_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_left(assigns_or_opts \\ []) + + def arrow_down_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-down-on-square-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_on_square_stack /> + + <.arrow_down_on_square_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_on_square_stack() %> + + <%= arrow_down_on_square_stack(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_on_square_stack(assigns_or_opts \\ []) + + def arrow_down_on_square_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_on_square_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-down-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_on_square /> + + <.arrow_down_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_on_square() %> + + <%= arrow_down_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_on_square(assigns_or_opts \\ []) + + def arrow_down_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-down-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_right /> + + <.arrow_down_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_right() %> + + <%= arrow_down_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_right(assigns_or_opts \\ []) + + def arrow_down_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-down-tray.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_tray /> + + <.arrow_down_tray class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_tray() %> + + <%= arrow_down_tray(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_tray(assigns_or_opts \\ []) + + def arrow_down_tray(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_tray(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down /> + + <.arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down() %> + + <%= arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down(assigns_or_opts \\ []) + + def arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-left-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left_circle /> + + <.arrow_left_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left_circle() %> + + <%= arrow_left_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left_circle(assigns_or_opts \\ []) + + def arrow_left_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-left-on-rectangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left_on_rectangle /> + + <.arrow_left_on_rectangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left_on_rectangle() %> + + <%= arrow_left_on_rectangle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left_on_rectangle(assigns_or_opts \\ []) + + def arrow_left_on_rectangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left_on_rectangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left /> + + <.arrow_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left() %> + + <%= arrow_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left(assigns_or_opts \\ []) + + def arrow_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-long-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_down /> + + <.arrow_long_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_down() %> + + <%= arrow_long_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_down(assigns_or_opts \\ []) + + def arrow_long_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-long-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_left /> + + <.arrow_long_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_left() %> + + <%= arrow_long_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_left(assigns_or_opts \\ []) + + def arrow_long_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-long-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_right /> + + <.arrow_long_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_right() %> + + <%= arrow_long_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_right(assigns_or_opts \\ []) + + def arrow_long_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-long-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_up /> + + <.arrow_long_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_up() %> + + <%= arrow_long_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_up(assigns_or_opts \\ []) + + def arrow_long_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-path.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_path /> + + <.arrow_path class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_path() %> + + <%= arrow_path(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_path(assigns_or_opts \\ []) + + def arrow_path(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_path(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-right-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right_circle /> + + <.arrow_right_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right_circle() %> + + <%= arrow_right_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right_circle(assigns_or_opts \\ []) + + def arrow_right_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-right-on-rectangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right_on_rectangle /> + + <.arrow_right_on_rectangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right_on_rectangle() %> + + <%= arrow_right_on_rectangle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right_on_rectangle(assigns_or_opts \\ []) + + def arrow_right_on_rectangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right_on_rectangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right /> + + <.arrow_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right() %> + + <%= arrow_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right(assigns_or_opts \\ []) + + def arrow_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-top-right-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_top_right_on_square /> + + <.arrow_top_right_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_top_right_on_square() %> + + <%= arrow_top_right_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_top_right_on_square(assigns_or_opts \\ []) + + def arrow_top_right_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_top_right_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-trending-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_trending_down /> + + <.arrow_trending_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_trending_down() %> + + <%= arrow_trending_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_trending_down(assigns_or_opts \\ []) + + def arrow_trending_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_trending_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-trending-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_trending_up /> + + <.arrow_trending_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_trending_up() %> + + <%= arrow_trending_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_trending_up(assigns_or_opts \\ []) + + def arrow_trending_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_trending_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-up-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_circle /> + + <.arrow_up_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_circle() %> + + <%= arrow_up_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_circle(assigns_or_opts \\ []) + + def arrow_up_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-up-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_left /> + + <.arrow_up_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_left() %> + + <%= arrow_up_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_left(assigns_or_opts \\ []) + + def arrow_up_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-up-on-square-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_on_square_stack /> + + <.arrow_up_on_square_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_on_square_stack() %> + + <%= arrow_up_on_square_stack(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_on_square_stack(assigns_or_opts \\ []) + + def arrow_up_on_square_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_on_square_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-up-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_on_square /> + + <.arrow_up_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_on_square() %> + + <%= arrow_up_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_on_square(assigns_or_opts \\ []) + + def arrow_up_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-up-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_right /> + + <.arrow_up_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_right() %> + + <%= arrow_up_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_right(assigns_or_opts \\ []) + + def arrow_up_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-up-tray.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_tray /> + + <.arrow_up_tray class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_tray() %> + + <%= arrow_up_tray(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_tray(assigns_or_opts \\ []) + + def arrow_up_tray(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_tray(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up /> + + <.arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up() %> + + <%= arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up(assigns_or_opts \\ []) + + def arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-uturn-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_down /> + + <.arrow_uturn_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_down() %> + + <%= arrow_uturn_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_down(assigns_or_opts \\ []) + + def arrow_uturn_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-uturn-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_left /> + + <.arrow_uturn_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_left() %> + + <%= arrow_uturn_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_left(assigns_or_opts \\ []) + + def arrow_uturn_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-uturn-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_right /> + + <.arrow_uturn_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_right() %> + + <%= arrow_uturn_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_right(assigns_or_opts \\ []) + + def arrow_uturn_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrow-uturn-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_up /> + + <.arrow_uturn_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_up() %> + + <%= arrow_uturn_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_up(assigns_or_opts \\ []) + + def arrow_uturn_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrows-pointing-in.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_pointing_in /> + + <.arrows_pointing_in class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_pointing_in() %> + + <%= arrows_pointing_in(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_pointing_in(assigns_or_opts \\ []) + + def arrows_pointing_in(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_pointing_in(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrows-pointing-out.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_pointing_out /> + + <.arrows_pointing_out class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_pointing_out() %> + + <%= arrows_pointing_out(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_pointing_out(assigns_or_opts \\ []) + + def arrows_pointing_out(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_pointing_out(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrows-right-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_right_left /> + + <.arrows_right_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_right_left() %> + + <%= arrows_right_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_right_left(assigns_or_opts \\ []) + + def arrows_right_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_right_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/arrows-up-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_up_down /> + + <.arrows_up_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_up_down() %> + + <%= arrows_up_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_up_down(assigns_or_opts \\ []) + + def arrows_up_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_up_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/at-symbol.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.at_symbol /> + + <.at_symbol class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= at_symbol() %> + + <%= at_symbol(class: "h-6 w-6 text-gray-500") %> + """ + def at_symbol(assigns_or_opts \\ []) + + def at_symbol(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def at_symbol(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/backspace.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.backspace /> + + <.backspace class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= backspace() %> + + <%= backspace(class: "h-6 w-6 text-gray-500") %> + """ + def backspace(assigns_or_opts \\ []) + + def backspace(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def backspace(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/backward.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.backward /> + + <.backward class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= backward() %> + + <%= backward(class: "h-6 w-6 text-gray-500") %> + """ + def backward(assigns_or_opts \\ []) + + def backward(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def backward(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/banknotes.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.banknotes /> + + <.banknotes class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= banknotes() %> + + <%= banknotes(class: "h-6 w-6 text-gray-500") %> + """ + def banknotes(assigns_or_opts \\ []) + + def banknotes(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def banknotes(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_2 /> + + <.bars_2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_2() %> + + <%= bars_2(class: "h-6 w-6 text-gray-500") %> + """ + def bars_2(assigns_or_opts \\ []) + + def bars_2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-3-bottom-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_bottom_left /> + + <.bars_3_bottom_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_bottom_left() %> + + <%= bars_3_bottom_left(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_bottom_left(assigns_or_opts \\ []) + + def bars_3_bottom_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_bottom_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-3-bottom-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_bottom_right /> + + <.bars_3_bottom_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_bottom_right() %> + + <%= bars_3_bottom_right(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_bottom_right(assigns_or_opts \\ []) + + def bars_3_bottom_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_bottom_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-3-center-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_center_left /> + + <.bars_3_center_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_center_left() %> + + <%= bars_3_center_left(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_center_left(assigns_or_opts \\ []) + + def bars_3_center_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_center_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-3.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3 /> + + <.bars_3 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3() %> + + <%= bars_3(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3(assigns_or_opts \\ []) + + def bars_3(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-4.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_4 /> + + <.bars_4 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_4() %> + + <%= bars_4(class: "h-6 w-6 text-gray-500") %> + """ + def bars_4(assigns_or_opts \\ []) + + def bars_4(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_4(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_arrow_down /> + + <.bars_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_arrow_down() %> + + <%= bars_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def bars_arrow_down(assigns_or_opts \\ []) + + def bars_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bars-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_arrow_up /> + + <.bars_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_arrow_up() %> + + <%= bars_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def bars_arrow_up(assigns_or_opts \\ []) + + def bars_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/beaker.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.beaker /> + + <.beaker class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= beaker() %> + + <%= beaker(class: "h-6 w-6 text-gray-500") %> + """ + def beaker(assigns_or_opts \\ []) + + def beaker(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def beaker(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bell-alert.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_alert /> + + <.bell_alert class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_alert() %> + + <%= bell_alert(class: "h-6 w-6 text-gray-500") %> + """ + def bell_alert(assigns_or_opts \\ []) + + def bell_alert(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_alert(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bell-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_slash /> + + <.bell_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_slash() %> + + <%= bell_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bell_slash(assigns_or_opts \\ []) + + def bell_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bell-snooze.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_snooze /> + + <.bell_snooze class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_snooze() %> + + <%= bell_snooze(class: "h-6 w-6 text-gray-500") %> + """ + def bell_snooze(assigns_or_opts \\ []) + + def bell_snooze(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_snooze(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bell.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell /> + + <.bell class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell() %> + + <%= bell(class: "h-6 w-6 text-gray-500") %> + """ + def bell(assigns_or_opts \\ []) + + def bell(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bolt-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bolt_slash /> + + <.bolt_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bolt_slash() %> + + <%= bolt_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bolt_slash(assigns_or_opts \\ []) + + def bolt_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bolt_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bolt.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bolt /> + + <.bolt class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bolt() %> + + <%= bolt(class: "h-6 w-6 text-gray-500") %> + """ + def bolt(assigns_or_opts \\ []) + + def bolt(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bolt(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/book-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.book_open /> + + <.book_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= book_open() %> + + <%= book_open(class: "h-6 w-6 text-gray-500") %> + """ + def book_open(assigns_or_opts \\ []) + + def book_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def book_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bookmark-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark_slash /> + + <.bookmark_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark_slash() %> + + <%= bookmark_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark_slash(assigns_or_opts \\ []) + + def bookmark_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bookmark-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark_square /> + + <.bookmark_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark_square() %> + + <%= bookmark_square(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark_square(assigns_or_opts \\ []) + + def bookmark_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/bookmark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark /> + + <.bookmark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark() %> + + <%= bookmark(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark(assigns_or_opts \\ []) + + def bookmark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/briefcase.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.briefcase /> + + <.briefcase class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= briefcase() %> + + <%= briefcase(class: "h-6 w-6 text-gray-500") %> + """ + def briefcase(assigns_or_opts \\ []) + + def briefcase(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def briefcase(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/building-library.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_library /> + + <.building_library class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_library() %> + + <%= building_library(class: "h-6 w-6 text-gray-500") %> + """ + def building_library(assigns_or_opts \\ []) + + def building_library(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_library(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/building-office-2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_office_2 /> + + <.building_office_2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_office_2() %> + + <%= building_office_2(class: "h-6 w-6 text-gray-500") %> + """ + def building_office_2(assigns_or_opts \\ []) + + def building_office_2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_office_2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/building-office.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_office /> + + <.building_office class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_office() %> + + <%= building_office(class: "h-6 w-6 text-gray-500") %> + """ + def building_office(assigns_or_opts \\ []) + + def building_office(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_office(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/building-storefront.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_storefront /> + + <.building_storefront class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_storefront() %> + + <%= building_storefront(class: "h-6 w-6 text-gray-500") %> + """ + def building_storefront(assigns_or_opts \\ []) + + def building_storefront(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_storefront(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cake.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cake /> + + <.cake class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cake() %> + + <%= cake(class: "h-6 w-6 text-gray-500") %> + """ + def cake(assigns_or_opts \\ []) + + def cake(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cake(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/calculator.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calculator /> + + <.calculator class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calculator() %> + + <%= calculator(class: "h-6 w-6 text-gray-500") %> + """ + def calculator(assigns_or_opts \\ []) + + def calculator(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calculator(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/calendar-days.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calendar_days /> + + <.calendar_days class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calendar_days() %> + + <%= calendar_days(class: "h-6 w-6 text-gray-500") %> + """ + def calendar_days(assigns_or_opts \\ []) + + def calendar_days(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calendar_days(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/calendar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calendar /> + + <.calendar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calendar() %> + + <%= calendar(class: "h-6 w-6 text-gray-500") %> + """ + def calendar(assigns_or_opts \\ []) + + def calendar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calendar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/camera.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.camera /> + + <.camera class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= camera() %> + + <%= camera(class: "h-6 w-6 text-gray-500") %> + """ + def camera(assigns_or_opts \\ []) + + def camera(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def camera(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chart-bar-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_bar_square /> + + <.chart_bar_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_bar_square() %> + + <%= chart_bar_square(class: "h-6 w-6 text-gray-500") %> + """ + def chart_bar_square(assigns_or_opts \\ []) + + def chart_bar_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_bar_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_bar /> + + <.chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_bar() %> + + <%= chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def chart_bar(assigns_or_opts \\ []) + + def chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chart-pie.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_pie /> + + <.chart_pie class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_pie() %> + + <%= chart_pie(class: "h-6 w-6 text-gray-500") %> + """ + def chart_pie(assigns_or_opts \\ []) + + def chart_pie(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_pie(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chat-bubble-bottom-center-text.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_bottom_center_text /> + + <.chat_bubble_bottom_center_text class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_bottom_center_text() %> + + <%= chat_bubble_bottom_center_text(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_bottom_center_text(assigns_or_opts \\ []) + + def chat_bubble_bottom_center_text(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_bottom_center_text(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chat-bubble-bottom-center.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_bottom_center /> + + <.chat_bubble_bottom_center class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_bottom_center() %> + + <%= chat_bubble_bottom_center(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_bottom_center(assigns_or_opts \\ []) + + def chat_bubble_bottom_center(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_bottom_center(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chat-bubble-left-ellipsis.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left_ellipsis /> + + <.chat_bubble_left_ellipsis class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left_ellipsis() %> + + <%= chat_bubble_left_ellipsis(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left_ellipsis(assigns_or_opts \\ []) + + def chat_bubble_left_ellipsis(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left_ellipsis(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chat-bubble-left-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left_right /> + + <.chat_bubble_left_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left_right() %> + + <%= chat_bubble_left_right(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left_right(assigns_or_opts \\ []) + + def chat_bubble_left_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chat-bubble-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left /> + + <.chat_bubble_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left() %> + + <%= chat_bubble_left(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left(assigns_or_opts \\ []) + + def chat_bubble_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chat-bubble-oval-left-ellipsis.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_oval_left_ellipsis /> + + <.chat_bubble_oval_left_ellipsis class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_oval_left_ellipsis() %> + + <%= chat_bubble_oval_left_ellipsis(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_oval_left_ellipsis(assigns_or_opts \\ []) + + def chat_bubble_oval_left_ellipsis(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_oval_left_ellipsis(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chat-bubble-oval-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_oval_left /> + + <.chat_bubble_oval_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_oval_left() %> + + <%= chat_bubble_oval_left(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_oval_left(assigns_or_opts \\ []) + + def chat_bubble_oval_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_oval_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/check-badge.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check_badge /> + + <.check_badge class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check_badge() %> + + <%= check_badge(class: "h-6 w-6 text-gray-500") %> + """ + def check_badge(assigns_or_opts \\ []) + + def check_badge(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check_badge(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/check-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check_circle /> + + <.check_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check_circle() %> + + <%= check_circle(class: "h-6 w-6 text-gray-500") %> + """ + def check_circle(assigns_or_opts \\ []) + + def check_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check /> + + <.check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check() %> + + <%= check(class: "h-6 w-6 text-gray-500") %> + """ + def check(assigns_or_opts \\ []) + + def check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-double-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_down /> + + <.chevron_double_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_down() %> + + <%= chevron_double_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_down(assigns_or_opts \\ []) + + def chevron_double_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-double-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_left /> + + <.chevron_double_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_left() %> + + <%= chevron_double_left(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_left(assigns_or_opts \\ []) + + def chevron_double_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-double-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_right /> + + <.chevron_double_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_right() %> + + <%= chevron_double_right(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_right(assigns_or_opts \\ []) + + def chevron_double_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-double-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_up /> + + <.chevron_double_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_up() %> + + <%= chevron_double_up(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_up(assigns_or_opts \\ []) + + def chevron_double_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_down /> + + <.chevron_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_down() %> + + <%= chevron_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_down(assigns_or_opts \\ []) + + def chevron_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_left /> + + <.chevron_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_left() %> + + <%= chevron_left(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_left(assigns_or_opts \\ []) + + def chevron_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_right /> + + <.chevron_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_right() %> + + <%= chevron_right(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_right(assigns_or_opts \\ []) + + def chevron_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-up-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_up_down /> + + <.chevron_up_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_up_down() %> + + <%= chevron_up_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_up_down(assigns_or_opts \\ []) + + def chevron_up_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_up_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/chevron-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_up /> + + <.chevron_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_up() %> + + <%= chevron_up(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_up(assigns_or_opts \\ []) + + def chevron_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/circle-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.circle_stack /> + + <.circle_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= circle_stack() %> + + <%= circle_stack(class: "h-6 w-6 text-gray-500") %> + """ + def circle_stack(assigns_or_opts \\ []) + + def circle_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def circle_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/clipboard-document-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document_check /> + + <.clipboard_document_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document_check() %> + + <%= clipboard_document_check(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document_check(assigns_or_opts \\ []) + + def clipboard_document_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/clipboard-document-list.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document_list /> + + <.clipboard_document_list class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document_list() %> + + <%= clipboard_document_list(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document_list(assigns_or_opts \\ []) + + def clipboard_document_list(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document_list(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/clipboard-document.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document /> + + <.clipboard_document class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document() %> + + <%= clipboard_document(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document(assigns_or_opts \\ []) + + def clipboard_document(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/clipboard.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard /> + + <.clipboard class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard() %> + + <%= clipboard(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard(assigns_or_opts \\ []) + + def clipboard(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/clock.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clock /> + + <.clock class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clock() %> + + <%= clock(class: "h-6 w-6 text-gray-500") %> + """ + def clock(assigns_or_opts \\ []) + + def clock(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clock(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cloud-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud_arrow_down /> + + <.cloud_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud_arrow_down() %> + + <%= cloud_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def cloud_arrow_down(assigns_or_opts \\ []) + + def cloud_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cloud-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud_arrow_up /> + + <.cloud_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud_arrow_up() %> + + <%= cloud_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def cloud_arrow_up(assigns_or_opts \\ []) + + def cloud_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cloud.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud /> + + <.cloud class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud() %> + + <%= cloud(class: "h-6 w-6 text-gray-500") %> + """ + def cloud(assigns_or_opts \\ []) + + def cloud(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/code-bracket-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.code_bracket_square /> + + <.code_bracket_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= code_bracket_square() %> + + <%= code_bracket_square(class: "h-6 w-6 text-gray-500") %> + """ + def code_bracket_square(assigns_or_opts \\ []) + + def code_bracket_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def code_bracket_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/code-bracket.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.code_bracket /> + + <.code_bracket class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= code_bracket() %> + + <%= code_bracket(class: "h-6 w-6 text-gray-500") %> + """ + def code_bracket(assigns_or_opts \\ []) + + def code_bracket(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def code_bracket(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cog-6-tooth.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog_6_tooth /> + + <.cog_6_tooth class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog_6_tooth() %> + + <%= cog_6_tooth(class: "h-6 w-6 text-gray-500") %> + """ + def cog_6_tooth(assigns_or_opts \\ []) + + def cog_6_tooth(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog_6_tooth(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cog-8-tooth.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog_8_tooth /> + + <.cog_8_tooth class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog_8_tooth() %> + + <%= cog_8_tooth(class: "h-6 w-6 text-gray-500") %> + """ + def cog_8_tooth(assigns_or_opts \\ []) + + def cog_8_tooth(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog_8_tooth(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cog.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog /> + + <.cog class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog() %> + + <%= cog(class: "h-6 w-6 text-gray-500") %> + """ + def cog(assigns_or_opts \\ []) + + def cog(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/command-line.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.command_line /> + + <.command_line class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= command_line() %> + + <%= command_line(class: "h-6 w-6 text-gray-500") %> + """ + def command_line(assigns_or_opts \\ []) + + def command_line(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def command_line(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/computer-desktop.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.computer_desktop /> + + <.computer_desktop class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= computer_desktop() %> + + <%= computer_desktop(class: "h-6 w-6 text-gray-500") %> + """ + def computer_desktop(assigns_or_opts \\ []) + + def computer_desktop(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def computer_desktop(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cpu-chip.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cpu_chip /> + + <.cpu_chip class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cpu_chip() %> + + <%= cpu_chip(class: "h-6 w-6 text-gray-500") %> + """ + def cpu_chip(assigns_or_opts \\ []) + + def cpu_chip(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cpu_chip(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/credit-card.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.credit_card /> + + <.credit_card class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= credit_card() %> + + <%= credit_card(class: "h-6 w-6 text-gray-500") %> + """ + def credit_card(assigns_or_opts \\ []) + + def credit_card(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def credit_card(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cube.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cube /> + + <.cube class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cube() %> + + <%= cube(class: "h-6 w-6 text-gray-500") %> + """ + def cube(assigns_or_opts \\ []) + + def cube(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cube(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/currency-dollar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_dollar /> + + <.currency_dollar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_dollar() %> + + <%= currency_dollar(class: "h-6 w-6 text-gray-500") %> + """ + def currency_dollar(assigns_or_opts \\ []) + + def currency_dollar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_dollar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/currency-euro.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_euro /> + + <.currency_euro class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_euro() %> + + <%= currency_euro(class: "h-6 w-6 text-gray-500") %> + """ + def currency_euro(assigns_or_opts \\ []) + + def currency_euro(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_euro(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/currency-pound.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_pound /> + + <.currency_pound class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_pound() %> + + <%= currency_pound(class: "h-6 w-6 text-gray-500") %> + """ + def currency_pound(assigns_or_opts \\ []) + + def currency_pound(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_pound(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/currency-rupee.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_rupee /> + + <.currency_rupee class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_rupee() %> + + <%= currency_rupee(class: "h-6 w-6 text-gray-500") %> + """ + def currency_rupee(assigns_or_opts \\ []) + + def currency_rupee(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_rupee(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/currency-yen.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_yen /> + + <.currency_yen class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_yen() %> + + <%= currency_yen(class: "h-6 w-6 text-gray-500") %> + """ + def currency_yen(assigns_or_opts \\ []) + + def currency_yen(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_yen(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cursor-arrow-rays.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cursor_arrow_rays /> + + <.cursor_arrow_rays class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cursor_arrow_rays() %> + + <%= cursor_arrow_rays(class: "h-6 w-6 text-gray-500") %> + """ + def cursor_arrow_rays(assigns_or_opts \\ []) + + def cursor_arrow_rays(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cursor_arrow_rays(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/cursor-arrow-ripple.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cursor_arrow_ripple /> + + <.cursor_arrow_ripple class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cursor_arrow_ripple() %> + + <%= cursor_arrow_ripple(class: "h-6 w-6 text-gray-500") %> + """ + def cursor_arrow_ripple(assigns_or_opts \\ []) + + def cursor_arrow_ripple(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cursor_arrow_ripple(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/device-phone-mobile.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.device_phone_mobile /> + + <.device_phone_mobile class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= device_phone_mobile() %> + + <%= device_phone_mobile(class: "h-6 w-6 text-gray-500") %> + """ + def device_phone_mobile(assigns_or_opts \\ []) + + def device_phone_mobile(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def device_phone_mobile(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/device-tablet.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.device_tablet /> + + <.device_tablet class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= device_tablet() %> + + <%= device_tablet(class: "h-6 w-6 text-gray-500") %> + """ + def device_tablet(assigns_or_opts \\ []) + + def device_tablet(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def device_tablet(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_arrow_down /> + + <.document_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_arrow_down() %> + + <%= document_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def document_arrow_down(assigns_or_opts \\ []) + + def document_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_arrow_up /> + + <.document_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_arrow_up() %> + + <%= document_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def document_arrow_up(assigns_or_opts \\ []) + + def document_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_chart_bar /> + + <.document_chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_chart_bar() %> + + <%= document_chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def document_chart_bar(assigns_or_opts \\ []) + + def document_chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_check /> + + <.document_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_check() %> + + <%= document_check(class: "h-6 w-6 text-gray-500") %> + """ + def document_check(assigns_or_opts \\ []) + + def document_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-duplicate.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_duplicate /> + + <.document_duplicate class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_duplicate() %> + + <%= document_duplicate(class: "h-6 w-6 text-gray-500") %> + """ + def document_duplicate(assigns_or_opts \\ []) + + def document_duplicate(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_duplicate(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-magnifying-glass.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_magnifying_glass /> + + <.document_magnifying_glass class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_magnifying_glass() %> + + <%= document_magnifying_glass(class: "h-6 w-6 text-gray-500") %> + """ + def document_magnifying_glass(assigns_or_opts \\ []) + + def document_magnifying_glass(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_magnifying_glass(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_minus /> + + <.document_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_minus() %> + + <%= document_minus(class: "h-6 w-6 text-gray-500") %> + """ + def document_minus(assigns_or_opts \\ []) + + def document_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_plus /> + + <.document_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_plus() %> + + <%= document_plus(class: "h-6 w-6 text-gray-500") %> + """ + def document_plus(assigns_or_opts \\ []) + + def document_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document-text.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_text /> + + <.document_text class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_text() %> + + <%= document_text(class: "h-6 w-6 text-gray-500") %> + """ + def document_text(assigns_or_opts \\ []) + + def document_text(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_text(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/document.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document /> + + <.document class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document() %> + + <%= document(class: "h-6 w-6 text-gray-500") %> + """ + def document(assigns_or_opts \\ []) + + def document(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/ellipsis-horizontal-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_horizontal_circle /> + + <.ellipsis_horizontal_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_horizontal_circle() %> + + <%= ellipsis_horizontal_circle(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_horizontal_circle(assigns_or_opts \\ []) + + def ellipsis_horizontal_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_horizontal_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/ellipsis-horizontal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_horizontal /> + + <.ellipsis_horizontal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_horizontal() %> + + <%= ellipsis_horizontal(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_horizontal(assigns_or_opts \\ []) + + def ellipsis_horizontal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_horizontal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/ellipsis-vertical.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_vertical /> + + <.ellipsis_vertical class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_vertical() %> + + <%= ellipsis_vertical(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_vertical(assigns_or_opts \\ []) + + def ellipsis_vertical(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_vertical(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/envelope-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.envelope_open /> + + <.envelope_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= envelope_open() %> + + <%= envelope_open(class: "h-6 w-6 text-gray-500") %> + """ + def envelope_open(assigns_or_opts \\ []) + + def envelope_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def envelope_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/envelope.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.envelope /> + + <.envelope class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= envelope() %> + + <%= envelope(class: "h-6 w-6 text-gray-500") %> + """ + def envelope(assigns_or_opts \\ []) + + def envelope(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def envelope(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/exclamation-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.exclamation_circle /> + + <.exclamation_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= exclamation_circle() %> + + <%= exclamation_circle(class: "h-6 w-6 text-gray-500") %> + """ + def exclamation_circle(assigns_or_opts \\ []) + + def exclamation_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def exclamation_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/exclamation-triangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.exclamation_triangle /> + + <.exclamation_triangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= exclamation_triangle() %> + + <%= exclamation_triangle(class: "h-6 w-6 text-gray-500") %> + """ + def exclamation_triangle(assigns_or_opts \\ []) + + def exclamation_triangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def exclamation_triangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/eye-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.eye_slash /> + + <.eye_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= eye_slash() %> + + <%= eye_slash(class: "h-6 w-6 text-gray-500") %> + """ + def eye_slash(assigns_or_opts \\ []) + + def eye_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def eye_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/eye.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.eye /> + + <.eye class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= eye() %> + + <%= eye(class: "h-6 w-6 text-gray-500") %> + """ + def eye(assigns_or_opts \\ []) + + def eye(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def eye(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/face-frown.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.face_frown /> + + <.face_frown class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= face_frown() %> + + <%= face_frown(class: "h-6 w-6 text-gray-500") %> + """ + def face_frown(assigns_or_opts \\ []) + + def face_frown(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def face_frown(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/face-smile.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.face_smile /> + + <.face_smile class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= face_smile() %> + + <%= face_smile(class: "h-6 w-6 text-gray-500") %> + """ + def face_smile(assigns_or_opts \\ []) + + def face_smile(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def face_smile(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/film.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.film /> + + <.film class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= film() %> + + <%= film(class: "h-6 w-6 text-gray-500") %> + """ + def film(assigns_or_opts \\ []) + + def film(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def film(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/finger-print.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.finger_print /> + + <.finger_print class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= finger_print() %> + + <%= finger_print(class: "h-6 w-6 text-gray-500") %> + """ + def finger_print(assigns_or_opts \\ []) + + def finger_print(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def finger_print(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/fire.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.fire /> + + <.fire class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= fire() %> + + <%= fire(class: "h-6 w-6 text-gray-500") %> + """ + def fire(assigns_or_opts \\ []) + + def fire(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def fire(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/flag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.flag /> + + <.flag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= flag() %> + + <%= flag(class: "h-6 w-6 text-gray-500") %> + """ + def flag(assigns_or_opts \\ []) + + def flag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def flag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/folder-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_arrow_down /> + + <.folder_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_arrow_down() %> + + <%= folder_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def folder_arrow_down(assigns_or_opts \\ []) + + def folder_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/folder-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_minus /> + + <.folder_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_minus() %> + + <%= folder_minus(class: "h-6 w-6 text-gray-500") %> + """ + def folder_minus(assigns_or_opts \\ []) + + def folder_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/folder-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_open /> + + <.folder_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_open() %> + + <%= folder_open(class: "h-6 w-6 text-gray-500") %> + """ + def folder_open(assigns_or_opts \\ []) + + def folder_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/folder-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_plus /> + + <.folder_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_plus() %> + + <%= folder_plus(class: "h-6 w-6 text-gray-500") %> + """ + def folder_plus(assigns_or_opts \\ []) + + def folder_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/folder.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder /> + + <.folder class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder() %> + + <%= folder(class: "h-6 w-6 text-gray-500") %> + """ + def folder(assigns_or_opts \\ []) + + def folder(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/forward.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.forward /> + + <.forward class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= forward() %> + + <%= forward(class: "h-6 w-6 text-gray-500") %> + """ + def forward(assigns_or_opts \\ []) + + def forward(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def forward(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/funnel.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.funnel /> + + <.funnel class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= funnel() %> + + <%= funnel(class: "h-6 w-6 text-gray-500") %> + """ + def funnel(assigns_or_opts \\ []) + + def funnel(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def funnel(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/gif.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gif /> + + <.gif class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gif() %> + + <%= gif(class: "h-6 w-6 text-gray-500") %> + """ + def gif(assigns_or_opts \\ []) + + def gif(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gif(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/gift-top.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gift_top /> + + <.gift_top class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gift_top() %> + + <%= gift_top(class: "h-6 w-6 text-gray-500") %> + """ + def gift_top(assigns_or_opts \\ []) + + def gift_top(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gift_top(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/gift.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gift /> + + <.gift class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gift() %> + + <%= gift(class: "h-6 w-6 text-gray-500") %> + """ + def gift(assigns_or_opts \\ []) + + def gift(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gift(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/globe-alt.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_alt /> + + <.globe_alt class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_alt() %> + + <%= globe_alt(class: "h-6 w-6 text-gray-500") %> + """ + def globe_alt(assigns_or_opts \\ []) + + def globe_alt(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_alt(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/globe-americas.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_americas /> + + <.globe_americas class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_americas() %> + + <%= globe_americas(class: "h-6 w-6 text-gray-500") %> + """ + def globe_americas(assigns_or_opts \\ []) + + def globe_americas(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_americas(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/globe-asia-australia.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_asia_australia /> + + <.globe_asia_australia class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_asia_australia() %> + + <%= globe_asia_australia(class: "h-6 w-6 text-gray-500") %> + """ + def globe_asia_australia(assigns_or_opts \\ []) + + def globe_asia_australia(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_asia_australia(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/globe-europe-africa.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_europe_africa /> + + <.globe_europe_africa class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_europe_africa() %> + + <%= globe_europe_africa(class: "h-6 w-6 text-gray-500") %> + """ + def globe_europe_africa(assigns_or_opts \\ []) + + def globe_europe_africa(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_europe_africa(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/hand-raised.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_raised /> + + <.hand_raised class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_raised() %> + + <%= hand_raised(class: "h-6 w-6 text-gray-500") %> + """ + def hand_raised(assigns_or_opts \\ []) + + def hand_raised(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_raised(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/hand-thumb-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_thumb_down /> + + <.hand_thumb_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_thumb_down() %> + + <%= hand_thumb_down(class: "h-6 w-6 text-gray-500") %> + """ + def hand_thumb_down(assigns_or_opts \\ []) + + def hand_thumb_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_thumb_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/hand-thumb-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_thumb_up /> + + <.hand_thumb_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_thumb_up() %> + + <%= hand_thumb_up(class: "h-6 w-6 text-gray-500") %> + """ + def hand_thumb_up(assigns_or_opts \\ []) + + def hand_thumb_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_thumb_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/hashtag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hashtag /> + + <.hashtag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hashtag() %> + + <%= hashtag(class: "h-6 w-6 text-gray-500") %> + """ + def hashtag(assigns_or_opts \\ []) + + def hashtag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hashtag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/heart.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.heart /> + + <.heart class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= heart() %> + + <%= heart(class: "h-6 w-6 text-gray-500") %> + """ + def heart(assigns_or_opts \\ []) + + def heart(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def heart(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/home-modern.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.home_modern /> + + <.home_modern class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= home_modern() %> + + <%= home_modern(class: "h-6 w-6 text-gray-500") %> + """ + def home_modern(assigns_or_opts \\ []) + + def home_modern(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def home_modern(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/home.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.home /> + + <.home class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= home() %> + + <%= home(class: "h-6 w-6 text-gray-500") %> + """ + def home(assigns_or_opts \\ []) + + def home(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def home(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/identification.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.identification /> + + <.identification class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= identification() %> + + <%= identification(class: "h-6 w-6 text-gray-500") %> + """ + def identification(assigns_or_opts \\ []) + + def identification(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def identification(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/inbox-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox_arrow_down /> + + <.inbox_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox_arrow_down() %> + + <%= inbox_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def inbox_arrow_down(assigns_or_opts \\ []) + + def inbox_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/inbox-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox_stack /> + + <.inbox_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox_stack() %> + + <%= inbox_stack(class: "h-6 w-6 text-gray-500") %> + """ + def inbox_stack(assigns_or_opts \\ []) + + def inbox_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/inbox.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox /> + + <.inbox class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox() %> + + <%= inbox(class: "h-6 w-6 text-gray-500") %> + """ + def inbox(assigns_or_opts \\ []) + + def inbox(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/information-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.information_circle /> + + <.information_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= information_circle() %> + + <%= information_circle(class: "h-6 w-6 text-gray-500") %> + """ + def information_circle(assigns_or_opts \\ []) + + def information_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def information_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/key.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.key /> + + <.key class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= key() %> + + <%= key(class: "h-6 w-6 text-gray-500") %> + """ + def key(assigns_or_opts \\ []) + + def key(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def key(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/language.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.language /> + + <.language class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= language() %> + + <%= language(class: "h-6 w-6 text-gray-500") %> + """ + def language(assigns_or_opts \\ []) + + def language(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def language(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/lifebuoy.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lifebuoy /> + + <.lifebuoy class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lifebuoy() %> + + <%= lifebuoy(class: "h-6 w-6 text-gray-500") %> + """ + def lifebuoy(assigns_or_opts \\ []) + + def lifebuoy(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lifebuoy(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/light-bulb.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.light_bulb /> + + <.light_bulb class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= light_bulb() %> + + <%= light_bulb(class: "h-6 w-6 text-gray-500") %> + """ + def light_bulb(assigns_or_opts \\ []) + + def light_bulb(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def light_bulb(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/link.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.link /> + + <.link class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= link() %> + + <%= link(class: "h-6 w-6 text-gray-500") %> + """ + def link(assigns_or_opts \\ []) + + def link(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def link(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/list-bullet.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.list_bullet /> + + <.list_bullet class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= list_bullet() %> + + <%= list_bullet(class: "h-6 w-6 text-gray-500") %> + """ + def list_bullet(assigns_or_opts \\ []) + + def list_bullet(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def list_bullet(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/lock-closed.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lock_closed /> + + <.lock_closed class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lock_closed() %> + + <%= lock_closed(class: "h-6 w-6 text-gray-500") %> + """ + def lock_closed(assigns_or_opts \\ []) + + def lock_closed(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lock_closed(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/lock-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lock_open /> + + <.lock_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lock_open() %> + + <%= lock_open(class: "h-6 w-6 text-gray-500") %> + """ + def lock_open(assigns_or_opts \\ []) + + def lock_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lock_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/magnifying-glass-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_circle /> + + <.magnifying_glass_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_circle() %> + + <%= magnifying_glass_circle(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_circle(assigns_or_opts \\ []) + + def magnifying_glass_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/magnifying-glass-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_minus /> + + <.magnifying_glass_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_minus() %> + + <%= magnifying_glass_minus(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_minus(assigns_or_opts \\ []) + + def magnifying_glass_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/magnifying-glass-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_plus /> + + <.magnifying_glass_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_plus() %> + + <%= magnifying_glass_plus(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_plus(assigns_or_opts \\ []) + + def magnifying_glass_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/magnifying-glass.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass /> + + <.magnifying_glass class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass() %> + + <%= magnifying_glass(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass(assigns_or_opts \\ []) + + def magnifying_glass(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/map-pin.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.map_pin /> + + <.map_pin class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= map_pin() %> + + <%= map_pin(class: "h-6 w-6 text-gray-500") %> + """ + def map_pin(assigns_or_opts \\ []) + + def map_pin(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def map_pin(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/map.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.map /> + + <.map class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= map() %> + + <%= map(class: "h-6 w-6 text-gray-500") %> + """ + def map(assigns_or_opts \\ []) + + def map(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def map(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/megaphone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.megaphone /> + + <.megaphone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= megaphone() %> + + <%= megaphone(class: "h-6 w-6 text-gray-500") %> + """ + def megaphone(assigns_or_opts \\ []) + + def megaphone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def megaphone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/microphone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.microphone /> + + <.microphone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= microphone() %> + + <%= microphone(class: "h-6 w-6 text-gray-500") %> + """ + def microphone(assigns_or_opts \\ []) + + def microphone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def microphone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/minus-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.minus_circle /> + + <.minus_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= minus_circle() %> + + <%= minus_circle(class: "h-6 w-6 text-gray-500") %> + """ + def minus_circle(assigns_or_opts \\ []) + + def minus_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def minus_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.minus /> + + <.minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= minus() %> + + <%= minus(class: "h-6 w-6 text-gray-500") %> + """ + def minus(assigns_or_opts \\ []) + + def minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/moon.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.moon /> + + <.moon class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= moon() %> + + <%= moon(class: "h-6 w-6 text-gray-500") %> + """ + def moon(assigns_or_opts \\ []) + + def moon(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def moon(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/musical-note.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.musical_note /> + + <.musical_note class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= musical_note() %> + + <%= musical_note(class: "h-6 w-6 text-gray-500") %> + """ + def musical_note(assigns_or_opts \\ []) + + def musical_note(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def musical_note(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/newspaper.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.newspaper /> + + <.newspaper class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= newspaper() %> + + <%= newspaper(class: "h-6 w-6 text-gray-500") %> + """ + def newspaper(assigns_or_opts \\ []) + + def newspaper(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def newspaper(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/no-symbol.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.no_symbol /> + + <.no_symbol class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= no_symbol() %> + + <%= no_symbol(class: "h-6 w-6 text-gray-500") %> + """ + def no_symbol(assigns_or_opts \\ []) + + def no_symbol(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def no_symbol(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/paper-airplane.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.paper_airplane /> + + <.paper_airplane class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= paper_airplane() %> + + <%= paper_airplane(class: "h-6 w-6 text-gray-500") %> + """ + def paper_airplane(assigns_or_opts \\ []) + + def paper_airplane(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def paper_airplane(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/paper-clip.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.paper_clip /> + + <.paper_clip class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= paper_clip() %> + + <%= paper_clip(class: "h-6 w-6 text-gray-500") %> + """ + def paper_clip(assigns_or_opts \\ []) + + def paper_clip(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def paper_clip(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/pause.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pause /> + + <.pause class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pause() %> + + <%= pause(class: "h-6 w-6 text-gray-500") %> + """ + def pause(assigns_or_opts \\ []) + + def pause(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pause(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/pencil-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pencil_square /> + + <.pencil_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pencil_square() %> + + <%= pencil_square(class: "h-6 w-6 text-gray-500") %> + """ + def pencil_square(assigns_or_opts \\ []) + + def pencil_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pencil_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/pencil.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pencil /> + + <.pencil class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pencil() %> + + <%= pencil(class: "h-6 w-6 text-gray-500") %> + """ + def pencil(assigns_or_opts \\ []) + + def pencil(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pencil(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/phone-arrow-down-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_arrow_down_left /> + + <.phone_arrow_down_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_arrow_down_left() %> + + <%= phone_arrow_down_left(class: "h-6 w-6 text-gray-500") %> + """ + def phone_arrow_down_left(assigns_or_opts \\ []) + + def phone_arrow_down_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_arrow_down_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/phone-arrow-up-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_arrow_up_right /> + + <.phone_arrow_up_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_arrow_up_right() %> + + <%= phone_arrow_up_right(class: "h-6 w-6 text-gray-500") %> + """ + def phone_arrow_up_right(assigns_or_opts \\ []) + + def phone_arrow_up_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_arrow_up_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/phone-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_x_mark /> + + <.phone_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_x_mark() %> + + <%= phone_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def phone_x_mark(assigns_or_opts \\ []) + + def phone_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/phone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone /> + + <.phone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone() %> + + <%= phone(class: "h-6 w-6 text-gray-500") %> + """ + def phone(assigns_or_opts \\ []) + + def phone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/photo.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.photo /> + + <.photo class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= photo() %> + + <%= photo(class: "h-6 w-6 text-gray-500") %> + """ + def photo(assigns_or_opts \\ []) + + def photo(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def photo(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/play-pause.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.play_pause /> + + <.play_pause class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= play_pause() %> + + <%= play_pause(class: "h-6 w-6 text-gray-500") %> + """ + def play_pause(assigns_or_opts \\ []) + + def play_pause(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def play_pause(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/play.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.play /> + + <.play class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= play() %> + + <%= play(class: "h-6 w-6 text-gray-500") %> + """ + def play(assigns_or_opts \\ []) + + def play(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def play(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/plus-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.plus_circle /> + + <.plus_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= plus_circle() %> + + <%= plus_circle(class: "h-6 w-6 text-gray-500") %> + """ + def plus_circle(assigns_or_opts \\ []) + + def plus_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def plus_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.plus /> + + <.plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= plus() %> + + <%= plus(class: "h-6 w-6 text-gray-500") %> + """ + def plus(assigns_or_opts \\ []) + + def plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/presentation-chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.presentation_chart_bar /> + + <.presentation_chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= presentation_chart_bar() %> + + <%= presentation_chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def presentation_chart_bar(assigns_or_opts \\ []) + + def presentation_chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def presentation_chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/presentation-chart-line.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.presentation_chart_line /> + + <.presentation_chart_line class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= presentation_chart_line() %> + + <%= presentation_chart_line(class: "h-6 w-6 text-gray-500") %> + """ + def presentation_chart_line(assigns_or_opts \\ []) + + def presentation_chart_line(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def presentation_chart_line(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/printer.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.printer /> + + <.printer class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= printer() %> + + <%= printer(class: "h-6 w-6 text-gray-500") %> + """ + def printer(assigns_or_opts \\ []) + + def printer(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def printer(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/puzzle-piece.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.puzzle_piece /> + + <.puzzle_piece class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= puzzle_piece() %> + + <%= puzzle_piece(class: "h-6 w-6 text-gray-500") %> + """ + def puzzle_piece(assigns_or_opts \\ []) + + def puzzle_piece(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def puzzle_piece(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/qr-code.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.qr_code /> + + <.qr_code class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= qr_code() %> + + <%= qr_code(class: "h-6 w-6 text-gray-500") %> + """ + def qr_code(assigns_or_opts \\ []) + + def qr_code(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def qr_code(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/question-mark-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.question_mark_circle /> + + <.question_mark_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= question_mark_circle() %> + + <%= question_mark_circle(class: "h-6 w-6 text-gray-500") %> + """ + def question_mark_circle(assigns_or_opts \\ []) + + def question_mark_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def question_mark_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/queue-list.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.queue_list /> + + <.queue_list class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= queue_list() %> + + <%= queue_list(class: "h-6 w-6 text-gray-500") %> + """ + def queue_list(assigns_or_opts \\ []) + + def queue_list(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def queue_list(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/radio.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.radio /> + + <.radio class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= radio() %> + + <%= radio(class: "h-6 w-6 text-gray-500") %> + """ + def radio(assigns_or_opts \\ []) + + def radio(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def radio(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/receipt-percent.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.receipt_percent /> + + <.receipt_percent class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= receipt_percent() %> + + <%= receipt_percent(class: "h-6 w-6 text-gray-500") %> + """ + def receipt_percent(assigns_or_opts \\ []) + + def receipt_percent(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def receipt_percent(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/receipt-refund.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.receipt_refund /> + + <.receipt_refund class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= receipt_refund() %> + + <%= receipt_refund(class: "h-6 w-6 text-gray-500") %> + """ + def receipt_refund(assigns_or_opts \\ []) + + def receipt_refund(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def receipt_refund(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/rectangle-group.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rectangle_group /> + + <.rectangle_group class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rectangle_group() %> + + <%= rectangle_group(class: "h-6 w-6 text-gray-500") %> + """ + def rectangle_group(assigns_or_opts \\ []) + + def rectangle_group(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rectangle_group(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/rectangle-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rectangle_stack /> + + <.rectangle_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rectangle_stack() %> + + <%= rectangle_stack(class: "h-6 w-6 text-gray-500") %> + """ + def rectangle_stack(assigns_or_opts \\ []) + + def rectangle_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rectangle_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/rss.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rss /> + + <.rss class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rss() %> + + <%= rss(class: "h-6 w-6 text-gray-500") %> + """ + def rss(assigns_or_opts \\ []) + + def rss(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rss(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/scale.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.scale /> + + <.scale class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= scale() %> + + <%= scale(class: "h-6 w-6 text-gray-500") %> + """ + def scale(assigns_or_opts \\ []) + + def scale(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def scale(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/scissors.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.scissors /> + + <.scissors class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= scissors() %> + + <%= scissors(class: "h-6 w-6 text-gray-500") %> + """ + def scissors(assigns_or_opts \\ []) + + def scissors(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def scissors(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/server-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.server_stack /> + + <.server_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= server_stack() %> + + <%= server_stack(class: "h-6 w-6 text-gray-500") %> + """ + def server_stack(assigns_or_opts \\ []) + + def server_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def server_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/server.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.server /> + + <.server class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= server() %> + + <%= server(class: "h-6 w-6 text-gray-500") %> + """ + def server(assigns_or_opts \\ []) + + def server(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def server(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/share.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.share /> + + <.share class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= share() %> + + <%= share(class: "h-6 w-6 text-gray-500") %> + """ + def share(assigns_or_opts \\ []) + + def share(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def share(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/shield-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shield_check /> + + <.shield_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shield_check() %> + + <%= shield_check(class: "h-6 w-6 text-gray-500") %> + """ + def shield_check(assigns_or_opts \\ []) + + def shield_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shield_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/shield-exclamation.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shield_exclamation /> + + <.shield_exclamation class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shield_exclamation() %> + + <%= shield_exclamation(class: "h-6 w-6 text-gray-500") %> + """ + def shield_exclamation(assigns_or_opts \\ []) + + def shield_exclamation(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shield_exclamation(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/shopping-bag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shopping_bag /> + + <.shopping_bag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shopping_bag() %> + + <%= shopping_bag(class: "h-6 w-6 text-gray-500") %> + """ + def shopping_bag(assigns_or_opts \\ []) + + def shopping_bag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shopping_bag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/shopping-cart.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shopping_cart /> + + <.shopping_cart class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shopping_cart() %> + + <%= shopping_cart(class: "h-6 w-6 text-gray-500") %> + """ + def shopping_cart(assigns_or_opts \\ []) + + def shopping_cart(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shopping_cart(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/signal-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.signal_slash /> + + <.signal_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= signal_slash() %> + + <%= signal_slash(class: "h-6 w-6 text-gray-500") %> + """ + def signal_slash(assigns_or_opts \\ []) + + def signal_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def signal_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/signal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.signal /> + + <.signal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= signal() %> + + <%= signal(class: "h-6 w-6 text-gray-500") %> + """ + def signal(assigns_or_opts \\ []) + + def signal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def signal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/sparkles.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.sparkles /> + + <.sparkles class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= sparkles() %> + + <%= sparkles(class: "h-6 w-6 text-gray-500") %> + """ + def sparkles(assigns_or_opts \\ []) + + def sparkles(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def sparkles(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/speaker-wave.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.speaker_wave /> + + <.speaker_wave class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= speaker_wave() %> + + <%= speaker_wave(class: "h-6 w-6 text-gray-500") %> + """ + def speaker_wave(assigns_or_opts \\ []) + + def speaker_wave(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def speaker_wave(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/speaker-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.speaker_x_mark /> + + <.speaker_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= speaker_x_mark() %> + + <%= speaker_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def speaker_x_mark(assigns_or_opts \\ []) + + def speaker_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def speaker_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/square-2-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.square_2_stack /> + + <.square_2_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= square_2_stack() %> + + <%= square_2_stack(class: "h-6 w-6 text-gray-500") %> + """ + def square_2_stack(assigns_or_opts \\ []) + + def square_2_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def square_2_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/squares-2x2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.squares_2x2 /> + + <.squares_2x2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= squares_2x2() %> + + <%= squares_2x2(class: "h-6 w-6 text-gray-500") %> + """ + def squares_2x2(assigns_or_opts \\ []) + + def squares_2x2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def squares_2x2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/squares-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.squares_plus /> + + <.squares_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= squares_plus() %> + + <%= squares_plus(class: "h-6 w-6 text-gray-500") %> + """ + def squares_plus(assigns_or_opts \\ []) + + def squares_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def squares_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/star.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.star /> + + <.star class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= star() %> + + <%= star(class: "h-6 w-6 text-gray-500") %> + """ + def star(assigns_or_opts \\ []) + + def star(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def star(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/stop.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.stop /> + + <.stop class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= stop() %> + + <%= stop(class: "h-6 w-6 text-gray-500") %> + """ + def stop(assigns_or_opts \\ []) + + def stop(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def stop(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/sun.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.sun /> + + <.sun class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= sun() %> + + <%= sun(class: "h-6 w-6 text-gray-500") %> + """ + def sun(assigns_or_opts \\ []) + + def sun(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def sun(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/swatch.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.swatch /> + + <.swatch class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= swatch() %> + + <%= swatch(class: "h-6 w-6 text-gray-500") %> + """ + def swatch(assigns_or_opts \\ []) + + def swatch(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def swatch(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/table-cells.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.table_cells /> + + <.table_cells class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= table_cells() %> + + <%= table_cells(class: "h-6 w-6 text-gray-500") %> + """ + def table_cells(assigns_or_opts \\ []) + + def table_cells(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def table_cells(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/tag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.tag /> + + <.tag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= tag() %> + + <%= tag(class: "h-6 w-6 text-gray-500") %> + """ + def tag(assigns_or_opts \\ []) + + def tag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def tag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/ticket.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ticket /> + + <.ticket class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ticket() %> + + <%= ticket(class: "h-6 w-6 text-gray-500") %> + """ + def ticket(assigns_or_opts \\ []) + + def ticket(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ticket(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/trash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.trash /> + + <.trash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= trash() %> + + <%= trash(class: "h-6 w-6 text-gray-500") %> + """ + def trash(assigns_or_opts \\ []) + + def trash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def trash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/truck.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.truck /> + + <.truck class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= truck() %> + + <%= truck(class: "h-6 w-6 text-gray-500") %> + """ + def truck(assigns_or_opts \\ []) + + def truck(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def truck(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/user-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_circle /> + + <.user_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_circle() %> + + <%= user_circle(class: "h-6 w-6 text-gray-500") %> + """ + def user_circle(assigns_or_opts \\ []) + + def user_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/user-group.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_group /> + + <.user_group class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_group() %> + + <%= user_group(class: "h-6 w-6 text-gray-500") %> + """ + def user_group(assigns_or_opts \\ []) + + def user_group(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_group(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/user-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_minus /> + + <.user_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_minus() %> + + <%= user_minus(class: "h-6 w-6 text-gray-500") %> + """ + def user_minus(assigns_or_opts \\ []) + + def user_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/user-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_plus /> + + <.user_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_plus() %> + + <%= user_plus(class: "h-6 w-6 text-gray-500") %> + """ + def user_plus(assigns_or_opts \\ []) + + def user_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/user.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user /> + + <.user class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user() %> + + <%= user(class: "h-6 w-6 text-gray-500") %> + """ + def user(assigns_or_opts \\ []) + + def user(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/users.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.users /> + + <.users class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= users() %> + + <%= users(class: "h-6 w-6 text-gray-500") %> + """ + def users(assigns_or_opts \\ []) + + def users(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def users(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/video-camera-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.video_camera_slash /> + + <.video_camera_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= video_camera_slash() %> + + <%= video_camera_slash(class: "h-6 w-6 text-gray-500") %> + """ + def video_camera_slash(assigns_or_opts \\ []) + + def video_camera_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def video_camera_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/video-camera.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.video_camera /> + + <.video_camera class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= video_camera() %> + + <%= video_camera(class: "h-6 w-6 text-gray-500") %> + """ + def video_camera(assigns_or_opts \\ []) + + def video_camera(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def video_camera(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/view-columns.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.view_columns /> + + <.view_columns class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= view_columns() %> + + <%= view_columns(class: "h-6 w-6 text-gray-500") %> + """ + def view_columns(assigns_or_opts \\ []) + + def view_columns(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def view_columns(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/wifi.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wifi /> + + <.wifi class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wifi() %> + + <%= wifi(class: "h-6 w-6 text-gray-500") %> + """ + def wifi(assigns_or_opts \\ []) + + def wifi(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wifi(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/wrench-screwdriver.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wrench_screwdriver /> + + <.wrench_screwdriver class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wrench_screwdriver() %> + + <%= wrench_screwdriver(class: "h-6 w-6 text-gray-500") %> + """ + def wrench_screwdriver(assigns_or_opts \\ []) + + def wrench_screwdriver(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wrench_screwdriver(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/mini/wrench.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wrench /> + + <.wrench class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wrench() %> + + <%= wrench(class: "h-6 w-6 text-gray-500") %> + """ + def wrench(assigns_or_opts \\ []) + + def wrench(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wrench(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/x-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.x_circle /> + + <.x_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= x_circle() %> + + <%= x_circle(class: "h-6 w-6 text-gray-500") %> + """ + def x_circle(assigns_or_opts \\ []) + + def x_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def x_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/mini/x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.x_mark /> + + <.x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= x_mark() %> + + <%= x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def x_mark(assigns_or_opts \\ []) + + def x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + +end diff --git a/lib/heroicons/outline.ex b/lib/heroicons/outline.ex new file mode 100644 index 0000000..a14b330 --- /dev/null +++ b/lib/heroicons/outline.ex @@ -0,0 +1,11716 @@ +defmodule Heroicons.Outline do + @moduledoc """ + Outline style icons drawn with a stroke, packaged as Phoenix Components. + + For primary navigation and marketing sections, with an outlined appearance, + designed to be rendered at 24x24. + """ + + use Phoenix.Component + + if function_exported?(Phoenix.Component, :assigns_to_attributes, 2) do + @assign_mod Phoenix.Component + @assigns_to_attrs_mod Phoenix.Component + else + @assign_mod Phoenix.LiveView + @assigns_to_attrs_mod Phoenix.LiveView.Helpers + end + + @doc """ + ![](assets/icons/outline/academic-cap.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.academic_cap /> + + <.academic_cap class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= academic_cap() %> + + <%= academic_cap(class: "h-6 w-6 text-gray-500") %> + """ + def academic_cap(assigns_or_opts \\ []) + + def academic_cap(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def academic_cap(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/adjustments-horizontal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.adjustments_horizontal /> + + <.adjustments_horizontal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= adjustments_horizontal() %> + + <%= adjustments_horizontal(class: "h-6 w-6 text-gray-500") %> + """ + def adjustments_horizontal(assigns_or_opts \\ []) + + def adjustments_horizontal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def adjustments_horizontal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/adjustments-vertical.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.adjustments_vertical /> + + <.adjustments_vertical class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= adjustments_vertical() %> + + <%= adjustments_vertical(class: "h-6 w-6 text-gray-500") %> + """ + def adjustments_vertical(assigns_or_opts \\ []) + + def adjustments_vertical(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def adjustments_vertical(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/archive-box-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box_arrow_down /> + + <.archive_box_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box_arrow_down() %> + + <%= archive_box_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box_arrow_down(assigns_or_opts \\ []) + + def archive_box_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/archive-box-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box_x_mark /> + + <.archive_box_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box_x_mark() %> + + <%= archive_box_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box_x_mark(assigns_or_opts \\ []) + + def archive_box_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/archive-box.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box /> + + <.archive_box class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box() %> + + <%= archive_box(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box(assigns_or_opts \\ []) + + def archive_box(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-down-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_circle /> + + <.arrow_down_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_circle() %> + + <%= arrow_down_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_circle(assigns_or_opts \\ []) + + def arrow_down_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-down-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_left /> + + <.arrow_down_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_left() %> + + <%= arrow_down_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_left(assigns_or_opts \\ []) + + def arrow_down_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-down-on-square-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_on_square_stack /> + + <.arrow_down_on_square_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_on_square_stack() %> + + <%= arrow_down_on_square_stack(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_on_square_stack(assigns_or_opts \\ []) + + def arrow_down_on_square_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_on_square_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-down-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_on_square /> + + <.arrow_down_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_on_square() %> + + <%= arrow_down_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_on_square(assigns_or_opts \\ []) + + def arrow_down_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-down-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_right /> + + <.arrow_down_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_right() %> + + <%= arrow_down_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_right(assigns_or_opts \\ []) + + def arrow_down_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-down-tray.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_tray /> + + <.arrow_down_tray class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_tray() %> + + <%= arrow_down_tray(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_tray(assigns_or_opts \\ []) + + def arrow_down_tray(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_tray(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down /> + + <.arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down() %> + + <%= arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down(assigns_or_opts \\ []) + + def arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-left-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left_circle /> + + <.arrow_left_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left_circle() %> + + <%= arrow_left_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left_circle(assigns_or_opts \\ []) + + def arrow_left_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-left-on-rectangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left_on_rectangle /> + + <.arrow_left_on_rectangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left_on_rectangle() %> + + <%= arrow_left_on_rectangle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left_on_rectangle(assigns_or_opts \\ []) + + def arrow_left_on_rectangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left_on_rectangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left /> + + <.arrow_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left() %> + + <%= arrow_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left(assigns_or_opts \\ []) + + def arrow_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-long-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_down /> + + <.arrow_long_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_down() %> + + <%= arrow_long_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_down(assigns_or_opts \\ []) + + def arrow_long_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-long-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_left /> + + <.arrow_long_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_left() %> + + <%= arrow_long_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_left(assigns_or_opts \\ []) + + def arrow_long_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-long-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_right /> + + <.arrow_long_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_right() %> + + <%= arrow_long_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_right(assigns_or_opts \\ []) + + def arrow_long_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-long-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_up /> + + <.arrow_long_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_up() %> + + <%= arrow_long_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_up(assigns_or_opts \\ []) + + def arrow_long_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-path.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_path /> + + <.arrow_path class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_path() %> + + <%= arrow_path(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_path(assigns_or_opts \\ []) + + def arrow_path(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_path(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-right-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right_circle /> + + <.arrow_right_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right_circle() %> + + <%= arrow_right_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right_circle(assigns_or_opts \\ []) + + def arrow_right_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-right-on-rectangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right_on_rectangle /> + + <.arrow_right_on_rectangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right_on_rectangle() %> + + <%= arrow_right_on_rectangle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right_on_rectangle(assigns_or_opts \\ []) + + def arrow_right_on_rectangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right_on_rectangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right /> + + <.arrow_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right() %> + + <%= arrow_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right(assigns_or_opts \\ []) + + def arrow_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-top-right-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_top_right_on_square /> + + <.arrow_top_right_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_top_right_on_square() %> + + <%= arrow_top_right_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_top_right_on_square(assigns_or_opts \\ []) + + def arrow_top_right_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_top_right_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-trending-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_trending_down /> + + <.arrow_trending_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_trending_down() %> + + <%= arrow_trending_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_trending_down(assigns_or_opts \\ []) + + def arrow_trending_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_trending_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-trending-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_trending_up /> + + <.arrow_trending_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_trending_up() %> + + <%= arrow_trending_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_trending_up(assigns_or_opts \\ []) + + def arrow_trending_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_trending_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-up-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_circle /> + + <.arrow_up_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_circle() %> + + <%= arrow_up_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_circle(assigns_or_opts \\ []) + + def arrow_up_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-up-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_left /> + + <.arrow_up_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_left() %> + + <%= arrow_up_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_left(assigns_or_opts \\ []) + + def arrow_up_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-up-on-square-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_on_square_stack /> + + <.arrow_up_on_square_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_on_square_stack() %> + + <%= arrow_up_on_square_stack(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_on_square_stack(assigns_or_opts \\ []) + + def arrow_up_on_square_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_on_square_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-up-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_on_square /> + + <.arrow_up_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_on_square() %> + + <%= arrow_up_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_on_square(assigns_or_opts \\ []) + + def arrow_up_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-up-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_right /> + + <.arrow_up_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_right() %> + + <%= arrow_up_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_right(assigns_or_opts \\ []) + + def arrow_up_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-up-tray.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_tray /> + + <.arrow_up_tray class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_tray() %> + + <%= arrow_up_tray(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_tray(assigns_or_opts \\ []) + + def arrow_up_tray(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_tray(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up /> + + <.arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up() %> + + <%= arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up(assigns_or_opts \\ []) + + def arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-uturn-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_down /> + + <.arrow_uturn_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_down() %> + + <%= arrow_uturn_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_down(assigns_or_opts \\ []) + + def arrow_uturn_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-uturn-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_left /> + + <.arrow_uturn_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_left() %> + + <%= arrow_uturn_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_left(assigns_or_opts \\ []) + + def arrow_uturn_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-uturn-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_right /> + + <.arrow_uturn_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_right() %> + + <%= arrow_uturn_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_right(assigns_or_opts \\ []) + + def arrow_uturn_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrow-uturn-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_up /> + + <.arrow_uturn_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_up() %> + + <%= arrow_uturn_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_up(assigns_or_opts \\ []) + + def arrow_uturn_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrows-pointing-in.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_pointing_in /> + + <.arrows_pointing_in class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_pointing_in() %> + + <%= arrows_pointing_in(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_pointing_in(assigns_or_opts \\ []) + + def arrows_pointing_in(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_pointing_in(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrows-pointing-out.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_pointing_out /> + + <.arrows_pointing_out class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_pointing_out() %> + + <%= arrows_pointing_out(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_pointing_out(assigns_or_opts \\ []) + + def arrows_pointing_out(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_pointing_out(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrows-right-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_right_left /> + + <.arrows_right_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_right_left() %> + + <%= arrows_right_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_right_left(assigns_or_opts \\ []) + + def arrows_right_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_right_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/arrows-up-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_up_down /> + + <.arrows_up_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_up_down() %> + + <%= arrows_up_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_up_down(assigns_or_opts \\ []) + + def arrows_up_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_up_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/at-symbol.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.at_symbol /> + + <.at_symbol class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= at_symbol() %> + + <%= at_symbol(class: "h-6 w-6 text-gray-500") %> + """ + def at_symbol(assigns_or_opts \\ []) + + def at_symbol(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def at_symbol(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/backspace.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.backspace /> + + <.backspace class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= backspace() %> + + <%= backspace(class: "h-6 w-6 text-gray-500") %> + """ + def backspace(assigns_or_opts \\ []) + + def backspace(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def backspace(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/backward.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.backward /> + + <.backward class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= backward() %> + + <%= backward(class: "h-6 w-6 text-gray-500") %> + """ + def backward(assigns_or_opts \\ []) + + def backward(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def backward(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/banknotes.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.banknotes /> + + <.banknotes class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= banknotes() %> + + <%= banknotes(class: "h-6 w-6 text-gray-500") %> + """ + def banknotes(assigns_or_opts \\ []) + + def banknotes(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def banknotes(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_2 /> + + <.bars_2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_2() %> + + <%= bars_2(class: "h-6 w-6 text-gray-500") %> + """ + def bars_2(assigns_or_opts \\ []) + + def bars_2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-3-bottom-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_bottom_left /> + + <.bars_3_bottom_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_bottom_left() %> + + <%= bars_3_bottom_left(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_bottom_left(assigns_or_opts \\ []) + + def bars_3_bottom_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_bottom_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-3-bottom-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_bottom_right /> + + <.bars_3_bottom_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_bottom_right() %> + + <%= bars_3_bottom_right(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_bottom_right(assigns_or_opts \\ []) + + def bars_3_bottom_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_bottom_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-3-center-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_center_left /> + + <.bars_3_center_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_center_left() %> + + <%= bars_3_center_left(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_center_left(assigns_or_opts \\ []) + + def bars_3_center_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_center_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-3.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3 /> + + <.bars_3 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3() %> + + <%= bars_3(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3(assigns_or_opts \\ []) + + def bars_3(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-4.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_4 /> + + <.bars_4 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_4() %> + + <%= bars_4(class: "h-6 w-6 text-gray-500") %> + """ + def bars_4(assigns_or_opts \\ []) + + def bars_4(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_4(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_arrow_down /> + + <.bars_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_arrow_down() %> + + <%= bars_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def bars_arrow_down(assigns_or_opts \\ []) + + def bars_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bars-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_arrow_up /> + + <.bars_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_arrow_up() %> + + <%= bars_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def bars_arrow_up(assigns_or_opts \\ []) + + def bars_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/beaker.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.beaker /> + + <.beaker class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= beaker() %> + + <%= beaker(class: "h-6 w-6 text-gray-500") %> + """ + def beaker(assigns_or_opts \\ []) + + def beaker(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def beaker(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bell-alert.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_alert /> + + <.bell_alert class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_alert() %> + + <%= bell_alert(class: "h-6 w-6 text-gray-500") %> + """ + def bell_alert(assigns_or_opts \\ []) + + def bell_alert(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_alert(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bell-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_slash /> + + <.bell_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_slash() %> + + <%= bell_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bell_slash(assigns_or_opts \\ []) + + def bell_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bell-snooze.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_snooze /> + + <.bell_snooze class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_snooze() %> + + <%= bell_snooze(class: "h-6 w-6 text-gray-500") %> + """ + def bell_snooze(assigns_or_opts \\ []) + + def bell_snooze(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_snooze(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bell.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell /> + + <.bell class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell() %> + + <%= bell(class: "h-6 w-6 text-gray-500") %> + """ + def bell(assigns_or_opts \\ []) + + def bell(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bolt-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bolt_slash /> + + <.bolt_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bolt_slash() %> + + <%= bolt_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bolt_slash(assigns_or_opts \\ []) + + def bolt_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bolt_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bolt.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bolt /> + + <.bolt class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bolt() %> + + <%= bolt(class: "h-6 w-6 text-gray-500") %> + """ + def bolt(assigns_or_opts \\ []) + + def bolt(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bolt(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/book-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.book_open /> + + <.book_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= book_open() %> + + <%= book_open(class: "h-6 w-6 text-gray-500") %> + """ + def book_open(assigns_or_opts \\ []) + + def book_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def book_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bookmark-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark_slash /> + + <.bookmark_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark_slash() %> + + <%= bookmark_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark_slash(assigns_or_opts \\ []) + + def bookmark_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bookmark-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark_square /> + + <.bookmark_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark_square() %> + + <%= bookmark_square(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark_square(assigns_or_opts \\ []) + + def bookmark_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/bookmark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark /> + + <.bookmark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark() %> + + <%= bookmark(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark(assigns_or_opts \\ []) + + def bookmark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/briefcase.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.briefcase /> + + <.briefcase class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= briefcase() %> + + <%= briefcase(class: "h-6 w-6 text-gray-500") %> + """ + def briefcase(assigns_or_opts \\ []) + + def briefcase(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def briefcase(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/building-library.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_library /> + + <.building_library class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_library() %> + + <%= building_library(class: "h-6 w-6 text-gray-500") %> + """ + def building_library(assigns_or_opts \\ []) + + def building_library(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_library(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/building-office-2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_office_2 /> + + <.building_office_2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_office_2() %> + + <%= building_office_2(class: "h-6 w-6 text-gray-500") %> + """ + def building_office_2(assigns_or_opts \\ []) + + def building_office_2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_office_2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/building-office.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_office /> + + <.building_office class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_office() %> + + <%= building_office(class: "h-6 w-6 text-gray-500") %> + """ + def building_office(assigns_or_opts \\ []) + + def building_office(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_office(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/building-storefront.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_storefront /> + + <.building_storefront class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_storefront() %> + + <%= building_storefront(class: "h-6 w-6 text-gray-500") %> + """ + def building_storefront(assigns_or_opts \\ []) + + def building_storefront(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_storefront(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cake.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cake /> + + <.cake class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cake() %> + + <%= cake(class: "h-6 w-6 text-gray-500") %> + """ + def cake(assigns_or_opts \\ []) + + def cake(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cake(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/calculator.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calculator /> + + <.calculator class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calculator() %> + + <%= calculator(class: "h-6 w-6 text-gray-500") %> + """ + def calculator(assigns_or_opts \\ []) + + def calculator(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calculator(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/calendar-days.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calendar_days /> + + <.calendar_days class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calendar_days() %> + + <%= calendar_days(class: "h-6 w-6 text-gray-500") %> + """ + def calendar_days(assigns_or_opts \\ []) + + def calendar_days(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calendar_days(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/calendar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calendar /> + + <.calendar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calendar() %> + + <%= calendar(class: "h-6 w-6 text-gray-500") %> + """ + def calendar(assigns_or_opts \\ []) + + def calendar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calendar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/camera.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.camera /> + + <.camera class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= camera() %> + + <%= camera(class: "h-6 w-6 text-gray-500") %> + """ + def camera(assigns_or_opts \\ []) + + def camera(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def camera(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chart-bar-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_bar_square /> + + <.chart_bar_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_bar_square() %> + + <%= chart_bar_square(class: "h-6 w-6 text-gray-500") %> + """ + def chart_bar_square(assigns_or_opts \\ []) + + def chart_bar_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_bar_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_bar /> + + <.chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_bar() %> + + <%= chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def chart_bar(assigns_or_opts \\ []) + + def chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chart-pie.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_pie /> + + <.chart_pie class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_pie() %> + + <%= chart_pie(class: "h-6 w-6 text-gray-500") %> + """ + def chart_pie(assigns_or_opts \\ []) + + def chart_pie(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_pie(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chat-bubble-bottom-center-text.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_bottom_center_text /> + + <.chat_bubble_bottom_center_text class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_bottom_center_text() %> + + <%= chat_bubble_bottom_center_text(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_bottom_center_text(assigns_or_opts \\ []) + + def chat_bubble_bottom_center_text(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_bottom_center_text(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chat-bubble-bottom-center.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_bottom_center /> + + <.chat_bubble_bottom_center class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_bottom_center() %> + + <%= chat_bubble_bottom_center(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_bottom_center(assigns_or_opts \\ []) + + def chat_bubble_bottom_center(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_bottom_center(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chat-bubble-left-ellipsis.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left_ellipsis /> + + <.chat_bubble_left_ellipsis class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left_ellipsis() %> + + <%= chat_bubble_left_ellipsis(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left_ellipsis(assigns_or_opts \\ []) + + def chat_bubble_left_ellipsis(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left_ellipsis(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chat-bubble-left-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left_right /> + + <.chat_bubble_left_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left_right() %> + + <%= chat_bubble_left_right(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left_right(assigns_or_opts \\ []) + + def chat_bubble_left_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chat-bubble-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left /> + + <.chat_bubble_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left() %> + + <%= chat_bubble_left(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left(assigns_or_opts \\ []) + + def chat_bubble_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chat-bubble-oval-left-ellipsis.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_oval_left_ellipsis /> + + <.chat_bubble_oval_left_ellipsis class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_oval_left_ellipsis() %> + + <%= chat_bubble_oval_left_ellipsis(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_oval_left_ellipsis(assigns_or_opts \\ []) + + def chat_bubble_oval_left_ellipsis(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_oval_left_ellipsis(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chat-bubble-oval-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_oval_left /> + + <.chat_bubble_oval_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_oval_left() %> + + <%= chat_bubble_oval_left(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_oval_left(assigns_or_opts \\ []) + + def chat_bubble_oval_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_oval_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/check-badge.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check_badge /> + + <.check_badge class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check_badge() %> + + <%= check_badge(class: "h-6 w-6 text-gray-500") %> + """ + def check_badge(assigns_or_opts \\ []) + + def check_badge(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check_badge(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/check-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check_circle /> + + <.check_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check_circle() %> + + <%= check_circle(class: "h-6 w-6 text-gray-500") %> + """ + def check_circle(assigns_or_opts \\ []) + + def check_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check /> + + <.check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check() %> + + <%= check(class: "h-6 w-6 text-gray-500") %> + """ + def check(assigns_or_opts \\ []) + + def check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-double-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_down /> + + <.chevron_double_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_down() %> + + <%= chevron_double_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_down(assigns_or_opts \\ []) + + def chevron_double_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-double-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_left /> + + <.chevron_double_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_left() %> + + <%= chevron_double_left(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_left(assigns_or_opts \\ []) + + def chevron_double_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-double-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_right /> + + <.chevron_double_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_right() %> + + <%= chevron_double_right(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_right(assigns_or_opts \\ []) + + def chevron_double_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-double-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_up /> + + <.chevron_double_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_up() %> + + <%= chevron_double_up(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_up(assigns_or_opts \\ []) + + def chevron_double_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_down /> + + <.chevron_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_down() %> + + <%= chevron_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_down(assigns_or_opts \\ []) + + def chevron_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_left /> + + <.chevron_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_left() %> + + <%= chevron_left(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_left(assigns_or_opts \\ []) + + def chevron_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_right /> + + <.chevron_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_right() %> + + <%= chevron_right(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_right(assigns_or_opts \\ []) + + def chevron_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-up-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_up_down /> + + <.chevron_up_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_up_down() %> + + <%= chevron_up_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_up_down(assigns_or_opts \\ []) + + def chevron_up_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_up_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/chevron-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_up /> + + <.chevron_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_up() %> + + <%= chevron_up(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_up(assigns_or_opts \\ []) + + def chevron_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/circle-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.circle_stack /> + + <.circle_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= circle_stack() %> + + <%= circle_stack(class: "h-6 w-6 text-gray-500") %> + """ + def circle_stack(assigns_or_opts \\ []) + + def circle_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def circle_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/clipboard-document-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document_check /> + + <.clipboard_document_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document_check() %> + + <%= clipboard_document_check(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document_check(assigns_or_opts \\ []) + + def clipboard_document_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/clipboard-document-list.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document_list /> + + <.clipboard_document_list class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document_list() %> + + <%= clipboard_document_list(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document_list(assigns_or_opts \\ []) + + def clipboard_document_list(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document_list(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/clipboard-document.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document /> + + <.clipboard_document class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document() %> + + <%= clipboard_document(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document(assigns_or_opts \\ []) + + def clipboard_document(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/clipboard.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard /> + + <.clipboard class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard() %> + + <%= clipboard(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard(assigns_or_opts \\ []) + + def clipboard(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/clock.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clock /> + + <.clock class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clock() %> + + <%= clock(class: "h-6 w-6 text-gray-500") %> + """ + def clock(assigns_or_opts \\ []) + + def clock(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clock(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cloud-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud_arrow_down /> + + <.cloud_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud_arrow_down() %> + + <%= cloud_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def cloud_arrow_down(assigns_or_opts \\ []) + + def cloud_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cloud-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud_arrow_up /> + + <.cloud_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud_arrow_up() %> + + <%= cloud_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def cloud_arrow_up(assigns_or_opts \\ []) + + def cloud_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cloud.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud /> + + <.cloud class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud() %> + + <%= cloud(class: "h-6 w-6 text-gray-500") %> + """ + def cloud(assigns_or_opts \\ []) + + def cloud(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/code-bracket-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.code_bracket_square /> + + <.code_bracket_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= code_bracket_square() %> + + <%= code_bracket_square(class: "h-6 w-6 text-gray-500") %> + """ + def code_bracket_square(assigns_or_opts \\ []) + + def code_bracket_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def code_bracket_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/code-bracket.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.code_bracket /> + + <.code_bracket class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= code_bracket() %> + + <%= code_bracket(class: "h-6 w-6 text-gray-500") %> + """ + def code_bracket(assigns_or_opts \\ []) + + def code_bracket(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def code_bracket(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cog-6-tooth.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog_6_tooth /> + + <.cog_6_tooth class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog_6_tooth() %> + + <%= cog_6_tooth(class: "h-6 w-6 text-gray-500") %> + """ + def cog_6_tooth(assigns_or_opts \\ []) + + def cog_6_tooth(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog_6_tooth(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cog-8-tooth.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog_8_tooth /> + + <.cog_8_tooth class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog_8_tooth() %> + + <%= cog_8_tooth(class: "h-6 w-6 text-gray-500") %> + """ + def cog_8_tooth(assigns_or_opts \\ []) + + def cog_8_tooth(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog_8_tooth(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cog.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog /> + + <.cog class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog() %> + + <%= cog(class: "h-6 w-6 text-gray-500") %> + """ + def cog(assigns_or_opts \\ []) + + def cog(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/command-line.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.command_line /> + + <.command_line class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= command_line() %> + + <%= command_line(class: "h-6 w-6 text-gray-500") %> + """ + def command_line(assigns_or_opts \\ []) + + def command_line(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def command_line(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/computer-desktop.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.computer_desktop /> + + <.computer_desktop class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= computer_desktop() %> + + <%= computer_desktop(class: "h-6 w-6 text-gray-500") %> + """ + def computer_desktop(assigns_or_opts \\ []) + + def computer_desktop(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def computer_desktop(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cpu-chip.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cpu_chip /> + + <.cpu_chip class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cpu_chip() %> + + <%= cpu_chip(class: "h-6 w-6 text-gray-500") %> + """ + def cpu_chip(assigns_or_opts \\ []) + + def cpu_chip(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cpu_chip(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/credit-card.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.credit_card /> + + <.credit_card class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= credit_card() %> + + <%= credit_card(class: "h-6 w-6 text-gray-500") %> + """ + def credit_card(assigns_or_opts \\ []) + + def credit_card(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def credit_card(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cube.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cube /> + + <.cube class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cube() %> + + <%= cube(class: "h-6 w-6 text-gray-500") %> + """ + def cube(assigns_or_opts \\ []) + + def cube(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cube(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/currency-dollar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_dollar /> + + <.currency_dollar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_dollar() %> + + <%= currency_dollar(class: "h-6 w-6 text-gray-500") %> + """ + def currency_dollar(assigns_or_opts \\ []) + + def currency_dollar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_dollar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/currency-euro.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_euro /> + + <.currency_euro class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_euro() %> + + <%= currency_euro(class: "h-6 w-6 text-gray-500") %> + """ + def currency_euro(assigns_or_opts \\ []) + + def currency_euro(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_euro(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/currency-pound.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_pound /> + + <.currency_pound class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_pound() %> + + <%= currency_pound(class: "h-6 w-6 text-gray-500") %> + """ + def currency_pound(assigns_or_opts \\ []) + + def currency_pound(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_pound(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/currency-rupee.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_rupee /> + + <.currency_rupee class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_rupee() %> + + <%= currency_rupee(class: "h-6 w-6 text-gray-500") %> + """ + def currency_rupee(assigns_or_opts \\ []) + + def currency_rupee(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_rupee(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/currency-yen.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_yen /> + + <.currency_yen class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_yen() %> + + <%= currency_yen(class: "h-6 w-6 text-gray-500") %> + """ + def currency_yen(assigns_or_opts \\ []) + + def currency_yen(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_yen(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cursor-arrow-rays.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cursor_arrow_rays /> + + <.cursor_arrow_rays class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cursor_arrow_rays() %> + + <%= cursor_arrow_rays(class: "h-6 w-6 text-gray-500") %> + """ + def cursor_arrow_rays(assigns_or_opts \\ []) + + def cursor_arrow_rays(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cursor_arrow_rays(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/cursor-arrow-ripple.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cursor_arrow_ripple /> + + <.cursor_arrow_ripple class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cursor_arrow_ripple() %> + + <%= cursor_arrow_ripple(class: "h-6 w-6 text-gray-500") %> + """ + def cursor_arrow_ripple(assigns_or_opts \\ []) + + def cursor_arrow_ripple(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cursor_arrow_ripple(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/device-phone-mobile.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.device_phone_mobile /> + + <.device_phone_mobile class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= device_phone_mobile() %> + + <%= device_phone_mobile(class: "h-6 w-6 text-gray-500") %> + """ + def device_phone_mobile(assigns_or_opts \\ []) + + def device_phone_mobile(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def device_phone_mobile(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/device-tablet.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.device_tablet /> + + <.device_tablet class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= device_tablet() %> + + <%= device_tablet(class: "h-6 w-6 text-gray-500") %> + """ + def device_tablet(assigns_or_opts \\ []) + + def device_tablet(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def device_tablet(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_arrow_down /> + + <.document_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_arrow_down() %> + + <%= document_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def document_arrow_down(assigns_or_opts \\ []) + + def document_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_arrow_up /> + + <.document_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_arrow_up() %> + + <%= document_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def document_arrow_up(assigns_or_opts \\ []) + + def document_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_chart_bar /> + + <.document_chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_chart_bar() %> + + <%= document_chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def document_chart_bar(assigns_or_opts \\ []) + + def document_chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_check /> + + <.document_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_check() %> + + <%= document_check(class: "h-6 w-6 text-gray-500") %> + """ + def document_check(assigns_or_opts \\ []) + + def document_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-duplicate.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_duplicate /> + + <.document_duplicate class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_duplicate() %> + + <%= document_duplicate(class: "h-6 w-6 text-gray-500") %> + """ + def document_duplicate(assigns_or_opts \\ []) + + def document_duplicate(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_duplicate(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-magnifying-glass.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_magnifying_glass /> + + <.document_magnifying_glass class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_magnifying_glass() %> + + <%= document_magnifying_glass(class: "h-6 w-6 text-gray-500") %> + """ + def document_magnifying_glass(assigns_or_opts \\ []) + + def document_magnifying_glass(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_magnifying_glass(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_minus /> + + <.document_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_minus() %> + + <%= document_minus(class: "h-6 w-6 text-gray-500") %> + """ + def document_minus(assigns_or_opts \\ []) + + def document_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_plus /> + + <.document_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_plus() %> + + <%= document_plus(class: "h-6 w-6 text-gray-500") %> + """ + def document_plus(assigns_or_opts \\ []) + + def document_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document-text.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_text /> + + <.document_text class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_text() %> + + <%= document_text(class: "h-6 w-6 text-gray-500") %> + """ + def document_text(assigns_or_opts \\ []) + + def document_text(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_text(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/document.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document /> + + <.document class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document() %> + + <%= document(class: "h-6 w-6 text-gray-500") %> + """ + def document(assigns_or_opts \\ []) + + def document(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/ellipsis-horizontal-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_horizontal_circle /> + + <.ellipsis_horizontal_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_horizontal_circle() %> + + <%= ellipsis_horizontal_circle(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_horizontal_circle(assigns_or_opts \\ []) + + def ellipsis_horizontal_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_horizontal_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/ellipsis-horizontal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_horizontal /> + + <.ellipsis_horizontal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_horizontal() %> + + <%= ellipsis_horizontal(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_horizontal(assigns_or_opts \\ []) + + def ellipsis_horizontal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_horizontal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/ellipsis-vertical.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_vertical /> + + <.ellipsis_vertical class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_vertical() %> + + <%= ellipsis_vertical(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_vertical(assigns_or_opts \\ []) + + def ellipsis_vertical(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_vertical(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/envelope-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.envelope_open /> + + <.envelope_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= envelope_open() %> + + <%= envelope_open(class: "h-6 w-6 text-gray-500") %> + """ + def envelope_open(assigns_or_opts \\ []) + + def envelope_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def envelope_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/envelope.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.envelope /> + + <.envelope class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= envelope() %> + + <%= envelope(class: "h-6 w-6 text-gray-500") %> + """ + def envelope(assigns_or_opts \\ []) + + def envelope(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def envelope(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/exclamation-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.exclamation_circle /> + + <.exclamation_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= exclamation_circle() %> + + <%= exclamation_circle(class: "h-6 w-6 text-gray-500") %> + """ + def exclamation_circle(assigns_or_opts \\ []) + + def exclamation_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def exclamation_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/exclamation-triangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.exclamation_triangle /> + + <.exclamation_triangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= exclamation_triangle() %> + + <%= exclamation_triangle(class: "h-6 w-6 text-gray-500") %> + """ + def exclamation_triangle(assigns_or_opts \\ []) + + def exclamation_triangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def exclamation_triangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/eye-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.eye_slash /> + + <.eye_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= eye_slash() %> + + <%= eye_slash(class: "h-6 w-6 text-gray-500") %> + """ + def eye_slash(assigns_or_opts \\ []) + + def eye_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def eye_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/eye.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.eye /> + + <.eye class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= eye() %> + + <%= eye(class: "h-6 w-6 text-gray-500") %> + """ + def eye(assigns_or_opts \\ []) + + def eye(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def eye(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/face-frown.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.face_frown /> + + <.face_frown class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= face_frown() %> + + <%= face_frown(class: "h-6 w-6 text-gray-500") %> + """ + def face_frown(assigns_or_opts \\ []) + + def face_frown(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def face_frown(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/face-smile.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.face_smile /> + + <.face_smile class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= face_smile() %> + + <%= face_smile(class: "h-6 w-6 text-gray-500") %> + """ + def face_smile(assigns_or_opts \\ []) + + def face_smile(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def face_smile(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/film.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.film /> + + <.film class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= film() %> + + <%= film(class: "h-6 w-6 text-gray-500") %> + """ + def film(assigns_or_opts \\ []) + + def film(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def film(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/finger-print.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.finger_print /> + + <.finger_print class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= finger_print() %> + + <%= finger_print(class: "h-6 w-6 text-gray-500") %> + """ + def finger_print(assigns_or_opts \\ []) + + def finger_print(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def finger_print(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/fire.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.fire /> + + <.fire class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= fire() %> + + <%= fire(class: "h-6 w-6 text-gray-500") %> + """ + def fire(assigns_or_opts \\ []) + + def fire(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def fire(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/flag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.flag /> + + <.flag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= flag() %> + + <%= flag(class: "h-6 w-6 text-gray-500") %> + """ + def flag(assigns_or_opts \\ []) + + def flag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def flag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/folder-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_arrow_down /> + + <.folder_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_arrow_down() %> + + <%= folder_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def folder_arrow_down(assigns_or_opts \\ []) + + def folder_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/folder-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_minus /> + + <.folder_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_minus() %> + + <%= folder_minus(class: "h-6 w-6 text-gray-500") %> + """ + def folder_minus(assigns_or_opts \\ []) + + def folder_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/folder-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_open /> + + <.folder_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_open() %> + + <%= folder_open(class: "h-6 w-6 text-gray-500") %> + """ + def folder_open(assigns_or_opts \\ []) + + def folder_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/folder-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_plus /> + + <.folder_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_plus() %> + + <%= folder_plus(class: "h-6 w-6 text-gray-500") %> + """ + def folder_plus(assigns_or_opts \\ []) + + def folder_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/folder.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder /> + + <.folder class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder() %> + + <%= folder(class: "h-6 w-6 text-gray-500") %> + """ + def folder(assigns_or_opts \\ []) + + def folder(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/forward.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.forward /> + + <.forward class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= forward() %> + + <%= forward(class: "h-6 w-6 text-gray-500") %> + """ + def forward(assigns_or_opts \\ []) + + def forward(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def forward(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/funnel.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.funnel /> + + <.funnel class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= funnel() %> + + <%= funnel(class: "h-6 w-6 text-gray-500") %> + """ + def funnel(assigns_or_opts \\ []) + + def funnel(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def funnel(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/gif.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gif /> + + <.gif class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gif() %> + + <%= gif(class: "h-6 w-6 text-gray-500") %> + """ + def gif(assigns_or_opts \\ []) + + def gif(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gif(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/gift-top.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gift_top /> + + <.gift_top class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gift_top() %> + + <%= gift_top(class: "h-6 w-6 text-gray-500") %> + """ + def gift_top(assigns_or_opts \\ []) + + def gift_top(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gift_top(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/gift.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gift /> + + <.gift class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gift() %> + + <%= gift(class: "h-6 w-6 text-gray-500") %> + """ + def gift(assigns_or_opts \\ []) + + def gift(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gift(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/globe-alt.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_alt /> + + <.globe_alt class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_alt() %> + + <%= globe_alt(class: "h-6 w-6 text-gray-500") %> + """ + def globe_alt(assigns_or_opts \\ []) + + def globe_alt(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_alt(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/globe-americas.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_americas /> + + <.globe_americas class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_americas() %> + + <%= globe_americas(class: "h-6 w-6 text-gray-500") %> + """ + def globe_americas(assigns_or_opts \\ []) + + def globe_americas(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_americas(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/globe-asia-australia.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_asia_australia /> + + <.globe_asia_australia class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_asia_australia() %> + + <%= globe_asia_australia(class: "h-6 w-6 text-gray-500") %> + """ + def globe_asia_australia(assigns_or_opts \\ []) + + def globe_asia_australia(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_asia_australia(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/globe-europe-africa.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_europe_africa /> + + <.globe_europe_africa class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_europe_africa() %> + + <%= globe_europe_africa(class: "h-6 w-6 text-gray-500") %> + """ + def globe_europe_africa(assigns_or_opts \\ []) + + def globe_europe_africa(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_europe_africa(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/hand-raised.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_raised /> + + <.hand_raised class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_raised() %> + + <%= hand_raised(class: "h-6 w-6 text-gray-500") %> + """ + def hand_raised(assigns_or_opts \\ []) + + def hand_raised(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_raised(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/hand-thumb-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_thumb_down /> + + <.hand_thumb_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_thumb_down() %> + + <%= hand_thumb_down(class: "h-6 w-6 text-gray-500") %> + """ + def hand_thumb_down(assigns_or_opts \\ []) + + def hand_thumb_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_thumb_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/hand-thumb-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_thumb_up /> + + <.hand_thumb_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_thumb_up() %> + + <%= hand_thumb_up(class: "h-6 w-6 text-gray-500") %> + """ + def hand_thumb_up(assigns_or_opts \\ []) + + def hand_thumb_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_thumb_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/hashtag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hashtag /> + + <.hashtag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hashtag() %> + + <%= hashtag(class: "h-6 w-6 text-gray-500") %> + """ + def hashtag(assigns_or_opts \\ []) + + def hashtag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hashtag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/heart.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.heart /> + + <.heart class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= heart() %> + + <%= heart(class: "h-6 w-6 text-gray-500") %> + """ + def heart(assigns_or_opts \\ []) + + def heart(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def heart(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/home-modern.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.home_modern /> + + <.home_modern class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= home_modern() %> + + <%= home_modern(class: "h-6 w-6 text-gray-500") %> + """ + def home_modern(assigns_or_opts \\ []) + + def home_modern(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def home_modern(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/home.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.home /> + + <.home class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= home() %> + + <%= home(class: "h-6 w-6 text-gray-500") %> + """ + def home(assigns_or_opts \\ []) + + def home(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def home(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/identification.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.identification /> + + <.identification class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= identification() %> + + <%= identification(class: "h-6 w-6 text-gray-500") %> + """ + def identification(assigns_or_opts \\ []) + + def identification(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def identification(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/inbox-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox_arrow_down /> + + <.inbox_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox_arrow_down() %> + + <%= inbox_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def inbox_arrow_down(assigns_or_opts \\ []) + + def inbox_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/inbox-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox_stack /> + + <.inbox_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox_stack() %> + + <%= inbox_stack(class: "h-6 w-6 text-gray-500") %> + """ + def inbox_stack(assigns_or_opts \\ []) + + def inbox_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/inbox.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox /> + + <.inbox class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox() %> + + <%= inbox(class: "h-6 w-6 text-gray-500") %> + """ + def inbox(assigns_or_opts \\ []) + + def inbox(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/information-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.information_circle /> + + <.information_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= information_circle() %> + + <%= information_circle(class: "h-6 w-6 text-gray-500") %> + """ + def information_circle(assigns_or_opts \\ []) + + def information_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def information_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/key.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.key /> + + <.key class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= key() %> + + <%= key(class: "h-6 w-6 text-gray-500") %> + """ + def key(assigns_or_opts \\ []) + + def key(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def key(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/language.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.language /> + + <.language class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= language() %> + + <%= language(class: "h-6 w-6 text-gray-500") %> + """ + def language(assigns_or_opts \\ []) + + def language(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def language(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/lifebuoy.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lifebuoy /> + + <.lifebuoy class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lifebuoy() %> + + <%= lifebuoy(class: "h-6 w-6 text-gray-500") %> + """ + def lifebuoy(assigns_or_opts \\ []) + + def lifebuoy(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lifebuoy(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/light-bulb.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.light_bulb /> + + <.light_bulb class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= light_bulb() %> + + <%= light_bulb(class: "h-6 w-6 text-gray-500") %> + """ + def light_bulb(assigns_or_opts \\ []) + + def light_bulb(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def light_bulb(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/link.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.link /> + + <.link class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= link() %> + + <%= link(class: "h-6 w-6 text-gray-500") %> + """ + def link(assigns_or_opts \\ []) + + def link(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def link(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/list-bullet.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.list_bullet /> + + <.list_bullet class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= list_bullet() %> + + <%= list_bullet(class: "h-6 w-6 text-gray-500") %> + """ + def list_bullet(assigns_or_opts \\ []) + + def list_bullet(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def list_bullet(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/lock-closed.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lock_closed /> + + <.lock_closed class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lock_closed() %> + + <%= lock_closed(class: "h-6 w-6 text-gray-500") %> + """ + def lock_closed(assigns_or_opts \\ []) + + def lock_closed(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lock_closed(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/lock-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lock_open /> + + <.lock_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lock_open() %> + + <%= lock_open(class: "h-6 w-6 text-gray-500") %> + """ + def lock_open(assigns_or_opts \\ []) + + def lock_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lock_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/magnifying-glass-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_circle /> + + <.magnifying_glass_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_circle() %> + + <%= magnifying_glass_circle(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_circle(assigns_or_opts \\ []) + + def magnifying_glass_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/magnifying-glass-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_minus /> + + <.magnifying_glass_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_minus() %> + + <%= magnifying_glass_minus(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_minus(assigns_or_opts \\ []) + + def magnifying_glass_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/magnifying-glass-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_plus /> + + <.magnifying_glass_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_plus() %> + + <%= magnifying_glass_plus(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_plus(assigns_or_opts \\ []) + + def magnifying_glass_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/magnifying-glass.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass /> + + <.magnifying_glass class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass() %> + + <%= magnifying_glass(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass(assigns_or_opts \\ []) + + def magnifying_glass(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/map-pin.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.map_pin /> + + <.map_pin class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= map_pin() %> + + <%= map_pin(class: "h-6 w-6 text-gray-500") %> + """ + def map_pin(assigns_or_opts \\ []) + + def map_pin(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def map_pin(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/map.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.map /> + + <.map class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= map() %> + + <%= map(class: "h-6 w-6 text-gray-500") %> + """ + def map(assigns_or_opts \\ []) + + def map(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def map(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/megaphone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.megaphone /> + + <.megaphone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= megaphone() %> + + <%= megaphone(class: "h-6 w-6 text-gray-500") %> + """ + def megaphone(assigns_or_opts \\ []) + + def megaphone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def megaphone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/microphone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.microphone /> + + <.microphone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= microphone() %> + + <%= microphone(class: "h-6 w-6 text-gray-500") %> + """ + def microphone(assigns_or_opts \\ []) + + def microphone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def microphone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/minus-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.minus_circle /> + + <.minus_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= minus_circle() %> + + <%= minus_circle(class: "h-6 w-6 text-gray-500") %> + """ + def minus_circle(assigns_or_opts \\ []) + + def minus_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def minus_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.minus /> + + <.minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= minus() %> + + <%= minus(class: "h-6 w-6 text-gray-500") %> + """ + def minus(assigns_or_opts \\ []) + + def minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/moon.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.moon /> + + <.moon class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= moon() %> + + <%= moon(class: "h-6 w-6 text-gray-500") %> + """ + def moon(assigns_or_opts \\ []) + + def moon(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def moon(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/musical-note.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.musical_note /> + + <.musical_note class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= musical_note() %> + + <%= musical_note(class: "h-6 w-6 text-gray-500") %> + """ + def musical_note(assigns_or_opts \\ []) + + def musical_note(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def musical_note(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/newspaper.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.newspaper /> + + <.newspaper class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= newspaper() %> + + <%= newspaper(class: "h-6 w-6 text-gray-500") %> + """ + def newspaper(assigns_or_opts \\ []) + + def newspaper(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def newspaper(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/no-symbol.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.no_symbol /> + + <.no_symbol class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= no_symbol() %> + + <%= no_symbol(class: "h-6 w-6 text-gray-500") %> + """ + def no_symbol(assigns_or_opts \\ []) + + def no_symbol(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def no_symbol(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/paper-airplane.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.paper_airplane /> + + <.paper_airplane class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= paper_airplane() %> + + <%= paper_airplane(class: "h-6 w-6 text-gray-500") %> + """ + def paper_airplane(assigns_or_opts \\ []) + + def paper_airplane(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def paper_airplane(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/paper-clip.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.paper_clip /> + + <.paper_clip class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= paper_clip() %> + + <%= paper_clip(class: "h-6 w-6 text-gray-500") %> + """ + def paper_clip(assigns_or_opts \\ []) + + def paper_clip(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def paper_clip(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/pause.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pause /> + + <.pause class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pause() %> + + <%= pause(class: "h-6 w-6 text-gray-500") %> + """ + def pause(assigns_or_opts \\ []) + + def pause(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pause(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/pencil-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pencil_square /> + + <.pencil_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pencil_square() %> + + <%= pencil_square(class: "h-6 w-6 text-gray-500") %> + """ + def pencil_square(assigns_or_opts \\ []) + + def pencil_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pencil_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/pencil.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pencil /> + + <.pencil class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pencil() %> + + <%= pencil(class: "h-6 w-6 text-gray-500") %> + """ + def pencil(assigns_or_opts \\ []) + + def pencil(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pencil(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/phone-arrow-down-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_arrow_down_left /> + + <.phone_arrow_down_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_arrow_down_left() %> + + <%= phone_arrow_down_left(class: "h-6 w-6 text-gray-500") %> + """ + def phone_arrow_down_left(assigns_or_opts \\ []) + + def phone_arrow_down_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_arrow_down_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/phone-arrow-up-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_arrow_up_right /> + + <.phone_arrow_up_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_arrow_up_right() %> + + <%= phone_arrow_up_right(class: "h-6 w-6 text-gray-500") %> + """ + def phone_arrow_up_right(assigns_or_opts \\ []) + + def phone_arrow_up_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_arrow_up_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/phone-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_x_mark /> + + <.phone_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_x_mark() %> + + <%= phone_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def phone_x_mark(assigns_or_opts \\ []) + + def phone_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/phone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone /> + + <.phone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone() %> + + <%= phone(class: "h-6 w-6 text-gray-500") %> + """ + def phone(assigns_or_opts \\ []) + + def phone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/photo.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.photo /> + + <.photo class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= photo() %> + + <%= photo(class: "h-6 w-6 text-gray-500") %> + """ + def photo(assigns_or_opts \\ []) + + def photo(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def photo(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/play-pause.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.play_pause /> + + <.play_pause class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= play_pause() %> + + <%= play_pause(class: "h-6 w-6 text-gray-500") %> + """ + def play_pause(assigns_or_opts \\ []) + + def play_pause(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def play_pause(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/play.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.play /> + + <.play class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= play() %> + + <%= play(class: "h-6 w-6 text-gray-500") %> + """ + def play(assigns_or_opts \\ []) + + def play(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def play(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/plus-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.plus_circle /> + + <.plus_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= plus_circle() %> + + <%= plus_circle(class: "h-6 w-6 text-gray-500") %> + """ + def plus_circle(assigns_or_opts \\ []) + + def plus_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def plus_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.plus /> + + <.plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= plus() %> + + <%= plus(class: "h-6 w-6 text-gray-500") %> + """ + def plus(assigns_or_opts \\ []) + + def plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/presentation-chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.presentation_chart_bar /> + + <.presentation_chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= presentation_chart_bar() %> + + <%= presentation_chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def presentation_chart_bar(assigns_or_opts \\ []) + + def presentation_chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def presentation_chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/presentation-chart-line.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.presentation_chart_line /> + + <.presentation_chart_line class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= presentation_chart_line() %> + + <%= presentation_chart_line(class: "h-6 w-6 text-gray-500") %> + """ + def presentation_chart_line(assigns_or_opts \\ []) + + def presentation_chart_line(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def presentation_chart_line(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/printer.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.printer /> + + <.printer class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= printer() %> + + <%= printer(class: "h-6 w-6 text-gray-500") %> + """ + def printer(assigns_or_opts \\ []) + + def printer(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def printer(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/puzzle-piece.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.puzzle_piece /> + + <.puzzle_piece class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= puzzle_piece() %> + + <%= puzzle_piece(class: "h-6 w-6 text-gray-500") %> + """ + def puzzle_piece(assigns_or_opts \\ []) + + def puzzle_piece(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def puzzle_piece(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/qr-code.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.qr_code /> + + <.qr_code class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= qr_code() %> + + <%= qr_code(class: "h-6 w-6 text-gray-500") %> + """ + def qr_code(assigns_or_opts \\ []) + + def qr_code(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def qr_code(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/question-mark-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.question_mark_circle /> + + <.question_mark_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= question_mark_circle() %> + + <%= question_mark_circle(class: "h-6 w-6 text-gray-500") %> + """ + def question_mark_circle(assigns_or_opts \\ []) + + def question_mark_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def question_mark_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/queue-list.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.queue_list /> + + <.queue_list class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= queue_list() %> + + <%= queue_list(class: "h-6 w-6 text-gray-500") %> + """ + def queue_list(assigns_or_opts \\ []) + + def queue_list(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def queue_list(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/radio.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.radio /> + + <.radio class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= radio() %> + + <%= radio(class: "h-6 w-6 text-gray-500") %> + """ + def radio(assigns_or_opts \\ []) + + def radio(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def radio(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/receipt-percent.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.receipt_percent /> + + <.receipt_percent class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= receipt_percent() %> + + <%= receipt_percent(class: "h-6 w-6 text-gray-500") %> + """ + def receipt_percent(assigns_or_opts \\ []) + + def receipt_percent(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def receipt_percent(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/receipt-refund.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.receipt_refund /> + + <.receipt_refund class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= receipt_refund() %> + + <%= receipt_refund(class: "h-6 w-6 text-gray-500") %> + """ + def receipt_refund(assigns_or_opts \\ []) + + def receipt_refund(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def receipt_refund(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/rectangle-group.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rectangle_group /> + + <.rectangle_group class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rectangle_group() %> + + <%= rectangle_group(class: "h-6 w-6 text-gray-500") %> + """ + def rectangle_group(assigns_or_opts \\ []) + + def rectangle_group(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rectangle_group(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/rectangle-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rectangle_stack /> + + <.rectangle_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rectangle_stack() %> + + <%= rectangle_stack(class: "h-6 w-6 text-gray-500") %> + """ + def rectangle_stack(assigns_or_opts \\ []) + + def rectangle_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rectangle_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/rss.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rss /> + + <.rss class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rss() %> + + <%= rss(class: "h-6 w-6 text-gray-500") %> + """ + def rss(assigns_or_opts \\ []) + + def rss(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rss(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/scale.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.scale /> + + <.scale class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= scale() %> + + <%= scale(class: "h-6 w-6 text-gray-500") %> + """ + def scale(assigns_or_opts \\ []) + + def scale(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def scale(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/scissors.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.scissors /> + + <.scissors class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= scissors() %> + + <%= scissors(class: "h-6 w-6 text-gray-500") %> + """ + def scissors(assigns_or_opts \\ []) + + def scissors(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def scissors(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/server-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.server_stack /> + + <.server_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= server_stack() %> + + <%= server_stack(class: "h-6 w-6 text-gray-500") %> + """ + def server_stack(assigns_or_opts \\ []) + + def server_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def server_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/server.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.server /> + + <.server class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= server() %> + + <%= server(class: "h-6 w-6 text-gray-500") %> + """ + def server(assigns_or_opts \\ []) + + def server(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def server(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/share.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.share /> + + <.share class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= share() %> + + <%= share(class: "h-6 w-6 text-gray-500") %> + """ + def share(assigns_or_opts \\ []) + + def share(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def share(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/shield-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shield_check /> + + <.shield_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shield_check() %> + + <%= shield_check(class: "h-6 w-6 text-gray-500") %> + """ + def shield_check(assigns_or_opts \\ []) + + def shield_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shield_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/shield-exclamation.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shield_exclamation /> + + <.shield_exclamation class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shield_exclamation() %> + + <%= shield_exclamation(class: "h-6 w-6 text-gray-500") %> + """ + def shield_exclamation(assigns_or_opts \\ []) + + def shield_exclamation(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shield_exclamation(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/shopping-bag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shopping_bag /> + + <.shopping_bag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shopping_bag() %> + + <%= shopping_bag(class: "h-6 w-6 text-gray-500") %> + """ + def shopping_bag(assigns_or_opts \\ []) + + def shopping_bag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shopping_bag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/shopping-cart.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shopping_cart /> + + <.shopping_cart class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shopping_cart() %> + + <%= shopping_cart(class: "h-6 w-6 text-gray-500") %> + """ + def shopping_cart(assigns_or_opts \\ []) + + def shopping_cart(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shopping_cart(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/signal-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.signal_slash /> + + <.signal_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= signal_slash() %> + + <%= signal_slash(class: "h-6 w-6 text-gray-500") %> + """ + def signal_slash(assigns_or_opts \\ []) + + def signal_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def signal_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/signal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.signal /> + + <.signal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= signal() %> + + <%= signal(class: "h-6 w-6 text-gray-500") %> + """ + def signal(assigns_or_opts \\ []) + + def signal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def signal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/sparkles.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.sparkles /> + + <.sparkles class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= sparkles() %> + + <%= sparkles(class: "h-6 w-6 text-gray-500") %> + """ + def sparkles(assigns_or_opts \\ []) + + def sparkles(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def sparkles(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/speaker-wave.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.speaker_wave /> + + <.speaker_wave class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= speaker_wave() %> + + <%= speaker_wave(class: "h-6 w-6 text-gray-500") %> + """ + def speaker_wave(assigns_or_opts \\ []) + + def speaker_wave(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def speaker_wave(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/speaker-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.speaker_x_mark /> + + <.speaker_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= speaker_x_mark() %> + + <%= speaker_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def speaker_x_mark(assigns_or_opts \\ []) + + def speaker_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def speaker_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/square-2-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.square_2_stack /> + + <.square_2_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= square_2_stack() %> + + <%= square_2_stack(class: "h-6 w-6 text-gray-500") %> + """ + def square_2_stack(assigns_or_opts \\ []) + + def square_2_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def square_2_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/squares-2x2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.squares_2x2 /> + + <.squares_2x2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= squares_2x2() %> + + <%= squares_2x2(class: "h-6 w-6 text-gray-500") %> + """ + def squares_2x2(assigns_or_opts \\ []) + + def squares_2x2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def squares_2x2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/squares-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.squares_plus /> + + <.squares_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= squares_plus() %> + + <%= squares_plus(class: "h-6 w-6 text-gray-500") %> + """ + def squares_plus(assigns_or_opts \\ []) + + def squares_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def squares_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/star.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.star /> + + <.star class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= star() %> + + <%= star(class: "h-6 w-6 text-gray-500") %> + """ + def star(assigns_or_opts \\ []) + + def star(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def star(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/stop.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.stop /> + + <.stop class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= stop() %> + + <%= stop(class: "h-6 w-6 text-gray-500") %> + """ + def stop(assigns_or_opts \\ []) + + def stop(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def stop(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/sun.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.sun /> + + <.sun class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= sun() %> + + <%= sun(class: "h-6 w-6 text-gray-500") %> + """ + def sun(assigns_or_opts \\ []) + + def sun(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def sun(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/swatch.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.swatch /> + + <.swatch class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= swatch() %> + + <%= swatch(class: "h-6 w-6 text-gray-500") %> + """ + def swatch(assigns_or_opts \\ []) + + def swatch(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def swatch(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/table-cells.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.table_cells /> + + <.table_cells class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= table_cells() %> + + <%= table_cells(class: "h-6 w-6 text-gray-500") %> + """ + def table_cells(assigns_or_opts \\ []) + + def table_cells(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def table_cells(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/tag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.tag /> + + <.tag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= tag() %> + + <%= tag(class: "h-6 w-6 text-gray-500") %> + """ + def tag(assigns_or_opts \\ []) + + def tag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def tag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/ticket.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ticket /> + + <.ticket class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ticket() %> + + <%= ticket(class: "h-6 w-6 text-gray-500") %> + """ + def ticket(assigns_or_opts \\ []) + + def ticket(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ticket(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/trash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.trash /> + + <.trash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= trash() %> + + <%= trash(class: "h-6 w-6 text-gray-500") %> + """ + def trash(assigns_or_opts \\ []) + + def trash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def trash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/truck.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.truck /> + + <.truck class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= truck() %> + + <%= truck(class: "h-6 w-6 text-gray-500") %> + """ + def truck(assigns_or_opts \\ []) + + def truck(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def truck(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/user-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_circle /> + + <.user_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_circle() %> + + <%= user_circle(class: "h-6 w-6 text-gray-500") %> + """ + def user_circle(assigns_or_opts \\ []) + + def user_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/user-group.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_group /> + + <.user_group class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_group() %> + + <%= user_group(class: "h-6 w-6 text-gray-500") %> + """ + def user_group(assigns_or_opts \\ []) + + def user_group(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_group(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/user-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_minus /> + + <.user_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_minus() %> + + <%= user_minus(class: "h-6 w-6 text-gray-500") %> + """ + def user_minus(assigns_or_opts \\ []) + + def user_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/user-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_plus /> + + <.user_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_plus() %> + + <%= user_plus(class: "h-6 w-6 text-gray-500") %> + """ + def user_plus(assigns_or_opts \\ []) + + def user_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/user.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user /> + + <.user class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user() %> + + <%= user(class: "h-6 w-6 text-gray-500") %> + """ + def user(assigns_or_opts \\ []) + + def user(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/users.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.users /> + + <.users class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= users() %> + + <%= users(class: "h-6 w-6 text-gray-500") %> + """ + def users(assigns_or_opts \\ []) + + def users(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def users(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/video-camera-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.video_camera_slash /> + + <.video_camera_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= video_camera_slash() %> + + <%= video_camera_slash(class: "h-6 w-6 text-gray-500") %> + """ + def video_camera_slash(assigns_or_opts \\ []) + + def video_camera_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def video_camera_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/video-camera.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.video_camera /> + + <.video_camera class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= video_camera() %> + + <%= video_camera(class: "h-6 w-6 text-gray-500") %> + """ + def video_camera(assigns_or_opts \\ []) + + def video_camera(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def video_camera(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/view-columns.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.view_columns /> + + <.view_columns class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= view_columns() %> + + <%= view_columns(class: "h-6 w-6 text-gray-500") %> + """ + def view_columns(assigns_or_opts \\ []) + + def view_columns(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def view_columns(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/wifi.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wifi /> + + <.wifi class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wifi() %> + + <%= wifi(class: "h-6 w-6 text-gray-500") %> + """ + def wifi(assigns_or_opts \\ []) + + def wifi(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wifi(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/wrench-screwdriver.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wrench_screwdriver /> + + <.wrench_screwdriver class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wrench_screwdriver() %> + + <%= wrench_screwdriver(class: "h-6 w-6 text-gray-500") %> + """ + def wrench_screwdriver(assigns_or_opts \\ []) + + def wrench_screwdriver(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wrench_screwdriver(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/wrench.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wrench /> + + <.wrench class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wrench() %> + + <%= wrench(class: "h-6 w-6 text-gray-500") %> + """ + def wrench(assigns_or_opts \\ []) + + def wrench(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wrench(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/outline/x-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.x_circle /> + + <.x_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= x_circle() %> + + <%= x_circle(class: "h-6 w-6 text-gray-500") %> + """ + def x_circle(assigns_or_opts \\ []) + + def x_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def x_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/outline/x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.x_mark /> + + <.x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= x_mark() %> + + <%= x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def x_mark(assigns_or_opts \\ []) + + def x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + +end diff --git a/lib/heroicons/solid.ex b/lib/heroicons/solid.ex new file mode 100644 index 0000000..f37737d --- /dev/null +++ b/lib/heroicons/solid.ex @@ -0,0 +1,11874 @@ +defmodule Heroicons.Solid do + @moduledoc """ + Solid style icons drawn with fills, packaged as Phoenix Components. + + For primary navigation and marketing sections, with a filled appearance, + designed to be rendered at 24x24. + """ + + use Phoenix.Component + + if function_exported?(Phoenix.Component, :assigns_to_attributes, 2) do + @assign_mod Phoenix.Component + @assigns_to_attrs_mod Phoenix.Component + else + @assign_mod Phoenix.LiveView + @assigns_to_attrs_mod Phoenix.LiveView.Helpers + end + + @doc """ + ![](assets/icons/solid/academic-cap.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.academic_cap /> + + <.academic_cap class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= academic_cap() %> + + <%= academic_cap(class: "h-6 w-6 text-gray-500") %> + """ + def academic_cap(assigns_or_opts \\ []) + + def academic_cap(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def academic_cap(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/adjustments-horizontal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.adjustments_horizontal /> + + <.adjustments_horizontal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= adjustments_horizontal() %> + + <%= adjustments_horizontal(class: "h-6 w-6 text-gray-500") %> + """ + def adjustments_horizontal(assigns_or_opts \\ []) + + def adjustments_horizontal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def adjustments_horizontal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/adjustments-vertical.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.adjustments_vertical /> + + <.adjustments_vertical class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= adjustments_vertical() %> + + <%= adjustments_vertical(class: "h-6 w-6 text-gray-500") %> + """ + def adjustments_vertical(assigns_or_opts \\ []) + + def adjustments_vertical(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def adjustments_vertical(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/archive-box-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box_arrow_down /> + + <.archive_box_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box_arrow_down() %> + + <%= archive_box_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box_arrow_down(assigns_or_opts \\ []) + + def archive_box_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/archive-box-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box_x_mark /> + + <.archive_box_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box_x_mark() %> + + <%= archive_box_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box_x_mark(assigns_or_opts \\ []) + + def archive_box_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/archive-box.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.archive_box /> + + <.archive_box class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= archive_box() %> + + <%= archive_box(class: "h-6 w-6 text-gray-500") %> + """ + def archive_box(assigns_or_opts \\ []) + + def archive_box(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def archive_box(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-down-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_circle /> + + <.arrow_down_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_circle() %> + + <%= arrow_down_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_circle(assigns_or_opts \\ []) + + def arrow_down_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-down-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_left /> + + <.arrow_down_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_left() %> + + <%= arrow_down_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_left(assigns_or_opts \\ []) + + def arrow_down_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-down-on-square-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_on_square_stack /> + + <.arrow_down_on_square_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_on_square_stack() %> + + <%= arrow_down_on_square_stack(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_on_square_stack(assigns_or_opts \\ []) + + def arrow_down_on_square_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_on_square_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-down-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_on_square /> + + <.arrow_down_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_on_square() %> + + <%= arrow_down_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_on_square(assigns_or_opts \\ []) + + def arrow_down_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-down-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_right /> + + <.arrow_down_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_right() %> + + <%= arrow_down_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_right(assigns_or_opts \\ []) + + def arrow_down_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-down-tray.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down_tray /> + + <.arrow_down_tray class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down_tray() %> + + <%= arrow_down_tray(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down_tray(assigns_or_opts \\ []) + + def arrow_down_tray(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down_tray(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_down /> + + <.arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_down() %> + + <%= arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_down(assigns_or_opts \\ []) + + def arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-left-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left_circle /> + + <.arrow_left_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left_circle() %> + + <%= arrow_left_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left_circle(assigns_or_opts \\ []) + + def arrow_left_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-left-on-rectangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left_on_rectangle /> + + <.arrow_left_on_rectangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left_on_rectangle() %> + + <%= arrow_left_on_rectangle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left_on_rectangle(assigns_or_opts \\ []) + + def arrow_left_on_rectangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left_on_rectangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_left /> + + <.arrow_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_left() %> + + <%= arrow_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_left(assigns_or_opts \\ []) + + def arrow_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-long-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_down /> + + <.arrow_long_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_down() %> + + <%= arrow_long_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_down(assigns_or_opts \\ []) + + def arrow_long_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-long-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_left /> + + <.arrow_long_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_left() %> + + <%= arrow_long_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_left(assigns_or_opts \\ []) + + def arrow_long_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-long-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_right /> + + <.arrow_long_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_right() %> + + <%= arrow_long_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_right(assigns_or_opts \\ []) + + def arrow_long_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-long-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_long_up /> + + <.arrow_long_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_long_up() %> + + <%= arrow_long_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_long_up(assigns_or_opts \\ []) + + def arrow_long_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_long_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-path.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_path /> + + <.arrow_path class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_path() %> + + <%= arrow_path(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_path(assigns_or_opts \\ []) + + def arrow_path(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_path(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-right-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right_circle /> + + <.arrow_right_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right_circle() %> + + <%= arrow_right_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right_circle(assigns_or_opts \\ []) + + def arrow_right_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-right-on-rectangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right_on_rectangle /> + + <.arrow_right_on_rectangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right_on_rectangle() %> + + <%= arrow_right_on_rectangle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right_on_rectangle(assigns_or_opts \\ []) + + def arrow_right_on_rectangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right_on_rectangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_right /> + + <.arrow_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_right() %> + + <%= arrow_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_right(assigns_or_opts \\ []) + + def arrow_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-top-right-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_top_right_on_square /> + + <.arrow_top_right_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_top_right_on_square() %> + + <%= arrow_top_right_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_top_right_on_square(assigns_or_opts \\ []) + + def arrow_top_right_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_top_right_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-trending-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_trending_down /> + + <.arrow_trending_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_trending_down() %> + + <%= arrow_trending_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_trending_down(assigns_or_opts \\ []) + + def arrow_trending_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_trending_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-trending-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_trending_up /> + + <.arrow_trending_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_trending_up() %> + + <%= arrow_trending_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_trending_up(assigns_or_opts \\ []) + + def arrow_trending_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_trending_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-up-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_circle /> + + <.arrow_up_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_circle() %> + + <%= arrow_up_circle(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_circle(assigns_or_opts \\ []) + + def arrow_up_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-up-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_left /> + + <.arrow_up_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_left() %> + + <%= arrow_up_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_left(assigns_or_opts \\ []) + + def arrow_up_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-up-on-square-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_on_square_stack /> + + <.arrow_up_on_square_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_on_square_stack() %> + + <%= arrow_up_on_square_stack(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_on_square_stack(assigns_or_opts \\ []) + + def arrow_up_on_square_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_on_square_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-up-on-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_on_square /> + + <.arrow_up_on_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_on_square() %> + + <%= arrow_up_on_square(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_on_square(assigns_or_opts \\ []) + + def arrow_up_on_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_on_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-up-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_right /> + + <.arrow_up_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_right() %> + + <%= arrow_up_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_right(assigns_or_opts \\ []) + + def arrow_up_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-up-tray.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up_tray /> + + <.arrow_up_tray class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up_tray() %> + + <%= arrow_up_tray(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up_tray(assigns_or_opts \\ []) + + def arrow_up_tray(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up_tray(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_up /> + + <.arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_up() %> + + <%= arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_up(assigns_or_opts \\ []) + + def arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-uturn-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_down /> + + <.arrow_uturn_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_down() %> + + <%= arrow_uturn_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_down(assigns_or_opts \\ []) + + def arrow_uturn_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-uturn-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_left /> + + <.arrow_uturn_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_left() %> + + <%= arrow_uturn_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_left(assigns_or_opts \\ []) + + def arrow_uturn_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-uturn-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_right /> + + <.arrow_uturn_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_right() %> + + <%= arrow_uturn_right(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_right(assigns_or_opts \\ []) + + def arrow_uturn_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrow-uturn-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrow_uturn_up /> + + <.arrow_uturn_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrow_uturn_up() %> + + <%= arrow_uturn_up(class: "h-6 w-6 text-gray-500") %> + """ + def arrow_uturn_up(assigns_or_opts \\ []) + + def arrow_uturn_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrow_uturn_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrows-pointing-in.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_pointing_in /> + + <.arrows_pointing_in class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_pointing_in() %> + + <%= arrows_pointing_in(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_pointing_in(assigns_or_opts \\ []) + + def arrows_pointing_in(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_pointing_in(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrows-pointing-out.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_pointing_out /> + + <.arrows_pointing_out class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_pointing_out() %> + + <%= arrows_pointing_out(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_pointing_out(assigns_or_opts \\ []) + + def arrows_pointing_out(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_pointing_out(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrows-right-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_right_left /> + + <.arrows_right_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_right_left() %> + + <%= arrows_right_left(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_right_left(assigns_or_opts \\ []) + + def arrows_right_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_right_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/arrows-up-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.arrows_up_down /> + + <.arrows_up_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= arrows_up_down() %> + + <%= arrows_up_down(class: "h-6 w-6 text-gray-500") %> + """ + def arrows_up_down(assigns_or_opts \\ []) + + def arrows_up_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def arrows_up_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/at-symbol.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.at_symbol /> + + <.at_symbol class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= at_symbol() %> + + <%= at_symbol(class: "h-6 w-6 text-gray-500") %> + """ + def at_symbol(assigns_or_opts \\ []) + + def at_symbol(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def at_symbol(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/backspace.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.backspace /> + + <.backspace class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= backspace() %> + + <%= backspace(class: "h-6 w-6 text-gray-500") %> + """ + def backspace(assigns_or_opts \\ []) + + def backspace(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def backspace(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/backward.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.backward /> + + <.backward class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= backward() %> + + <%= backward(class: "h-6 w-6 text-gray-500") %> + """ + def backward(assigns_or_opts \\ []) + + def backward(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def backward(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/banknotes.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.banknotes /> + + <.banknotes class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= banknotes() %> + + <%= banknotes(class: "h-6 w-6 text-gray-500") %> + """ + def banknotes(assigns_or_opts \\ []) + + def banknotes(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def banknotes(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_2 /> + + <.bars_2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_2() %> + + <%= bars_2(class: "h-6 w-6 text-gray-500") %> + """ + def bars_2(assigns_or_opts \\ []) + + def bars_2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-3-bottom-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_bottom_left /> + + <.bars_3_bottom_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_bottom_left() %> + + <%= bars_3_bottom_left(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_bottom_left(assigns_or_opts \\ []) + + def bars_3_bottom_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_bottom_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-3-bottom-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_bottom_right /> + + <.bars_3_bottom_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_bottom_right() %> + + <%= bars_3_bottom_right(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_bottom_right(assigns_or_opts \\ []) + + def bars_3_bottom_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_bottom_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-3-center-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3_center_left /> + + <.bars_3_center_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3_center_left() %> + + <%= bars_3_center_left(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3_center_left(assigns_or_opts \\ []) + + def bars_3_center_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3_center_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-3.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_3 /> + + <.bars_3 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_3() %> + + <%= bars_3(class: "h-6 w-6 text-gray-500") %> + """ + def bars_3(assigns_or_opts \\ []) + + def bars_3(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_3(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-4.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_4 /> + + <.bars_4 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_4() %> + + <%= bars_4(class: "h-6 w-6 text-gray-500") %> + """ + def bars_4(assigns_or_opts \\ []) + + def bars_4(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_4(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_arrow_down /> + + <.bars_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_arrow_down() %> + + <%= bars_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def bars_arrow_down(assigns_or_opts \\ []) + + def bars_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bars-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bars_arrow_up /> + + <.bars_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bars_arrow_up() %> + + <%= bars_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def bars_arrow_up(assigns_or_opts \\ []) + + def bars_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bars_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/beaker.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.beaker /> + + <.beaker class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= beaker() %> + + <%= beaker(class: "h-6 w-6 text-gray-500") %> + """ + def beaker(assigns_or_opts \\ []) + + def beaker(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def beaker(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bell-alert.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_alert /> + + <.bell_alert class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_alert() %> + + <%= bell_alert(class: "h-6 w-6 text-gray-500") %> + """ + def bell_alert(assigns_or_opts \\ []) + + def bell_alert(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_alert(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bell-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_slash /> + + <.bell_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_slash() %> + + <%= bell_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bell_slash(assigns_or_opts \\ []) + + def bell_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bell-snooze.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell_snooze /> + + <.bell_snooze class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell_snooze() %> + + <%= bell_snooze(class: "h-6 w-6 text-gray-500") %> + """ + def bell_snooze(assigns_or_opts \\ []) + + def bell_snooze(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell_snooze(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bell.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bell /> + + <.bell class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bell() %> + + <%= bell(class: "h-6 w-6 text-gray-500") %> + """ + def bell(assigns_or_opts \\ []) + + def bell(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bell(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bolt-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bolt_slash /> + + <.bolt_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bolt_slash() %> + + <%= bolt_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bolt_slash(assigns_or_opts \\ []) + + def bolt_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bolt_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bolt.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bolt /> + + <.bolt class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bolt() %> + + <%= bolt(class: "h-6 w-6 text-gray-500") %> + """ + def bolt(assigns_or_opts \\ []) + + def bolt(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bolt(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/book-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.book_open /> + + <.book_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= book_open() %> + + <%= book_open(class: "h-6 w-6 text-gray-500") %> + """ + def book_open(assigns_or_opts \\ []) + + def book_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def book_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bookmark-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark_slash /> + + <.bookmark_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark_slash() %> + + <%= bookmark_slash(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark_slash(assigns_or_opts \\ []) + + def bookmark_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bookmark-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark_square /> + + <.bookmark_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark_square() %> + + <%= bookmark_square(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark_square(assigns_or_opts \\ []) + + def bookmark_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/bookmark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.bookmark /> + + <.bookmark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= bookmark() %> + + <%= bookmark(class: "h-6 w-6 text-gray-500") %> + """ + def bookmark(assigns_or_opts \\ []) + + def bookmark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def bookmark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/briefcase.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.briefcase /> + + <.briefcase class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= briefcase() %> + + <%= briefcase(class: "h-6 w-6 text-gray-500") %> + """ + def briefcase(assigns_or_opts \\ []) + + def briefcase(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def briefcase(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/building-library.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_library /> + + <.building_library class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_library() %> + + <%= building_library(class: "h-6 w-6 text-gray-500") %> + """ + def building_library(assigns_or_opts \\ []) + + def building_library(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_library(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/building-office-2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_office_2 /> + + <.building_office_2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_office_2() %> + + <%= building_office_2(class: "h-6 w-6 text-gray-500") %> + """ + def building_office_2(assigns_or_opts \\ []) + + def building_office_2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_office_2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/building-office.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_office /> + + <.building_office class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_office() %> + + <%= building_office(class: "h-6 w-6 text-gray-500") %> + """ + def building_office(assigns_or_opts \\ []) + + def building_office(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_office(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/building-storefront.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.building_storefront /> + + <.building_storefront class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= building_storefront() %> + + <%= building_storefront(class: "h-6 w-6 text-gray-500") %> + """ + def building_storefront(assigns_or_opts \\ []) + + def building_storefront(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def building_storefront(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cake.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cake /> + + <.cake class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cake() %> + + <%= cake(class: "h-6 w-6 text-gray-500") %> + """ + def cake(assigns_or_opts \\ []) + + def cake(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cake(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/calculator.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calculator /> + + <.calculator class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calculator() %> + + <%= calculator(class: "h-6 w-6 text-gray-500") %> + """ + def calculator(assigns_or_opts \\ []) + + def calculator(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calculator(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/calendar-days.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calendar_days /> + + <.calendar_days class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calendar_days() %> + + <%= calendar_days(class: "h-6 w-6 text-gray-500") %> + """ + def calendar_days(assigns_or_opts \\ []) + + def calendar_days(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calendar_days(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/calendar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.calendar /> + + <.calendar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= calendar() %> + + <%= calendar(class: "h-6 w-6 text-gray-500") %> + """ + def calendar(assigns_or_opts \\ []) + + def calendar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def calendar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/camera.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.camera /> + + <.camera class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= camera() %> + + <%= camera(class: "h-6 w-6 text-gray-500") %> + """ + def camera(assigns_or_opts \\ []) + + def camera(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def camera(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chart-bar-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_bar_square /> + + <.chart_bar_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_bar_square() %> + + <%= chart_bar_square(class: "h-6 w-6 text-gray-500") %> + """ + def chart_bar_square(assigns_or_opts \\ []) + + def chart_bar_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_bar_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_bar /> + + <.chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_bar() %> + + <%= chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def chart_bar(assigns_or_opts \\ []) + + def chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chart-pie.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chart_pie /> + + <.chart_pie class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chart_pie() %> + + <%= chart_pie(class: "h-6 w-6 text-gray-500") %> + """ + def chart_pie(assigns_or_opts \\ []) + + def chart_pie(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chart_pie(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chat-bubble-bottom-center-text.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_bottom_center_text /> + + <.chat_bubble_bottom_center_text class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_bottom_center_text() %> + + <%= chat_bubble_bottom_center_text(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_bottom_center_text(assigns_or_opts \\ []) + + def chat_bubble_bottom_center_text(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_bottom_center_text(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chat-bubble-bottom-center.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_bottom_center /> + + <.chat_bubble_bottom_center class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_bottom_center() %> + + <%= chat_bubble_bottom_center(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_bottom_center(assigns_or_opts \\ []) + + def chat_bubble_bottom_center(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_bottom_center(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chat-bubble-left-ellipsis.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left_ellipsis /> + + <.chat_bubble_left_ellipsis class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left_ellipsis() %> + + <%= chat_bubble_left_ellipsis(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left_ellipsis(assigns_or_opts \\ []) + + def chat_bubble_left_ellipsis(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left_ellipsis(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chat-bubble-left-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left_right /> + + <.chat_bubble_left_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left_right() %> + + <%= chat_bubble_left_right(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left_right(assigns_or_opts \\ []) + + def chat_bubble_left_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chat-bubble-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_left /> + + <.chat_bubble_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_left() %> + + <%= chat_bubble_left(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_left(assigns_or_opts \\ []) + + def chat_bubble_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chat-bubble-oval-left-ellipsis.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_oval_left_ellipsis /> + + <.chat_bubble_oval_left_ellipsis class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_oval_left_ellipsis() %> + + <%= chat_bubble_oval_left_ellipsis(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_oval_left_ellipsis(assigns_or_opts \\ []) + + def chat_bubble_oval_left_ellipsis(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_oval_left_ellipsis(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chat-bubble-oval-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chat_bubble_oval_left /> + + <.chat_bubble_oval_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chat_bubble_oval_left() %> + + <%= chat_bubble_oval_left(class: "h-6 w-6 text-gray-500") %> + """ + def chat_bubble_oval_left(assigns_or_opts \\ []) + + def chat_bubble_oval_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chat_bubble_oval_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/check-badge.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check_badge /> + + <.check_badge class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check_badge() %> + + <%= check_badge(class: "h-6 w-6 text-gray-500") %> + """ + def check_badge(assigns_or_opts \\ []) + + def check_badge(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check_badge(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/check-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check_circle /> + + <.check_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check_circle() %> + + <%= check_circle(class: "h-6 w-6 text-gray-500") %> + """ + def check_circle(assigns_or_opts \\ []) + + def check_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.check /> + + <.check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= check() %> + + <%= check(class: "h-6 w-6 text-gray-500") %> + """ + def check(assigns_or_opts \\ []) + + def check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-double-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_down /> + + <.chevron_double_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_down() %> + + <%= chevron_double_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_down(assigns_or_opts \\ []) + + def chevron_double_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-double-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_left /> + + <.chevron_double_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_left() %> + + <%= chevron_double_left(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_left(assigns_or_opts \\ []) + + def chevron_double_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-double-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_right /> + + <.chevron_double_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_right() %> + + <%= chevron_double_right(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_right(assigns_or_opts \\ []) + + def chevron_double_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-double-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_double_up /> + + <.chevron_double_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_double_up() %> + + <%= chevron_double_up(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_double_up(assigns_or_opts \\ []) + + def chevron_double_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_double_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_down /> + + <.chevron_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_down() %> + + <%= chevron_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_down(assigns_or_opts \\ []) + + def chevron_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_left /> + + <.chevron_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_left() %> + + <%= chevron_left(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_left(assigns_or_opts \\ []) + + def chevron_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_right /> + + <.chevron_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_right() %> + + <%= chevron_right(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_right(assigns_or_opts \\ []) + + def chevron_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-up-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_up_down /> + + <.chevron_up_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_up_down() %> + + <%= chevron_up_down(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_up_down(assigns_or_opts \\ []) + + def chevron_up_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_up_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/chevron-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.chevron_up /> + + <.chevron_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= chevron_up() %> + + <%= chevron_up(class: "h-6 w-6 text-gray-500") %> + """ + def chevron_up(assigns_or_opts \\ []) + + def chevron_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def chevron_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/circle-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.circle_stack /> + + <.circle_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= circle_stack() %> + + <%= circle_stack(class: "h-6 w-6 text-gray-500") %> + """ + def circle_stack(assigns_or_opts \\ []) + + def circle_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def circle_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/clipboard-document-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document_check /> + + <.clipboard_document_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document_check() %> + + <%= clipboard_document_check(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document_check(assigns_or_opts \\ []) + + def clipboard_document_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/clipboard-document-list.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document_list /> + + <.clipboard_document_list class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document_list() %> + + <%= clipboard_document_list(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document_list(assigns_or_opts \\ []) + + def clipboard_document_list(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document_list(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/clipboard-document.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard_document /> + + <.clipboard_document class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard_document() %> + + <%= clipboard_document(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard_document(assigns_or_opts \\ []) + + def clipboard_document(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard_document(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/clipboard.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clipboard /> + + <.clipboard class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clipboard() %> + + <%= clipboard(class: "h-6 w-6 text-gray-500") %> + """ + def clipboard(assigns_or_opts \\ []) + + def clipboard(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clipboard(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/clock.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.clock /> + + <.clock class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= clock() %> + + <%= clock(class: "h-6 w-6 text-gray-500") %> + """ + def clock(assigns_or_opts \\ []) + + def clock(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def clock(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cloud-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud_arrow_down /> + + <.cloud_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud_arrow_down() %> + + <%= cloud_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def cloud_arrow_down(assigns_or_opts \\ []) + + def cloud_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cloud-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud_arrow_up /> + + <.cloud_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud_arrow_up() %> + + <%= cloud_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def cloud_arrow_up(assigns_or_opts \\ []) + + def cloud_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cloud.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cloud /> + + <.cloud class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cloud() %> + + <%= cloud(class: "h-6 w-6 text-gray-500") %> + """ + def cloud(assigns_or_opts \\ []) + + def cloud(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cloud(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/code-bracket-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.code_bracket_square /> + + <.code_bracket_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= code_bracket_square() %> + + <%= code_bracket_square(class: "h-6 w-6 text-gray-500") %> + """ + def code_bracket_square(assigns_or_opts \\ []) + + def code_bracket_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def code_bracket_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/code-bracket.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.code_bracket /> + + <.code_bracket class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= code_bracket() %> + + <%= code_bracket(class: "h-6 w-6 text-gray-500") %> + """ + def code_bracket(assigns_or_opts \\ []) + + def code_bracket(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def code_bracket(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cog-6-tooth.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog_6_tooth /> + + <.cog_6_tooth class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog_6_tooth() %> + + <%= cog_6_tooth(class: "h-6 w-6 text-gray-500") %> + """ + def cog_6_tooth(assigns_or_opts \\ []) + + def cog_6_tooth(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog_6_tooth(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cog-8-tooth.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog_8_tooth /> + + <.cog_8_tooth class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog_8_tooth() %> + + <%= cog_8_tooth(class: "h-6 w-6 text-gray-500") %> + """ + def cog_8_tooth(assigns_or_opts \\ []) + + def cog_8_tooth(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog_8_tooth(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cog.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cog /> + + <.cog class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cog() %> + + <%= cog(class: "h-6 w-6 text-gray-500") %> + """ + def cog(assigns_or_opts \\ []) + + def cog(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cog(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/command-line.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.command_line /> + + <.command_line class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= command_line() %> + + <%= command_line(class: "h-6 w-6 text-gray-500") %> + """ + def command_line(assigns_or_opts \\ []) + + def command_line(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def command_line(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/computer-desktop.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.computer_desktop /> + + <.computer_desktop class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= computer_desktop() %> + + <%= computer_desktop(class: "h-6 w-6 text-gray-500") %> + """ + def computer_desktop(assigns_or_opts \\ []) + + def computer_desktop(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def computer_desktop(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cpu-chip.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cpu_chip /> + + <.cpu_chip class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cpu_chip() %> + + <%= cpu_chip(class: "h-6 w-6 text-gray-500") %> + """ + def cpu_chip(assigns_or_opts \\ []) + + def cpu_chip(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cpu_chip(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/credit-card.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.credit_card /> + + <.credit_card class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= credit_card() %> + + <%= credit_card(class: "h-6 w-6 text-gray-500") %> + """ + def credit_card(assigns_or_opts \\ []) + + def credit_card(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def credit_card(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cube.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cube /> + + <.cube class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cube() %> + + <%= cube(class: "h-6 w-6 text-gray-500") %> + """ + def cube(assigns_or_opts \\ []) + + def cube(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cube(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/currency-dollar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_dollar /> + + <.currency_dollar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_dollar() %> + + <%= currency_dollar(class: "h-6 w-6 text-gray-500") %> + """ + def currency_dollar(assigns_or_opts \\ []) + + def currency_dollar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_dollar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/currency-euro.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_euro /> + + <.currency_euro class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_euro() %> + + <%= currency_euro(class: "h-6 w-6 text-gray-500") %> + """ + def currency_euro(assigns_or_opts \\ []) + + def currency_euro(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_euro(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/currency-pound.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_pound /> + + <.currency_pound class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_pound() %> + + <%= currency_pound(class: "h-6 w-6 text-gray-500") %> + """ + def currency_pound(assigns_or_opts \\ []) + + def currency_pound(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_pound(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/currency-rupee.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_rupee /> + + <.currency_rupee class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_rupee() %> + + <%= currency_rupee(class: "h-6 w-6 text-gray-500") %> + """ + def currency_rupee(assigns_or_opts \\ []) + + def currency_rupee(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_rupee(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/currency-yen.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.currency_yen /> + + <.currency_yen class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= currency_yen() %> + + <%= currency_yen(class: "h-6 w-6 text-gray-500") %> + """ + def currency_yen(assigns_or_opts \\ []) + + def currency_yen(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def currency_yen(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cursor-arrow-rays.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cursor_arrow_rays /> + + <.cursor_arrow_rays class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cursor_arrow_rays() %> + + <%= cursor_arrow_rays(class: "h-6 w-6 text-gray-500") %> + """ + def cursor_arrow_rays(assigns_or_opts \\ []) + + def cursor_arrow_rays(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cursor_arrow_rays(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/cursor-arrow-ripple.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.cursor_arrow_ripple /> + + <.cursor_arrow_ripple class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= cursor_arrow_ripple() %> + + <%= cursor_arrow_ripple(class: "h-6 w-6 text-gray-500") %> + """ + def cursor_arrow_ripple(assigns_or_opts \\ []) + + def cursor_arrow_ripple(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def cursor_arrow_ripple(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/device-phone-mobile.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.device_phone_mobile /> + + <.device_phone_mobile class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= device_phone_mobile() %> + + <%= device_phone_mobile(class: "h-6 w-6 text-gray-500") %> + """ + def device_phone_mobile(assigns_or_opts \\ []) + + def device_phone_mobile(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def device_phone_mobile(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/device-tablet.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.device_tablet /> + + <.device_tablet class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= device_tablet() %> + + <%= device_tablet(class: "h-6 w-6 text-gray-500") %> + """ + def device_tablet(assigns_or_opts \\ []) + + def device_tablet(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def device_tablet(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_arrow_down /> + + <.document_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_arrow_down() %> + + <%= document_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def document_arrow_down(assigns_or_opts \\ []) + + def document_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-arrow-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_arrow_up /> + + <.document_arrow_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_arrow_up() %> + + <%= document_arrow_up(class: "h-6 w-6 text-gray-500") %> + """ + def document_arrow_up(assigns_or_opts \\ []) + + def document_arrow_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_arrow_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_chart_bar /> + + <.document_chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_chart_bar() %> + + <%= document_chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def document_chart_bar(assigns_or_opts \\ []) + + def document_chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_check /> + + <.document_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_check() %> + + <%= document_check(class: "h-6 w-6 text-gray-500") %> + """ + def document_check(assigns_or_opts \\ []) + + def document_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-duplicate.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_duplicate /> + + <.document_duplicate class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_duplicate() %> + + <%= document_duplicate(class: "h-6 w-6 text-gray-500") %> + """ + def document_duplicate(assigns_or_opts \\ []) + + def document_duplicate(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_duplicate(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-magnifying-glass.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_magnifying_glass /> + + <.document_magnifying_glass class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_magnifying_glass() %> + + <%= document_magnifying_glass(class: "h-6 w-6 text-gray-500") %> + """ + def document_magnifying_glass(assigns_or_opts \\ []) + + def document_magnifying_glass(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_magnifying_glass(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_minus /> + + <.document_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_minus() %> + + <%= document_minus(class: "h-6 w-6 text-gray-500") %> + """ + def document_minus(assigns_or_opts \\ []) + + def document_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_plus /> + + <.document_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_plus() %> + + <%= document_plus(class: "h-6 w-6 text-gray-500") %> + """ + def document_plus(assigns_or_opts \\ []) + + def document_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document-text.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document_text /> + + <.document_text class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document_text() %> + + <%= document_text(class: "h-6 w-6 text-gray-500") %> + """ + def document_text(assigns_or_opts \\ []) + + def document_text(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document_text(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/document.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.document /> + + <.document class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= document() %> + + <%= document(class: "h-6 w-6 text-gray-500") %> + """ + def document(assigns_or_opts \\ []) + + def document(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def document(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/ellipsis-horizontal-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_horizontal_circle /> + + <.ellipsis_horizontal_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_horizontal_circle() %> + + <%= ellipsis_horizontal_circle(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_horizontal_circle(assigns_or_opts \\ []) + + def ellipsis_horizontal_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_horizontal_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/ellipsis-horizontal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_horizontal /> + + <.ellipsis_horizontal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_horizontal() %> + + <%= ellipsis_horizontal(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_horizontal(assigns_or_opts \\ []) + + def ellipsis_horizontal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_horizontal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/ellipsis-vertical.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ellipsis_vertical /> + + <.ellipsis_vertical class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ellipsis_vertical() %> + + <%= ellipsis_vertical(class: "h-6 w-6 text-gray-500") %> + """ + def ellipsis_vertical(assigns_or_opts \\ []) + + def ellipsis_vertical(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ellipsis_vertical(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/envelope-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.envelope_open /> + + <.envelope_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= envelope_open() %> + + <%= envelope_open(class: "h-6 w-6 text-gray-500") %> + """ + def envelope_open(assigns_or_opts \\ []) + + def envelope_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def envelope_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/envelope.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.envelope /> + + <.envelope class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= envelope() %> + + <%= envelope(class: "h-6 w-6 text-gray-500") %> + """ + def envelope(assigns_or_opts \\ []) + + def envelope(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def envelope(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/exclamation-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.exclamation_circle /> + + <.exclamation_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= exclamation_circle() %> + + <%= exclamation_circle(class: "h-6 w-6 text-gray-500") %> + """ + def exclamation_circle(assigns_or_opts \\ []) + + def exclamation_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def exclamation_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/exclamation-triangle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.exclamation_triangle /> + + <.exclamation_triangle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= exclamation_triangle() %> + + <%= exclamation_triangle(class: "h-6 w-6 text-gray-500") %> + """ + def exclamation_triangle(assigns_or_opts \\ []) + + def exclamation_triangle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def exclamation_triangle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/eye-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.eye_slash /> + + <.eye_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= eye_slash() %> + + <%= eye_slash(class: "h-6 w-6 text-gray-500") %> + """ + def eye_slash(assigns_or_opts \\ []) + + def eye_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def eye_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/eye.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.eye /> + + <.eye class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= eye() %> + + <%= eye(class: "h-6 w-6 text-gray-500") %> + """ + def eye(assigns_or_opts \\ []) + + def eye(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def eye(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/face-frown.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.face_frown /> + + <.face_frown class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= face_frown() %> + + <%= face_frown(class: "h-6 w-6 text-gray-500") %> + """ + def face_frown(assigns_or_opts \\ []) + + def face_frown(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def face_frown(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/face-smile.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.face_smile /> + + <.face_smile class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= face_smile() %> + + <%= face_smile(class: "h-6 w-6 text-gray-500") %> + """ + def face_smile(assigns_or_opts \\ []) + + def face_smile(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def face_smile(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/film.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.film /> + + <.film class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= film() %> + + <%= film(class: "h-6 w-6 text-gray-500") %> + """ + def film(assigns_or_opts \\ []) + + def film(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def film(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/finger-print.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.finger_print /> + + <.finger_print class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= finger_print() %> + + <%= finger_print(class: "h-6 w-6 text-gray-500") %> + """ + def finger_print(assigns_or_opts \\ []) + + def finger_print(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def finger_print(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/fire.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.fire /> + + <.fire class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= fire() %> + + <%= fire(class: "h-6 w-6 text-gray-500") %> + """ + def fire(assigns_or_opts \\ []) + + def fire(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def fire(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/flag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.flag /> + + <.flag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= flag() %> + + <%= flag(class: "h-6 w-6 text-gray-500") %> + """ + def flag(assigns_or_opts \\ []) + + def flag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def flag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/folder-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_arrow_down /> + + <.folder_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_arrow_down() %> + + <%= folder_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def folder_arrow_down(assigns_or_opts \\ []) + + def folder_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/folder-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_minus /> + + <.folder_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_minus() %> + + <%= folder_minus(class: "h-6 w-6 text-gray-500") %> + """ + def folder_minus(assigns_or_opts \\ []) + + def folder_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/folder-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_open /> + + <.folder_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_open() %> + + <%= folder_open(class: "h-6 w-6 text-gray-500") %> + """ + def folder_open(assigns_or_opts \\ []) + + def folder_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/folder-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder_plus /> + + <.folder_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder_plus() %> + + <%= folder_plus(class: "h-6 w-6 text-gray-500") %> + """ + def folder_plus(assigns_or_opts \\ []) + + def folder_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/folder.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.folder /> + + <.folder class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= folder() %> + + <%= folder(class: "h-6 w-6 text-gray-500") %> + """ + def folder(assigns_or_opts \\ []) + + def folder(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def folder(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/forward.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.forward /> + + <.forward class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= forward() %> + + <%= forward(class: "h-6 w-6 text-gray-500") %> + """ + def forward(assigns_or_opts \\ []) + + def forward(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def forward(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/funnel.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.funnel /> + + <.funnel class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= funnel() %> + + <%= funnel(class: "h-6 w-6 text-gray-500") %> + """ + def funnel(assigns_or_opts \\ []) + + def funnel(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def funnel(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/gif.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gif /> + + <.gif class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gif() %> + + <%= gif(class: "h-6 w-6 text-gray-500") %> + """ + def gif(assigns_or_opts \\ []) + + def gif(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gif(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/gift-top.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gift_top /> + + <.gift_top class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gift_top() %> + + <%= gift_top(class: "h-6 w-6 text-gray-500") %> + """ + def gift_top(assigns_or_opts \\ []) + + def gift_top(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gift_top(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/gift.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.gift /> + + <.gift class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= gift() %> + + <%= gift(class: "h-6 w-6 text-gray-500") %> + """ + def gift(assigns_or_opts \\ []) + + def gift(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def gift(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/globe-alt.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_alt /> + + <.globe_alt class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_alt() %> + + <%= globe_alt(class: "h-6 w-6 text-gray-500") %> + """ + def globe_alt(assigns_or_opts \\ []) + + def globe_alt(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_alt(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/globe-americas.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_americas /> + + <.globe_americas class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_americas() %> + + <%= globe_americas(class: "h-6 w-6 text-gray-500") %> + """ + def globe_americas(assigns_or_opts \\ []) + + def globe_americas(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_americas(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/globe-asia-australia.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_asia_australia /> + + <.globe_asia_australia class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_asia_australia() %> + + <%= globe_asia_australia(class: "h-6 w-6 text-gray-500") %> + """ + def globe_asia_australia(assigns_or_opts \\ []) + + def globe_asia_australia(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_asia_australia(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/globe-europe-africa.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.globe_europe_africa /> + + <.globe_europe_africa class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= globe_europe_africa() %> + + <%= globe_europe_africa(class: "h-6 w-6 text-gray-500") %> + """ + def globe_europe_africa(assigns_or_opts \\ []) + + def globe_europe_africa(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def globe_europe_africa(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/hand-raised.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_raised /> + + <.hand_raised class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_raised() %> + + <%= hand_raised(class: "h-6 w-6 text-gray-500") %> + """ + def hand_raised(assigns_or_opts \\ []) + + def hand_raised(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_raised(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/hand-thumb-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_thumb_down /> + + <.hand_thumb_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_thumb_down() %> + + <%= hand_thumb_down(class: "h-6 w-6 text-gray-500") %> + """ + def hand_thumb_down(assigns_or_opts \\ []) + + def hand_thumb_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_thumb_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/hand-thumb-up.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hand_thumb_up /> + + <.hand_thumb_up class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hand_thumb_up() %> + + <%= hand_thumb_up(class: "h-6 w-6 text-gray-500") %> + """ + def hand_thumb_up(assigns_or_opts \\ []) + + def hand_thumb_up(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hand_thumb_up(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/hashtag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.hashtag /> + + <.hashtag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= hashtag() %> + + <%= hashtag(class: "h-6 w-6 text-gray-500") %> + """ + def hashtag(assigns_or_opts \\ []) + + def hashtag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def hashtag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/heart.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.heart /> + + <.heart class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= heart() %> + + <%= heart(class: "h-6 w-6 text-gray-500") %> + """ + def heart(assigns_or_opts \\ []) + + def heart(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def heart(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/home-modern.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.home_modern /> + + <.home_modern class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= home_modern() %> + + <%= home_modern(class: "h-6 w-6 text-gray-500") %> + """ + def home_modern(assigns_or_opts \\ []) + + def home_modern(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def home_modern(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/home.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.home /> + + <.home class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= home() %> + + <%= home(class: "h-6 w-6 text-gray-500") %> + """ + def home(assigns_or_opts \\ []) + + def home(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def home(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/identification.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.identification /> + + <.identification class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= identification() %> + + <%= identification(class: "h-6 w-6 text-gray-500") %> + """ + def identification(assigns_or_opts \\ []) + + def identification(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def identification(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/inbox-arrow-down.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox_arrow_down /> + + <.inbox_arrow_down class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox_arrow_down() %> + + <%= inbox_arrow_down(class: "h-6 w-6 text-gray-500") %> + """ + def inbox_arrow_down(assigns_or_opts \\ []) + + def inbox_arrow_down(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox_arrow_down(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/inbox-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox_stack /> + + <.inbox_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox_stack() %> + + <%= inbox_stack(class: "h-6 w-6 text-gray-500") %> + """ + def inbox_stack(assigns_or_opts \\ []) + + def inbox_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/inbox.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.inbox /> + + <.inbox class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= inbox() %> + + <%= inbox(class: "h-6 w-6 text-gray-500") %> + """ + def inbox(assigns_or_opts \\ []) + + def inbox(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def inbox(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/information-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.information_circle /> + + <.information_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= information_circle() %> + + <%= information_circle(class: "h-6 w-6 text-gray-500") %> + """ + def information_circle(assigns_or_opts \\ []) + + def information_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def information_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/key.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.key /> + + <.key class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= key() %> + + <%= key(class: "h-6 w-6 text-gray-500") %> + """ + def key(assigns_or_opts \\ []) + + def key(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def key(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/language.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.language /> + + <.language class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= language() %> + + <%= language(class: "h-6 w-6 text-gray-500") %> + """ + def language(assigns_or_opts \\ []) + + def language(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def language(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/lifebuoy.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lifebuoy /> + + <.lifebuoy class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lifebuoy() %> + + <%= lifebuoy(class: "h-6 w-6 text-gray-500") %> + """ + def lifebuoy(assigns_or_opts \\ []) + + def lifebuoy(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lifebuoy(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/light-bulb.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.light_bulb /> + + <.light_bulb class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= light_bulb() %> + + <%= light_bulb(class: "h-6 w-6 text-gray-500") %> + """ + def light_bulb(assigns_or_opts \\ []) + + def light_bulb(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def light_bulb(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/link.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.link /> + + <.link class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= link() %> + + <%= link(class: "h-6 w-6 text-gray-500") %> + """ + def link(assigns_or_opts \\ []) + + def link(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def link(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/list-bullet.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.list_bullet /> + + <.list_bullet class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= list_bullet() %> + + <%= list_bullet(class: "h-6 w-6 text-gray-500") %> + """ + def list_bullet(assigns_or_opts \\ []) + + def list_bullet(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def list_bullet(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/lock-closed.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lock_closed /> + + <.lock_closed class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lock_closed() %> + + <%= lock_closed(class: "h-6 w-6 text-gray-500") %> + """ + def lock_closed(assigns_or_opts \\ []) + + def lock_closed(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lock_closed(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/lock-open.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.lock_open /> + + <.lock_open class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= lock_open() %> + + <%= lock_open(class: "h-6 w-6 text-gray-500") %> + """ + def lock_open(assigns_or_opts \\ []) + + def lock_open(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def lock_open(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/magnifying-glass-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_circle /> + + <.magnifying_glass_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_circle() %> + + <%= magnifying_glass_circle(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_circle(assigns_or_opts \\ []) + + def magnifying_glass_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/magnifying-glass-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_minus /> + + <.magnifying_glass_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_minus() %> + + <%= magnifying_glass_minus(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_minus(assigns_or_opts \\ []) + + def magnifying_glass_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/magnifying-glass-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass_plus /> + + <.magnifying_glass_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass_plus() %> + + <%= magnifying_glass_plus(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass_plus(assigns_or_opts \\ []) + + def magnifying_glass_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/magnifying-glass.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.magnifying_glass /> + + <.magnifying_glass class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= magnifying_glass() %> + + <%= magnifying_glass(class: "h-6 w-6 text-gray-500") %> + """ + def magnifying_glass(assigns_or_opts \\ []) + + def magnifying_glass(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def magnifying_glass(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/map-pin.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.map_pin /> + + <.map_pin class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= map_pin() %> + + <%= map_pin(class: "h-6 w-6 text-gray-500") %> + """ + def map_pin(assigns_or_opts \\ []) + + def map_pin(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def map_pin(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/map.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.map /> + + <.map class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= map() %> + + <%= map(class: "h-6 w-6 text-gray-500") %> + """ + def map(assigns_or_opts \\ []) + + def map(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def map(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/megaphone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.megaphone /> + + <.megaphone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= megaphone() %> + + <%= megaphone(class: "h-6 w-6 text-gray-500") %> + """ + def megaphone(assigns_or_opts \\ []) + + def megaphone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def megaphone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/microphone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.microphone /> + + <.microphone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= microphone() %> + + <%= microphone(class: "h-6 w-6 text-gray-500") %> + """ + def microphone(assigns_or_opts \\ []) + + def microphone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def microphone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/minus-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.minus_circle /> + + <.minus_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= minus_circle() %> + + <%= minus_circle(class: "h-6 w-6 text-gray-500") %> + """ + def minus_circle(assigns_or_opts \\ []) + + def minus_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def minus_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.minus /> + + <.minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= minus() %> + + <%= minus(class: "h-6 w-6 text-gray-500") %> + """ + def minus(assigns_or_opts \\ []) + + def minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/moon.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.moon /> + + <.moon class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= moon() %> + + <%= moon(class: "h-6 w-6 text-gray-500") %> + """ + def moon(assigns_or_opts \\ []) + + def moon(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def moon(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/musical-note.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.musical_note /> + + <.musical_note class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= musical_note() %> + + <%= musical_note(class: "h-6 w-6 text-gray-500") %> + """ + def musical_note(assigns_or_opts \\ []) + + def musical_note(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def musical_note(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/newspaper.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.newspaper /> + + <.newspaper class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= newspaper() %> + + <%= newspaper(class: "h-6 w-6 text-gray-500") %> + """ + def newspaper(assigns_or_opts \\ []) + + def newspaper(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def newspaper(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/no-symbol.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.no_symbol /> + + <.no_symbol class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= no_symbol() %> + + <%= no_symbol(class: "h-6 w-6 text-gray-500") %> + """ + def no_symbol(assigns_or_opts \\ []) + + def no_symbol(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def no_symbol(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/paper-airplane.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.paper_airplane /> + + <.paper_airplane class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= paper_airplane() %> + + <%= paper_airplane(class: "h-6 w-6 text-gray-500") %> + """ + def paper_airplane(assigns_or_opts \\ []) + + def paper_airplane(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def paper_airplane(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/paper-clip.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.paper_clip /> + + <.paper_clip class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= paper_clip() %> + + <%= paper_clip(class: "h-6 w-6 text-gray-500") %> + """ + def paper_clip(assigns_or_opts \\ []) + + def paper_clip(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def paper_clip(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/pause.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pause /> + + <.pause class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pause() %> + + <%= pause(class: "h-6 w-6 text-gray-500") %> + """ + def pause(assigns_or_opts \\ []) + + def pause(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pause(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/pencil-square.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pencil_square /> + + <.pencil_square class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pencil_square() %> + + <%= pencil_square(class: "h-6 w-6 text-gray-500") %> + """ + def pencil_square(assigns_or_opts \\ []) + + def pencil_square(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pencil_square(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/pencil.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.pencil /> + + <.pencil class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= pencil() %> + + <%= pencil(class: "h-6 w-6 text-gray-500") %> + """ + def pencil(assigns_or_opts \\ []) + + def pencil(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def pencil(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/phone-arrow-down-left.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_arrow_down_left /> + + <.phone_arrow_down_left class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_arrow_down_left() %> + + <%= phone_arrow_down_left(class: "h-6 w-6 text-gray-500") %> + """ + def phone_arrow_down_left(assigns_or_opts \\ []) + + def phone_arrow_down_left(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_arrow_down_left(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/phone-arrow-up-right.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_arrow_up_right /> + + <.phone_arrow_up_right class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_arrow_up_right() %> + + <%= phone_arrow_up_right(class: "h-6 w-6 text-gray-500") %> + """ + def phone_arrow_up_right(assigns_or_opts \\ []) + + def phone_arrow_up_right(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_arrow_up_right(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/phone-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone_x_mark /> + + <.phone_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone_x_mark() %> + + <%= phone_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def phone_x_mark(assigns_or_opts \\ []) + + def phone_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/phone.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.phone /> + + <.phone class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= phone() %> + + <%= phone(class: "h-6 w-6 text-gray-500") %> + """ + def phone(assigns_or_opts \\ []) + + def phone(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def phone(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/photo.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.photo /> + + <.photo class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= photo() %> + + <%= photo(class: "h-6 w-6 text-gray-500") %> + """ + def photo(assigns_or_opts \\ []) + + def photo(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def photo(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/play-pause.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.play_pause /> + + <.play_pause class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= play_pause() %> + + <%= play_pause(class: "h-6 w-6 text-gray-500") %> + """ + def play_pause(assigns_or_opts \\ []) + + def play_pause(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def play_pause(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/play.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.play /> + + <.play class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= play() %> + + <%= play(class: "h-6 w-6 text-gray-500") %> + """ + def play(assigns_or_opts \\ []) + + def play(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def play(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/plus-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.plus_circle /> + + <.plus_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= plus_circle() %> + + <%= plus_circle(class: "h-6 w-6 text-gray-500") %> + """ + def plus_circle(assigns_or_opts \\ []) + + def plus_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def plus_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.plus /> + + <.plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= plus() %> + + <%= plus(class: "h-6 w-6 text-gray-500") %> + """ + def plus(assigns_or_opts \\ []) + + def plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/presentation-chart-bar.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.presentation_chart_bar /> + + <.presentation_chart_bar class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= presentation_chart_bar() %> + + <%= presentation_chart_bar(class: "h-6 w-6 text-gray-500") %> + """ + def presentation_chart_bar(assigns_or_opts \\ []) + + def presentation_chart_bar(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def presentation_chart_bar(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/presentation-chart-line.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.presentation_chart_line /> + + <.presentation_chart_line class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= presentation_chart_line() %> + + <%= presentation_chart_line(class: "h-6 w-6 text-gray-500") %> + """ + def presentation_chart_line(assigns_or_opts \\ []) + + def presentation_chart_line(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def presentation_chart_line(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/printer.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.printer /> + + <.printer class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= printer() %> + + <%= printer(class: "h-6 w-6 text-gray-500") %> + """ + def printer(assigns_or_opts \\ []) + + def printer(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def printer(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/puzzle-piece.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.puzzle_piece /> + + <.puzzle_piece class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= puzzle_piece() %> + + <%= puzzle_piece(class: "h-6 w-6 text-gray-500") %> + """ + def puzzle_piece(assigns_or_opts \\ []) + + def puzzle_piece(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def puzzle_piece(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/qr-code.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.qr_code /> + + <.qr_code class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= qr_code() %> + + <%= qr_code(class: "h-6 w-6 text-gray-500") %> + """ + def qr_code(assigns_or_opts \\ []) + + def qr_code(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def qr_code(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/question-mark-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.question_mark_circle /> + + <.question_mark_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= question_mark_circle() %> + + <%= question_mark_circle(class: "h-6 w-6 text-gray-500") %> + """ + def question_mark_circle(assigns_or_opts \\ []) + + def question_mark_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def question_mark_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/queue-list.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.queue_list /> + + <.queue_list class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= queue_list() %> + + <%= queue_list(class: "h-6 w-6 text-gray-500") %> + """ + def queue_list(assigns_or_opts \\ []) + + def queue_list(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def queue_list(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/radio.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.radio /> + + <.radio class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= radio() %> + + <%= radio(class: "h-6 w-6 text-gray-500") %> + """ + def radio(assigns_or_opts \\ []) + + def radio(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def radio(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/receipt-percent.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.receipt_percent /> + + <.receipt_percent class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= receipt_percent() %> + + <%= receipt_percent(class: "h-6 w-6 text-gray-500") %> + """ + def receipt_percent(assigns_or_opts \\ []) + + def receipt_percent(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def receipt_percent(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/receipt-refund.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.receipt_refund /> + + <.receipt_refund class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= receipt_refund() %> + + <%= receipt_refund(class: "h-6 w-6 text-gray-500") %> + """ + def receipt_refund(assigns_or_opts \\ []) + + def receipt_refund(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def receipt_refund(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/rectangle-group.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rectangle_group /> + + <.rectangle_group class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rectangle_group() %> + + <%= rectangle_group(class: "h-6 w-6 text-gray-500") %> + """ + def rectangle_group(assigns_or_opts \\ []) + + def rectangle_group(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rectangle_group(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/rectangle-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rectangle_stack /> + + <.rectangle_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rectangle_stack() %> + + <%= rectangle_stack(class: "h-6 w-6 text-gray-500") %> + """ + def rectangle_stack(assigns_or_opts \\ []) + + def rectangle_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rectangle_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/rss.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.rss /> + + <.rss class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= rss() %> + + <%= rss(class: "h-6 w-6 text-gray-500") %> + """ + def rss(assigns_or_opts \\ []) + + def rss(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def rss(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/scale.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.scale /> + + <.scale class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= scale() %> + + <%= scale(class: "h-6 w-6 text-gray-500") %> + """ + def scale(assigns_or_opts \\ []) + + def scale(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def scale(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/scissors.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.scissors /> + + <.scissors class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= scissors() %> + + <%= scissors(class: "h-6 w-6 text-gray-500") %> + """ + def scissors(assigns_or_opts \\ []) + + def scissors(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def scissors(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/server-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.server_stack /> + + <.server_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= server_stack() %> + + <%= server_stack(class: "h-6 w-6 text-gray-500") %> + """ + def server_stack(assigns_or_opts \\ []) + + def server_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def server_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/server.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.server /> + + <.server class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= server() %> + + <%= server(class: "h-6 w-6 text-gray-500") %> + """ + def server(assigns_or_opts \\ []) + + def server(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def server(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/share.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.share /> + + <.share class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= share() %> + + <%= share(class: "h-6 w-6 text-gray-500") %> + """ + def share(assigns_or_opts \\ []) + + def share(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def share(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/shield-check.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shield_check /> + + <.shield_check class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shield_check() %> + + <%= shield_check(class: "h-6 w-6 text-gray-500") %> + """ + def shield_check(assigns_or_opts \\ []) + + def shield_check(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shield_check(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/shield-exclamation.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shield_exclamation /> + + <.shield_exclamation class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shield_exclamation() %> + + <%= shield_exclamation(class: "h-6 w-6 text-gray-500") %> + """ + def shield_exclamation(assigns_or_opts \\ []) + + def shield_exclamation(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shield_exclamation(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/shopping-bag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shopping_bag /> + + <.shopping_bag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shopping_bag() %> + + <%= shopping_bag(class: "h-6 w-6 text-gray-500") %> + """ + def shopping_bag(assigns_or_opts \\ []) + + def shopping_bag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shopping_bag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/shopping-cart.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.shopping_cart /> + + <.shopping_cart class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= shopping_cart() %> + + <%= shopping_cart(class: "h-6 w-6 text-gray-500") %> + """ + def shopping_cart(assigns_or_opts \\ []) + + def shopping_cart(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def shopping_cart(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/signal-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.signal_slash /> + + <.signal_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= signal_slash() %> + + <%= signal_slash(class: "h-6 w-6 text-gray-500") %> + """ + def signal_slash(assigns_or_opts \\ []) + + def signal_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def signal_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/signal.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.signal /> + + <.signal class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= signal() %> + + <%= signal(class: "h-6 w-6 text-gray-500") %> + """ + def signal(assigns_or_opts \\ []) + + def signal(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def signal(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/sparkles.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.sparkles /> + + <.sparkles class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= sparkles() %> + + <%= sparkles(class: "h-6 w-6 text-gray-500") %> + """ + def sparkles(assigns_or_opts \\ []) + + def sparkles(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def sparkles(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/speaker-wave.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.speaker_wave /> + + <.speaker_wave class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= speaker_wave() %> + + <%= speaker_wave(class: "h-6 w-6 text-gray-500") %> + """ + def speaker_wave(assigns_or_opts \\ []) + + def speaker_wave(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def speaker_wave(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/speaker-x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.speaker_x_mark /> + + <.speaker_x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= speaker_x_mark() %> + + <%= speaker_x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def speaker_x_mark(assigns_or_opts \\ []) + + def speaker_x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def speaker_x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/square-2-stack.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.square_2_stack /> + + <.square_2_stack class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= square_2_stack() %> + + <%= square_2_stack(class: "h-6 w-6 text-gray-500") %> + """ + def square_2_stack(assigns_or_opts \\ []) + + def square_2_stack(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def square_2_stack(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/squares-2x2.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.squares_2x2 /> + + <.squares_2x2 class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= squares_2x2() %> + + <%= squares_2x2(class: "h-6 w-6 text-gray-500") %> + """ + def squares_2x2(assigns_or_opts \\ []) + + def squares_2x2(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def squares_2x2(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/squares-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.squares_plus /> + + <.squares_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= squares_plus() %> + + <%= squares_plus(class: "h-6 w-6 text-gray-500") %> + """ + def squares_plus(assigns_or_opts \\ []) + + def squares_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def squares_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/star.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.star /> + + <.star class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= star() %> + + <%= star(class: "h-6 w-6 text-gray-500") %> + """ + def star(assigns_or_opts \\ []) + + def star(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def star(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/stop.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.stop /> + + <.stop class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= stop() %> + + <%= stop(class: "h-6 w-6 text-gray-500") %> + """ + def stop(assigns_or_opts \\ []) + + def stop(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def stop(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/sun.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.sun /> + + <.sun class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= sun() %> + + <%= sun(class: "h-6 w-6 text-gray-500") %> + """ + def sun(assigns_or_opts \\ []) + + def sun(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def sun(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/swatch.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.swatch /> + + <.swatch class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= swatch() %> + + <%= swatch(class: "h-6 w-6 text-gray-500") %> + """ + def swatch(assigns_or_opts \\ []) + + def swatch(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def swatch(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/table-cells.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.table_cells /> + + <.table_cells class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= table_cells() %> + + <%= table_cells(class: "h-6 w-6 text-gray-500") %> + """ + def table_cells(assigns_or_opts \\ []) + + def table_cells(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def table_cells(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/tag.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.tag /> + + <.tag class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= tag() %> + + <%= tag(class: "h-6 w-6 text-gray-500") %> + """ + def tag(assigns_or_opts \\ []) + + def tag(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def tag(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/ticket.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.ticket /> + + <.ticket class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= ticket() %> + + <%= ticket(class: "h-6 w-6 text-gray-500") %> + """ + def ticket(assigns_or_opts \\ []) + + def ticket(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def ticket(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/trash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.trash /> + + <.trash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= trash() %> + + <%= trash(class: "h-6 w-6 text-gray-500") %> + """ + def trash(assigns_or_opts \\ []) + + def trash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def trash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/truck.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.truck /> + + <.truck class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= truck() %> + + <%= truck(class: "h-6 w-6 text-gray-500") %> + """ + def truck(assigns_or_opts \\ []) + + def truck(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def truck(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/user-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_circle /> + + <.user_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_circle() %> + + <%= user_circle(class: "h-6 w-6 text-gray-500") %> + """ + def user_circle(assigns_or_opts \\ []) + + def user_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/user-group.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_group /> + + <.user_group class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_group() %> + + <%= user_group(class: "h-6 w-6 text-gray-500") %> + """ + def user_group(assigns_or_opts \\ []) + + def user_group(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_group(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/user-minus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_minus /> + + <.user_minus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_minus() %> + + <%= user_minus(class: "h-6 w-6 text-gray-500") %> + """ + def user_minus(assigns_or_opts \\ []) + + def user_minus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_minus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/user-plus.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user_plus /> + + <.user_plus class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user_plus() %> + + <%= user_plus(class: "h-6 w-6 text-gray-500") %> + """ + def user_plus(assigns_or_opts \\ []) + + def user_plus(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user_plus(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/user.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.user /> + + <.user class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= user() %> + + <%= user(class: "h-6 w-6 text-gray-500") %> + """ + def user(assigns_or_opts \\ []) + + def user(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def user(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/users.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.users /> + + <.users class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= users() %> + + <%= users(class: "h-6 w-6 text-gray-500") %> + """ + def users(assigns_or_opts \\ []) + + def users(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def users(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/video-camera-slash.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.video_camera_slash /> + + <.video_camera_slash class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= video_camera_slash() %> + + <%= video_camera_slash(class: "h-6 w-6 text-gray-500") %> + """ + def video_camera_slash(assigns_or_opts \\ []) + + def video_camera_slash(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def video_camera_slash(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/video-camera.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.video_camera /> + + <.video_camera class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= video_camera() %> + + <%= video_camera(class: "h-6 w-6 text-gray-500") %> + """ + def video_camera(assigns_or_opts \\ []) + + def video_camera(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def video_camera(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/view-columns.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.view_columns /> + + <.view_columns class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= view_columns() %> + + <%= view_columns(class: "h-6 w-6 text-gray-500") %> + """ + def view_columns(assigns_or_opts \\ []) + + def view_columns(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def view_columns(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/wifi.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wifi /> + + <.wifi class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wifi() %> + + <%= wifi(class: "h-6 w-6 text-gray-500") %> + """ + def wifi(assigns_or_opts \\ []) + + def wifi(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wifi(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/wrench-screwdriver.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wrench_screwdriver /> + + <.wrench_screwdriver class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wrench_screwdriver() %> + + <%= wrench_screwdriver(class: "h-6 w-6 text-gray-500") %> + """ + def wrench_screwdriver(assigns_or_opts \\ []) + + def wrench_screwdriver(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wrench_screwdriver(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n\n\n"]} + end + + @doc """ + ![](assets/icons/solid/wrench.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.wrench /> + + <.wrench class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= wrench() %> + + <%= wrench(class: "h-6 w-6 text-gray-500") %> + """ + def wrench(assigns_or_opts \\ []) + + def wrench(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def wrench(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/x-circle.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.x_circle /> + + <.x_circle class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= x_circle() %> + + <%= x_circle(class: "h-6 w-6 text-gray-500") %> + """ + def x_circle(assigns_or_opts \\ []) + + def x_circle(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def x_circle(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + + @doc """ + ![](assets/icons/solid/x-mark.svg) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <.x_mark /> + + <.x_mark class="h-6 w-6 text-gray-500" /> + + or as a function + + <%= x_mark() %> + + <%= x_mark(class: "h-6 w-6 text-gray-500") %> + """ + def x_mark(assigns_or_opts \\ []) + + def x_mark(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def x_mark(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, ["\n\n"]} + end + +end diff --git a/lib/mix/heroicons/generator_helpers.ex b/lib/mix/heroicons/generator_helpers.ex new file mode 100644 index 0000000..4d895d1 --- /dev/null +++ b/lib/mix/heroicons/generator_helpers.ex @@ -0,0 +1,19 @@ +defmodule Mix.Heroicons.GeneratorHelpers do + alias Mix.Heroicons.SvgProcessor + + def icon_name(path) do + Path.basename(path, ".svg") + |> String.replace("-", "_") + |> String.to_atom() + end + + def icon_body(path, svg_opts) do + icon = + File.read!(path) + |> SvgProcessor.process(svg_opts) + + <<"> = icon + + body + end +end diff --git a/lib/heroicons/svg_processor.ex b/lib/mix/heroicons/svg_processor.ex similarity index 77% rename from lib/heroicons/svg_processor.ex rename to lib/mix/heroicons/svg_processor.ex index 0eb91ea..6d9edc0 100644 --- a/lib/heroicons/svg_processor.ex +++ b/lib/mix/heroicons/svg_processor.ex @@ -1,4 +1,6 @@ -defmodule Heroicons.SvgProcessor do +defmodule Mix.Heroicons.SvgProcessor do + alias Mix.Heroicons.SvgProcessor.Handler + @moduledoc """ An SVG parser loosly based on https://github.com/svg/svgo @@ -12,7 +14,7 @@ defmodule Heroicons.SvgProcessor do """ def process(svg, opts \\ []) do - {:ok, stack} = Saxy.parse_string(svg, Heroicons.SvgProcessor.Handler, {[], opts}) + {:ok, stack} = Saxy.parse_string(svg, Handler, {[], opts}) Saxy.encode!(stack) end end diff --git a/lib/heroicons/svg_processor/handler.ex b/lib/mix/heroicons/svg_processor/handler.ex similarity index 57% rename from lib/heroicons/svg_processor/handler.ex rename to lib/mix/heroicons/svg_processor/handler.ex index 42c1c17..92dca4c 100644 --- a/lib/heroicons/svg_processor/handler.ex +++ b/lib/mix/heroicons/svg_processor/handler.ex @@ -1,4 +1,4 @@ -defmodule Heroicons.SvgProcessor.Handler do +defmodule Mix.Heroicons.SvgProcessor.Handler do @moduledoc false @behaviour Saxy.Handler @@ -11,14 +11,21 @@ defmodule Heroicons.SvgProcessor.Handler do @impl Saxy.Handler def handle_event(:start_element, {"svg", attributes}, {stack, opts}) do attributes = - filter_attributes(attributes, opts) - |> add_attributes(opts) - |> sort_attributes(opts) + remove_dimensions(attributes, Keyword.get(opts, :remove_dimensions)) + |> remove_attributes(Keyword.get(opts, :remove_attributes)) + |> add_attributes(Keyword.get(opts, :add_attributes)) + |> sort_attributes(Keyword.get(opts, :sort_attributes)) tag = {"svg", attributes, []} {:ok, {[tag | stack], opts}} end + def handle_event(:start_element, {"path", attributes}, {stack, opts}) do + attributes = remove_attributes(attributes, Keyword.get(opts, :remove_path_attributes, [])) + tag = {"path", attributes, []} + {:ok, {[tag | stack], opts}} + end + def handle_event(:start_element, {tag_name, attributes}, {stack, opts}) do tag = {tag_name, attributes, []} {:ok, {[tag | stack], opts}} @@ -62,25 +69,39 @@ defmodule Heroicons.SvgProcessor.Handler do {:ok, stack} end - defp filter_attributes(attributes, opts) do - remove_dimensions = Keyword.get(opts, :remove_dimensions) - remove_attrs = Keyword.get(opts, :remove_attributes, []) - + defp remove_dimensions(attributes, true) do Enum.reject(attributes, fn {attr, _value} -> - (remove_dimensions && (attr == "width" || attr == "height")) || - attr in remove_attrs + attr == "width" || attr == "height" end) end - defp add_attributes(attributes, opts) do - attributes ++ Keyword.get(opts, :add_attributes, []) + defp remove_dimensions(attributes, _) do + attributes end - defp sort_attributes(attributes, opts) do - if Keyword.get(opts, :sort_attributes) do - Enum.sort_by(attributes, fn {attr, _value} -> attr end) - else - attributes - end + defp remove_attributes(attributes, nil) do + attributes + end + + defp remove_attributes(attributes, remove_attrs) do + Enum.reject(attributes, fn {attr, _value} -> + attr in remove_attrs + end) + end + + defp add_attributes(attributes, nil) do + attributes + end + + defp add_attributes(attributes, add_attrs) do + attributes ++ add_attrs + end + + defp sort_attributes(attributes, true) do + Enum.sort_by(attributes, fn {attr, _value} -> attr end) + end + + defp sort_attributes(attributes, nil) do + attributes end end diff --git a/lib/mix/tasks/heroicons/generate.ex b/lib/mix/tasks/heroicons/generate.ex new file mode 100644 index 0000000..682c15f --- /dev/null +++ b/lib/mix/tasks/heroicons/generate.ex @@ -0,0 +1,85 @@ +defmodule Mix.Tasks.Heroicons.Generate do + use Mix.Task + import Mix.Heroicons.GeneratorHelpers + + @icon_sets [ + %{ + module: Heroicons.Outline, + path: "lib/heroicons/outline.ex", + moduledoc: + "Outline style icons drawn with a stroke, packaged as Phoenix Components.\n\n For primary navigation and marketing sections, with an outlined appearance,\n designed to be rendered at 24x24.", + icon_dir: "icons/outline/", + # Following https://github.com/tailwindlabs/heroicons/blob/b933d51df1f27c35414389fea185e9bac0097481/svgo.24.outline.yaml + svg_opts: [ + remove_dimensions: true, + sort_attributes: true, + remove_attributes: ["stroke"], + remove_path_attributes: ["stroke-width"], + add_attributes: [ + {"stroke-width", "1.5"}, + {"stroke", "currentColor"}, + {"aria-hidden", "true"} + ] + ] + }, + %{ + module: Heroicons.Solid, + path: "lib/heroicons/solid.ex", + moduledoc: + "Solid style icons drawn with fills, packaged as Phoenix Components.\n\n For primary navigation and marketing sections, with a filled appearance,\n designed to be rendered at 24x24.", + icon_dir: "icons/solid/", + # Following https://github.com/tailwindlabs/heroicons/blob/b933d51df1f27c35414389fea185e9bac0097481/svgo.24.solid.yaml + svg_opts: [ + remove_dimensions: true, + sort_attributes: true, + remove_attributes: ["fill"], + add_attributes: [ + {"fill", "currentColor"}, + {"aria-hidden", "true"} + ] + ] + }, + %{ + module: Heroicons.Mini, + path: "lib/heroicons/mini.ex", + moduledoc: "Solid style icons drawn with fills, packaged as Phoenix Components.\n\n For smaller elements like buttons, form elements, and to support text,\n designed to be rendered at 20x20.", + icon_dir: "icons/mini/", + # Following https://github.com/tailwindlabs/heroicons/blob/b933d51df1f27c35414389fea185e9bac0097481/svgo.20.solid.yaml + svg_opts: [ + remove_dimensions: true, + sort_attributes: true, + remove_attributes: ["fill"], + add_attributes: [ + {"fill", "currentColor"}, + {"aria-hidden", "true"} + ] + ] + } + ] + + @impl Mix.Task + def run(_args) do + for %{module: module, path: path, moduledoc: moduledoc, icon_dir: icon_dir, svg_opts: svg_opts} <- + @icon_sets do + icon_paths = + Path.absname(icon_dir, :code.priv_dir(:heroicons)) + |> Path.join("*.svg") + |> Path.wildcard() + + + Mix.Generator.create_file( + path, + EEx.eval_file( + "priv/templates/icon_set.ex", + [ + module: module, + moduledoc: moduledoc, + icon_paths: icon_paths, + svg_opts: svg_opts + ], + functions: __ENV__.functions + ) + ) + end + end +end diff --git a/mix.exs b/mix.exs index 16bc255..2ae1d24 100644 --- a/mix.exs +++ b/mix.exs @@ -29,7 +29,7 @@ defmodule HeroiconsElixir.MixProject do {:phoenix_html, "~> 2.14 or ~> 3.0"}, {:phoenix_live_view, ">= 0.16.0", optional: true}, {:ex_doc, "~> 0.23", only: :dev, runtime: false}, - {:saxy, "~> 1.4"} + {:saxy, "~> 1.4", only: :dev} ] end diff --git a/priv/templates/icon_set.ex b/priv/templates/icon_set.ex new file mode 100644 index 0000000..3c9a2de --- /dev/null +++ b/priv/templates/icon_set.ex @@ -0,0 +1,58 @@ +defmodule <%= inspect module %> do + @moduledoc """ + <%= moduledoc %> + """ + + use Phoenix.Component + + if function_exported?(Phoenix.Component, :assigns_to_attributes, 2) do + @assign_mod Phoenix.Component + @assigns_to_attrs_mod Phoenix.Component + else + @assign_mod Phoenix.LiveView + @assigns_to_attrs_mod Phoenix.LiveView.Helpers + end + <%= for path <- icon_paths, name = icon_name(path), body = icon_body(path, svg_opts) do %> + @doc """ + ![](assets/<%= Path.relative_to(path, :code.priv_dir(:heroicons)) %>) {: width=24px} + + ## Examples + + Use as a `Phoenix.Component` + + <%= ~s(<.#{name} />) %> + + <%= ~s(<.#{name} class="h-6 w-6 text-gray-500" />) %> + + or as a function + + <%= ~s(<%= #{name}() %>) %> + + <%= ~s(<%= #{name}(class: "h-6 w-6 text-gray-500") %>) %> + """ + def <%= name %>(assigns_or_opts \\ []) + + def <%= name %>(assigns) when is_map(assigns) do + attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns) + assigns = @assign_mod.assign(assigns, :attrs, attrs) + + ~H""" + + """ + end + + def <%= name %>(opts) when is_list(opts) do + attrs = + for {k, v} <- opts do + safe_k = + k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata() + + safe_v = v |> Phoenix.HTML.Safe.to_iodata() + + {:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]} + end + + {:safe, [" body, printable_limit: :infinity %>]} + end +<% end %> +end diff --git a/test/heroicons_test.exs b/test/heroicons_test.exs index b7b6fe2..ab09c9b 100644 --- a/test/heroicons_test.exs +++ b/test/heroicons_test.exs @@ -4,14 +4,9 @@ defmodule HeroiconsTest do import Phoenix.LiveViewTest test "generated function" do - academic_cap = - :code.priv_dir(:heroicons) - |> Path.join("outline/academic-cap.svg") - |> File.read!() - assert Heroicons.Outline.academic_cap() - |> Phoenix.HTML.safe_to_string() == - academic_cap + |> Phoenix.HTML.safe_to_string() =~ + ~s( Phoenix.HTML.safe_to_string() =~ @@ -35,19 +30,20 @@ defmodule HeroiconsTest do end test "generated components" do - for mod <- [Heroicons.Outline, Heroicons.Solid] do - assert render_component(&mod.academic_cap/1, assigns()) =~ - ~s() + assert render_component(&Heroicons.Outline.academic_cap/1, assigns()) =~ + ~s(