From ee46003c157b0955eba13c7d9bc6e0e7a7f592eb Mon Sep 17 00:00:00 2001 From: Manuel Cillero Date: Sun, 14 May 2023 18:11:51 +0200 Subject: [PATCH] =?UTF-8?q?=F0=9F=8E=A8=20Incluye=20componentes=20base=20o?= =?UTF-8?q?riginales=20de=20PageTop?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pagetop-minimal/Cargo.toml | 9 +- pagetop-minimal/README.md | 3 +- pagetop-minimal/build.rs | 3 + pagetop-minimal/src/component.rs | 22 + pagetop-minimal/src/component/anchor.rs | 222 +++ pagetop-minimal/src/component/block.rs | 129 ++ pagetop-minimal/src/component/container.rs | 194 ++ pagetop-minimal/src/component/form_element.rs | 11 + .../src/component/form_element/button.rs | 183 ++ .../src/component/form_element/date.rs | 236 +++ .../src/component/form_element/form.rs | 164 ++ .../src/component/form_element/hidden.rs | 76 + .../src/component/form_element/input.rs | 357 ++++ pagetop-minimal/src/component/grid.rs | 4 + pagetop-minimal/src/component/grid/column.rs | 171 ++ pagetop-minimal/src/component/grid/row.rs | 114 ++ pagetop-minimal/src/component/heading.rs | 205 ++ pagetop-minimal/src/component/html.rs | 84 + pagetop-minimal/src/component/icon.rs | 94 + pagetop-minimal/src/component/image.rs | 111 ++ pagetop-minimal/src/component/paragraph.rs | 149 ++ pagetop-minimal/src/lib.rs | 15 +- pagetop-minimal/src/module.rs | 1 + pagetop-minimal/src/module/menu.rs | 21 + .../src/module/menu/locales/en-US/menu.ftl | 2 + .../src/module/menu/locales/es-ES/menu.ftl | 2 + .../static/icons/bootstrap-icons.css | 1705 +++++++++++++++++ .../static/icons/bootstrap-icons.woff | Bin 0 -> 137216 bytes .../static/icons/bootstrap-icons.woff2 | Bin 0 -> 102380 bytes 29 files changed, 4276 insertions(+), 11 deletions(-) create mode 100644 pagetop-minimal/build.rs create mode 100644 pagetop-minimal/src/component.rs create mode 100644 pagetop-minimal/src/component/anchor.rs create mode 100644 pagetop-minimal/src/component/block.rs create mode 100644 pagetop-minimal/src/component/container.rs create mode 100644 pagetop-minimal/src/component/form_element.rs create mode 100644 pagetop-minimal/src/component/form_element/button.rs create mode 100644 pagetop-minimal/src/component/form_element/date.rs create mode 100644 pagetop-minimal/src/component/form_element/form.rs create mode 100644 pagetop-minimal/src/component/form_element/hidden.rs create mode 100644 pagetop-minimal/src/component/form_element/input.rs create mode 100644 pagetop-minimal/src/component/grid.rs create mode 100644 pagetop-minimal/src/component/grid/column.rs create mode 100644 pagetop-minimal/src/component/grid/row.rs create mode 100644 pagetop-minimal/src/component/heading.rs create mode 100644 pagetop-minimal/src/component/html.rs create mode 100644 pagetop-minimal/src/component/icon.rs create mode 100644 pagetop-minimal/src/component/image.rs create mode 100644 pagetop-minimal/src/component/paragraph.rs create mode 100644 pagetop-minimal/src/module.rs create mode 100644 pagetop-minimal/src/module/menu.rs create mode 100644 pagetop-minimal/src/module/menu/locales/en-US/menu.ftl create mode 100644 pagetop-minimal/src/module/menu/locales/es-ES/menu.ftl create mode 100644 pagetop-minimal/static/icons/bootstrap-icons.css create mode 100644 pagetop-minimal/static/icons/bootstrap-icons.woff create mode 100644 pagetop-minimal/static/icons/bootstrap-icons.woff2 diff --git a/pagetop-minimal/Cargo.toml b/pagetop-minimal/Cargo.toml index e4b69669..b7d8833a 100644 --- a/pagetop-minimal/Cargo.toml +++ b/pagetop-minimal/Cargo.toml @@ -7,13 +7,16 @@ authors = [ "Manuel Cillero " ] description = """\ - Theme for PageTop with a minimal set of styles to view the basic composition of pages and \ - components.\ + Module for PageTop with a minimal set of components for page composition.\ """ homepage = "https://pagetop.cillero.es" repository = "https://github.com/manuelcillero/pagetop" license = "Apache-2.0 OR MIT" [dependencies] -pagetop = { path = "../pagetop", version = "0.0" } +pagetop = { version = "0.0", path = "../pagetop" } +static-files = "0.2.3" maud = "0.25.0" + +[build-dependencies] +pagetop-build = { version = "0.0", path = "../pagetop-build" } diff --git a/pagetop-minimal/README.md b/pagetop-minimal/README.md index 7562929a..45400005 100644 --- a/pagetop-minimal/README.md +++ b/pagetop-minimal/README.md @@ -1,5 +1,4 @@ -Tema de prueba para **PageTop** con un conjunto mínimo de estilos para ver la composición básica de -páginas y componentes. +Proporciona un conjunto básico de componentes para la composición de páginas en **PageTop**. [PageTop](https://github.com/manuelcillero/pagetop/tree/main/pagetop), es un entorno de desarrollo basado en algunos de los *crates* más estables y populares del ecosistema Rust para proporcionar diff --git a/pagetop-minimal/build.rs b/pagetop-minimal/build.rs new file mode 100644 index 00000000..4e3488af --- /dev/null +++ b/pagetop-minimal/build.rs @@ -0,0 +1,3 @@ +fn main() -> std::io::Result<()> { + pagetop_build::bundle_resources("./static", "minimal", None) +} diff --git a/pagetop-minimal/src/component.rs b/pagetop-minimal/src/component.rs new file mode 100644 index 00000000..781a47ee --- /dev/null +++ b/pagetop-minimal/src/component.rs @@ -0,0 +1,22 @@ +mod container; +pub use container::{Container, ContainerType, COMPONENT_CONTAINER}; + +pub mod grid; + +mod html; +pub use html::{Html, COMPONENT_HTML}; +mod icon; +pub use icon::{Icon, COMPONENT_ICON}; +mod heading; +pub use heading::{Heading, HeadingDisplay, HeadingType, COMPONENT_HEADING}; +mod paragraph; +pub use paragraph::{Paragraph, ParagraphDisplay, COMPONENT_PARAGRAPH}; +mod anchor; +pub use anchor::{Anchor, AnchorIcon, AnchorTarget, AnchorType, COMPONENT_ANCHOR}; +mod block; +pub use block::{Block, COMPONENT_BLOCK}; +mod image; +pub use image::{Image, COMPONENT_IMAGE}; + +pub mod form_element; +pub use form_element::{Form, FormMethod, COMPONENT_FORM}; diff --git a/pagetop-minimal/src/component/anchor.rs b/pagetop-minimal/src/component/anchor.rs new file mode 100644 index 00000000..b2a59b5c --- /dev/null +++ b/pagetop-minimal/src/component/anchor.rs @@ -0,0 +1,222 @@ +use pagetop::prelude::*; + +use crate::component::Icon; + +pub_handle!(COMPONENT_ANCHOR); + +#[derive(Default)] +pub enum AnchorType { + #[default] + Link, + Button, + Location, +} + +#[derive(Default)] +pub enum AnchorTarget { + #[default] + Default, + Blank, + Parent, + Top, + Context(String), +} + +pub type AnchorIcon = ComponentsBundle; + +#[rustfmt::skip] +#[derive(Default)] +pub struct Anchor { + weight : isize, + renderable : Renderable, + id : IdentifierValue, + classes : Classes, + anchor_type: AnchorType, + href : AttributeValue, + html : HtmlMarkup, + left_icon : AnchorIcon, + right_icon : AnchorIcon, + target : AnchorTarget, + template : String, +} + +impl ComponentTrait for Anchor { + fn new() -> Self { + Anchor::default() + } + + fn handle(&self) -> Handle { + COMPONENT_ANCHOR + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + #[rustfmt::skip] + fn default_render(&self, rcx: &mut RenderContext) -> Markup { + let target = match &self.target() { + AnchorTarget::Blank => Some("_blank"), + AnchorTarget::Parent => Some("_parent"), + AnchorTarget::Top => Some("_top"), + AnchorTarget::Context(name) => Some(name.as_str()), + _ => None, + }; + html! { + a + id=[self.id().get()] + class=[self.classes().get()] + href=[self.href().get()] + target=[target] + { + (self.left_icon().render(rcx)) + span { (*self.html()) } + (self.right_icon().render(rcx)) + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Anchor { + pub fn link(href: &str, html: Markup) -> Self { + Anchor::new().with_href(href).with_html(html) + } + + pub fn button(href: &str, html: Markup) -> Self { + Anchor::new() + .with_type(AnchorType::Button) + .with_href(href) + .with_html(html) + } + + pub fn location(id: &str) -> Self { + Anchor::new().with_type(AnchorType::Location).with_id(id) + } + + // Anchor BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_type(&mut self, anchor_type: AnchorType) -> &mut Self { + self.anchor_type = anchor_type; + self.classes.alter_value( + ClassesOp::SetDefault, + match self.anchor_type { + AnchorType::Button => "btn btn-primary", + _ => "", + }, + ); + self + } + + #[fn_builder] + pub fn alter_href(&mut self, href: &str) -> &mut Self { + self.href.alter_value(href); + self + } + + #[fn_builder] + pub fn alter_html(&mut self, html: Markup) -> &mut Self { + self.html.markup = html; + self + } + + #[fn_builder] + pub fn alter_left_icon(&mut self, icon: Icon) -> &mut Self { + self.left_icon.clear(); + self.left_icon.add(icon); + self + } + + #[fn_builder] + pub fn alter_right_icon(&mut self, icon: Icon) -> &mut Self { + self.right_icon.clear(); + self.right_icon.add(icon); + self + } + + #[fn_builder] + pub fn alter_target(&mut self, target: AnchorTarget) -> &mut Self { + self.target = target; + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Anchor GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn anchor_type(&self) -> &AnchorType { + &self.anchor_type + } + + pub fn href(&self) -> &AttributeValue { + &self.href + } + + pub fn html(&self) -> &Markup { + &self.html.markup + } + + pub fn left_icon(&self) -> &AnchorIcon { + &self.left_icon + } + + pub fn right_icon(&self) -> &AnchorIcon { + &self.right_icon + } + + pub fn target(&self) -> &AnchorTarget { + &self.target + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/block.rs b/pagetop-minimal/src/component/block.rs new file mode 100644 index 00000000..8a18c613 --- /dev/null +++ b/pagetop-minimal/src/component/block.rs @@ -0,0 +1,129 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_BLOCK); + +hook_before_render_component!(HOOK_BEFORE_RENDER_BLOCK, Block); + +#[rustfmt::skip] +#[derive(Default)] +pub struct Block { + weight : isize, + renderable: Renderable, + id : IdentifierValue, + classes : Classes, + title : AttributeValue, + components: ComponentsBundle, + template : String, +} + +impl ComponentTrait for Block { + fn new() -> Self { + Block::default().with_classes(ClassesOp::SetDefault, "block") + } + + fn handle(&self) -> Handle { + COMPONENT_BLOCK + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn before_render(&mut self, rcx: &mut RenderContext) { + before_render_inline(self, rcx); + } + + fn default_render(&self, rcx: &mut RenderContext) -> Markup { + let id = rcx.required_id::(self.id()); + html! { + div id=(id) class=[self.classes().get()] { + @if let Some(title) = self.title().get() { + h2 class="block-title" { (title) } + } + div class="block-body" { + (self.components().render(rcx)) + } + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Block { + // Block BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_title(&mut self, title: &str) -> &mut Self { + self.title.alter_value(title); + self + } + + #[fn_builder] + pub fn alter_component(&mut self, component: impl ComponentTrait) -> &mut Self { + self.components.add(component); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Block GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn title(&self) -> &AttributeValue { + &self.title + } + + pub fn components(&self) -> &ComponentsBundle { + &self.components + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/container.rs b/pagetop-minimal/src/component/container.rs new file mode 100644 index 00000000..2fdac21a --- /dev/null +++ b/pagetop-minimal/src/component/container.rs @@ -0,0 +1,194 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_CONTAINER); + +hook_before_render_component!(HOOK_BEFORE_RENDER_CONTAINER, Container); + +#[derive(Default)] +pub enum ContainerType { + #[default] + Wrapper, + Header, + Footer, + Main, + Section, +} + +#[rustfmt::skip] +#[derive(Default)] +pub struct Container { + weight : isize, + renderable : Renderable, + id : IdentifierValue, + classes : Classes, + inner_classes : Classes, + container_type: ContainerType, + components : ComponentsBundle, + template : String, +} + +impl ComponentTrait for Container { + fn new() -> Self { + Container::default() + .with_classes(ClassesOp::SetDefault, "container") + .with_inner_classes(ClassesOp::SetDefault, "container") + } + + fn handle(&self) -> Handle { + COMPONENT_CONTAINER + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn before_render(&mut self, rcx: &mut RenderContext) { + before_render_inline(self, rcx); + } + + fn default_render(&self, rcx: &mut RenderContext) -> Markup { + match self.container_type() { + ContainerType::Header => html! { + header id=[self.id().get()] class=[self.classes().get()] { + div class=[self.inner_classes().get()] { + (self.components().render(rcx)) + } + } + }, + ContainerType::Footer => html! { + footer id=[self.id().get()] class=[self.classes().get()] { + div class=[self.inner_classes().get()] { + (self.components().render(rcx)) + } + } + }, + ContainerType::Main => html! { + main id=[self.id().get()] class=[self.classes().get()] { + div class=[self.inner_classes().get()] { + (self.components().render(rcx)) + } + } + }, + ContainerType::Section => html! { + section id=[self.id().get()] class=[self.classes().get()] { + div class=[self.inner_classes().get()] { + (self.components().render(rcx)) + } + } + }, + _ => html! { + div id=[self.id().get()] class=[self.classes().get()] { + (self.components().render(rcx)) + } + }, + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Container { + pub fn header() -> Self { + let mut c = Container::new().with_classes(ClassesOp::SetDefault, "header"); + c.container_type = ContainerType::Header; + c + } + + pub fn footer() -> Self { + let mut c = Container::new().with_classes(ClassesOp::SetDefault, "footer"); + c.container_type = ContainerType::Footer; + c + } + + pub fn main() -> Self { + let mut c = Container::new().with_classes(ClassesOp::SetDefault, "main"); + c.container_type = ContainerType::Main; + c + } + + pub fn section() -> Self { + let mut c = Container::new().with_classes(ClassesOp::SetDefault, "section"); + c.container_type = ContainerType::Section; + c + } + + // Container BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_inner_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.inner_classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_component(&mut self, component: impl ComponentTrait) -> &mut Self { + self.components.add(component); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Container GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn inner_classes(&self) -> &Classes { + &self.inner_classes + } + + pub fn container_type(&self) -> &ContainerType { + &self.container_type + } + + pub fn components(&self) -> &ComponentsBundle { + &self.components + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/form_element.rs b/pagetop-minimal/src/component/form_element.rs new file mode 100644 index 00000000..bbd4e309 --- /dev/null +++ b/pagetop-minimal/src/component/form_element.rs @@ -0,0 +1,11 @@ +mod form; +pub use form::{Form, FormMethod, COMPONENT_FORM}; + +mod input; +pub use input::{Input, InputType, COMPONENT_INPUT}; +mod hidden; +pub use hidden::{Hidden, COMPONENT_HIDDEN}; +mod date; +pub use date::{Date, COMPONENT_DATE}; +mod button; +pub use button::{Button, ButtonType, COMPONENT_BUTTON}; diff --git a/pagetop-minimal/src/component/form_element/button.rs b/pagetop-minimal/src/component/form_element/button.rs new file mode 100644 index 00000000..50c977c3 --- /dev/null +++ b/pagetop-minimal/src/component/form_element/button.rs @@ -0,0 +1,183 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_BUTTON); + +#[derive(Default)] +pub enum ButtonType { + #[default] + Button, + Submit, + Reset, +} + +#[rustfmt::skip] +#[derive(Default)] +pub struct Button { + weight : isize, + renderable : Renderable, + classes : Classes, + button_type: ButtonType, + name : AttributeValue, + value : AttributeValue, + autofocus : AttributeValue, + disabled : AttributeValue, + template : String, +} + +impl ComponentTrait for Button { + fn new() -> Self { + Button::default() + .with_classes(ClassesOp::SetDefault, "btn btn-primary") + .with_classes(ClassesOp::AddFirst, "form-button") + } + + fn handle(&self) -> Handle { + COMPONENT_BUTTON + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn default_render(&self, _: &mut RenderContext) -> Markup { + let button_type = match self.button_type() { + ButtonType::Button => "button", + ButtonType::Submit => "submit", + ButtonType::Reset => "reset", + }; + let id = self.name().get().map(|name| concat_string!("edit-", name)); + html! { + button + type=(button_type) + id=[id] + class=[self.classes().get()] + name=[self.name().get()] + value=[self.value().get()] + autofocus=[self.autofocus().get()] + disabled=[self.disabled().get()] + { + @if let Some(value) = self.value().get() { (value) } + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Button { + pub fn with(value: &str) -> Self { + Button::new().with_value(value) + } + + pub fn submit(value: &str) -> Self { + let mut button = Button::new() + .with_classes(ClassesOp::Replace("form-button"), "form-submit") + .with_value(value); + button.button_type = ButtonType::Submit; + button + } + + pub fn reset(value: &str) -> Self { + let mut button = Button::new() + .with_classes(ClassesOp::Replace("form-button"), "form-reset") + .with_value(value); + button.button_type = ButtonType::Reset; + button + } + + // Button BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_name(&mut self, name: &str) -> &mut Self { + self.name.alter_value(name); + self + } + + #[fn_builder] + pub fn alter_value(&mut self, value: &str) -> &mut Self { + self.value.alter_value(value); + self + } + + #[fn_builder] + pub fn alter_autofocus(&mut self, toggle: bool) -> &mut Self { + self.autofocus.alter_value(match toggle { + true => "autofocus", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_disabled(&mut self, toggle: bool) -> &mut Self { + self.disabled.alter_value(match toggle { + true => "disabled", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Button GETTERS. + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn button_type(&self) -> &ButtonType { + &self.button_type + } + + pub fn name(&self) -> &AttributeValue { + &self.name + } + + pub fn value(&self) -> &AttributeValue { + &self.value + } + + pub fn autofocus(&self) -> &AttributeValue { + &self.autofocus + } + + pub fn disabled(&self) -> &AttributeValue { + &self.disabled + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/form_element/date.rs b/pagetop-minimal/src/component/form_element/date.rs new file mode 100644 index 00000000..b742f56d --- /dev/null +++ b/pagetop-minimal/src/component/form_element/date.rs @@ -0,0 +1,236 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_DATE); + +#[rustfmt::skip] +#[derive(Default)] +pub struct Date { + weight : isize, + renderable : Renderable, + classes : Classes, + name : AttributeValue, + value : AttributeValue, + label : AttributeValue, + placeholder : AttributeValue, + autofocus : AttributeValue, + autocomplete: AttributeValue, + disabled : AttributeValue, + readonly : AttributeValue, + required : AttributeValue, + help_text : AttributeValue, + template : String, +} + +impl ComponentTrait for Date { + fn new() -> Self { + Date::default() + .with_classes(ClassesOp::SetDefault, "form-item") + .with_classes(ClassesOp::AddFirst, "form-type-date") + } + + fn handle(&self) -> Handle { + COMPONENT_DATE + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn default_render(&self, _: &mut RenderContext) -> Markup { + let id = self.name().get().map(|name| concat_string!("edit-", name)); + html! { + div class=[self.classes().get()] { + @if let Some(label) = self.label().get() { + label class="form-label" for=[&id] { + (label) " " + @if self.required().get().is_some() { + span + class="form-required" + title="Este campo es obligatorio." { "*" } " "; + } + } + } + input + type="date" + id=[id] + class="form-control" + name=[self.name().get()] + value=[self.value().get()] + placeholder=[self.placeholder().get()] + autofocus=[self.autofocus().get()] + autocomplete=[self.autocomplete().get()] + readonly=[self.readonly().get()] + required=[self.required().get()] + disabled=[self.disabled().get()]; + @if let Some(help_text) = self.help_text().get() { + div class="form-text" { (help_text) } + } + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Date { + // Date BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_name(&mut self, name: &str) -> &mut Self { + self.name.alter_value(name); + self + } + + #[fn_builder] + pub fn alter_value(&mut self, value: &str) -> &mut Self { + self.value.alter_value(value); + self + } + + #[fn_builder] + pub fn alter_label(&mut self, label: &str) -> &mut Self { + self.label.alter_value(label); + self + } + + #[fn_builder] + pub fn alter_placeholder(&mut self, placeholder: &str) -> &mut Self { + self.placeholder.alter_value(placeholder); + self + } + + #[fn_builder] + pub fn alter_autofocus(&mut self, toggle: bool) -> &mut Self { + self.autofocus.alter_value(match toggle { + true => "autofocus", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_autocomplete(&mut self, toggle: bool) -> &mut Self { + self.autocomplete.alter_value(match toggle { + true => "", + false => "off", + }); + self + } + + #[fn_builder] + pub fn alter_disabled(&mut self, toggle: bool) -> &mut Self { + self.disabled.alter_value(match toggle { + true => "disabled", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_readonly(&mut self, toggle: bool) -> &mut Self { + self.readonly.alter_value(match toggle { + true => "readonly", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_required(&mut self, toggle: bool) -> &mut Self { + self.required.alter_value(match toggle { + true => "required", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_help_text(&mut self, help_text: &str) -> &mut Self { + self.help_text.alter_value(help_text); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Date GETTERS. + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn name(&self) -> &AttributeValue { + &self.name + } + + pub fn value(&self) -> &AttributeValue { + &self.value + } + + pub fn label(&self) -> &AttributeValue { + &self.label + } + + pub fn placeholder(&self) -> &AttributeValue { + &self.placeholder + } + + pub fn autofocus(&self) -> &AttributeValue { + &self.autofocus + } + + pub fn autocomplete(&self) -> &AttributeValue { + &self.autocomplete + } + + pub fn disabled(&self) -> &AttributeValue { + &self.disabled + } + + pub fn readonly(&self) -> &AttributeValue { + &self.readonly + } + + pub fn required(&self) -> &AttributeValue { + &self.required + } + + pub fn help_text(&self) -> &AttributeValue { + &self.help_text + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/form_element/form.rs b/pagetop-minimal/src/component/form_element/form.rs new file mode 100644 index 00000000..dd9ef100 --- /dev/null +++ b/pagetop-minimal/src/component/form_element/form.rs @@ -0,0 +1,164 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_FORM); + +hook_before_render_component!(HOOK_BEFORE_RENDER_FORM, Form); + +#[derive(Default)] +pub enum FormMethod { + #[default] + Post, + Get, +} + +#[rustfmt::skip] +#[derive(Default)] +pub struct Form { + weight : isize, + renderable: Renderable, + id : IdentifierValue, + classes : Classes, + action : AttributeValue, + charset : AttributeValue, + method : FormMethod, + elements : ComponentsBundle, + template : String, +} + +impl ComponentTrait for Form { + fn new() -> Self { + Form::default() + .with_classes(ClassesOp::SetDefault, "form") + .with_charset("UTF-8") + } + + fn handle(&self) -> Handle { + COMPONENT_FORM + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn before_render(&mut self, rcx: &mut RenderContext) { + before_render_inline(self, rcx); + } + + fn default_render(&self, rcx: &mut RenderContext) -> Markup { + let method = match self.method() { + FormMethod::Post => Some("post".to_owned()), + FormMethod::Get => None, + }; + html! { + form + id=[self.id().get()] + class=[self.classes().get()] + action=[self.action().get()] + method=[method] + accept-charset=[self.charset().get()] + { + div { (self.elements().render(rcx)) } + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Form { + // Form BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_action(&mut self, action: &str) -> &mut Self { + self.action.alter_value(action); + self + } + + #[fn_builder] + pub fn alter_charset(&mut self, charset: &str) -> &mut Self { + self.charset.alter_value(charset); + self + } + + #[fn_builder] + pub fn alter_method(&mut self, method: FormMethod) -> &mut Self { + self.method = method; + self + } + + #[fn_builder] + pub fn alter_element(&mut self, element: impl ComponentTrait) -> &mut Self { + self.elements.add(element); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Form GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn action(&self) -> &AttributeValue { + &self.action + } + + pub fn charset(&self) -> &AttributeValue { + &self.charset + } + + pub fn method(&self) -> &FormMethod { + &self.method + } + + pub fn elements(&self) -> &ComponentsBundle { + &self.elements + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/form_element/hidden.rs b/pagetop-minimal/src/component/form_element/hidden.rs new file mode 100644 index 00000000..14e4613c --- /dev/null +++ b/pagetop-minimal/src/component/form_element/hidden.rs @@ -0,0 +1,76 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_HIDDEN); + +#[rustfmt::skip] +#[derive(Default)] +pub struct Hidden { + weight: isize, + name : NameValue, + value : AttributeValue, +} + +impl ComponentTrait for Hidden { + fn new() -> Self { + Hidden::default() + } + + fn handle(&self) -> Handle { + COMPONENT_HIDDEN + } + + fn weight(&self) -> isize { + self.weight + } + + fn default_render(&self, _: &mut RenderContext) -> Markup { + let id = self.name().get().map(|name| concat_string!("value-", name)); + html! { + input type="hidden" id=[id] name=[self.name().get()] value=[self.value().get()]; + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Hidden { + pub fn set(name: &str, value: &str) -> Self { + Hidden::new().with_name(name).with_value(value) + } + + // Hidden BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_name(&mut self, name: &str) -> &mut Self { + self.name.alter_value(name); + self + } + + #[fn_builder] + pub fn alter_value(&mut self, value: &str) -> &mut Self { + self.value.alter_value(value); + self + } + + // Hidden GETTERS. + + pub fn name(&self) -> &NameValue { + &self.name + } + + pub fn value(&self) -> &AttributeValue { + &self.value + } +} diff --git a/pagetop-minimal/src/component/form_element/input.rs b/pagetop-minimal/src/component/form_element/input.rs new file mode 100644 index 00000000..7391754b --- /dev/null +++ b/pagetop-minimal/src/component/form_element/input.rs @@ -0,0 +1,357 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_INPUT); + +#[derive(Default)] +pub enum InputType { + #[default] + Textfield, + Password, + Search, + Email, + Telephone, + Url, +} + +#[rustfmt::skip] +#[derive(Default)] +pub struct Input { + weight : isize, + renderable : Renderable, + classes : Classes, + input_type : InputType, + name : NameValue, + value : AttributeValue, + label : AttributeValue, + size : Option, + minlength : Option, + maxlength : Option, + placeholder : AttributeValue, + autofocus : AttributeValue, + autocomplete: AttributeValue, + disabled : AttributeValue, + readonly : AttributeValue, + required : AttributeValue, + help_text : AttributeValue, + template : String, +} + +impl ComponentTrait for Input { + fn new() -> Self { + Input::default() + .with_classes(ClassesOp::SetDefault, "form-item") + .with_classes(ClassesOp::AddFirst, "form-type-textfield") + .with_size(Some(60)) + .with_maxlength(Some(128)) + } + + fn handle(&self) -> Handle { + COMPONENT_INPUT + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + #[rustfmt::skip] + fn default_render(&self, _: &mut RenderContext) -> Markup { + let type_input = match self.input_type() { + InputType::Textfield => "text", + InputType::Password => "password", + InputType::Search => "search", + InputType::Email => "email", + InputType::Telephone => "tel", + InputType::Url => "url", + }; + let id = self.name().get().map(|name| concat_string!("edit-", name)); + html! { + div class=[self.classes().get()] { + @if let Some(label) = self.label().get() { + label class="form-label" for=[&id] { + (label) " " + @if self.required().get().is_some() { + span + class="form-required" + title="Este campo es obligatorio." { "*" } " "; + } + } + } + input + type=(type_input) + id=[id] + class="form-control" + name=[self.name().get()] + value=[self.value().get()] + size=[self.size()] + minlength=[self.minlength()] + maxlength=[self.maxlength()] + placeholder=[self.placeholder().get()] + autofocus=[self.autofocus().get()] + autocomplete=[self.autocomplete().get()] + readonly=[self.readonly().get()] + required=[self.required().get()] + disabled=[self.disabled().get()]; + @if let Some(help_text) = self.help_text().get() { + div class="form-text" { (help_text) } + } + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Input { + pub fn textfield() -> Self { + Input::new() + } + + #[rustfmt::skip] + pub fn password() -> Self { + let mut input = Input::new().with_classes( + ClassesOp::Replace("form-type-textfield"), + "form-type-password", + ); + input.input_type = InputType::Password; + input + } + + #[rustfmt::skip] + pub fn search() -> Self { + let mut input = Input::new().with_classes( + ClassesOp::Replace("form-type-textfield"), + "form-type-search", + ); + input.input_type = InputType::Search; + input + } + + #[rustfmt::skip] + pub fn email() -> Self { + let mut input = Input::new().with_classes( + ClassesOp::Replace("form-type-textfield"), + "form-type-email" + ); + input.input_type = InputType::Email; + input + } + + #[rustfmt::skip] + pub fn telephone() -> Self { + let mut input = Input::new().with_classes( + ClassesOp::Replace("form-type-textfield"), + "form-type-telephone", + ); + input.input_type = InputType::Telephone; + input + } + + #[rustfmt::skip] + pub fn url() -> Self { + let mut input = Input::new().with_classes( + ClassesOp::Replace("form-type-textfield"), + "form-type-url" + ); + input.input_type = InputType::Url; + input + } + + // Input BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_name(&mut self, name: &str) -> &mut Self { + self.name.alter_value(name); + self.alter_classes( + ClassesOp::SetDefault, + concat_string!("form-item form-item-", name).as_str(), + ); + self + } + + #[fn_builder] + pub fn alter_value(&mut self, value: &str) -> &mut Self { + self.value.alter_value(value); + self + } + + #[fn_builder] + pub fn alter_label(&mut self, label: &str) -> &mut Self { + self.label.alter_value(label); + self + } + + #[fn_builder] + pub fn alter_size(&mut self, size: Option) -> &mut Self { + self.size = size; + self + } + + #[fn_builder] + pub fn alter_minlength(&mut self, minlength: Option) -> &mut Self { + self.minlength = minlength; + self + } + + #[fn_builder] + pub fn alter_maxlength(&mut self, maxlength: Option) -> &mut Self { + self.maxlength = maxlength; + self + } + + #[fn_builder] + pub fn alter_placeholder(&mut self, placeholder: &str) -> &mut Self { + self.placeholder.alter_value(placeholder); + self + } + + #[fn_builder] + pub fn alter_autofocus(&mut self, toggle: bool) -> &mut Self { + self.autofocus.alter_value(match toggle { + true => "autofocus", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_autocomplete(&mut self, toggle: bool) -> &mut Self { + self.autocomplete.alter_value(match toggle { + true => "", + false => "off", + }); + self + } + + #[fn_builder] + pub fn alter_disabled(&mut self, toggle: bool) -> &mut Self { + self.disabled.alter_value(match toggle { + true => "disabled", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_readonly(&mut self, toggle: bool) -> &mut Self { + self.readonly.alter_value(match toggle { + true => "readonly", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_required(&mut self, toggle: bool) -> &mut Self { + self.required.alter_value(match toggle { + true => "required", + false => "", + }); + self + } + + #[fn_builder] + pub fn alter_help_text(&mut self, help_text: &str) -> &mut Self { + self.help_text.alter_value(help_text); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Input GETTERS. + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn input_type(&self) -> &InputType { + &self.input_type + } + + pub fn name(&self) -> &NameValue { + &self.name + } + + pub fn value(&self) -> &AttributeValue { + &self.value + } + + pub fn label(&self) -> &AttributeValue { + &self.label + } + + pub fn size(&self) -> Option { + self.size + } + + pub fn minlength(&self) -> Option { + self.minlength + } + + pub fn maxlength(&self) -> Option { + self.maxlength + } + + pub fn placeholder(&self) -> &AttributeValue { + &self.placeholder + } + + pub fn autofocus(&self) -> &AttributeValue { + &self.autofocus + } + + pub fn autocomplete(&self) -> &AttributeValue { + &self.autocomplete + } + + pub fn disabled(&self) -> &AttributeValue { + &self.disabled + } + + pub fn readonly(&self) -> &AttributeValue { + &self.readonly + } + + pub fn required(&self) -> &AttributeValue { + &self.required + } + + pub fn help_text(&self) -> &AttributeValue { + &self.help_text + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/grid.rs b/pagetop-minimal/src/component/grid.rs new file mode 100644 index 00000000..b85bf837 --- /dev/null +++ b/pagetop-minimal/src/component/grid.rs @@ -0,0 +1,4 @@ +mod row; +pub use row::{Row, COMPONENT_ROW}; +mod column; +pub use column::{Column, ColumnSize, COMPONENT_COLUMN}; diff --git a/pagetop-minimal/src/component/grid/column.rs b/pagetop-minimal/src/component/grid/column.rs new file mode 100644 index 00000000..d27ac2c5 --- /dev/null +++ b/pagetop-minimal/src/component/grid/column.rs @@ -0,0 +1,171 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_COLUMN); + +hook_before_render_component!(HOOK_BEFORE_RENDER_COLUMN, Column); + +const SIZE__DEFAULT: &str = "col-md"; +const SIZE__1_OF_12: &str = "col-md-1"; +const SIZE__2_OF_12: &str = "col-md-2"; +const SIZE__3_OF_12: &str = "col-md-3"; +const SIZE__4_OF_12: &str = "col-md-4"; +const SIZE__5_OF_12: &str = "col-md-5"; +const SIZE__6_OF_12: &str = "col-md-6"; +const SIZE__7_OF_12: &str = "col-md-7"; +const SIZE__8_OF_12: &str = "col-md-8"; +const SIZE__9_OF_12: &str = "col-md-9"; +const SIZE_10_OF_12: &str = "col-md-10"; +const SIZE_11_OF_12: &str = "col-md-11"; +const SIZE_12_OF_12: &str = "col-md-12"; + +#[derive(Default)] +pub enum ColumnSize { + #[default] + Default, + Is1of12, + Is2of12, + Is3of12, + Is4of12, + Is5of12, + Is6of12, + Is7of12, + Is8of12, + Is9of12, + Is10of12, + Is11of12, + IsFull, +} + +#[rustfmt::skip] +#[derive(Default)] +pub struct Column { + weight : isize, + renderable: Renderable, + id : IdentifierValue, + classes : Classes, + size : ColumnSize, + components: ComponentsBundle, + template : String, +} + +impl ComponentTrait for Column { + fn new() -> Self { + Column::default().with_classes(ClassesOp::SetDefault, SIZE__DEFAULT) + } + + fn handle(&self) -> Handle { + COMPONENT_COLUMN + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn before_render(&mut self, rcx: &mut RenderContext) { + before_render_inline(self, rcx); + } + + fn default_render(&self, rcx: &mut RenderContext) -> Markup { + html! { + div id=[self.id().get()] class=[self.classes().get()] { + (self.components().render(rcx)) + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Column { + // Column BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[rustfmt::skip] + #[fn_builder] + pub fn alter_size(&mut self, size: ColumnSize) -> &mut Self { + match size { + ColumnSize::Default => self.alter_classes(ClassesOp::SetDefault, SIZE__DEFAULT), + ColumnSize::Is1of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__1_OF_12), + ColumnSize::Is2of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__2_OF_12), + ColumnSize::Is3of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__3_OF_12), + ColumnSize::Is4of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__4_OF_12), + ColumnSize::Is5of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__5_OF_12), + ColumnSize::Is6of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__6_OF_12), + ColumnSize::Is7of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__7_OF_12), + ColumnSize::Is8of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__8_OF_12), + ColumnSize::Is9of12 => self.alter_classes(ClassesOp::SetDefault, SIZE__9_OF_12), + ColumnSize::Is10of12 => self.alter_classes(ClassesOp::SetDefault, SIZE_10_OF_12), + ColumnSize::Is11of12 => self.alter_classes(ClassesOp::SetDefault, SIZE_11_OF_12), + ColumnSize::IsFull => self.alter_classes(ClassesOp::SetDefault, SIZE_12_OF_12), + }; + self.size = size; + self + } + + #[fn_builder] + pub fn alter_component(&mut self, component: impl ComponentTrait) -> &mut Self { + self.components.add(component); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Column GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn size(&self) -> &ColumnSize { + &self.size + } + + pub fn components(&self) -> &ComponentsBundle { + &self.components + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/grid/row.rs b/pagetop-minimal/src/component/grid/row.rs new file mode 100644 index 00000000..24d946cf --- /dev/null +++ b/pagetop-minimal/src/component/grid/row.rs @@ -0,0 +1,114 @@ +use pagetop::prelude::*; + +use crate::component::grid; + +pub_handle!(COMPONENT_ROW); + +hook_before_render_component!(HOOK_BEFORE_RENDER_ROW, Row); + +#[rustfmt::skip] +#[derive(Default)] +pub struct Row { + weight : isize, + renderable: Renderable, + id : IdentifierValue, + classes : Classes, + columns : ComponentsBundle, + template : String, +} + +impl ComponentTrait for Row { + fn new() -> Self { + Row::default().with_classes(ClassesOp::SetDefault, "row") + } + + fn handle(&self) -> Handle { + COMPONENT_ROW + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn before_render(&mut self, rcx: &mut RenderContext) { + before_render_inline(self, rcx); + } + + fn default_render(&self, rcx: &mut RenderContext) -> Markup { + html! { + div id=[self.id().get()] class=[self.classes().get()] { + (self.columns().render(rcx)) + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Row { + // Row BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_column(&mut self, column: grid::Column) -> &mut Self { + self.columns.add(column); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Row GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn columns(&self) -> &ComponentsBundle { + &self.columns + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/heading.rs b/pagetop-minimal/src/component/heading.rs new file mode 100644 index 00000000..5d138d48 --- /dev/null +++ b/pagetop-minimal/src/component/heading.rs @@ -0,0 +1,205 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_HEADING); + +#[derive(Default)] +pub enum HeadingType { + #[default] + H1, + H2, + H3, + H4, + H5, + H6, +} + +#[derive(Default)] +pub enum HeadingDisplay { + #[default] + Normal, + XxLarge, + Large, + Medium, + Small, + XxSmall, + Subtitle, +} + +#[rustfmt::skip] +#[derive(Default)] +pub struct Heading { + weight : isize, + renderable : Renderable, + id : IdentifierValue, + classes : Classes, + heading_type: HeadingType, + html : HtmlMarkup, + display : HeadingDisplay, + template : String, +} + +impl ComponentTrait for Heading { + fn new() -> Self { + Heading::default() + } + + fn handle(&self) -> Handle { + COMPONENT_HEADING + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn default_render(&self, _: &mut RenderContext) -> Markup { + let id = self.id().get(); + let classes = self.classes().get(); + html! { @match &self.heading_type() { + HeadingType::H1 => h1 id=[id] class=[classes] { (*self.html()) }, + HeadingType::H2 => h2 id=[id] class=[classes] { (*self.html()) }, + HeadingType::H3 => h3 id=[id] class=[classes] { (*self.html()) }, + HeadingType::H4 => h4 id=[id] class=[classes] { (*self.html()) }, + HeadingType::H5 => h5 id=[id] class=[classes] { (*self.html()) }, + HeadingType::H6 => h6 id=[id] class=[classes] { (*self.html()) }, + }} + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Heading { + pub fn h1(html: Markup) -> Self { + Heading::new() + .with_heading_type(HeadingType::H1) + .with_html(html) + } + + pub fn h2(html: Markup) -> Self { + Heading::new() + .with_heading_type(HeadingType::H2) + .with_html(html) + } + + pub fn h3(html: Markup) -> Self { + Heading::new() + .with_heading_type(HeadingType::H3) + .with_html(html) + } + + pub fn h4(html: Markup) -> Self { + Heading::new() + .with_heading_type(HeadingType::H4) + .with_html(html) + } + + pub fn h5(html: Markup) -> Self { + Heading::new() + .with_heading_type(HeadingType::H5) + .with_html(html) + } + + pub fn h6(html: Markup) -> Self { + Heading::new() + .with_heading_type(HeadingType::H6) + .with_html(html) + } + + // Heading BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_heading_type(&mut self, heading_type: HeadingType) -> &mut Self { + self.heading_type = heading_type; + self + } + + #[fn_builder] + pub fn alter_html(&mut self, html: Markup) -> &mut Self { + self.html.markup = html; + self + } + + #[rustfmt::skip] + #[fn_builder] + pub fn alter_display(&mut self, display: HeadingDisplay) -> &mut Self { + self.display = display; + self.classes.alter_value( + ClassesOp::SetDefault, + match &self.display() { + HeadingDisplay::XxLarge => "display-2", + HeadingDisplay::Large => "display-3", + HeadingDisplay::Medium => "display-4", + HeadingDisplay::Small => "display-5", + HeadingDisplay::XxSmall => "display-6", + HeadingDisplay::Normal => "", + HeadingDisplay::Subtitle => "", + }, + ); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Paragraph GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn heading_type(&self) -> &HeadingType { + &self.heading_type + } + + pub fn html(&self) -> &Markup { + &self.html.markup + } + + pub fn display(&self) -> &HeadingDisplay { + &self.display + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/html.rs b/pagetop-minimal/src/component/html.rs new file mode 100644 index 00000000..468340ad --- /dev/null +++ b/pagetop-minimal/src/component/html.rs @@ -0,0 +1,84 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_HTML); + +#[rustfmt::skip] +#[derive(Default)] +pub struct Html { + weight : isize, + renderable: Renderable, + html : HtmlMarkup, + template : String, +} + +impl ComponentTrait for Html { + fn new() -> Self { + Html::default() + } + + fn handle(&self) -> Handle { + COMPONENT_HTML + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn default_render(&self, _: &mut RenderContext) -> Markup { + html! { (*self.html()) } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Html { + pub fn with(html: Markup) -> Self { + Html::new().with_html(html) + } + + // Html BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_html(&mut self, html: Markup) -> &mut Self { + self.html.markup = html; + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Html GETTERS. + + pub fn html(&self) -> &Markup { + &self.html.markup + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/icon.rs b/pagetop-minimal/src/component/icon.rs new file mode 100644 index 00000000..f5553bde --- /dev/null +++ b/pagetop-minimal/src/component/icon.rs @@ -0,0 +1,94 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_ICON); + +#[rustfmt::skip] +#[derive(Default)] +pub struct Icon { + weight : isize, + renderable: Renderable, + icon_name : String, + classes : Classes, +} + +impl ComponentTrait for Icon { + fn new() -> Self { + Icon::default().with_classes(ClassesOp::SetDefault, "bi-question-circle-fill") + } + + fn handle(&self) -> Handle { + COMPONENT_ICON + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn before_render(&mut self, rcx: &mut RenderContext) { + rcx.alter(ContextOp::AddStyleSheet( + StyleSheet::located("/minimal/icons/bootstrap-icons.css").with_version("1.8.2"), + )); + } + + fn default_render(&self, _: &mut RenderContext) -> Markup { + html! { i class=[self.classes().get()] {}; } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Icon { + pub fn with(icon_name: &str) -> Self { + Icon::new().with_icon_name(icon_name) + } + + // Icon BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_icon_name(&mut self, name: &str) -> &mut Self { + self.icon_name = name.to_owned(); + self.alter_classes( + ClassesOp::SetDefault, + concat_string!("bi-", self.icon_name).as_str(), + ); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + // Icon GETTERS. + + pub fn icon_name(&self) -> &str { + self.icon_name.as_str() + } + + pub fn classes(&self) -> &Classes { + &self.classes + } +} diff --git a/pagetop-minimal/src/component/image.rs b/pagetop-minimal/src/component/image.rs new file mode 100644 index 00000000..fd15654e --- /dev/null +++ b/pagetop-minimal/src/component/image.rs @@ -0,0 +1,111 @@ +use pagetop::prelude::*; + +pub_handle!(COMPONENT_IMAGE); + +#[rustfmt::skip] +#[derive(Default)] +pub struct Image { + weight : isize, + renderable: Renderable, + id : IdentifierValue, + classes : Classes, + source : AttributeValue, + template : String, +} + +impl ComponentTrait for Image { + fn new() -> Self { + Image::default().with_classes(ClassesOp::SetDefault, "img-fluid") + } + + fn handle(&self) -> Handle { + COMPONENT_IMAGE + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn default_render(&self, _: &mut RenderContext) -> Markup { + html! { + img + src=[self.source().get()] + id=[self.id().get()] + class=[self.classes().get()]; + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Image { + pub fn with(source: &str) -> Self { + Image::new().with_source(source) + } + + // Image BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_source(&mut self, source: &str) -> &mut Self { + self.source.alter_value(source); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Image GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn source(&self) -> &AttributeValue { + &self.source + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/component/paragraph.rs b/pagetop-minimal/src/component/paragraph.rs new file mode 100644 index 00000000..ef55df0c --- /dev/null +++ b/pagetop-minimal/src/component/paragraph.rs @@ -0,0 +1,149 @@ +use pagetop::prelude::*; + +use crate::component::Html; + +pub_handle!(COMPONENT_PARAGRAPH); + +#[derive(Default)] +pub enum ParagraphDisplay { + #[default] + Normal, + XxLarge, + Large, + Medium, + Small, + XxSmall, +} + +#[rustfmt::skip] +#[derive(Default)] +pub struct Paragraph { + weight : isize, + renderable: Renderable, + id : IdentifierValue, + classes : Classes, + components: ComponentsBundle, + display : ParagraphDisplay, + template : String, +} + +impl ComponentTrait for Paragraph { + fn new() -> Self { + Paragraph::default() + } + + fn handle(&self) -> Handle { + COMPONENT_PARAGRAPH + } + + fn weight(&self) -> isize { + self.weight + } + + fn is_renderable(&self, rcx: &RenderContext) -> bool { + (self.renderable.check)(rcx) + } + + fn default_render(&self, rcx: &mut RenderContext) -> Markup { + html! { + p + id=[self.id().get()] + class=[self.classes().get()] + { + (self.components().render(rcx)) + } + } + } + + fn as_ref_any(&self) -> &dyn AnyComponent { + self + } + + fn as_mut_any(&mut self) -> &mut dyn AnyComponent { + self + } +} + +impl Paragraph { + pub fn with(html: Markup) -> Self { + Paragraph::new().with_component(Html::with(html)) + } + + // Paragraph BUILDER. + + #[fn_builder] + pub fn alter_weight(&mut self, weight: isize) -> &mut Self { + self.weight = weight; + self + } + + #[fn_builder] + pub fn alter_renderable(&mut self, check: IsRenderable) -> &mut Self { + self.renderable.check = check; + self + } + + #[fn_builder] + pub fn alter_id(&mut self, id: &str) -> &mut Self { + self.id.alter_value(id); + self + } + + #[fn_builder] + pub fn alter_classes(&mut self, op: ClassesOp, classes: &str) -> &mut Self { + self.classes.alter_value(op, classes); + self + } + + #[fn_builder] + pub fn alter_component(&mut self, component: impl ComponentTrait) -> &mut Self { + self.components.add(component); + self + } + + #[rustfmt::skip] + #[fn_builder] + pub fn alter_display(&mut self, display: ParagraphDisplay) -> &mut Self { + self.display = display; + self.classes.alter_value( + ClassesOp::SetDefault, + match &self.display() { + ParagraphDisplay::XxLarge => "fs-2", + ParagraphDisplay::Large => "fs-3", + ParagraphDisplay::Medium => "fs-4", + ParagraphDisplay::Small => "fs-5", + ParagraphDisplay::XxSmall => "fs-6", + ParagraphDisplay::Normal => "", + }, + ); + self + } + + #[fn_builder] + pub fn alter_template(&mut self, template: &str) -> &mut Self { + self.template = template.to_owned(); + self + } + + // Paragraph GETTERS. + + pub fn id(&self) -> &IdentifierValue { + &self.id + } + + pub fn classes(&self) -> &Classes { + &self.classes + } + + pub fn components(&self) -> &ComponentsBundle { + &self.components + } + + pub fn display(&self) -> &ParagraphDisplay { + &self.display + } + + pub fn template(&self) -> &str { + self.template.as_str() + } +} diff --git a/pagetop-minimal/src/lib.rs b/pagetop-minimal/src/lib.rs index 15c6c3a2..690f0faf 100644 --- a/pagetop-minimal/src/lib.rs +++ b/pagetop-minimal/src/lib.rs @@ -1,17 +1,20 @@ use pagetop::prelude::*; -pub_handle!(THEME_MINIMAL); +pub mod component; +pub mod module; + +pub_handle!(MODULE_MINIMAL); + +include!(concat!(env!("OUT_DIR"), "/minimal.rs")); pub struct Minimal; impl ModuleTrait for Minimal { fn handle(&self) -> Handle { - THEME_MINIMAL + MODULE_MINIMAL } - fn theme(&self) -> Option { - Some(&Minimal) + fn configure_service(&self, cfg: &mut server::web::ServiceConfig) { + serve_static_files!(cfg, "/minimal", bundle_minimal); } } - -impl ThemeTrait for Minimal {} diff --git a/pagetop-minimal/src/module.rs b/pagetop-minimal/src/module.rs new file mode 100644 index 00000000..b9a0e3e0 --- /dev/null +++ b/pagetop-minimal/src/module.rs @@ -0,0 +1 @@ +pub mod menu; diff --git a/pagetop-minimal/src/module/menu.rs b/pagetop-minimal/src/module/menu.rs new file mode 100644 index 00000000..64d568e9 --- /dev/null +++ b/pagetop-minimal/src/module/menu.rs @@ -0,0 +1,21 @@ +use pagetop::prelude::*; + +pub_handle!(MODULE_MENU); + +pub_locale!("src/module/menu/locales"); + +pub struct Menu; + +impl ModuleTrait for Menu { + fn handle(&self) -> Handle { + MODULE_MENU + } + + fn name(&self) -> String { + l("module_name") + } + + fn description(&self) -> Option { + Some(l("module_description")) + } +} diff --git a/pagetop-minimal/src/module/menu/locales/en-US/menu.ftl b/pagetop-minimal/src/module/menu/locales/en-US/menu.ftl new file mode 100644 index 00000000..b35e9677 --- /dev/null +++ b/pagetop-minimal/src/module/menu/locales/en-US/menu.ftl @@ -0,0 +1,2 @@ +module_name = Menu +module_description = ... diff --git a/pagetop-minimal/src/module/menu/locales/es-ES/menu.ftl b/pagetop-minimal/src/module/menu/locales/es-ES/menu.ftl new file mode 100644 index 00000000..a36de8ac --- /dev/null +++ b/pagetop-minimal/src/module/menu/locales/es-ES/menu.ftl @@ -0,0 +1,2 @@ +module_name = Menú +module_description = ... diff --git a/pagetop-minimal/static/icons/bootstrap-icons.css b/pagetop-minimal/static/icons/bootstrap-icons.css new file mode 100644 index 00000000..9a7d8ae2 --- /dev/null +++ b/pagetop-minimal/static/icons/bootstrap-icons.css @@ -0,0 +1,1705 @@ +@font-face { + font-family: "bootstrap-icons"; + src: url("bootstrap-icons.woff2?ver=1.8.2") format("woff2"), + url("bootstrap-icons.woff?ver=1.8.2") format("woff"); +} + +.bi::before, +[class^="bi-"]::before, +[class*=" bi-"]::before { + display: inline-block; + font-display: block; + font-family: bootstrap-icons !important; + font-style: normal; + font-weight: normal !important; + font-variant: normal; + text-transform: none; + line-height: 1; + vertical-align: -.125em; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +.bi-123::before { content: "\f67f"; } +.bi-alarm-fill::before { content: "\f101"; } +.bi-alarm::before { content: "\f102"; } +.bi-align-bottom::before { content: "\f103"; } +.bi-align-center::before { content: "\f104"; } +.bi-align-end::before { content: "\f105"; } +.bi-align-middle::before { content: "\f106"; } +.bi-align-start::before { content: "\f107"; } +.bi-align-top::before { content: "\f108"; } +.bi-alt::before { content: "\f109"; } +.bi-app-indicator::before { content: "\f10a"; } +.bi-app::before { content: "\f10b"; } +.bi-archive-fill::before { content: "\f10c"; } +.bi-archive::before { content: "\f10d"; } +.bi-arrow-90deg-down::before { content: "\f10e"; } +.bi-arrow-90deg-left::before { content: "\f10f"; } +.bi-arrow-90deg-right::before { content: "\f110"; } +.bi-arrow-90deg-up::before { content: "\f111"; } +.bi-arrow-bar-down::before { content: "\f112"; } +.bi-arrow-bar-left::before { content: "\f113"; } +.bi-arrow-bar-right::before { content: "\f114"; } +.bi-arrow-bar-up::before { content: "\f115"; } +.bi-arrow-clockwise::before { content: "\f116"; } +.bi-arrow-counterclockwise::before { content: "\f117"; } +.bi-arrow-down-circle-fill::before { content: "\f118"; } +.bi-arrow-down-circle::before { content: "\f119"; } +.bi-arrow-down-left-circle-fill::before { content: "\f11a"; } +.bi-arrow-down-left-circle::before { content: "\f11b"; } +.bi-arrow-down-left-square-fill::before { content: "\f11c"; } +.bi-arrow-down-left-square::before { content: "\f11d"; } +.bi-arrow-down-left::before { content: "\f11e"; } +.bi-arrow-down-right-circle-fill::before { content: "\f11f"; } +.bi-arrow-down-right-circle::before { content: "\f120"; } +.bi-arrow-down-right-square-fill::before { content: "\f121"; } +.bi-arrow-down-right-square::before { content: "\f122"; } +.bi-arrow-down-right::before { content: "\f123"; } +.bi-arrow-down-short::before { content: "\f124"; } +.bi-arrow-down-square-fill::before { content: "\f125"; } +.bi-arrow-down-square::before { content: "\f126"; } +.bi-arrow-down-up::before { content: "\f127"; } +.bi-arrow-down::before { content: "\f128"; } +.bi-arrow-left-circle-fill::before { content: "\f129"; } +.bi-arrow-left-circle::before { content: "\f12a"; } +.bi-arrow-left-right::before { content: "\f12b"; } +.bi-arrow-left-short::before { content: "\f12c"; } +.bi-arrow-left-square-fill::before { content: "\f12d"; } +.bi-arrow-left-square::before { content: "\f12e"; } +.bi-arrow-left::before { content: "\f12f"; } +.bi-arrow-repeat::before { content: "\f130"; } +.bi-arrow-return-left::before { content: "\f131"; } +.bi-arrow-return-right::before { content: "\f132"; } +.bi-arrow-right-circle-fill::before { content: "\f133"; } +.bi-arrow-right-circle::before { content: "\f134"; } +.bi-arrow-right-short::before { content: "\f135"; } +.bi-arrow-right-square-fill::before { content: "\f136"; } +.bi-arrow-right-square::before { content: "\f137"; } +.bi-arrow-right::before { content: "\f138"; } +.bi-arrow-up-circle-fill::before { content: "\f139"; } +.bi-arrow-up-circle::before { content: "\f13a"; } +.bi-arrow-up-left-circle-fill::before { content: "\f13b"; } +.bi-arrow-up-left-circle::before { content: "\f13c"; } +.bi-arrow-up-left-square-fill::before { content: "\f13d"; } +.bi-arrow-up-left-square::before { content: "\f13e"; } +.bi-arrow-up-left::before { content: "\f13f"; } +.bi-arrow-up-right-circle-fill::before { content: "\f140"; } +.bi-arrow-up-right-circle::before { content: "\f141"; } +.bi-arrow-up-right-square-fill::before { content: "\f142"; } +.bi-arrow-up-right-square::before { content: "\f143"; } +.bi-arrow-up-right::before { content: "\f144"; } +.bi-arrow-up-short::before { content: "\f145"; } +.bi-arrow-up-square-fill::before { content: "\f146"; } +.bi-arrow-up-square::before { content: "\f147"; } +.bi-arrow-up::before { content: "\f148"; } +.bi-arrows-angle-contract::before { content: "\f149"; } +.bi-arrows-angle-expand::before { content: "\f14a"; } +.bi-arrows-collapse::before { content: "\f14b"; } +.bi-arrows-expand::before { content: "\f14c"; } +.bi-arrows-fullscreen::before { content: "\f14d"; } +.bi-arrows-move::before { content: "\f14e"; } +.bi-aspect-ratio-fill::before { content: "\f14f"; } +.bi-aspect-ratio::before { content: "\f150"; } +.bi-asterisk::before { content: "\f151"; } +.bi-at::before { content: "\f152"; } +.bi-award-fill::before { content: "\f153"; } +.bi-award::before { content: "\f154"; } +.bi-back::before { content: "\f155"; } +.bi-backspace-fill::before { content: "\f156"; } +.bi-backspace-reverse-fill::before { content: "\f157"; } +.bi-backspace-reverse::before { content: "\f158"; } +.bi-backspace::before { content: "\f159"; } +.bi-badge-3d-fill::before { content: "\f15a"; } +.bi-badge-3d::before { content: "\f15b"; } +.bi-badge-4k-fill::before { content: "\f15c"; } +.bi-badge-4k::before { content: "\f15d"; } +.bi-badge-8k-fill::before { content: "\f15e"; } +.bi-badge-8k::before { content: "\f15f"; } +.bi-badge-ad-fill::before { content: "\f160"; } +.bi-badge-ad::before { content: "\f161"; } +.bi-badge-ar-fill::before { content: "\f162"; } +.bi-badge-ar::before { content: "\f163"; } +.bi-badge-cc-fill::before { content: "\f164"; } +.bi-badge-cc::before { content: "\f165"; } +.bi-badge-hd-fill::before { content: "\f166"; } +.bi-badge-hd::before { content: "\f167"; } +.bi-badge-tm-fill::before { content: "\f168"; } +.bi-badge-tm::before { content: "\f169"; } +.bi-badge-vo-fill::before { content: "\f16a"; } +.bi-badge-vo::before { content: "\f16b"; } +.bi-badge-vr-fill::before { content: "\f16c"; } +.bi-badge-vr::before { content: "\f16d"; } +.bi-badge-wc-fill::before { content: "\f16e"; } +.bi-badge-wc::before { content: "\f16f"; } +.bi-bag-check-fill::before { content: "\f170"; } +.bi-bag-check::before { content: "\f171"; } +.bi-bag-dash-fill::before { content: "\f172"; } +.bi-bag-dash::before { content: "\f173"; } +.bi-bag-fill::before { content: "\f174"; } +.bi-bag-plus-fill::before { content: "\f175"; } +.bi-bag-plus::before { content: "\f176"; } +.bi-bag-x-fill::before { content: "\f177"; } +.bi-bag-x::before { content: "\f178"; } +.bi-bag::before { content: "\f179"; } +.bi-bar-chart-fill::before { content: "\f17a"; } +.bi-bar-chart-line-fill::before { content: "\f17b"; } +.bi-bar-chart-line::before { content: "\f17c"; } +.bi-bar-chart-steps::before { content: "\f17d"; } +.bi-bar-chart::before { content: "\f17e"; } +.bi-basket-fill::before { content: "\f17f"; } +.bi-basket::before { content: "\f180"; } +.bi-basket2-fill::before { content: "\f181"; } +.bi-basket2::before { content: "\f182"; } +.bi-basket3-fill::before { content: "\f183"; } +.bi-basket3::before { content: "\f184"; } +.bi-battery-charging::before { content: "\f185"; } +.bi-battery-full::before { content: "\f186"; } +.bi-battery-half::before { content: "\f187"; } +.bi-battery::before { content: "\f188"; } +.bi-bell-fill::before { content: "\f189"; } +.bi-bell::before { content: "\f18a"; } +.bi-bezier::before { content: "\f18b"; } +.bi-bezier2::before { content: "\f18c"; } +.bi-bicycle::before { content: "\f18d"; } +.bi-binoculars-fill::before { content: "\f18e"; } +.bi-binoculars::before { content: "\f18f"; } +.bi-blockquote-left::before { content: "\f190"; } +.bi-blockquote-right::before { content: "\f191"; } +.bi-book-fill::before { content: "\f192"; } +.bi-book-half::before { content: "\f193"; } +.bi-book::before { content: "\f194"; } +.bi-bookmark-check-fill::before { content: "\f195"; } +.bi-bookmark-check::before { content: "\f196"; } +.bi-bookmark-dash-fill::before { content: "\f197"; } +.bi-bookmark-dash::before { content: "\f198"; } +.bi-bookmark-fill::before { content: "\f199"; } +.bi-bookmark-heart-fill::before { content: "\f19a"; } +.bi-bookmark-heart::before { content: "\f19b"; } +.bi-bookmark-plus-fill::before { content: "\f19c"; } +.bi-bookmark-plus::before { content: "\f19d"; } +.bi-bookmark-star-fill::before { content: "\f19e"; } +.bi-bookmark-star::before { content: "\f19f"; } +.bi-bookmark-x-fill::before { content: "\f1a0"; } +.bi-bookmark-x::before { content: "\f1a1"; } +.bi-bookmark::before { content: "\f1a2"; } +.bi-bookmarks-fill::before { content: "\f1a3"; } +.bi-bookmarks::before { content: "\f1a4"; } +.bi-bookshelf::before { content: "\f1a5"; } +.bi-bootstrap-fill::before { content: "\f1a6"; } +.bi-bootstrap-reboot::before { content: "\f1a7"; } +.bi-bootstrap::before { content: "\f1a8"; } +.bi-border-all::before { content: "\f1a9"; } +.bi-border-bottom::before { content: "\f1aa"; } +.bi-border-center::before { content: "\f1ab"; } +.bi-border-inner::before { content: "\f1ac"; } +.bi-border-left::before { content: "\f1ad"; } +.bi-border-middle::before { content: "\f1ae"; } +.bi-border-outer::before { content: "\f1af"; } +.bi-border-right::before { content: "\f1b0"; } +.bi-border-style::before { content: "\f1b1"; } +.bi-border-top::before { content: "\f1b2"; } +.bi-border-width::before { content: "\f1b3"; } +.bi-border::before { content: "\f1b4"; } +.bi-bounding-box-circles::before { content: "\f1b5"; } +.bi-bounding-box::before { content: "\f1b6"; } +.bi-box-arrow-down-left::before { content: "\f1b7"; } +.bi-box-arrow-down-right::before { content: "\f1b8"; } +.bi-box-arrow-down::before { content: "\f1b9"; } +.bi-box-arrow-in-down-left::before { content: "\f1ba"; } +.bi-box-arrow-in-down-right::before { content: "\f1bb"; } +.bi-box-arrow-in-down::before { content: "\f1bc"; } +.bi-box-arrow-in-left::before { content: "\f1bd"; } +.bi-box-arrow-in-right::before { content: "\f1be"; } +.bi-box-arrow-in-up-left::before { content: "\f1bf"; } +.bi-box-arrow-in-up-right::before { content: "\f1c0"; } +.bi-box-arrow-in-up::before { content: "\f1c1"; } +.bi-box-arrow-left::before { content: "\f1c2"; } +.bi-box-arrow-right::before { content: "\f1c3"; } +.bi-box-arrow-up-left::before { content: "\f1c4"; } +.bi-box-arrow-up-right::before { content: "\f1c5"; } +.bi-box-arrow-up::before { content: "\f1c6"; } +.bi-box-seam::before { content: "\f1c7"; } +.bi-box::before { content: "\f1c8"; } +.bi-braces::before { content: "\f1c9"; } +.bi-bricks::before { content: "\f1ca"; } +.bi-briefcase-fill::before { content: "\f1cb"; } +.bi-briefcase::before { content: "\f1cc"; } +.bi-brightness-alt-high-fill::before { content: "\f1cd"; } +.bi-brightness-alt-high::before { content: "\f1ce"; } +.bi-brightness-alt-low-fill::before { content: "\f1cf"; } +.bi-brightness-alt-low::before { content: "\f1d0"; } +.bi-brightness-high-fill::before { content: "\f1d1"; } +.bi-brightness-high::before { content: "\f1d2"; } +.bi-brightness-low-fill::before { content: "\f1d3"; } +.bi-brightness-low::before { content: "\f1d4"; } +.bi-broadcast-pin::before { content: "\f1d5"; } +.bi-broadcast::before { content: "\f1d6"; } +.bi-brush-fill::before { content: "\f1d7"; } +.bi-brush::before { content: "\f1d8"; } +.bi-bucket-fill::before { content: "\f1d9"; } +.bi-bucket::before { content: "\f1da"; } +.bi-bug-fill::before { content: "\f1db"; } +.bi-bug::before { content: "\f1dc"; } +.bi-building::before { content: "\f1dd"; } +.bi-bullseye::before { content: "\f1de"; } +.bi-calculator-fill::before { content: "\f1df"; } +.bi-calculator::before { content: "\f1e0"; } +.bi-calendar-check-fill::before { content: "\f1e1"; } +.bi-calendar-check::before { content: "\f1e2"; } +.bi-calendar-date-fill::before { content: "\f1e3"; } +.bi-calendar-date::before { content: "\f1e4"; } +.bi-calendar-day-fill::before { content: "\f1e5"; } +.bi-calendar-day::before { content: "\f1e6"; } +.bi-calendar-event-fill::before { content: "\f1e7"; } +.bi-calendar-event::before { content: "\f1e8"; } +.bi-calendar-fill::before { content: "\f1e9"; } +.bi-calendar-minus-fill::before { content: "\f1ea"; } +.bi-calendar-minus::before { content: "\f1eb"; } +.bi-calendar-month-fill::before { content: "\f1ec"; } +.bi-calendar-month::before { content: "\f1ed"; } +.bi-calendar-plus-fill::before { content: "\f1ee"; } +.bi-calendar-plus::before { content: "\f1ef"; } +.bi-calendar-range-fill::before { content: "\f1f0"; } +.bi-calendar-range::before { content: "\f1f1"; } +.bi-calendar-week-fill::before { content: "\f1f2"; } +.bi-calendar-week::before { content: "\f1f3"; } +.bi-calendar-x-fill::before { content: "\f1f4"; } +.bi-calendar-x::before { content: "\f1f5"; } +.bi-calendar::before { content: "\f1f6"; } +.bi-calendar2-check-fill::before { content: "\f1f7"; } +.bi-calendar2-check::before { content: "\f1f8"; } +.bi-calendar2-date-fill::before { content: "\f1f9"; } +.bi-calendar2-date::before { content: "\f1fa"; } +.bi-calendar2-day-fill::before { content: "\f1fb"; } +.bi-calendar2-day::before { content: "\f1fc"; } +.bi-calendar2-event-fill::before { content: "\f1fd"; } +.bi-calendar2-event::before { content: "\f1fe"; } +.bi-calendar2-fill::before { content: "\f1ff"; } +.bi-calendar2-minus-fill::before { content: "\f200"; } +.bi-calendar2-minus::before { content: "\f201"; } +.bi-calendar2-month-fill::before { content: "\f202"; } +.bi-calendar2-month::before { content: "\f203"; } +.bi-calendar2-plus-fill::before { content: "\f204"; } +.bi-calendar2-plus::before { content: "\f205"; } +.bi-calendar2-range-fill::before { content: "\f206"; } +.bi-calendar2-range::before { content: "\f207"; } +.bi-calendar2-week-fill::before { content: "\f208"; } +.bi-calendar2-week::before { content: "\f209"; } +.bi-calendar2-x-fill::before { content: "\f20a"; } +.bi-calendar2-x::before { content: "\f20b"; } +.bi-calendar2::before { content: "\f20c"; } +.bi-calendar3-event-fill::before { content: "\f20d"; } +.bi-calendar3-event::before { content: "\f20e"; } +.bi-calendar3-fill::before { content: "\f20f"; } +.bi-calendar3-range-fill::before { content: "\f210"; } +.bi-calendar3-range::before { content: "\f211"; } +.bi-calendar3-week-fill::before { content: "\f212"; } +.bi-calendar3-week::before { content: "\f213"; } +.bi-calendar3::before { content: "\f214"; } +.bi-calendar4-event::before { content: "\f215"; } +.bi-calendar4-range::before { content: "\f216"; } +.bi-calendar4-week::before { content: "\f217"; } +.bi-calendar4::before { content: "\f218"; } +.bi-camera-fill::before { content: "\f219"; } +.bi-camera-reels-fill::before { content: "\f21a"; } +.bi-camera-reels::before { content: "\f21b"; } +.bi-camera-video-fill::before { content: "\f21c"; } +.bi-camera-video-off-fill::before { content: "\f21d"; } +.bi-camera-video-off::before { content: "\f21e"; } +.bi-camera-video::before { content: "\f21f"; } +.bi-camera::before { content: "\f220"; } +.bi-camera2::before { content: "\f221"; } +.bi-capslock-fill::before { content: "\f222"; } +.bi-capslock::before { content: "\f223"; } +.bi-card-checklist::before { content: "\f224"; } +.bi-card-heading::before { content: "\f225"; } +.bi-card-image::before { content: "\f226"; } +.bi-card-list::before { content: "\f227"; } +.bi-card-text::before { content: "\f228"; } +.bi-caret-down-fill::before { content: "\f229"; } +.bi-caret-down-square-fill::before { content: "\f22a"; } +.bi-caret-down-square::before { content: "\f22b"; } +.bi-caret-down::before { content: "\f22c"; } +.bi-caret-left-fill::before { content: "\f22d"; } +.bi-caret-left-square-fill::before { content: "\f22e"; } +.bi-caret-left-square::before { content: "\f22f"; } +.bi-caret-left::before { content: "\f230"; } +.bi-caret-right-fill::before { content: "\f231"; } +.bi-caret-right-square-fill::before { content: "\f232"; } +.bi-caret-right-square::before { content: "\f233"; } +.bi-caret-right::before { content: "\f234"; } +.bi-caret-up-fill::before { content: "\f235"; } +.bi-caret-up-square-fill::before { content: "\f236"; } +.bi-caret-up-square::before { content: "\f237"; } +.bi-caret-up::before { content: "\f238"; } +.bi-cart-check-fill::before { content: "\f239"; } +.bi-cart-check::before { content: "\f23a"; } +.bi-cart-dash-fill::before { content: "\f23b"; } +.bi-cart-dash::before { content: "\f23c"; } +.bi-cart-fill::before { content: "\f23d"; } +.bi-cart-plus-fill::before { content: "\f23e"; } +.bi-cart-plus::before { content: "\f23f"; } +.bi-cart-x-fill::before { content: "\f240"; } +.bi-cart-x::before { content: "\f241"; } +.bi-cart::before { content: "\f242"; } +.bi-cart2::before { content: "\f243"; } +.bi-cart3::before { content: "\f244"; } +.bi-cart4::before { content: "\f245"; } +.bi-cash-stack::before { content: "\f246"; } +.bi-cash::before { content: "\f247"; } +.bi-cast::before { content: "\f248"; } +.bi-chat-dots-fill::before { content: "\f249"; } +.bi-chat-dots::before { content: "\f24a"; } +.bi-chat-fill::before { content: "\f24b"; } +.bi-chat-left-dots-fill::before { content: "\f24c"; } +.bi-chat-left-dots::before { content: "\f24d"; } +.bi-chat-left-fill::before { content: "\f24e"; } +.bi-chat-left-quote-fill::before { content: "\f24f"; } +.bi-chat-left-quote::before { content: "\f250"; } +.bi-chat-left-text-fill::before { content: "\f251"; } +.bi-chat-left-text::before { content: "\f252"; } +.bi-chat-left::before { content: "\f253"; } +.bi-chat-quote-fill::before { content: "\f254"; } +.bi-chat-quote::before { content: "\f255"; } +.bi-chat-right-dots-fill::before { content: "\f256"; } +.bi-chat-right-dots::before { content: "\f257"; } +.bi-chat-right-fill::before { content: "\f258"; } +.bi-chat-right-quote-fill::before { content: "\f259"; } +.bi-chat-right-quote::before { content: "\f25a"; } +.bi-chat-right-text-fill::before { content: "\f25b"; } +.bi-chat-right-text::before { content: "\f25c"; } +.bi-chat-right::before { content: "\f25d"; } +.bi-chat-square-dots-fill::before { content: "\f25e"; } +.bi-chat-square-dots::before { content: "\f25f"; } +.bi-chat-square-fill::before { content: "\f260"; } +.bi-chat-square-quote-fill::before { content: "\f261"; } +.bi-chat-square-quote::before { content: "\f262"; } +.bi-chat-square-text-fill::before { content: "\f263"; } +.bi-chat-square-text::before { content: "\f264"; } +.bi-chat-square::before { content: "\f265"; } +.bi-chat-text-fill::before { content: "\f266"; } +.bi-chat-text::before { content: "\f267"; } +.bi-chat::before { content: "\f268"; } +.bi-check-all::before { content: "\f269"; } +.bi-check-circle-fill::before { content: "\f26a"; } +.bi-check-circle::before { content: "\f26b"; } +.bi-check-square-fill::before { content: "\f26c"; } +.bi-check-square::before { content: "\f26d"; } +.bi-check::before { content: "\f26e"; } +.bi-check2-all::before { content: "\f26f"; } +.bi-check2-circle::before { content: "\f270"; } +.bi-check2-square::before { content: "\f271"; } +.bi-check2::before { content: "\f272"; } +.bi-chevron-bar-contract::before { content: "\f273"; } +.bi-chevron-bar-down::before { content: "\f274"; } +.bi-chevron-bar-expand::before { content: "\f275"; } +.bi-chevron-bar-left::before { content: "\f276"; } +.bi-chevron-bar-right::before { content: "\f277"; } +.bi-chevron-bar-up::before { content: "\f278"; } +.bi-chevron-compact-down::before { content: "\f279"; } +.bi-chevron-compact-left::before { content: "\f27a"; } +.bi-chevron-compact-right::before { content: "\f27b"; } +.bi-chevron-compact-up::before { content: "\f27c"; } +.bi-chevron-contract::before { content: "\f27d"; } +.bi-chevron-double-down::before { content: "\f27e"; } +.bi-chevron-double-left::before { content: "\f27f"; } +.bi-chevron-double-right::before { content: "\f280"; } +.bi-chevron-double-up::before { content: "\f281"; } +.bi-chevron-down::before { content: "\f282"; } +.bi-chevron-expand::before { content: "\f283"; } +.bi-chevron-left::before { content: "\f284"; } +.bi-chevron-right::before { content: "\f285"; } +.bi-chevron-up::before { content: "\f286"; } +.bi-circle-fill::before { content: "\f287"; } +.bi-circle-half::before { content: "\f288"; } +.bi-circle-square::before { content: "\f289"; } +.bi-circle::before { content: "\f28a"; } +.bi-clipboard-check::before { content: "\f28b"; } +.bi-clipboard-data::before { content: "\f28c"; } +.bi-clipboard-minus::before { content: "\f28d"; } +.bi-clipboard-plus::before { content: "\f28e"; } +.bi-clipboard-x::before { content: "\f28f"; } +.bi-clipboard::before { content: "\f290"; } +.bi-clock-fill::before { content: "\f291"; } +.bi-clock-history::before { content: "\f292"; } +.bi-clock::before { content: "\f293"; } +.bi-cloud-arrow-down-fill::before { content: "\f294"; } +.bi-cloud-arrow-down::before { content: "\f295"; } +.bi-cloud-arrow-up-fill::before { content: "\f296"; } +.bi-cloud-arrow-up::before { content: "\f297"; } +.bi-cloud-check-fill::before { content: "\f298"; } +.bi-cloud-check::before { content: "\f299"; } +.bi-cloud-download-fill::before { content: "\f29a"; } +.bi-cloud-download::before { content: "\f29b"; } +.bi-cloud-drizzle-fill::before { content: "\f29c"; } +.bi-cloud-drizzle::before { content: "\f29d"; } +.bi-cloud-fill::before { content: "\f29e"; } +.bi-cloud-fog-fill::before { content: "\f29f"; } +.bi-cloud-fog::before { content: "\f2a0"; } +.bi-cloud-fog2-fill::before { content: "\f2a1"; } +.bi-cloud-fog2::before { content: "\f2a2"; } +.bi-cloud-hail-fill::before { content: "\f2a3"; } +.bi-cloud-hail::before { content: "\f2a4"; } +.bi-cloud-haze-1::before { content: "\f2a5"; } +.bi-cloud-haze-fill::before { content: "\f2a6"; } +.bi-cloud-haze::before { content: "\f2a7"; } +.bi-cloud-haze2-fill::before { content: "\f2a8"; } +.bi-cloud-lightning-fill::before { content: "\f2a9"; } +.bi-cloud-lightning-rain-fill::before { content: "\f2aa"; } +.bi-cloud-lightning-rain::before { content: "\f2ab"; } +.bi-cloud-lightning::before { content: "\f2ac"; } +.bi-cloud-minus-fill::before { content: "\f2ad"; } +.bi-cloud-minus::before { content: "\f2ae"; } +.bi-cloud-moon-fill::before { content: "\f2af"; } +.bi-cloud-moon::before { content: "\f2b0"; } +.bi-cloud-plus-fill::before { content: "\f2b1"; } +.bi-cloud-plus::before { content: "\f2b2"; } +.bi-cloud-rain-fill::before { content: "\f2b3"; } +.bi-cloud-rain-heavy-fill::before { content: "\f2b4"; } +.bi-cloud-rain-heavy::before { content: "\f2b5"; } +.bi-cloud-rain::before { content: "\f2b6"; } +.bi-cloud-slash-fill::before { content: "\f2b7"; } +.bi-cloud-slash::before { content: "\f2b8"; } +.bi-cloud-sleet-fill::before { content: "\f2b9"; } +.bi-cloud-sleet::before { content: "\f2ba"; } +.bi-cloud-snow-fill::before { content: "\f2bb"; } +.bi-cloud-snow::before { content: "\f2bc"; } +.bi-cloud-sun-fill::before { content: "\f2bd"; } +.bi-cloud-sun::before { content: "\f2be"; } +.bi-cloud-upload-fill::before { content: "\f2bf"; } +.bi-cloud-upload::before { content: "\f2c0"; } +.bi-cloud::before { content: "\f2c1"; } +.bi-clouds-fill::before { content: "\f2c2"; } +.bi-clouds::before { content: "\f2c3"; } +.bi-cloudy-fill::before { content: "\f2c4"; } +.bi-cloudy::before { content: "\f2c5"; } +.bi-code-slash::before { content: "\f2c6"; } +.bi-code-square::before { content: "\f2c7"; } +.bi-code::before { content: "\f2c8"; } +.bi-collection-fill::before { content: "\f2c9"; } +.bi-collection-play-fill::before { content: "\f2ca"; } +.bi-collection-play::before { content: "\f2cb"; } +.bi-collection::before { content: "\f2cc"; } +.bi-columns-gap::before { content: "\f2cd"; } +.bi-columns::before { content: "\f2ce"; } +.bi-command::before { content: "\f2cf"; } +.bi-compass-fill::before { content: "\f2d0"; } +.bi-compass::before { content: "\f2d1"; } +.bi-cone-striped::before { content: "\f2d2"; } +.bi-cone::before { content: "\f2d3"; } +.bi-controller::before { content: "\f2d4"; } +.bi-cpu-fill::before { content: "\f2d5"; } +.bi-cpu::before { content: "\f2d6"; } +.bi-credit-card-2-back-fill::before { content: "\f2d7"; } +.bi-credit-card-2-back::before { content: "\f2d8"; } +.bi-credit-card-2-front-fill::before { content: "\f2d9"; } +.bi-credit-card-2-front::before { content: "\f2da"; } +.bi-credit-card-fill::before { content: "\f2db"; } +.bi-credit-card::before { content: "\f2dc"; } +.bi-crop::before { content: "\f2dd"; } +.bi-cup-fill::before { content: "\f2de"; } +.bi-cup-straw::before { content: "\f2df"; } +.bi-cup::before { content: "\f2e0"; } +.bi-cursor-fill::before { content: "\f2e1"; } +.bi-cursor-text::before { content: "\f2e2"; } +.bi-cursor::before { content: "\f2e3"; } +.bi-dash-circle-dotted::before { content: "\f2e4"; } +.bi-dash-circle-fill::before { content: "\f2e5"; } +.bi-dash-circle::before { content: "\f2e6"; } +.bi-dash-square-dotted::before { content: "\f2e7"; } +.bi-dash-square-fill::before { content: "\f2e8"; } +.bi-dash-square::before { content: "\f2e9"; } +.bi-dash::before { content: "\f2ea"; } +.bi-diagram-2-fill::before { content: "\f2eb"; } +.bi-diagram-2::before { content: "\f2ec"; } +.bi-diagram-3-fill::before { content: "\f2ed"; } +.bi-diagram-3::before { content: "\f2ee"; } +.bi-diamond-fill::before { content: "\f2ef"; } +.bi-diamond-half::before { content: "\f2f0"; } +.bi-diamond::before { content: "\f2f1"; } +.bi-dice-1-fill::before { content: "\f2f2"; } +.bi-dice-1::before { content: "\f2f3"; } +.bi-dice-2-fill::before { content: "\f2f4"; } +.bi-dice-2::before { content: "\f2f5"; } +.bi-dice-3-fill::before { content: "\f2f6"; } +.bi-dice-3::before { content: "\f2f7"; } +.bi-dice-4-fill::before { content: "\f2f8"; } +.bi-dice-4::before { content: "\f2f9"; } +.bi-dice-5-fill::before { content: "\f2fa"; } +.bi-dice-5::before { content: "\f2fb"; } +.bi-dice-6-fill::before { content: "\f2fc"; } +.bi-dice-6::before { content: "\f2fd"; } +.bi-disc-fill::before { content: "\f2fe"; } +.bi-disc::before { content: "\f2ff"; } +.bi-discord::before { content: "\f300"; } +.bi-display-fill::before { content: "\f301"; } +.bi-display::before { content: "\f302"; } +.bi-distribute-horizontal::before { content: "\f303"; } +.bi-distribute-vertical::before { content: "\f304"; } +.bi-door-closed-fill::before { content: "\f305"; } +.bi-door-closed::before { content: "\f306"; } +.bi-door-open-fill::before { content: "\f307"; } +.bi-door-open::before { content: "\f308"; } +.bi-dot::before { content: "\f309"; } +.bi-download::before { content: "\f30a"; } +.bi-droplet-fill::before { content: "\f30b"; } +.bi-droplet-half::before { content: "\f30c"; } +.bi-droplet::before { content: "\f30d"; } +.bi-earbuds::before { content: "\f30e"; } +.bi-easel-fill::before { content: "\f30f"; } +.bi-easel::before { content: "\f310"; } +.bi-egg-fill::before { content: "\f311"; } +.bi-egg-fried::before { content: "\f312"; } +.bi-egg::before { content: "\f313"; } +.bi-eject-fill::before { content: "\f314"; } +.bi-eject::before { content: "\f315"; } +.bi-emoji-angry-fill::before { content: "\f316"; } +.bi-emoji-angry::before { content: "\f317"; } +.bi-emoji-dizzy-fill::before { content: "\f318"; } +.bi-emoji-dizzy::before { content: "\f319"; } +.bi-emoji-expressionless-fill::before { content: "\f31a"; } +.bi-emoji-expressionless::before { content: "\f31b"; } +.bi-emoji-frown-fill::before { content: "\f31c"; } +.bi-emoji-frown::before { content: "\f31d"; } +.bi-emoji-heart-eyes-fill::before { content: "\f31e"; } +.bi-emoji-heart-eyes::before { content: "\f31f"; } +.bi-emoji-laughing-fill::before { content: "\f320"; } +.bi-emoji-laughing::before { content: "\f321"; } +.bi-emoji-neutral-fill::before { content: "\f322"; } +.bi-emoji-neutral::before { content: "\f323"; } +.bi-emoji-smile-fill::before { content: "\f324"; } +.bi-emoji-smile-upside-down-fill::before { content: "\f325"; } +.bi-emoji-smile-upside-down::before { content: "\f326"; } +.bi-emoji-smile::before { content: "\f327"; } +.bi-emoji-sunglasses-fill::before { content: "\f328"; } +.bi-emoji-sunglasses::before { content: "\f329"; } +.bi-emoji-wink-fill::before { content: "\f32a"; } +.bi-emoji-wink::before { content: "\f32b"; } +.bi-envelope-fill::before { content: "\f32c"; } +.bi-envelope-open-fill::before { content: "\f32d"; } +.bi-envelope-open::before { content: "\f32e"; } +.bi-envelope::before { content: "\f32f"; } +.bi-eraser-fill::before { content: "\f330"; } +.bi-eraser::before { content: "\f331"; } +.bi-exclamation-circle-fill::before { content: "\f332"; } +.bi-exclamation-circle::before { content: "\f333"; } +.bi-exclamation-diamond-fill::before { content: "\f334"; } +.bi-exclamation-diamond::before { content: "\f335"; } +.bi-exclamation-octagon-fill::before { content: "\f336"; } +.bi-exclamation-octagon::before { content: "\f337"; } +.bi-exclamation-square-fill::before { content: "\f338"; } +.bi-exclamation-square::before { content: "\f339"; } +.bi-exclamation-triangle-fill::before { content: "\f33a"; } +.bi-exclamation-triangle::before { content: "\f33b"; } +.bi-exclamation::before { content: "\f33c"; } +.bi-exclude::before { content: "\f33d"; } +.bi-eye-fill::before { content: "\f33e"; } +.bi-eye-slash-fill::before { content: "\f33f"; } +.bi-eye-slash::before { content: "\f340"; } +.bi-eye::before { content: "\f341"; } +.bi-eyedropper::before { content: "\f342"; } +.bi-eyeglasses::before { content: "\f343"; } +.bi-facebook::before { content: "\f344"; } +.bi-file-arrow-down-fill::before { content: "\f345"; } +.bi-file-arrow-down::before { content: "\f346"; } +.bi-file-arrow-up-fill::before { content: "\f347"; } +.bi-file-arrow-up::before { content: "\f348"; } +.bi-file-bar-graph-fill::before { content: "\f349"; } +.bi-file-bar-graph::before { content: "\f34a"; } +.bi-file-binary-fill::before { content: "\f34b"; } +.bi-file-binary::before { content: "\f34c"; } +.bi-file-break-fill::before { content: "\f34d"; } +.bi-file-break::before { content: "\f34e"; } +.bi-file-check-fill::before { content: "\f34f"; } +.bi-file-check::before { content: "\f350"; } +.bi-file-code-fill::before { content: "\f351"; } +.bi-file-code::before { content: "\f352"; } +.bi-file-diff-fill::before { content: "\f353"; } +.bi-file-diff::before { content: "\f354"; } +.bi-file-earmark-arrow-down-fill::before { content: "\f355"; } +.bi-file-earmark-arrow-down::before { content: "\f356"; } +.bi-file-earmark-arrow-up-fill::before { content: "\f357"; } +.bi-file-earmark-arrow-up::before { content: "\f358"; } +.bi-file-earmark-bar-graph-fill::before { content: "\f359"; } +.bi-file-earmark-bar-graph::before { content: "\f35a"; } +.bi-file-earmark-binary-fill::before { content: "\f35b"; } +.bi-file-earmark-binary::before { content: "\f35c"; } +.bi-file-earmark-break-fill::before { content: "\f35d"; } +.bi-file-earmark-break::before { content: "\f35e"; } +.bi-file-earmark-check-fill::before { content: "\f35f"; } +.bi-file-earmark-check::before { content: "\f360"; } +.bi-file-earmark-code-fill::before { content: "\f361"; } +.bi-file-earmark-code::before { content: "\f362"; } +.bi-file-earmark-diff-fill::before { content: "\f363"; } +.bi-file-earmark-diff::before { content: "\f364"; } +.bi-file-earmark-easel-fill::before { content: "\f365"; } +.bi-file-earmark-easel::before { content: "\f366"; } +.bi-file-earmark-excel-fill::before { content: "\f367"; } +.bi-file-earmark-excel::before { content: "\f368"; } +.bi-file-earmark-fill::before { content: "\f369"; } +.bi-file-earmark-font-fill::before { content: "\f36a"; } +.bi-file-earmark-font::before { content: "\f36b"; } +.bi-file-earmark-image-fill::before { content: "\f36c"; } +.bi-file-earmark-image::before { content: "\f36d"; } +.bi-file-earmark-lock-fill::before { content: "\f36e"; } +.bi-file-earmark-lock::before { content: "\f36f"; } +.bi-file-earmark-lock2-fill::before { content: "\f370"; } +.bi-file-earmark-lock2::before { content: "\f371"; } +.bi-file-earmark-medical-fill::before { content: "\f372"; } +.bi-file-earmark-medical::before { content: "\f373"; } +.bi-file-earmark-minus-fill::before { content: "\f374"; } +.bi-file-earmark-minus::before { content: "\f375"; } +.bi-file-earmark-music-fill::before { content: "\f376"; } +.bi-file-earmark-music::before { content: "\f377"; } +.bi-file-earmark-person-fill::before { content: "\f378"; } +.bi-file-earmark-person::before { content: "\f379"; } +.bi-file-earmark-play-fill::before { content: "\f37a"; } +.bi-file-earmark-play::before { content: "\f37b"; } +.bi-file-earmark-plus-fill::before { content: "\f37c"; } +.bi-file-earmark-plus::before { content: "\f37d"; } +.bi-file-earmark-post-fill::before { content: "\f37e"; } +.bi-file-earmark-post::before { content: "\f37f"; } +.bi-file-earmark-ppt-fill::before { content: "\f380"; } +.bi-file-earmark-ppt::before { content: "\f381"; } +.bi-file-earmark-richtext-fill::before { content: "\f382"; } +.bi-file-earmark-richtext::before { content: "\f383"; } +.bi-file-earmark-ruled-fill::before { content: "\f384"; } +.bi-file-earmark-ruled::before { content: "\f385"; } +.bi-file-earmark-slides-fill::before { content: "\f386"; } +.bi-file-earmark-slides::before { content: "\f387"; } +.bi-file-earmark-spreadsheet-fill::before { content: "\f388"; } +.bi-file-earmark-spreadsheet::before { content: "\f389"; } +.bi-file-earmark-text-fill::before { content: "\f38a"; } +.bi-file-earmark-text::before { content: "\f38b"; } +.bi-file-earmark-word-fill::before { content: "\f38c"; } +.bi-file-earmark-word::before { content: "\f38d"; } +.bi-file-earmark-x-fill::before { content: "\f38e"; } +.bi-file-earmark-x::before { content: "\f38f"; } +.bi-file-earmark-zip-fill::before { content: "\f390"; } +.bi-file-earmark-zip::before { content: "\f391"; } +.bi-file-earmark::before { content: "\f392"; } +.bi-file-easel-fill::before { content: "\f393"; } +.bi-file-easel::before { content: "\f394"; } +.bi-file-excel-fill::before { content: "\f395"; } +.bi-file-excel::before { content: "\f396"; } +.bi-file-fill::before { content: "\f397"; } +.bi-file-font-fill::before { content: "\f398"; } +.bi-file-font::before { content: "\f399"; } +.bi-file-image-fill::before { content: "\f39a"; } +.bi-file-image::before { content: "\f39b"; } +.bi-file-lock-fill::before { content: "\f39c"; } +.bi-file-lock::before { content: "\f39d"; } +.bi-file-lock2-fill::before { content: "\f39e"; } +.bi-file-lock2::before { content: "\f39f"; } +.bi-file-medical-fill::before { content: "\f3a0"; } +.bi-file-medical::before { content: "\f3a1"; } +.bi-file-minus-fill::before { content: "\f3a2"; } +.bi-file-minus::before { content: "\f3a3"; } +.bi-file-music-fill::before { content: "\f3a4"; } +.bi-file-music::before { content: "\f3a5"; } +.bi-file-person-fill::before { content: "\f3a6"; } +.bi-file-person::before { content: "\f3a7"; } +.bi-file-play-fill::before { content: "\f3a8"; } +.bi-file-play::before { content: "\f3a9"; } +.bi-file-plus-fill::before { content: "\f3aa"; } +.bi-file-plus::before { content: "\f3ab"; } +.bi-file-post-fill::before { content: "\f3ac"; } +.bi-file-post::before { content: "\f3ad"; } +.bi-file-ppt-fill::before { content: "\f3ae"; } +.bi-file-ppt::before { content: "\f3af"; } +.bi-file-richtext-fill::before { content: "\f3b0"; } +.bi-file-richtext::before { content: "\f3b1"; } +.bi-file-ruled-fill::before { content: "\f3b2"; } +.bi-file-ruled::before { content: "\f3b3"; } +.bi-file-slides-fill::before { content: "\f3b4"; } +.bi-file-slides::before { content: "\f3b5"; } +.bi-file-spreadsheet-fill::before { content: "\f3b6"; } +.bi-file-spreadsheet::before { content: "\f3b7"; } +.bi-file-text-fill::before { content: "\f3b8"; } +.bi-file-text::before { content: "\f3b9"; } +.bi-file-word-fill::before { content: "\f3ba"; } +.bi-file-word::before { content: "\f3bb"; } +.bi-file-x-fill::before { content: "\f3bc"; } +.bi-file-x::before { content: "\f3bd"; } +.bi-file-zip-fill::before { content: "\f3be"; } +.bi-file-zip::before { content: "\f3bf"; } +.bi-file::before { content: "\f3c0"; } +.bi-files-alt::before { content: "\f3c1"; } +.bi-files::before { content: "\f3c2"; } +.bi-film::before { content: "\f3c3"; } +.bi-filter-circle-fill::before { content: "\f3c4"; } +.bi-filter-circle::before { content: "\f3c5"; } +.bi-filter-left::before { content: "\f3c6"; } +.bi-filter-right::before { content: "\f3c7"; } +.bi-filter-square-fill::before { content: "\f3c8"; } +.bi-filter-square::before { content: "\f3c9"; } +.bi-filter::before { content: "\f3ca"; } +.bi-flag-fill::before { content: "\f3cb"; } +.bi-flag::before { content: "\f3cc"; } +.bi-flower1::before { content: "\f3cd"; } +.bi-flower2::before { content: "\f3ce"; } +.bi-flower3::before { content: "\f3cf"; } +.bi-folder-check::before { content: "\f3d0"; } +.bi-folder-fill::before { content: "\f3d1"; } +.bi-folder-minus::before { content: "\f3d2"; } +.bi-folder-plus::before { content: "\f3d3"; } +.bi-folder-symlink-fill::before { content: "\f3d4"; } +.bi-folder-symlink::before { content: "\f3d5"; } +.bi-folder-x::before { content: "\f3d6"; } +.bi-folder::before { content: "\f3d7"; } +.bi-folder2-open::before { content: "\f3d8"; } +.bi-folder2::before { content: "\f3d9"; } +.bi-fonts::before { content: "\f3da"; } +.bi-forward-fill::before { content: "\f3db"; } +.bi-forward::before { content: "\f3dc"; } +.bi-front::before { content: "\f3dd"; } +.bi-fullscreen-exit::before { content: "\f3de"; } +.bi-fullscreen::before { content: "\f3df"; } +.bi-funnel-fill::before { content: "\f3e0"; } +.bi-funnel::before { content: "\f3e1"; } +.bi-gear-fill::before { content: "\f3e2"; } +.bi-gear-wide-connected::before { content: "\f3e3"; } +.bi-gear-wide::before { content: "\f3e4"; } +.bi-gear::before { content: "\f3e5"; } +.bi-gem::before { content: "\f3e6"; } +.bi-geo-alt-fill::before { content: "\f3e7"; } +.bi-geo-alt::before { content: "\f3e8"; } +.bi-geo-fill::before { content: "\f3e9"; } +.bi-geo::before { content: "\f3ea"; } +.bi-gift-fill::before { content: "\f3eb"; } +.bi-gift::before { content: "\f3ec"; } +.bi-github::before { content: "\f3ed"; } +.bi-globe::before { content: "\f3ee"; } +.bi-globe2::before { content: "\f3ef"; } +.bi-google::before { content: "\f3f0"; } +.bi-graph-down::before { content: "\f3f1"; } +.bi-graph-up::before { content: "\f3f2"; } +.bi-grid-1x2-fill::before { content: "\f3f3"; } +.bi-grid-1x2::before { content: "\f3f4"; } +.bi-grid-3x2-gap-fill::before { content: "\f3f5"; } +.bi-grid-3x2-gap::before { content: "\f3f6"; } +.bi-grid-3x2::before { content: "\f3f7"; } +.bi-grid-3x3-gap-fill::before { content: "\f3f8"; } +.bi-grid-3x3-gap::before { content: "\f3f9"; } +.bi-grid-3x3::before { content: "\f3fa"; } +.bi-grid-fill::before { content: "\f3fb"; } +.bi-grid::before { content: "\f3fc"; } +.bi-grip-horizontal::before { content: "\f3fd"; } +.bi-grip-vertical::before { content: "\f3fe"; } +.bi-hammer::before { content: "\f3ff"; } +.bi-hand-index-fill::before { content: "\f400"; } +.bi-hand-index-thumb-fill::before { content: "\f401"; } +.bi-hand-index-thumb::before { content: "\f402"; } +.bi-hand-index::before { content: "\f403"; } +.bi-hand-thumbs-down-fill::before { content: "\f404"; } +.bi-hand-thumbs-down::before { content: "\f405"; } +.bi-hand-thumbs-up-fill::before { content: "\f406"; } +.bi-hand-thumbs-up::before { content: "\f407"; } +.bi-handbag-fill::before { content: "\f408"; } +.bi-handbag::before { content: "\f409"; } +.bi-hash::before { content: "\f40a"; } +.bi-hdd-fill::before { content: "\f40b"; } +.bi-hdd-network-fill::before { content: "\f40c"; } +.bi-hdd-network::before { content: "\f40d"; } +.bi-hdd-rack-fill::before { content: "\f40e"; } +.bi-hdd-rack::before { content: "\f40f"; } +.bi-hdd-stack-fill::before { content: "\f410"; } +.bi-hdd-stack::before { content: "\f411"; } +.bi-hdd::before { content: "\f412"; } +.bi-headphones::before { content: "\f413"; } +.bi-headset::before { content: "\f414"; } +.bi-heart-fill::before { content: "\f415"; } +.bi-heart-half::before { content: "\f416"; } +.bi-heart::before { content: "\f417"; } +.bi-heptagon-fill::before { content: "\f418"; } +.bi-heptagon-half::before { content: "\f419"; } +.bi-heptagon::before { content: "\f41a"; } +.bi-hexagon-fill::before { content: "\f41b"; } +.bi-hexagon-half::before { content: "\f41c"; } +.bi-hexagon::before { content: "\f41d"; } +.bi-hourglass-bottom::before { content: "\f41e"; } +.bi-hourglass-split::before { content: "\f41f"; } +.bi-hourglass-top::before { content: "\f420"; } +.bi-hourglass::before { content: "\f421"; } +.bi-house-door-fill::before { content: "\f422"; } +.bi-house-door::before { content: "\f423"; } +.bi-house-fill::before { content: "\f424"; } +.bi-house::before { content: "\f425"; } +.bi-hr::before { content: "\f426"; } +.bi-hurricane::before { content: "\f427"; } +.bi-image-alt::before { content: "\f428"; } +.bi-image-fill::before { content: "\f429"; } +.bi-image::before { content: "\f42a"; } +.bi-images::before { content: "\f42b"; } +.bi-inbox-fill::before { content: "\f42c"; } +.bi-inbox::before { content: "\f42d"; } +.bi-inboxes-fill::before { content: "\f42e"; } +.bi-inboxes::before { content: "\f42f"; } +.bi-info-circle-fill::before { content: "\f430"; } +.bi-info-circle::before { content: "\f431"; } +.bi-info-square-fill::before { content: "\f432"; } +.bi-info-square::before { content: "\f433"; } +.bi-info::before { content: "\f434"; } +.bi-input-cursor-text::before { content: "\f435"; } +.bi-input-cursor::before { content: "\f436"; } +.bi-instagram::before { content: "\f437"; } +.bi-intersect::before { content: "\f438"; } +.bi-journal-album::before { content: "\f439"; } +.bi-journal-arrow-down::before { content: "\f43a"; } +.bi-journal-arrow-up::before { content: "\f43b"; } +.bi-journal-bookmark-fill::before { content: "\f43c"; } +.bi-journal-bookmark::before { content: "\f43d"; } +.bi-journal-check::before { content: "\f43e"; } +.bi-journal-code::before { content: "\f43f"; } +.bi-journal-medical::before { content: "\f440"; } +.bi-journal-minus::before { content: "\f441"; } +.bi-journal-plus::before { content: "\f442"; } +.bi-journal-richtext::before { content: "\f443"; } +.bi-journal-text::before { content: "\f444"; } +.bi-journal-x::before { content: "\f445"; } +.bi-journal::before { content: "\f446"; } +.bi-journals::before { content: "\f447"; } +.bi-joystick::before { content: "\f448"; } +.bi-justify-left::before { content: "\f449"; } +.bi-justify-right::before { content: "\f44a"; } +.bi-justify::before { content: "\f44b"; } +.bi-kanban-fill::before { content: "\f44c"; } +.bi-kanban::before { content: "\f44d"; } +.bi-key-fill::before { content: "\f44e"; } +.bi-key::before { content: "\f44f"; } +.bi-keyboard-fill::before { content: "\f450"; } +.bi-keyboard::before { content: "\f451"; } +.bi-ladder::before { content: "\f452"; } +.bi-lamp-fill::before { content: "\f453"; } +.bi-lamp::before { content: "\f454"; } +.bi-laptop-fill::before { content: "\f455"; } +.bi-laptop::before { content: "\f456"; } +.bi-layer-backward::before { content: "\f457"; } +.bi-layer-forward::before { content: "\f458"; } +.bi-layers-fill::before { content: "\f459"; } +.bi-layers-half::before { content: "\f45a"; } +.bi-layers::before { content: "\f45b"; } +.bi-layout-sidebar-inset-reverse::before { content: "\f45c"; } +.bi-layout-sidebar-inset::before { content: "\f45d"; } +.bi-layout-sidebar-reverse::before { content: "\f45e"; } +.bi-layout-sidebar::before { content: "\f45f"; } +.bi-layout-split::before { content: "\f460"; } +.bi-layout-text-sidebar-reverse::before { content: "\f461"; } +.bi-layout-text-sidebar::before { content: "\f462"; } +.bi-layout-text-window-reverse::before { content: "\f463"; } +.bi-layout-text-window::before { content: "\f464"; } +.bi-layout-three-columns::before { content: "\f465"; } +.bi-layout-wtf::before { content: "\f466"; } +.bi-life-preserver::before { content: "\f467"; } +.bi-lightbulb-fill::before { content: "\f468"; } +.bi-lightbulb-off-fill::before { content: "\f469"; } +.bi-lightbulb-off::before { content: "\f46a"; } +.bi-lightbulb::before { content: "\f46b"; } +.bi-lightning-charge-fill::before { content: "\f46c"; } +.bi-lightning-charge::before { content: "\f46d"; } +.bi-lightning-fill::before { content: "\f46e"; } +.bi-lightning::before { content: "\f46f"; } +.bi-link-45deg::before { content: "\f470"; } +.bi-link::before { content: "\f471"; } +.bi-linkedin::before { content: "\f472"; } +.bi-list-check::before { content: "\f473"; } +.bi-list-nested::before { content: "\f474"; } +.bi-list-ol::before { content: "\f475"; } +.bi-list-stars::before { content: "\f476"; } +.bi-list-task::before { content: "\f477"; } +.bi-list-ul::before { content: "\f478"; } +.bi-list::before { content: "\f479"; } +.bi-lock-fill::before { content: "\f47a"; } +.bi-lock::before { content: "\f47b"; } +.bi-mailbox::before { content: "\f47c"; } +.bi-mailbox2::before { content: "\f47d"; } +.bi-map-fill::before { content: "\f47e"; } +.bi-map::before { content: "\f47f"; } +.bi-markdown-fill::before { content: "\f480"; } +.bi-markdown::before { content: "\f481"; } +.bi-mask::before { content: "\f482"; } +.bi-megaphone-fill::before { content: "\f483"; } +.bi-megaphone::before { content: "\f484"; } +.bi-menu-app-fill::before { content: "\f485"; } +.bi-menu-app::before { content: "\f486"; } +.bi-menu-button-fill::before { content: "\f487"; } +.bi-menu-button-wide-fill::before { content: "\f488"; } +.bi-menu-button-wide::before { content: "\f489"; } +.bi-menu-button::before { content: "\f48a"; } +.bi-menu-down::before { content: "\f48b"; } +.bi-menu-up::before { content: "\f48c"; } +.bi-mic-fill::before { content: "\f48d"; } +.bi-mic-mute-fill::before { content: "\f48e"; } +.bi-mic-mute::before { content: "\f48f"; } +.bi-mic::before { content: "\f490"; } +.bi-minecart-loaded::before { content: "\f491"; } +.bi-minecart::before { content: "\f492"; } +.bi-moisture::before { content: "\f493"; } +.bi-moon-fill::before { content: "\f494"; } +.bi-moon-stars-fill::before { content: "\f495"; } +.bi-moon-stars::before { content: "\f496"; } +.bi-moon::before { content: "\f497"; } +.bi-mouse-fill::before { content: "\f498"; } +.bi-mouse::before { content: "\f499"; } +.bi-mouse2-fill::before { content: "\f49a"; } +.bi-mouse2::before { content: "\f49b"; } +.bi-mouse3-fill::before { content: "\f49c"; } +.bi-mouse3::before { content: "\f49d"; } +.bi-music-note-beamed::before { content: "\f49e"; } +.bi-music-note-list::before { content: "\f49f"; } +.bi-music-note::before { content: "\f4a0"; } +.bi-music-player-fill::before { content: "\f4a1"; } +.bi-music-player::before { content: "\f4a2"; } +.bi-newspaper::before { content: "\f4a3"; } +.bi-node-minus-fill::before { content: "\f4a4"; } +.bi-node-minus::before { content: "\f4a5"; } +.bi-node-plus-fill::before { content: "\f4a6"; } +.bi-node-plus::before { content: "\f4a7"; } +.bi-nut-fill::before { content: "\f4a8"; } +.bi-nut::before { content: "\f4a9"; } +.bi-octagon-fill::before { content: "\f4aa"; } +.bi-octagon-half::before { content: "\f4ab"; } +.bi-octagon::before { content: "\f4ac"; } +.bi-option::before { content: "\f4ad"; } +.bi-outlet::before { content: "\f4ae"; } +.bi-paint-bucket::before { content: "\f4af"; } +.bi-palette-fill::before { content: "\f4b0"; } +.bi-palette::before { content: "\f4b1"; } +.bi-palette2::before { content: "\f4b2"; } +.bi-paperclip::before { content: "\f4b3"; } +.bi-paragraph::before { content: "\f4b4"; } +.bi-patch-check-fill::before { content: "\f4b5"; } +.bi-patch-check::before { content: "\f4b6"; } +.bi-patch-exclamation-fill::before { content: "\f4b7"; } +.bi-patch-exclamation::before { content: "\f4b8"; } +.bi-patch-minus-fill::before { content: "\f4b9"; } +.bi-patch-minus::before { content: "\f4ba"; } +.bi-patch-plus-fill::before { content: "\f4bb"; } +.bi-patch-plus::before { content: "\f4bc"; } +.bi-patch-question-fill::before { content: "\f4bd"; } +.bi-patch-question::before { content: "\f4be"; } +.bi-pause-btn-fill::before { content: "\f4bf"; } +.bi-pause-btn::before { content: "\f4c0"; } +.bi-pause-circle-fill::before { content: "\f4c1"; } +.bi-pause-circle::before { content: "\f4c2"; } +.bi-pause-fill::before { content: "\f4c3"; } +.bi-pause::before { content: "\f4c4"; } +.bi-peace-fill::before { content: "\f4c5"; } +.bi-peace::before { content: "\f4c6"; } +.bi-pen-fill::before { content: "\f4c7"; } +.bi-pen::before { content: "\f4c8"; } +.bi-pencil-fill::before { content: "\f4c9"; } +.bi-pencil-square::before { content: "\f4ca"; } +.bi-pencil::before { content: "\f4cb"; } +.bi-pentagon-fill::before { content: "\f4cc"; } +.bi-pentagon-half::before { content: "\f4cd"; } +.bi-pentagon::before { content: "\f4ce"; } +.bi-people-fill::before { content: "\f4cf"; } +.bi-people::before { content: "\f4d0"; } +.bi-percent::before { content: "\f4d1"; } +.bi-person-badge-fill::before { content: "\f4d2"; } +.bi-person-badge::before { content: "\f4d3"; } +.bi-person-bounding-box::before { content: "\f4d4"; } +.bi-person-check-fill::before { content: "\f4d5"; } +.bi-person-check::before { content: "\f4d6"; } +.bi-person-circle::before { content: "\f4d7"; } +.bi-person-dash-fill::before { content: "\f4d8"; } +.bi-person-dash::before { content: "\f4d9"; } +.bi-person-fill::before { content: "\f4da"; } +.bi-person-lines-fill::before { content: "\f4db"; } +.bi-person-plus-fill::before { content: "\f4dc"; } +.bi-person-plus::before { content: "\f4dd"; } +.bi-person-square::before { content: "\f4de"; } +.bi-person-x-fill::before { content: "\f4df"; } +.bi-person-x::before { content: "\f4e0"; } +.bi-person::before { content: "\f4e1"; } +.bi-phone-fill::before { content: "\f4e2"; } +.bi-phone-landscape-fill::before { content: "\f4e3"; } +.bi-phone-landscape::before { content: "\f4e4"; } +.bi-phone-vibrate-fill::before { content: "\f4e5"; } +.bi-phone-vibrate::before { content: "\f4e6"; } +.bi-phone::before { content: "\f4e7"; } +.bi-pie-chart-fill::before { content: "\f4e8"; } +.bi-pie-chart::before { content: "\f4e9"; } +.bi-pin-angle-fill::before { content: "\f4ea"; } +.bi-pin-angle::before { content: "\f4eb"; } +.bi-pin-fill::before { content: "\f4ec"; } +.bi-pin::before { content: "\f4ed"; } +.bi-pip-fill::before { content: "\f4ee"; } +.bi-pip::before { content: "\f4ef"; } +.bi-play-btn-fill::before { content: "\f4f0"; } +.bi-play-btn::before { content: "\f4f1"; } +.bi-play-circle-fill::before { content: "\f4f2"; } +.bi-play-circle::before { content: "\f4f3"; } +.bi-play-fill::before { content: "\f4f4"; } +.bi-play::before { content: "\f4f5"; } +.bi-plug-fill::before { content: "\f4f6"; } +.bi-plug::before { content: "\f4f7"; } +.bi-plus-circle-dotted::before { content: "\f4f8"; } +.bi-plus-circle-fill::before { content: "\f4f9"; } +.bi-plus-circle::before { content: "\f4fa"; } +.bi-plus-square-dotted::before { content: "\f4fb"; } +.bi-plus-square-fill::before { content: "\f4fc"; } +.bi-plus-square::before { content: "\f4fd"; } +.bi-plus::before { content: "\f4fe"; } +.bi-power::before { content: "\f4ff"; } +.bi-printer-fill::before { content: "\f500"; } +.bi-printer::before { content: "\f501"; } +.bi-puzzle-fill::before { content: "\f502"; } +.bi-puzzle::before { content: "\f503"; } +.bi-question-circle-fill::before { content: "\f504"; } +.bi-question-circle::before { content: "\f505"; } +.bi-question-diamond-fill::before { content: "\f506"; } +.bi-question-diamond::before { content: "\f507"; } +.bi-question-octagon-fill::before { content: "\f508"; } +.bi-question-octagon::before { content: "\f509"; } +.bi-question-square-fill::before { content: "\f50a"; } +.bi-question-square::before { content: "\f50b"; } +.bi-question::before { content: "\f50c"; } +.bi-rainbow::before { content: "\f50d"; } +.bi-receipt-cutoff::before { content: "\f50e"; } +.bi-receipt::before { content: "\f50f"; } +.bi-reception-0::before { content: "\f510"; } +.bi-reception-1::before { content: "\f511"; } +.bi-reception-2::before { content: "\f512"; } +.bi-reception-3::before { content: "\f513"; } +.bi-reception-4::before { content: "\f514"; } +.bi-record-btn-fill::before { content: "\f515"; } +.bi-record-btn::before { content: "\f516"; } +.bi-record-circle-fill::before { content: "\f517"; } +.bi-record-circle::before { content: "\f518"; } +.bi-record-fill::before { content: "\f519"; } +.bi-record::before { content: "\f51a"; } +.bi-record2-fill::before { content: "\f51b"; } +.bi-record2::before { content: "\f51c"; } +.bi-reply-all-fill::before { content: "\f51d"; } +.bi-reply-all::before { content: "\f51e"; } +.bi-reply-fill::before { content: "\f51f"; } +.bi-reply::before { content: "\f520"; } +.bi-rss-fill::before { content: "\f521"; } +.bi-rss::before { content: "\f522"; } +.bi-rulers::before { content: "\f523"; } +.bi-save-fill::before { content: "\f524"; } +.bi-save::before { content: "\f525"; } +.bi-save2-fill::before { content: "\f526"; } +.bi-save2::before { content: "\f527"; } +.bi-scissors::before { content: "\f528"; } +.bi-screwdriver::before { content: "\f529"; } +.bi-search::before { content: "\f52a"; } +.bi-segmented-nav::before { content: "\f52b"; } +.bi-server::before { content: "\f52c"; } +.bi-share-fill::before { content: "\f52d"; } +.bi-share::before { content: "\f52e"; } +.bi-shield-check::before { content: "\f52f"; } +.bi-shield-exclamation::before { content: "\f530"; } +.bi-shield-fill-check::before { content: "\f531"; } +.bi-shield-fill-exclamation::before { content: "\f532"; } +.bi-shield-fill-minus::before { content: "\f533"; } +.bi-shield-fill-plus::before { content: "\f534"; } +.bi-shield-fill-x::before { content: "\f535"; } +.bi-shield-fill::before { content: "\f536"; } +.bi-shield-lock-fill::before { content: "\f537"; } +.bi-shield-lock::before { content: "\f538"; } +.bi-shield-minus::before { content: "\f539"; } +.bi-shield-plus::before { content: "\f53a"; } +.bi-shield-shaded::before { content: "\f53b"; } +.bi-shield-slash-fill::before { content: "\f53c"; } +.bi-shield-slash::before { content: "\f53d"; } +.bi-shield-x::before { content: "\f53e"; } +.bi-shield::before { content: "\f53f"; } +.bi-shift-fill::before { content: "\f540"; } +.bi-shift::before { content: "\f541"; } +.bi-shop-window::before { content: "\f542"; } +.bi-shop::before { content: "\f543"; } +.bi-shuffle::before { content: "\f544"; } +.bi-signpost-2-fill::before { content: "\f545"; } +.bi-signpost-2::before { content: "\f546"; } +.bi-signpost-fill::before { content: "\f547"; } +.bi-signpost-split-fill::before { content: "\f548"; } +.bi-signpost-split::before { content: "\f549"; } +.bi-signpost::before { content: "\f54a"; } +.bi-sim-fill::before { content: "\f54b"; } +.bi-sim::before { content: "\f54c"; } +.bi-skip-backward-btn-fill::before { content: "\f54d"; } +.bi-skip-backward-btn::before { content: "\f54e"; } +.bi-skip-backward-circle-fill::before { content: "\f54f"; } +.bi-skip-backward-circle::before { content: "\f550"; } +.bi-skip-backward-fill::before { content: "\f551"; } +.bi-skip-backward::before { content: "\f552"; } +.bi-skip-end-btn-fill::before { content: "\f553"; } +.bi-skip-end-btn::before { content: "\f554"; } +.bi-skip-end-circle-fill::before { content: "\f555"; } +.bi-skip-end-circle::before { content: "\f556"; } +.bi-skip-end-fill::before { content: "\f557"; } +.bi-skip-end::before { content: "\f558"; } +.bi-skip-forward-btn-fill::before { content: "\f559"; } +.bi-skip-forward-btn::before { content: "\f55a"; } +.bi-skip-forward-circle-fill::before { content: "\f55b"; } +.bi-skip-forward-circle::before { content: "\f55c"; } +.bi-skip-forward-fill::before { content: "\f55d"; } +.bi-skip-forward::before { content: "\f55e"; } +.bi-skip-start-btn-fill::before { content: "\f55f"; } +.bi-skip-start-btn::before { content: "\f560"; } +.bi-skip-start-circle-fill::before { content: "\f561"; } +.bi-skip-start-circle::before { content: "\f562"; } +.bi-skip-start-fill::before { content: "\f563"; } +.bi-skip-start::before { content: "\f564"; } +.bi-slack::before { content: "\f565"; } +.bi-slash-circle-fill::before { content: "\f566"; } +.bi-slash-circle::before { content: "\f567"; } +.bi-slash-square-fill::before { content: "\f568"; } +.bi-slash-square::before { content: "\f569"; } +.bi-slash::before { content: "\f56a"; } +.bi-sliders::before { content: "\f56b"; } +.bi-smartwatch::before { content: "\f56c"; } +.bi-snow::before { content: "\f56d"; } +.bi-snow2::before { content: "\f56e"; } +.bi-snow3::before { content: "\f56f"; } +.bi-sort-alpha-down-alt::before { content: "\f570"; } +.bi-sort-alpha-down::before { content: "\f571"; } +.bi-sort-alpha-up-alt::before { content: "\f572"; } +.bi-sort-alpha-up::before { content: "\f573"; } +.bi-sort-down-alt::before { content: "\f574"; } +.bi-sort-down::before { content: "\f575"; } +.bi-sort-numeric-down-alt::before { content: "\f576"; } +.bi-sort-numeric-down::before { content: "\f577"; } +.bi-sort-numeric-up-alt::before { content: "\f578"; } +.bi-sort-numeric-up::before { content: "\f579"; } +.bi-sort-up-alt::before { content: "\f57a"; } +.bi-sort-up::before { content: "\f57b"; } +.bi-soundwave::before { content: "\f57c"; } +.bi-speaker-fill::before { content: "\f57d"; } +.bi-speaker::before { content: "\f57e"; } +.bi-speedometer::before { content: "\f57f"; } +.bi-speedometer2::before { content: "\f580"; } +.bi-spellcheck::before { content: "\f581"; } +.bi-square-fill::before { content: "\f582"; } +.bi-square-half::before { content: "\f583"; } +.bi-square::before { content: "\f584"; } +.bi-stack::before { content: "\f585"; } +.bi-star-fill::before { content: "\f586"; } +.bi-star-half::before { content: "\f587"; } +.bi-star::before { content: "\f588"; } +.bi-stars::before { content: "\f589"; } +.bi-stickies-fill::before { content: "\f58a"; } +.bi-stickies::before { content: "\f58b"; } +.bi-sticky-fill::before { content: "\f58c"; } +.bi-sticky::before { content: "\f58d"; } +.bi-stop-btn-fill::before { content: "\f58e"; } +.bi-stop-btn::before { content: "\f58f"; } +.bi-stop-circle-fill::before { content: "\f590"; } +.bi-stop-circle::before { content: "\f591"; } +.bi-stop-fill::before { content: "\f592"; } +.bi-stop::before { content: "\f593"; } +.bi-stoplights-fill::before { content: "\f594"; } +.bi-stoplights::before { content: "\f595"; } +.bi-stopwatch-fill::before { content: "\f596"; } +.bi-stopwatch::before { content: "\f597"; } +.bi-subtract::before { content: "\f598"; } +.bi-suit-club-fill::before { content: "\f599"; } +.bi-suit-club::before { content: "\f59a"; } +.bi-suit-diamond-fill::before { content: "\f59b"; } +.bi-suit-diamond::before { content: "\f59c"; } +.bi-suit-heart-fill::before { content: "\f59d"; } +.bi-suit-heart::before { content: "\f59e"; } +.bi-suit-spade-fill::before { content: "\f59f"; } +.bi-suit-spade::before { content: "\f5a0"; } +.bi-sun-fill::before { content: "\f5a1"; } +.bi-sun::before { content: "\f5a2"; } +.bi-sunglasses::before { content: "\f5a3"; } +.bi-sunrise-fill::before { content: "\f5a4"; } +.bi-sunrise::before { content: "\f5a5"; } +.bi-sunset-fill::before { content: "\f5a6"; } +.bi-sunset::before { content: "\f5a7"; } +.bi-symmetry-horizontal::before { content: "\f5a8"; } +.bi-symmetry-vertical::before { content: "\f5a9"; } +.bi-table::before { content: "\f5aa"; } +.bi-tablet-fill::before { content: "\f5ab"; } +.bi-tablet-landscape-fill::before { content: "\f5ac"; } +.bi-tablet-landscape::before { content: "\f5ad"; } +.bi-tablet::before { content: "\f5ae"; } +.bi-tag-fill::before { content: "\f5af"; } +.bi-tag::before { content: "\f5b0"; } +.bi-tags-fill::before { content: "\f5b1"; } +.bi-tags::before { content: "\f5b2"; } +.bi-telegram::before { content: "\f5b3"; } +.bi-telephone-fill::before { content: "\f5b4"; } +.bi-telephone-forward-fill::before { content: "\f5b5"; } +.bi-telephone-forward::before { content: "\f5b6"; } +.bi-telephone-inbound-fill::before { content: "\f5b7"; } +.bi-telephone-inbound::before { content: "\f5b8"; } +.bi-telephone-minus-fill::before { content: "\f5b9"; } +.bi-telephone-minus::before { content: "\f5ba"; } +.bi-telephone-outbound-fill::before { content: "\f5bb"; } +.bi-telephone-outbound::before { content: "\f5bc"; } +.bi-telephone-plus-fill::before { content: "\f5bd"; } +.bi-telephone-plus::before { content: "\f5be"; } +.bi-telephone-x-fill::before { content: "\f5bf"; } +.bi-telephone-x::before { content: "\f5c0"; } +.bi-telephone::before { content: "\f5c1"; } +.bi-terminal-fill::before { content: "\f5c2"; } +.bi-terminal::before { content: "\f5c3"; } +.bi-text-center::before { content: "\f5c4"; } +.bi-text-indent-left::before { content: "\f5c5"; } +.bi-text-indent-right::before { content: "\f5c6"; } +.bi-text-left::before { content: "\f5c7"; } +.bi-text-paragraph::before { content: "\f5c8"; } +.bi-text-right::before { content: "\f5c9"; } +.bi-textarea-resize::before { content: "\f5ca"; } +.bi-textarea-t::before { content: "\f5cb"; } +.bi-textarea::before { content: "\f5cc"; } +.bi-thermometer-half::before { content: "\f5cd"; } +.bi-thermometer-high::before { content: "\f5ce"; } +.bi-thermometer-low::before { content: "\f5cf"; } +.bi-thermometer-snow::before { content: "\f5d0"; } +.bi-thermometer-sun::before { content: "\f5d1"; } +.bi-thermometer::before { content: "\f5d2"; } +.bi-three-dots-vertical::before { content: "\f5d3"; } +.bi-three-dots::before { content: "\f5d4"; } +.bi-toggle-off::before { content: "\f5d5"; } +.bi-toggle-on::before { content: "\f5d6"; } +.bi-toggle2-off::before { content: "\f5d7"; } +.bi-toggle2-on::before { content: "\f5d8"; } +.bi-toggles::before { content: "\f5d9"; } +.bi-toggles2::before { content: "\f5da"; } +.bi-tools::before { content: "\f5db"; } +.bi-tornado::before { content: "\f5dc"; } +.bi-trash-fill::before { content: "\f5dd"; } +.bi-trash::before { content: "\f5de"; } +.bi-trash2-fill::before { content: "\f5df"; } +.bi-trash2::before { content: "\f5e0"; } +.bi-tree-fill::before { content: "\f5e1"; } +.bi-tree::before { content: "\f5e2"; } +.bi-triangle-fill::before { content: "\f5e3"; } +.bi-triangle-half::before { content: "\f5e4"; } +.bi-triangle::before { content: "\f5e5"; } +.bi-trophy-fill::before { content: "\f5e6"; } +.bi-trophy::before { content: "\f5e7"; } +.bi-tropical-storm::before { content: "\f5e8"; } +.bi-truck-flatbed::before { content: "\f5e9"; } +.bi-truck::before { content: "\f5ea"; } +.bi-tsunami::before { content: "\f5eb"; } +.bi-tv-fill::before { content: "\f5ec"; } +.bi-tv::before { content: "\f5ed"; } +.bi-twitch::before { content: "\f5ee"; } +.bi-twitter::before { content: "\f5ef"; } +.bi-type-bold::before { content: "\f5f0"; } +.bi-type-h1::before { content: "\f5f1"; } +.bi-type-h2::before { content: "\f5f2"; } +.bi-type-h3::before { content: "\f5f3"; } +.bi-type-italic::before { content: "\f5f4"; } +.bi-type-strikethrough::before { content: "\f5f5"; } +.bi-type-underline::before { content: "\f5f6"; } +.bi-type::before { content: "\f5f7"; } +.bi-ui-checks-grid::before { content: "\f5f8"; } +.bi-ui-checks::before { content: "\f5f9"; } +.bi-ui-radios-grid::before { content: "\f5fa"; } +.bi-ui-radios::before { content: "\f5fb"; } +.bi-umbrella-fill::before { content: "\f5fc"; } +.bi-umbrella::before { content: "\f5fd"; } +.bi-union::before { content: "\f5fe"; } +.bi-unlock-fill::before { content: "\f5ff"; } +.bi-unlock::before { content: "\f600"; } +.bi-upc-scan::before { content: "\f601"; } +.bi-upc::before { content: "\f602"; } +.bi-upload::before { content: "\f603"; } +.bi-vector-pen::before { content: "\f604"; } +.bi-view-list::before { content: "\f605"; } +.bi-view-stacked::before { content: "\f606"; } +.bi-vinyl-fill::before { content: "\f607"; } +.bi-vinyl::before { content: "\f608"; } +.bi-voicemail::before { content: "\f609"; } +.bi-volume-down-fill::before { content: "\f60a"; } +.bi-volume-down::before { content: "\f60b"; } +.bi-volume-mute-fill::before { content: "\f60c"; } +.bi-volume-mute::before { content: "\f60d"; } +.bi-volume-off-fill::before { content: "\f60e"; } +.bi-volume-off::before { content: "\f60f"; } +.bi-volume-up-fill::before { content: "\f610"; } +.bi-volume-up::before { content: "\f611"; } +.bi-vr::before { content: "\f612"; } +.bi-wallet-fill::before { content: "\f613"; } +.bi-wallet::before { content: "\f614"; } +.bi-wallet2::before { content: "\f615"; } +.bi-watch::before { content: "\f616"; } +.bi-water::before { content: "\f617"; } +.bi-whatsapp::before { content: "\f618"; } +.bi-wifi-1::before { content: "\f619"; } +.bi-wifi-2::before { content: "\f61a"; } +.bi-wifi-off::before { content: "\f61b"; } +.bi-wifi::before { content: "\f61c"; } +.bi-wind::before { content: "\f61d"; } +.bi-window-dock::before { content: "\f61e"; } +.bi-window-sidebar::before { content: "\f61f"; } +.bi-window::before { content: "\f620"; } +.bi-wrench::before { content: "\f621"; } +.bi-x-circle-fill::before { content: "\f622"; } +.bi-x-circle::before { content: "\f623"; } +.bi-x-diamond-fill::before { content: "\f624"; } +.bi-x-diamond::before { content: "\f625"; } +.bi-x-octagon-fill::before { content: "\f626"; } +.bi-x-octagon::before { content: "\f627"; } +.bi-x-square-fill::before { content: "\f628"; } +.bi-x-square::before { content: "\f629"; } +.bi-x::before { content: "\f62a"; } +.bi-youtube::before { content: "\f62b"; } +.bi-zoom-in::before { content: "\f62c"; } +.bi-zoom-out::before { content: "\f62d"; } +.bi-bank::before { content: "\f62e"; } +.bi-bank2::before { content: "\f62f"; } +.bi-bell-slash-fill::before { content: "\f630"; } +.bi-bell-slash::before { content: "\f631"; } +.bi-cash-coin::before { content: "\f632"; } +.bi-check-lg::before { content: "\f633"; } +.bi-coin::before { content: "\f634"; } +.bi-currency-bitcoin::before { content: "\f635"; } +.bi-currency-dollar::before { content: "\f636"; } +.bi-currency-euro::before { content: "\f637"; } +.bi-currency-exchange::before { content: "\f638"; } +.bi-currency-pound::before { content: "\f639"; } +.bi-currency-yen::before { content: "\f63a"; } +.bi-dash-lg::before { content: "\f63b"; } +.bi-exclamation-lg::before { content: "\f63c"; } +.bi-file-earmark-pdf-fill::before { content: "\f63d"; } +.bi-file-earmark-pdf::before { content: "\f63e"; } +.bi-file-pdf-fill::before { content: "\f63f"; } +.bi-file-pdf::before { content: "\f640"; } +.bi-gender-ambiguous::before { content: "\f641"; } +.bi-gender-female::before { content: "\f642"; } +.bi-gender-male::before { content: "\f643"; } +.bi-gender-trans::before { content: "\f644"; } +.bi-headset-vr::before { content: "\f645"; } +.bi-info-lg::before { content: "\f646"; } +.bi-mastodon::before { content: "\f647"; } +.bi-messenger::before { content: "\f648"; } +.bi-piggy-bank-fill::before { content: "\f649"; } +.bi-piggy-bank::before { content: "\f64a"; } +.bi-pin-map-fill::before { content: "\f64b"; } +.bi-pin-map::before { content: "\f64c"; } +.bi-plus-lg::before { content: "\f64d"; } +.bi-question-lg::before { content: "\f64e"; } +.bi-recycle::before { content: "\f64f"; } +.bi-reddit::before { content: "\f650"; } +.bi-safe-fill::before { content: "\f651"; } +.bi-safe2-fill::before { content: "\f652"; } +.bi-safe2::before { content: "\f653"; } +.bi-sd-card-fill::before { content: "\f654"; } +.bi-sd-card::before { content: "\f655"; } +.bi-skype::before { content: "\f656"; } +.bi-slash-lg::before { content: "\f657"; } +.bi-translate::before { content: "\f658"; } +.bi-x-lg::before { content: "\f659"; } +.bi-safe::before { content: "\f65a"; } +.bi-apple::before { content: "\f65b"; } +.bi-microsoft::before { content: "\f65d"; } +.bi-windows::before { content: "\f65e"; } +.bi-behance::before { content: "\f65c"; } +.bi-dribbble::before { content: "\f65f"; } +.bi-line::before { content: "\f660"; } +.bi-medium::before { content: "\f661"; } +.bi-paypal::before { content: "\f662"; } +.bi-pinterest::before { content: "\f663"; } +.bi-signal::before { content: "\f664"; } +.bi-snapchat::before { content: "\f665"; } +.bi-spotify::before { content: "\f666"; } +.bi-stack-overflow::before { content: "\f667"; } +.bi-strava::before { content: "\f668"; } +.bi-wordpress::before { content: "\f669"; } +.bi-vimeo::before { content: "\f66a"; } +.bi-activity::before { content: "\f66b"; } +.bi-easel2-fill::before { content: "\f66c"; } +.bi-easel2::before { content: "\f66d"; } +.bi-easel3-fill::before { content: "\f66e"; } +.bi-easel3::before { content: "\f66f"; } +.bi-fan::before { content: "\f670"; } +.bi-fingerprint::before { content: "\f671"; } +.bi-graph-down-arrow::before { content: "\f672"; } +.bi-graph-up-arrow::before { content: "\f673"; } +.bi-hypnotize::before { content: "\f674"; } +.bi-magic::before { content: "\f675"; } +.bi-person-rolodex::before { content: "\f676"; } +.bi-person-video::before { content: "\f677"; } +.bi-person-video2::before { content: "\f678"; } +.bi-person-video3::before { content: "\f679"; } +.bi-person-workspace::before { content: "\f67a"; } +.bi-radioactive::before { content: "\f67b"; } +.bi-webcam-fill::before { content: "\f67c"; } +.bi-webcam::before { content: "\f67d"; } +.bi-yin-yang::before { content: "\f67e"; } +.bi-bandaid-fill::before { content: "\f680"; } +.bi-bandaid::before { content: "\f681"; } +.bi-bluetooth::before { content: "\f682"; } +.bi-body-text::before { content: "\f683"; } +.bi-boombox::before { content: "\f684"; } +.bi-boxes::before { content: "\f685"; } +.bi-dpad-fill::before { content: "\f686"; } +.bi-dpad::before { content: "\f687"; } +.bi-ear-fill::before { content: "\f688"; } +.bi-ear::before { content: "\f689"; } +.bi-envelope-check-1::before { content: "\f68a"; } +.bi-envelope-check-fill::before { content: "\f68b"; } +.bi-envelope-check::before { content: "\f68c"; } +.bi-envelope-dash-1::before { content: "\f68d"; } +.bi-envelope-dash-fill::before { content: "\f68e"; } +.bi-envelope-dash::before { content: "\f68f"; } +.bi-envelope-exclamation-1::before { content: "\f690"; } +.bi-envelope-exclamation-fill::before { content: "\f691"; } +.bi-envelope-exclamation::before { content: "\f692"; } +.bi-envelope-plus-fill::before { content: "\f693"; } +.bi-envelope-plus::before { content: "\f694"; } +.bi-envelope-slash-1::before { content: "\f695"; } +.bi-envelope-slash-fill::before { content: "\f696"; } +.bi-envelope-slash::before { content: "\f697"; } +.bi-envelope-x-1::before { content: "\f698"; } +.bi-envelope-x-fill::before { content: "\f699"; } +.bi-envelope-x::before { content: "\f69a"; } +.bi-explicit-fill::before { content: "\f69b"; } +.bi-explicit::before { content: "\f69c"; } +.bi-git::before { content: "\f69d"; } +.bi-infinity::before { content: "\f69e"; } +.bi-list-columns-reverse::before { content: "\f69f"; } +.bi-list-columns::before { content: "\f6a0"; } +.bi-meta::before { content: "\f6a1"; } +.bi-mortorboard-fill::before { content: "\f6a2"; } +.bi-mortorboard::before { content: "\f6a3"; } +.bi-nintendo-switch::before { content: "\f6a4"; } +.bi-pc-display-horizontal::before { content: "\f6a5"; } +.bi-pc-display::before { content: "\f6a6"; } +.bi-pc-horizontal::before { content: "\f6a7"; } +.bi-pc::before { content: "\f6a8"; } +.bi-playstation::before { content: "\f6a9"; } +.bi-plus-slash-minus::before { content: "\f6aa"; } +.bi-projector-fill::before { content: "\f6ab"; } +.bi-projector::before { content: "\f6ac"; } +.bi-qr-code-scan::before { content: "\f6ad"; } +.bi-qr-code::before { content: "\f6ae"; } +.bi-quora::before { content: "\f6af"; } +.bi-quote::before { content: "\f6b0"; } +.bi-robot::before { content: "\f6b1"; } +.bi-send-check-fill::before { content: "\f6b2"; } +.bi-send-check::before { content: "\f6b3"; } +.bi-send-dash-fill::before { content: "\f6b4"; } +.bi-send-dash::before { content: "\f6b5"; } +.bi-send-exclamation-1::before { content: "\f6b6"; } +.bi-send-exclamation-fill::before { content: "\f6b7"; } +.bi-send-exclamation::before { content: "\f6b8"; } +.bi-send-fill::before { content: "\f6b9"; } +.bi-send-plus-fill::before { content: "\f6ba"; } +.bi-send-plus::before { content: "\f6bb"; } +.bi-send-slash-fill::before { content: "\f6bc"; } +.bi-send-slash::before { content: "\f6bd"; } +.bi-send-x-fill::before { content: "\f6be"; } +.bi-send-x::before { content: "\f6bf"; } +.bi-send::before { content: "\f6c0"; } +.bi-steam::before { content: "\f6c1"; } +.bi-terminal-dash-1::before { content: "\f6c2"; } +.bi-terminal-dash::before { content: "\f6c3"; } +.bi-terminal-plus::before { content: "\f6c4"; } +.bi-terminal-split::before { content: "\f6c5"; } +.bi-ticket-detailed-fill::before { content: "\f6c6"; } +.bi-ticket-detailed::before { content: "\f6c7"; } +.bi-ticket-fill::before { content: "\f6c8"; } +.bi-ticket-perforated-fill::before { content: "\f6c9"; } +.bi-ticket-perforated::before { content: "\f6ca"; } +.bi-ticket::before { content: "\f6cb"; } +.bi-tiktok::before { content: "\f6cc"; } +.bi-window-dash::before { content: "\f6cd"; } +.bi-window-desktop::before { content: "\f6ce"; } +.bi-window-fullscreen::before { content: "\f6cf"; } +.bi-window-plus::before { content: "\f6d0"; } +.bi-window-split::before { content: "\f6d1"; } +.bi-window-stack::before { content: "\f6d2"; } +.bi-window-x::before { content: "\f6d3"; } +.bi-xbox::before { content: "\f6d4"; } +.bi-ethernet::before { content: "\f6d5"; } +.bi-hdmi-fill::before { content: "\f6d6"; } +.bi-hdmi::before { content: "\f6d7"; } +.bi-usb-c-fill::before { content: "\f6d8"; } +.bi-usb-c::before { content: "\f6d9"; } +.bi-usb-fill::before { content: "\f6da"; } +.bi-usb-plug-fill::before { content: "\f6db"; } +.bi-usb-plug::before { content: "\f6dc"; } +.bi-usb-symbol::before { content: "\f6dd"; } +.bi-usb::before { content: "\f6de"; } +.bi-boombox-fill::before { content: "\f6df"; } +.bi-displayport-1::before { content: "\f6e0"; } +.bi-displayport::before { content: "\f6e1"; } +.bi-gpu-card::before { content: "\f6e2"; } +.bi-memory::before { content: "\f6e3"; } +.bi-modem-fill::before { content: "\f6e4"; } +.bi-modem::before { content: "\f6e5"; } +.bi-motherboard-fill::before { content: "\f6e6"; } +.bi-motherboard::before { content: "\f6e7"; } +.bi-optical-audio-fill::before { content: "\f6e8"; } +.bi-optical-audio::before { content: "\f6e9"; } +.bi-pci-card::before { content: "\f6ea"; } +.bi-router-fill::before { content: "\f6eb"; } +.bi-router::before { content: "\f6ec"; } +.bi-ssd-fill::before { content: "\f6ed"; } +.bi-ssd::before { content: "\f6ee"; } +.bi-thunderbolt-fill::before { content: "\f6ef"; } +.bi-thunderbolt::before { content: "\f6f0"; } +.bi-usb-drive-fill::before { content: "\f6f1"; } +.bi-usb-drive::before { content: "\f6f2"; } +.bi-usb-micro-fill::before { content: "\f6f3"; } +.bi-usb-micro::before { content: "\f6f4"; } +.bi-usb-mini-fill::before { content: "\f6f5"; } +.bi-usb-mini::before { content: "\f6f6"; } +.bi-cloud-haze2::before { content: "\f6f7"; } +.bi-device-hdd-fill::before { content: "\f6f8"; } +.bi-device-hdd::before { content: "\f6f9"; } +.bi-device-ssd-fill::before { content: "\f6fa"; } +.bi-device-ssd::before { content: "\f6fb"; } +.bi-displayport-fill::before { content: "\f6fc"; } +.bi-mortarboard-fill::before { content: "\f6fd"; } +.bi-mortarboard::before { content: "\f6fe"; } +.bi-terminal-x::before { content: "\f6ff"; } +.bi-arrow-through-heart-fill::before { content: "\f700"; } +.bi-arrow-through-heart::before { content: "\f701"; } +.bi-badge-sd-fill::before { content: "\f702"; } +.bi-badge-sd::before { content: "\f703"; } +.bi-bag-heart-fill::before { content: "\f704"; } +.bi-bag-heart::before { content: "\f705"; } +.bi-balloon-fill::before { content: "\f706"; } +.bi-balloon-heart-fill::before { content: "\f707"; } +.bi-balloon-heart::before { content: "\f708"; } +.bi-balloon::before { content: "\f709"; } +.bi-box2-fill::before { content: "\f70a"; } +.bi-box2-heart-fill::before { content: "\f70b"; } +.bi-box2-heart::before { content: "\f70c"; } +.bi-box2::before { content: "\f70d"; } +.bi-braces-asterisk::before { content: "\f70e"; } +.bi-calendar-heart-fill::before { content: "\f70f"; } +.bi-calendar-heart::before { content: "\f710"; } +.bi-calendar2-heart-fill::before { content: "\f711"; } +.bi-calendar2-heart::before { content: "\f712"; } +.bi-chat-heart-fill::before { content: "\f713"; } +.bi-chat-heart::before { content: "\f714"; } +.bi-chat-left-heart-fill::before { content: "\f715"; } +.bi-chat-left-heart::before { content: "\f716"; } +.bi-chat-right-heart-fill::before { content: "\f717"; } +.bi-chat-right-heart::before { content: "\f718"; } +.bi-chat-square-heart-fill::before { content: "\f719"; } +.bi-chat-square-heart::before { content: "\f71a"; } +.bi-clipboard-check-fill::before { content: "\f71b"; } +.bi-clipboard-data-fill::before { content: "\f71c"; } +.bi-clipboard-fill::before { content: "\f71d"; } +.bi-clipboard-heart-fill::before { content: "\f71e"; } +.bi-clipboard-heart::before { content: "\f71f"; } +.bi-clipboard-minus-fill::before { content: "\f720"; } +.bi-clipboard-plus-fill::before { content: "\f721"; } +.bi-clipboard-pulse::before { content: "\f722"; } +.bi-clipboard-x-fill::before { content: "\f723"; } +.bi-clipboard2-check-fill::before { content: "\f724"; } +.bi-clipboard2-check::before { content: "\f725"; } +.bi-clipboard2-data-fill::before { content: "\f726"; } +.bi-clipboard2-data::before { content: "\f727"; } +.bi-clipboard2-fill::before { content: "\f728"; } +.bi-clipboard2-heart-fill::before { content: "\f729"; } +.bi-clipboard2-heart::before { content: "\f72a"; } +.bi-clipboard2-minus-fill::before { content: "\f72b"; } +.bi-clipboard2-minus::before { content: "\f72c"; } +.bi-clipboard2-plus-fill::before { content: "\f72d"; } +.bi-clipboard2-plus::before { content: "\f72e"; } +.bi-clipboard2-pulse-fill::before { content: "\f72f"; } +.bi-clipboard2-pulse::before { content: "\f730"; } +.bi-clipboard2-x-fill::before { content: "\f731"; } +.bi-clipboard2-x::before { content: "\f732"; } +.bi-clipboard2::before { content: "\f733"; } +.bi-emoji-kiss-fill::before { content: "\f734"; } +.bi-emoji-kiss::before { content: "\f735"; } +.bi-envelope-heart-fill::before { content: "\f736"; } +.bi-envelope-heart::before { content: "\f737"; } +.bi-envelope-open-heart-fill::before { content: "\f738"; } +.bi-envelope-open-heart::before { content: "\f739"; } +.bi-envelope-paper-fill::before { content: "\f73a"; } +.bi-envelope-paper-heart-fill::before { content: "\f73b"; } +.bi-envelope-paper-heart::before { content: "\f73c"; } +.bi-envelope-paper::before { content: "\f73d"; } +.bi-filetype-aac::before { content: "\f73e"; } +.bi-filetype-ai::before { content: "\f73f"; } +.bi-filetype-bmp::before { content: "\f740"; } +.bi-filetype-cs::before { content: "\f741"; } +.bi-filetype-css::before { content: "\f742"; } +.bi-filetype-csv::before { content: "\f743"; } +.bi-filetype-doc::before { content: "\f744"; } +.bi-filetype-docx::before { content: "\f745"; } +.bi-filetype-exe::before { content: "\f746"; } +.bi-filetype-gif::before { content: "\f747"; } +.bi-filetype-heic::before { content: "\f748"; } +.bi-filetype-html::before { content: "\f749"; } +.bi-filetype-java::before { content: "\f74a"; } +.bi-filetype-jpg::before { content: "\f74b"; } +.bi-filetype-js::before { content: "\f74c"; } +.bi-filetype-jsx::before { content: "\f74d"; } +.bi-filetype-key::before { content: "\f74e"; } +.bi-filetype-m4p::before { content: "\f74f"; } +.bi-filetype-md::before { content: "\f750"; } +.bi-filetype-mdx::before { content: "\f751"; } +.bi-filetype-mov::before { content: "\f752"; } +.bi-filetype-mp3::before { content: "\f753"; } +.bi-filetype-mp4::before { content: "\f754"; } +.bi-filetype-otf::before { content: "\f755"; } +.bi-filetype-pdf::before { content: "\f756"; } +.bi-filetype-php::before { content: "\f757"; } +.bi-filetype-png::before { content: "\f758"; } +.bi-filetype-ppt-1::before { content: "\f759"; } +.bi-filetype-ppt::before { content: "\f75a"; } +.bi-filetype-psd::before { content: "\f75b"; } +.bi-filetype-py::before { content: "\f75c"; } +.bi-filetype-raw::before { content: "\f75d"; } +.bi-filetype-rb::before { content: "\f75e"; } +.bi-filetype-sass::before { content: "\f75f"; } +.bi-filetype-scss::before { content: "\f760"; } +.bi-filetype-sh::before { content: "\f761"; } +.bi-filetype-svg::before { content: "\f762"; } +.bi-filetype-tiff::before { content: "\f763"; } +.bi-filetype-tsx::before { content: "\f764"; } +.bi-filetype-ttf::before { content: "\f765"; } +.bi-filetype-txt::before { content: "\f766"; } +.bi-filetype-wav::before { content: "\f767"; } +.bi-filetype-woff::before { content: "\f768"; } +.bi-filetype-xls-1::before { content: "\f769"; } +.bi-filetype-xls::before { content: "\f76a"; } +.bi-filetype-xml::before { content: "\f76b"; } +.bi-filetype-yml::before { content: "\f76c"; } +.bi-heart-arrow::before { content: "\f76d"; } +.bi-heart-pulse-fill::before { content: "\f76e"; } +.bi-heart-pulse::before { content: "\f76f"; } +.bi-heartbreak-fill::before { content: "\f770"; } +.bi-heartbreak::before { content: "\f771"; } +.bi-hearts::before { content: "\f772"; } +.bi-hospital-fill::before { content: "\f773"; } +.bi-hospital::before { content: "\f774"; } +.bi-house-heart-fill::before { content: "\f775"; } +.bi-house-heart::before { content: "\f776"; } +.bi-incognito::before { content: "\f777"; } +.bi-magnet-fill::before { content: "\f778"; } +.bi-magnet::before { content: "\f779"; } +.bi-person-heart::before { content: "\f77a"; } +.bi-person-hearts::before { content: "\f77b"; } +.bi-phone-flip::before { content: "\f77c"; } +.bi-plugin::before { content: "\f77d"; } +.bi-postage-fill::before { content: "\f77e"; } +.bi-postage-heart-fill::before { content: "\f77f"; } +.bi-postage-heart::before { content: "\f780"; } +.bi-postage::before { content: "\f781"; } +.bi-postcard-fill::before { content: "\f782"; } +.bi-postcard-heart-fill::before { content: "\f783"; } +.bi-postcard-heart::before { content: "\f784"; } +.bi-postcard::before { content: "\f785"; } +.bi-search-heart-fill::before { content: "\f786"; } +.bi-search-heart::before { content: "\f787"; } +.bi-sliders2-vertical::before { content: "\f788"; } +.bi-sliders2::before { content: "\f789"; } +.bi-trash3-fill::before { content: "\f78a"; } +.bi-trash3::before { content: "\f78b"; } +.bi-valentine::before { content: "\f78c"; } +.bi-valentine2::before { content: "\f78d"; } +.bi-wrench-adjustable-circle-fill::before { content: "\f78e"; } +.bi-wrench-adjustable-circle::before { content: "\f78f"; } +.bi-wrench-adjustable::before { content: "\f790"; } +.bi-filetype-json::before { content: "\f791"; } +.bi-filetype-pptx::before { content: "\f792"; } +.bi-filetype-xlsx::before { content: "\f793"; } diff --git a/pagetop-minimal/static/icons/bootstrap-icons.woff b/pagetop-minimal/static/icons/bootstrap-icons.woff new file mode 100644 index 0000000000000000000000000000000000000000..4cd66b71ad5f51be58843c52c66f78a8f7b89e47 GIT binary patch literal 137216 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Œ)MU&S(i~sr;ux&6XbkY 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

f4zyRkE1aA>Xa|PEa3QVZOr!r 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 G0001yd~9+6 literal 0 HcmV?d00001

Ua;3k(y1@iWd^?TBH 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