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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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"]}
end
@doc """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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"]}
end
@doc """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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"]}
end
@doc """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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"]}
end
@doc """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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"]}
end
@doc """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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"]}
end
@doc """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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 """
 {: 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"""