defmodule Heroicons.Solid do
@moduledoc """
Solid style icons drawn with fills, packaged as Phoenix Components.
For primary navigation and marketing sections, with a filled appearance,
designed to be rendered at 24x24.
"""
use Phoenix.Component
if function_exported?(Phoenix.Component, :assigns_to_attributes, 2) do
@assign_mod Phoenix.Component
@assigns_to_attrs_mod Phoenix.Component
else
@assign_mod Phoenix.LiveView
@assigns_to_attrs_mod Phoenix.LiveView.Helpers
end
@doc """
 {: width=24px}
## Examples
Use as a `Phoenix.Component`
<.academic_cap />
<.academic_cap class="h-6 w-6 text-gray-500" />
or as a function
<%= academic_cap() %>
<%= academic_cap(class: "h-6 w-6 text-gray-500") %>
"""
def academic_cap(assigns_or_opts \\ [])
def academic_cap(assigns) when is_map(assigns) do
attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns)
assigns = @assign_mod.assign(assigns, :attrs, attrs)
~H"""
"""
end
def academic_cap(opts) when is_list(opts) do
attrs =
for {k, v} <- opts do
safe_k =
k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata()
safe_v = v |> Phoenix.HTML.Safe.to_iodata()
{:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]}
end
{:safe, ["\n \n \n \n"]}
end
@doc """
 {: 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 \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 \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"]}
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"]}
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"]}
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"]}
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"]}
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 \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"]}
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 \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 \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"]}
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 \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 \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 \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"]}
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 \n \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 \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_square />
<.code_square class="h-6 w-6 text-gray-500" />
or as a function
<%= code_square() %>
<%= code_square(class: "h-6 w-6 text-gray-500") %>
"""
def code_square(assigns_or_opts \\ [])
def code_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_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 />
<.code class="h-6 w-6 text-gray-500" />
or as a function
<%= code() %>
<%= code(class: "h-6 w-6 text-gray-500") %>
"""
def code(assigns_or_opts \\ [])
def code(assigns) when is_map(assigns) do
attrs = @assigns_to_attrs_mod.assigns_to_attributes(assigns)
assigns = @assign_mod.assign(assigns, :attrs, attrs)
~H"""
"""
end
def code(opts) when is_list(opts) do
attrs =
for {k, v} <- opts do
safe_k =
k |> Atom.to_string() |> String.replace("_", "-") |> Phoenix.HTML.Safe.to_iodata()
safe_v = v |> Phoenix.HTML.Safe.to_iodata()
{:safe, [?\s, safe_k, ?=, ?", safe_v, ?"]}
end
{:safe, ["\n \n"]}
end
@doc """
 {: 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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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 \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"""