@bildvitta/quasar-ui-asteroid 2.12.2 → 2.14.0

package/dist/asteroid.umd.js

@@ -0,0 +1,3793 @@
+/*!
+* @bildvitta/quasar-ui-asteroid v3.0.0-alpha.2
+* (c) 2022 Bild & Vitta <systemteam@bild.com.br>
+* Released under the MIT License.
+*/
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('vue'), require('quasar'), require('autonumeric'), require('fuse.js'), require('lodash-es'), require('signature_pad'), require('sortablejs')) :
+  typeof define === 'function' && define.amd ? define(['vue', 'quasar', 'autonumeric', 'fuse.js', 'lodash-es', 'signature_pad', 'sortablejs'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global["{{ umdExportName }}"] = factory(global.Vue, global.Quasar, global.AutoNumeric, global.Fuse, global._, global.SignaturePad, global.Sortable));
+})(this, (function (vue, quasar, AutoNumeric, Fuse, lodashEs, SignaturePad, Sortable) { 'use strict';
+
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  var AutoNumeric__default = /*#__PURE__*/_interopDefaultLegacy(AutoNumeric);
+  var Fuse__default = /*#__PURE__*/_interopDefaultLegacy(Fuse);
+  var SignaturePad__default = /*#__PURE__*/_interopDefaultLegacy(SignaturePad);
+  var Sortable__default = /*#__PURE__*/_interopDefaultLegacy(Sortable);
+
+  const levels = {
+    good: {
+      color: 'warning',
+      label: 'Good',
+      progress: 0.5,
+      textClass: 'text-warning'
+    },
+
+    strong: {
+      color: 'positive',
+      label: 'Strong',
+      progress: 0.75,
+      textClass: 'text-positive'
+    },
+
+    veryStrong: {
+      color: 'positive',
+      label: 'Very strong',
+      progress: 1,
+      textClass: 'text-positive'
+    },
+
+    veryWeak: {
+      color: 'negative',
+      label: 'Very weak',
+      progress: 0,
+      textClass: 'text-negative'
+    },
+
+    weak: {
+      color: 'warning',
+      label: 'Weak',
+      progress: 0.25,
+      textClass: 'text-warning'
+    }
+  };
+
+  var passwordMixin = {
+    props: {
+      levels: {
+        default: () => levels,
+        type: Object
+      },
+
+      // https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/minlength
+      minlength: {
+        default: 8,
+        type: [Number, String]
+      },
+
+      specials: {
+        default: /[!@#$%^&*()_+\-=[\]{}|;:'",<.>/?`~]/g,
+        type: RegExp
+      },
+
+      trackColor: {
+        default: 'blue-grey-1',
+        type: String
+      },
+
+      useLowercase: {
+        default: true,
+        type: Boolean
+      },
+
+      useNumbers: {
+        default: true,
+        type: Boolean
+      },
+
+      useSpecial: {
+        default: true,
+        type: Boolean
+      },
+
+      useUppercase: {
+        default: true,
+        type: Boolean
+      }
+    }
+  };
+
+  var screenMixin = {
+    // TODO: Esses nomes precisam ser alterados para algo mais inteligente.
+
+    computed: {
+      $_isSmall () {
+        // until 599
+        return this.$q.screen.xs
+      },
+
+      $_isMedium () {
+        // from 600 until 1023
+        return this.$q.screen.sm
+      },
+
+      $_isLarge () {
+        // from 1024 until the limit
+        return this.$q.screen.gt.sm
+      },
+
+      $_untilMedium () {
+        // from 0 until 599
+        return this.$q.screen.lt.sm
+      },
+
+      $_untilLarge () {
+        // from 0 until 1023
+        return this.$q.screen.lt.md
+      },
+
+      $_isMobile () {
+        return this.$q.platform.is.mobile
+      }
+    }
+  };
+
+  var script$q = {
+    name: 'QasActions',
+
+    mixins: [screenMixin],
+
+    props: {
+      align: {
+        default: 'end',
+        type: String,
+        validator: value => ['start', 'around', 'between', 'center', 'end'].includes(value)
+      },
+
+      gutter: {
+        default: 'md',
+        type: String,
+        validator: value => ['xs', 'sm', 'md', 'lg', 'xl'].includes(value)
+      }
+    },
+
+    computed: {
+      classes () {
+        return [
+          `justify-${this.align}`,
+          `q-col-gutter-${this.gutter}`,
+          this.$_isSmall ? 'column reverse' : 'row'
+        ]
+      }
+    }
+  };
+
+  const _hoisted_1$f = { class: "col-12 col-sm-auto" };
+  const _hoisted_2$9 = { class: "col-12 col-sm-auto" };
+
+  function render$q(_ctx, _cache, $props, $setup, $data, $options) {
+    return (vue.openBlock(), vue.createElementBlock("div", {
+      class: vue.normalizeClass($options.classes)
+    }, [
+      vue.createElementVNode("div", _hoisted_1$f, [
+        vue.renderSlot(_ctx.$slots, "secondary")
+      ]),
+      vue.createElementVNode("div", _hoisted_2$9, [
+        vue.renderSlot(_ctx.$slots, "primary")
+      ])
+    ], 2 /* CLASS */))
+  }
+
+  script$q.render = render$q;
+  script$q.__file = "src/components/actions/QasActions.vue";
+
+  var script$p = {
+    name: 'QasBtn',
+
+    mixins: [screenMixin],
+
+    inheritAttrs: false,
+
+    props: {
+      hideLabelOnSmallScreen: {
+        type: Boolean
+      }
+    },
+
+    computed: {
+      attributes () {
+        const { label, ...attributes } = this.$attrs;
+        return attributes
+      },
+
+      hasLabel () {
+        return !!(this.$attrs.label || this.$slots.default)
+      },
+
+      showLabel () {
+        return this.hasLabel && !(this.hideLabelOnSmallScreen && this.$_isSmall)
+      },
+
+      slots () {
+        const { default: _, ...slots } = this.$slots;
+        return slots
+      }
+    }
+  };
+
+  function render$p(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_btn = vue.resolveComponent("q-btn");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_btn, vue.mergeProps({
+      color: "primary",
+      "no-caps": "",
+      unelevated: ""
+    }, $options.attributes), vue.createSlots({
+      default: vue.withCtx(() => [
+        ($options.showLabel)
+          ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }, () => [
+              vue.createTextVNode(vue.toDisplayString(_ctx.$attrs.label), 1 /* TEXT */)
+            ])
+          : vue.createCommentVNode("v-if", true)
+      ]),
+      _: 2 /* DYNAMIC */
+    }, [
+      vue.renderList($options.slots, (_, name) => {
+        return {
+          name: name,
+          fn: vue.withCtx((context) => [
+            vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(context || {})))
+          ])
+        }
+      })
+    ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */))
+  }
+
+  script$p.render = render$p;
+  script$p.__file = "src/components/btn/QasBtn.vue";
+
+  var script$o = {
+    name: 'QasActionsMenu',
+
+    components: {
+      QasBtn: script$p
+    },
+
+    props: {
+      icon: {
+        default: 'o_settings',
+        type: String
+      },
+
+      label: {
+        default: 'Configurações',
+        type: String
+      },
+
+      list: {
+        default: () => ({}),
+        type: Object
+      }
+    },
+
+    methods: {
+      onClick (item) {
+        if (typeof item.handler === 'function') {
+          const { handler, ...filtered } = item;
+          item.handler(filtered);
+        }
+      }
+    }
+  };
+
+  const _hoisted_1$e = { class: "flex items-center justify-center q-gutter-x-md" };
+
+  function render$o(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_icon = vue.resolveComponent("q-icon");
+    const _component_q_item_section = vue.resolveComponent("q-item-section");
+    const _component_q_item = vue.resolveComponent("q-item");
+    const _component_q_list = vue.resolveComponent("q-list");
+    const _component_q_menu = vue.resolveComponent("q-menu");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+
+    return (vue.openBlock(), vue.createBlock(_component_qas_btn, {
+      class: "qas-actions-menu",
+      color: "primary",
+      "hide-label-on-small-screen": "",
+      icon: $props.icon,
+      label: $props.label,
+      outline: ""
+    }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_q_menu, { class: "qas-actions-menu__menu" }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_q_list, {
+              class: "qas-actions-menu__list",
+              separator: ""
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($props.list, (item, key) => {
+                  return vue.renderSlot(_ctx.$slots, key, { item: item }, () => [
+                    (vue.openBlock(), vue.createBlock(_component_q_item, vue.mergeProps({
+                      key: key,
+                      class: "text-bold text-primary",
+                      clickable: ""
+                    }, item.props, {
+                      onClick: $event => ($options.onClick(item))
+                    }), {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(_component_q_item_section, null, {
+                          default: vue.withCtx(() => [
+                            vue.createElementVNode("div", _hoisted_1$e, [
+                              vue.createVNode(_component_q_icon, {
+                                name: item.icon,
+                                size: item.iconSize
+                              }, null, 8 /* PROPS */, ["name", "size"]),
+                              vue.createElementVNode("div", null, vue.toDisplayString(item.label), 1 /* TEXT */)
+                            ])
+                          ]),
+                          _: 2 /* DYNAMIC */
+                        }, 1024 /* DYNAMIC_SLOTS */)
+                      ]),
+                      _: 2 /* DYNAMIC */
+                    }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["onClick"]))
+                  ])
+                }), 256 /* UNKEYED_FRAGMENT */))
+              ]),
+              _: 3 /* FORWARDED */
+            })
+          ]),
+          _: 3 /* FORWARDED */
+        })
+      ]),
+      _: 3 /* FORWARDED */
+    }, 8 /* PROPS */, ["icon", "label"]))
+  }
+
+  script$o.render = render$o;
+  script$o.__file = "src/components/actions-menu/QasActionsMenu.vue";
+
+  function addCounterSuffix (label, counter) {
+    return counter ? `${label} (${counter})` : label
+  }
+
+  // https://stackoverflow.com/a/64167032/977687
+
+  function getSlotChildrenText (children) {
+    return children.map(node => {
+      if (!node.children || typeof node.children === 'string') {
+        return node.children || ''
+      } else if (Array.isArray(node.children)) {
+        return getSlotChildrenText(node.children)
+      } else if (node.children.default) {
+        return getSlotChildrenText(node.children.default())
+      }
+
+      return undefined
+    }).join('')
+  }
+
+  var script$n = {
+    name: 'QasBreakline',
+
+    props: {
+      split: {
+        default: '\n',
+        type: String
+      },
+
+      tag: {
+        default: 'div',
+        type: String
+      },
+
+      text: {
+        default: '',
+        type: String
+      }
+    },
+
+    computed: {
+      lines () {
+        const text = this.text || getSlotChildrenText(this.$slots.default());
+        return text.split(this.split)
+      }
+    }
+  };
+
+  function render$n(_ctx, _cache, $props, $setup, $data, $options) {
+    return (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($options.lines, (line, index) => {
+      return (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.tag), vue.mergeProps({ key: index }, _ctx.$attrs), {
+        default: vue.withCtx(() => [
+          vue.createTextVNode(vue.toDisplayString(line), 1 /* TEXT */)
+        ]),
+        _: 2 /* DYNAMIC */
+      }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */))
+    }), 128 /* KEYED_FRAGMENT */))
+  }
+
+  script$n.render = render$n;
+  script$n.__file = "src/components/breakline/QasBreakline.vue";
+
+  var script$m = {
+    name: 'QasAlert',
+
+    components: {
+      QasBreakline: script$n,
+      QasBtn: script$p
+    },
+
+    props: {
+      color: {
+        default: 'primary',
+        type: String
+      },
+
+      modelValue: {
+        default: true,
+        type: Boolean
+      },
+
+      text: {
+        default: '',
+        type: String
+      },
+
+      title: {
+        default: '',
+        type: String
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    data () {
+      return {
+        model: true
+      }
+    },
+
+    computed: {
+      classes () {
+        return {
+          [`text-${this.color}`]: true,
+          [`bg-${this.color}-contrast`]: ['primary', 'secondary'].includes(this.color)
+        }
+      }
+    },
+
+    watch: {
+      modelValue: {
+        handler (value) {
+          this.model = value;
+        },
+        immediate: true
+      }
+    },
+
+    methods: {
+      close () {
+        this.$emit('update:modelValue', false);
+      }
+    }
+  };
+
+  const _hoisted_1$d = { class: "q-gutter-md q-mr-lg" };
+  const _hoisted_2$8 = {
+    key: 0,
+    class: "text-bold text-h5"
+  };
+
+  function render$m(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+    const _component_qas_breakline = vue.resolveComponent("qas-breakline");
+
+    return ($data.model)
+      ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: vue.normalizeClass(["q-pa-lg qas-alert relative-position rounded-borders", $options.classes])
+        }, [
+          vue.createVNode(_component_qas_btn, {
+            class: "absolute-top-right q-mr-md q-mt-sm",
+            color: $props.color,
+            dense: "",
+            flat: "",
+            icon: "o_close",
+            rounded: "",
+            onClick: $options.close
+          }, null, 8 /* PROPS */, ["color", "onClick"]),
+          vue.createElementVNode("div", _hoisted_1$d, [
+            vue.renderSlot(_ctx.$slots, "header", {}, () => [
+              ($props.title)
+                ? (vue.openBlock(), vue.createElementBlock("h5", _hoisted_2$8, vue.toDisplayString($props.title), 1 /* TEXT */))
+                : vue.createCommentVNode("v-if", true)
+            ]),
+            vue.renderSlot(_ctx.$slots, "default", {}, () => [
+              vue.createVNode(_component_qas_breakline, {
+                tag: "p",
+                text: $props.text
+              }, null, 8 /* PROPS */, ["text"])
+            ])
+          ])
+        ], 2 /* CLASS */))
+      : vue.createCommentVNode("v-if", true)
+  }
+
+  script$m.render = render$m;
+  script$m.__file = "src/components/alert/QasAlert.vue";
+
+  var script$l = {
+    props: {
+      apps: {
+        default: () => [],
+        type: Array
+      },
+
+      brand: {
+        default: '',
+        type: String
+      },
+
+      isAuth: {
+        type: Boolean
+      },
+
+      notifications: {
+        default: () => ({}),
+        type: Object
+      },
+
+      title: {
+        default: '',
+        required: true,
+        type: String
+      },
+
+      user: {
+        default: () => ({}),
+        require: true,
+        type: Object
+      }
+    },
+
+    emits: ['sign-out', 'toggle-menu'],
+
+    data () {
+      return {
+        menuDrawer: true
+      }
+    },
+
+    computed: {
+      developmentBadgeLabel () {
+        const hosts = {
+          develop: 'Develop',
+          feature: 'Feature',
+          localhost: 'Local',
+          release: 'Release'
+        };
+
+        if (process.env.DEV) {
+          return hosts.localhost
+        }
+
+        const current = Object.keys(hosts).find(
+          host => location.hostname.includes(host)
+        );
+
+        return current ? hosts[current] : ''
+      },
+
+      hasApps () {
+        return !!this.apps.length
+      },
+
+      hasDevelopmentBadge () {
+        return !!this.developmentBadgeLabel
+      },
+
+      hasNotifications () {
+        return !!Object.keys(this.notifications).length
+      }
+    },
+
+    methods: {
+      goToProfile () {
+        return this.$router.push(this.user.to)
+      },
+
+      signOut () {
+        this.$emit('sign-out');
+      },
+
+      toggleMenuDrawer () {
+        this.$emit('toggle-menu');
+      }
+    }
+  };
+
+  const _hoisted_1$c = ["alt", "src"];
+  const _hoisted_2$7 = {
+    key: 1,
+    class: "text-bold text-primary-contrast text-subtitle1 text-uppercase"
+  };
+  const _hoisted_3$3 = { class: "items-center no-wrap q-gutter-md row" };
+  const _hoisted_4$2 = { key: 0 };
+  const _hoisted_5$1 = ["title"];
+  const _hoisted_6 = { class: "q-px-sm qas-toolbar__user-data qs-lh-lg text-caption" };
+  const _hoisted_7 = { class: "ellipsis" };
+  const _hoisted_8 = { class: "ellipsis text-bold" };
+  const _hoisted_9 = { class: "qas-toolbar__user-menu" };
+  const _hoisted_10 = { class: "q-pa-lg text-center" };
+  const _hoisted_11 = { class: "ellipsis q-mt-lg qs-lh-sm text-bold text-subtitle1" };
+  const _hoisted_12 = { class: "ellipsis q-mt-xs text-caption" };
+  const _hoisted_13 = { class: "q-mt-sm" };
+  const _hoisted_14 = { class: "q-mt-sm" };
+
+  function render$l(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_ajax_bar = vue.resolveComponent("q-ajax-bar");
+    const _component_q_btn = vue.resolveComponent("q-btn");
+    const _component_q_badge = vue.resolveComponent("q-badge");
+    const _component_router_link = vue.resolveComponent("router-link");
+    const _component_q_toolbar_title = vue.resolveComponent("q-toolbar-title");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+    const _component_qas_apps_menu = vue.resolveComponent("qas-apps-menu");
+    const _component_qas_avatar = vue.resolveComponent("qas-avatar");
+    const _component_q_menu = vue.resolveComponent("q-menu");
+    const _component_q_toolbar = vue.resolveComponent("q-toolbar");
+    const _directive_close_popup = vue.resolveDirective("close-popup");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_toolbar, { class: "qas-toolbar" }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_q_ajax_bar, {
+          color: "white",
+          position: "top",
+          size: "2px"
+        }),
+        vue.createVNode(_component_q_btn, {
+          dense: "",
+          flat: "",
+          icon: "o_menu",
+          round: "",
+          onClick: $options.toggleMenuDrawer
+        }, null, 8 /* PROPS */, ["onClick"]),
+        vue.createVNode(_component_q_toolbar_title, { class: "flex" }, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_router_link, {
+              class: "cursor-pointer text-no-decoration",
+              to: "/"
+            }, {
+              default: vue.withCtx(() => [
+                ($props.brand)
+                  ? (vue.openBlock(), vue.createElementBlock("img", {
+                      key: 0,
+                      alt: $props.title,
+                      class: "q-mr-sm qas-toolbar__brand",
+                      src: $props.brand
+                    }, null, 8 /* PROPS */, _hoisted_1$c))
+                  : vue.createCommentVNode("v-if", true),
+                ($props.title)
+                  ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$7, vue.toDisplayString($props.title), 1 /* TEXT */))
+                  : vue.createCommentVNode("v-if", true),
+                ($options.hasDevelopmentBadge)
+                  ? (vue.openBlock(), vue.createBlock(_component_q_badge, {
+                      key: 2,
+                      align: "middle",
+                      class: "q-ml-sm",
+                      color: "negative",
+                      label: $options.developmentBadgeLabel
+                    }, null, 8 /* PROPS */, ["label"]))
+                  : vue.createCommentVNode("v-if", true)
+              ]),
+              _: 1 /* STABLE */
+            })
+          ]),
+          _: 1 /* STABLE */
+        }),
+        vue.createElementVNode("div", _hoisted_3$3, [
+          vue.createCommentVNode(" TODO: Notificações. "),
+          ($options.hasNotifications)
+            ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4$2, [
+                vue.createVNode(_component_qas_btn, {
+                  class: "q-mr-md",
+                  dense: "",
+                  icon: "o_notifications",
+                  round: ""
+                }, {
+                  default: vue.withCtx(() => [
+                    ($props.notifications)
+                      ? (vue.openBlock(), vue.createBlock(_component_q_badge, {
+                          key: 0,
+                          color: "red",
+                          floating: ""
+                        }, {
+                          default: vue.withCtx(() => [
+                            vue.createTextVNode(vue.toDisplayString($props.notifications.count), 1 /* TEXT */)
+                          ]),
+                          _: 1 /* STABLE */
+                        }))
+                      : vue.createCommentVNode("v-if", true)
+                  ]),
+                  _: 1 /* STABLE */
+                })
+              ]))
+            : vue.createCommentVNode("v-if", true),
+          ($options.hasApps)
+            ? (vue.openBlock(), vue.createBlock(_component_qas_apps_menu, {
+                key: 1,
+                apps: $props.apps
+              }, null, 8 /* PROPS */, ["apps"]))
+            : vue.createCommentVNode("v-if", true),
+          vue.renderSlot(_ctx.$slots, "tools"),
+          ($props.isAuth)
+            ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 2,
+                class: "cursor-pointer items-center q-mr-sm qas-toolbar__user rounded-borders row",
+                title: $props.user.name || $props.user.givenName
+              }, [
+                vue.createVNode(_component_qas_avatar, {
+                  class: "rounded-borders-left",
+                  color: "white",
+                  dark: "",
+                  image: $props.user.photo,
+                  rounded: "",
+                  size: "42px",
+                  "text-color": "primary",
+                  title: $props.user.name || $props.user.givenName
+                }, null, 8 /* PROPS */, ["image", "title"]),
+                vue.createElementVNode("div", _hoisted_6, [
+                  vue.createElementVNode("div", _hoisted_7, vue.toDisplayString($props.user.name || $props.user.givenName), 1 /* TEXT */),
+                  vue.createElementVNode("div", _hoisted_8, vue.toDisplayString($props.user.email), 1 /* TEXT */)
+                ]),
+                vue.createVNode(_component_q_menu, {
+                  anchor: "bottom end",
+                  "max-height": "400px",
+                  offset: [0, 5],
+                  self: "top end"
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createElementVNode("div", _hoisted_9, [
+                      vue.createElementVNode("div", _hoisted_10, [
+                        vue.createElementVNode("button", {
+                          class: "unset",
+                          onClick: _cache[0] || (_cache[0] = (...args) => ($options.goToProfile && $options.goToProfile(...args)))
+                        }, [
+                          vue.createVNode(_component_qas_avatar, {
+                            image: $props.user.photo,
+                            size: "145px",
+                            title: $props.user.name || $props.user.givenName
+                          }, null, 8 /* PROPS */, ["image", "title"])
+                        ]),
+                        vue.createElementVNode("div", _hoisted_11, vue.toDisplayString($props.user.name || $props.user.givenName), 1 /* TEXT */),
+                        vue.createElementVNode("div", _hoisted_12, vue.toDisplayString($props.user.email), 1 /* TEXT */),
+                        vue.createElementVNode("div", _hoisted_13, [
+                          vue.createVNode(_component_qas_btn, {
+                            flat: "",
+                            icon: "o_edit",
+                            label: "Editar",
+                            to: $props.user.to
+                          }, null, 8 /* PROPS */, ["to"])
+                        ]),
+                        vue.createElementVNode("div", _hoisted_14, [
+                          vue.withDirectives(vue.createVNode(_component_qas_btn, {
+                            class: "q-px-lg q-py-xs",
+                            dense: "",
+                            icon: "o_exit_to_app",
+                            label: "Sair",
+                            outline: "",
+                            onClick: $options.signOut
+                          }, null, 8 /* PROPS */, ["onClick"]), [
+                            [_directive_close_popup]
+                          ])
+                        ]),
+                        vue.renderSlot(_ctx.$slots, "user", { user: $props.user })
+                      ])
+                    ])
+                  ]),
+                  _: 3 /* FORWARDED */
+                })
+              ], 8 /* PROPS */, _hoisted_5$1))
+            : vue.createCommentVNode("v-if", true)
+        ])
+      ]),
+      _: 3 /* FORWARDED */
+    }))
+  }
+
+  script$l.render = render$l;
+  script$l.__file = "src/components/app-bar/QasAppBar.vue";
+
+  var script$k = {
+    mixins: [screenMixin],
+
+    props: {
+      itemClass: {
+        default: '',
+        type: [Array, Object, String]
+      },
+
+      items: {
+        default: () => [],
+        type: Array
+      },
+
+      modelValue: {
+        default: true,
+        type: Boolean
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    data () {
+      return {
+        miniMode: false
+      }
+    },
+
+    computed: {
+      activeHeaderClass () {
+        return 'qas-app-menu__header--active'
+      },
+
+      activeItemClass () {
+        return 'bg-primary text-primary-contrast'
+      },
+
+      model: {
+        get () {
+          return this.modelValue
+        },
+
+        set (value) {
+          return this.$emit('update:modelValue', value)
+        }
+      }
+    },
+
+    methods: {
+      beforeHide () {
+        if (this.$_isLarge) {
+          this.model = true;
+          this.miniMode = !this.miniMode;
+        }
+      },
+
+      hasChildren ({ children }) {
+        return !!children?.length
+      },
+
+      shouldExpand ({ children, to }) {
+        return !!children?.length && this.$route.matched.some(item => item.path === to.path)
+      }
+    }
+  };
+
+  function render$k(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_icon = vue.resolveComponent("q-icon");
+    const _component_q_item_section = vue.resolveComponent("q-item-section");
+    const _component_q_item_label = vue.resolveComponent("q-item-label");
+    const _component_q_item = vue.resolveComponent("q-item");
+    const _component_q_expansion_item = vue.resolveComponent("q-expansion-item");
+    const _component_q_list = vue.resolveComponent("q-list");
+    const _component_q_drawer = vue.resolveComponent("q-drawer");
+    const _directive_ripple = vue.resolveDirective("ripple");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_drawer, {
+      modelValue: $options.model,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($options.model) = $event)),
+      class: "bg-primary-contrast qas-app-menu",
+      mini: $data.miniMode,
+      width: 230,
+      onBeforeHide: $options.beforeHide
+    }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_q_list, {
+          class: "text-primary",
+          padding: ""
+        }, {
+          default: vue.withCtx(() => [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($props.items, (header, index) => {
+              return (vue.openBlock(), vue.createElementBlock("div", { key: index }, [
+                ($options.hasChildren(header))
+                  ? (vue.openBlock(), vue.createBlock(_component_q_expansion_item, {
+                      key: 0,
+                      "active-class": $options.activeHeaderClass,
+                      "default-opened": $options.shouldExpand(header),
+                      "expand-icon": "o_keyboard_arrow_down",
+                      "expand-separator": "",
+                      icon: header.icon,
+                      label: header.label,
+                      to: header.to
+                    }, {
+                      default: vue.withCtx(() => [
+                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(header.children, (item, itemIndex) => {
+                          return vue.withDirectives((vue.openBlock(), vue.createBlock(_component_q_item, {
+                            key: itemIndex,
+                            "active-class": $options.activeItemClass,
+                            clickable: "",
+                            to: item.to
+                          }, {
+                            default: vue.withCtx(() => [
+                              (item.icon)
+                                ? (vue.openBlock(), vue.createBlock(_component_q_item_section, {
+                                    key: 0,
+                                    avatar: ""
+                                  }, {
+                                    default: vue.withCtx(() => [
+                                      vue.createVNode(_component_q_icon, {
+                                        name: item.icon
+                                      }, null, 8 /* PROPS */, ["name"])
+                                    ]),
+                                    _: 2 /* DYNAMIC */
+                                  }, 1024 /* DYNAMIC_SLOTS */))
+                                : vue.createCommentVNode("v-if", true),
+                              vue.createVNode(_component_q_item_section, null, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(_component_q_item_label, null, {
+                                    default: vue.withCtx(() => [
+                                      vue.createTextVNode(vue.toDisplayString(item.label), 1 /* TEXT */)
+                                    ]),
+                                    _: 2 /* DYNAMIC */
+                                  }, 1024 /* DYNAMIC_SLOTS */)
+                                ]),
+                                _: 2 /* DYNAMIC */
+                              }, 1024 /* DYNAMIC_SLOTS */)
+                            ]),
+                            _: 2 /* DYNAMIC */
+                          }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["active-class", "to"])), [
+                            [_directive_ripple]
+                          ])
+                        }), 128 /* KEYED_FRAGMENT */))
+                      ]),
+                      _: 2 /* DYNAMIC */
+                    }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["active-class", "default-opened", "icon", "label", "to"]))
+                  : vue.withDirectives((vue.openBlock(), vue.createBlock(_component_q_item, {
+                      key: index,
+                      "active-class": $options.activeItemClass,
+                      clickable: "",
+                      to: header.to
+                    }, {
+                      default: vue.withCtx(() => [
+                        (header.icon)
+                          ? (vue.openBlock(), vue.createBlock(_component_q_item_section, {
+                              key: 0,
+                              avatar: ""
+                            }, {
+                              default: vue.withCtx(() => [
+                                vue.createVNode(_component_q_icon, {
+                                  name: header.icon
+                                }, null, 8 /* PROPS */, ["name"])
+                              ]),
+                              _: 2 /* DYNAMIC */
+                            }, 1024 /* DYNAMIC_SLOTS */))
+                          : vue.createCommentVNode("v-if", true),
+                        vue.createVNode(_component_q_item_section, null, {
+                          default: vue.withCtx(() => [
+                            vue.createVNode(_component_q_item_label, null, {
+                              default: vue.withCtx(() => [
+                                vue.createTextVNode(vue.toDisplayString(header.label), 1 /* TEXT */)
+                              ]),
+                              _: 2 /* DYNAMIC */
+                            }, 1024 /* DYNAMIC_SLOTS */)
+                          ]),
+                          _: 2 /* DYNAMIC */
+                        }, 1024 /* DYNAMIC_SLOTS */)
+                      ]),
+                      _: 2 /* DYNAMIC */
+                    }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["active-class", "to"])), [
+                      [_directive_ripple]
+                    ])
+              ]))
+            }), 128 /* KEYED_FRAGMENT */))
+          ]),
+          _: 1 /* STABLE */
+        })
+      ]),
+      _: 1 /* STABLE */
+    }, 8 /* PROPS */, ["modelValue", "mini", "onBeforeHide"]))
+  }
+
+  script$k.render = render$k;
+  script$k.__file = "src/components/app-menu/QasAppMenu.vue";
+
+  var script$j = {
+    props: {
+      apps: {
+        default: () => [],
+        type: Array
+      }
+    }
+  };
+
+  const _hoisted_1$b = { class: "bg-white q-col-gutter-sm q-pa-sm row" };
+  const _hoisted_2$6 = { class: "q-mt-xs" };
+
+  function render$j(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_img = vue.resolveComponent("q-img");
+    const _component_q_btn = vue.resolveComponent("q-btn");
+    const _component_q_popup_proxy = vue.resolveComponent("q-popup-proxy");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+
+    return (vue.openBlock(), vue.createBlock(_component_qas_btn, {
+      dense: "",
+      icon: "o_apps",
+      round: ""
+    }, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_q_popup_proxy, {
+          anchor: "bottom middle",
+          "max-width": "400px",
+          self: "top middle"
+        }, {
+          default: vue.withCtx(() => [
+            vue.createElementVNode("div", _hoisted_1$b, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($props.apps, (app, index) => {
+                return (vue.openBlock(), vue.createElementBlock("div", {
+                  key: index,
+                  class: "col-6 col-sm-4"
+                }, [
+                  vue.createVNode(_component_q_btn, {
+                    class: "full-width q-pa-sm",
+                    flat: "",
+                    href: app.href,
+                    "no-caps": "",
+                    type: "a"
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(_component_q_img, {
+                        alt: app.label,
+                        class: "rounded-borders",
+                        src: app.image
+                      }, null, 8 /* PROPS */, ["alt", "src"]),
+                      vue.createElementVNode("div", _hoisted_2$6, vue.toDisplayString(app.label), 1 /* TEXT */)
+                    ]),
+                    _: 2 /* DYNAMIC */
+                  }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["href"])
+                ]))
+              }), 128 /* KEYED_FRAGMENT */))
+            ])
+          ]),
+          _: 1 /* STABLE */
+        })
+      ]),
+      _: 1 /* STABLE */
+    }))
+  }
+
+  script$j.render = render$j;
+  script$j.__file = "src/components/apps-menu/QasAppsMenu.vue";
+
+  var script$i = {
+    name: 'QasAvatar',
+
+    props: {
+      color: {
+        default: 'primary',
+        type: String
+      },
+
+      dark: {
+        type: Boolean
+      },
+
+      icon: {
+        default: 'o_error',
+        type: String
+      },
+
+      image: {
+        default: '',
+        type: String
+      },
+
+      textColor: {
+        default: '',
+        type: String
+      },
+
+      title: {
+        default: '',
+        type: String
+      }
+    },
+
+    data () {
+      return {
+        hasImageError: false
+      }
+    },
+
+    computed: {
+      avatarClass () {
+        if (this.hasImage) {
+          return null
+        }
+
+        const contrastColor = this.textColor ? this.textColor : this.contrastColor;
+
+        return [
+          this.dark
+            ? `bg-${this.color} text-${contrastColor}`
+            : `bg-${contrastColor} text-${this.color}`
+        ]
+      },
+
+      contrastColor () {
+        return `${this.color}-contrast`
+      },
+
+      firstLetter () {
+        return this.title[0].toUpperCase()
+      },
+
+      hasImage () {
+        return !this.hasImageError && !!this.image
+      },
+
+      hasTitle () {
+        return !!this.title
+      }
+    },
+
+    watch: {
+      image () {
+        this.hasImageError = false;
+      }
+    },
+
+    methods: {
+      onImageLoadedError () {
+        this.hasImageError = true;
+      }
+    }
+  };
+
+  function render$i(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_img = vue.resolveComponent("q-img");
+    const _component_q_icon = vue.resolveComponent("q-icon");
+    const _component_q_avatar = vue.resolveComponent("q-avatar");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_avatar, {
+      class: vue.normalizeClass(["text-bold", $options.avatarClass]),
+      rounded: ""
+    }, {
+      default: vue.withCtx(() => [
+        ($options.hasImage)
+          ? (vue.openBlock(), vue.createBlock(_component_q_img, {
+              key: 0,
+              alt: $props.title,
+              ratio: 1,
+              "spinner-color": "primary",
+              "spinner-size": "16px",
+              src: $props.image,
+              onError: $options.onImageLoadedError
+            }, null, 8 /* PROPS */, ["alt", "src", "onError"]))
+          : ($options.hasTitle)
+            ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                vue.createTextVNode(vue.toDisplayString($options.firstLetter), 1 /* TEXT */)
+              ], 2112 /* STABLE_FRAGMENT, DEV_ROOT_FRAGMENT */))
+            : (vue.openBlock(), vue.createBlock(_component_q_icon, {
+                key: 2,
+                name: $props.icon
+              }, null, 8 /* PROPS */, ["name"]))
+      ]),
+      _: 1 /* STABLE */
+    }, 8 /* PROPS */, ["class"]))
+  }
+
+  script$i.render = render$i;
+  script$i.__file = "src/components/avatar/QasAvatar.vue";
+
+  var script$h = {
+    name: 'QasBox',
+
+    props: {
+      outlined: {
+        type: Boolean
+      },
+
+      unelevated: {
+        type: Boolean
+      }
+    },
+
+    computed: {
+      boxClass () {
+        return {
+          'border-primary-contrast': this.outlined,
+          'shadow-primary': !this.unelevated
+        }
+      }
+    }
+  };
+
+  function render$h(_ctx, _cache, $props, $setup, $data, $options) {
+    return (vue.openBlock(), vue.createElementBlock("div", {
+      class: vue.normalizeClass(["bg-white q-px-md q-py-lg rounded-borders", $options.boxClass])
+    }, [
+      vue.renderSlot(_ctx.$slots, "default")
+    ], 2 /* CLASS */))
+  }
+
+  script$h.render = render$h;
+  script$h.__file = "src/components/box/QasBox.vue";
+
+  var script$g = {
+    name: 'QasActionsMenu',
+
+    props: {
+      bgImagePosition: {
+        type: String,
+        default: 'center'
+      },
+
+      formMode: {
+        type: Boolean
+      },
+
+      gutter: {
+        type: String,
+        default: 'sm'
+      },
+
+      images: {
+        default: () => ([]),
+        type: Array
+      },
+
+      outlined: {
+        type: Boolean
+      },
+
+      result: {
+        default: () => ({}),
+        type: Object
+      },
+
+      useHeader: {
+        type: Boolean
+      }
+    },
+
+    data () {
+      return {
+        slideImage: 0
+      }
+    },
+
+    computed: {
+      bgImagePositionClass () {
+        return `bg-position-${this.bgImagePosition}`
+      },
+
+      cardClasses () {
+        return this.formMode ? 'bg-white border-primary no-shadow' : 'box-shadow-1'
+      },
+
+      gutterClass () {
+        return `q-col-gutter-${this.gutter}`
+      },
+
+      hasActionsSlot () {
+        return !!this.$slots.actions
+      },
+
+      hasImages () {
+        return this.images.length > 1
+      },
+
+      imagesLength () {
+        return this.images?.length
+      },
+
+      imagesList () {
+        return this.imagesLength && this.images.slice(0, 3)
+      }
+    },
+
+    methods: {
+      getNavigationIcon (active, btn) {
+        return active ? 'o_radio_button_checked' : btn.icon
+      }
+    }
+  };
+
+  const _hoisted_1$a = { class: "col-12 col-lg-3 col-md-4 col-sm-6" };
+  const _hoisted_2$5 = {
+    key: 0,
+    class: "overflow-hidden relative-position w-full"
+  };
+  const _hoisted_3$2 = { class: "absolute-top flex items-center q-pa-md" };
+  const _hoisted_4$1 = {
+    key: 1,
+    class: "border-primary-contrast border-top overflow-hidden row"
+  };
+
+  function render$g(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+    const _component_q_carousel_slide = vue.resolveComponent("q-carousel-slide");
+    const _component_q_carousel = vue.resolveComponent("q-carousel");
+    const _component_q_card_section = vue.resolveComponent("q-card-section");
+    const _component_q_card = vue.resolveComponent("q-card");
+
+    return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$a, [
+      vue.createVNode(_component_q_card, {
+        class: vue.normalizeClass(["border-radius-lg column full-height", $options.cardClasses])
+      }, {
+        default: vue.withCtx(() => [
+          ($props.useHeader)
+            ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$5, [
+                vue.renderSlot(_ctx.$slots, "header", {}, () => [
+                  vue.createVNode(_component_q_carousel, {
+                    modelValue: $data.slideImage,
+                    "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($data.slideImage) = $event)),
+                    animated: "",
+                    class: "cursor-pointer",
+                    height: "205px",
+                    infinite: "",
+                    navigation: $options.hasImages,
+                    "navigation-icon": "o_fiber_manual_record",
+                    swipeable: ""
+                  }, {
+                    "navigation-icon": vue.withCtx(({ active, btnProps, onClick }) => [
+                      vue.createVNode(_component_qas_btn, {
+                        color: "white",
+                        dense: "",
+                        flat: "",
+                        icon: $options.getNavigationIcon(active, btnProps),
+                        round: "",
+                        size: "sm",
+                        onClick: onClick
+                      }, null, 8 /* PROPS */, ["icon", "onClick"])
+                    ]),
+                    default: vue.withCtx(() => [
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($options.imagesList, (item, index) => {
+                        return (vue.openBlock(), vue.createBlock(_component_q_carousel_slide, {
+                          key: index,
+                          class: vue.normalizeClass(["bg-no-repeat", $options.bgImagePositionClass]),
+                          "img-src": item,
+                          name: index
+                        }, null, 8 /* PROPS */, ["class", "img-src", "name"]))
+                      }), 128 /* KEYED_FRAGMENT */))
+                    ]),
+                    _: 1 /* STABLE */
+                  }, 8 /* PROPS */, ["modelValue", "navigation"]),
+                  vue.createElementVNode("div", _hoisted_3$2, [
+                    vue.renderSlot(_ctx.$slots, "carousel-header")
+                  ])
+                ])
+              ]))
+            : vue.createCommentVNode("v-if", true),
+          vue.createVNode(_component_q_card_section, { class: "col-grow column justify-between w-full" }, {
+            default: vue.withCtx(() => [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(["w-full", $options.gutterClass])
+              }, [
+                vue.renderSlot(_ctx.$slots, "default")
+              ], 2 /* CLASS */)
+            ]),
+            _: 3 /* FORWARDED */
+          }),
+          ($options.hasActionsSlot)
+            ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4$1, [
+                vue.renderSlot(_ctx.$slots, "actions")
+              ]))
+            : vue.createCommentVNode("v-if", true)
+        ]),
+        _: 3 /* FORWARDED */
+      }, 8 /* PROPS */, ["class"])
+    ]))
+  }
+
+  script$g.render = render$g;
+  script$g.__file = "src/components/card/QasCard.vue";
+
+  var script$f = {
+    name: 'QasCopy',
+
+    props: {
+      icon: {
+        default: 'o_file_copy',
+        type: String
+      },
+
+      size: {
+        default: 'xs',
+        type: String
+      },
+
+      text: {
+        required: true,
+        type: String
+      }
+    },
+
+    data () {
+      return {
+        isLoading: false
+      }
+    },
+
+    methods: {
+      async copy () {
+        this.isLoading = true;
+
+        try {
+          await quasar.copyToClipboard(this.text);
+          this.$qas.success('Copiado!', this.text);
+        } catch (error) {
+          this.$qas.error('Não foi possível copiar.', this.text);
+        } finally {
+          setTimeout(() => { this.isLoading = false; }, 500);
+        }
+      }
+    }
+  };
+
+  const _hoisted_1$9 = /*#__PURE__*/vue.createTextVNode("Copiar");
+
+  function render$f(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_tooltip = vue.resolveComponent("q-tooltip");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+
+    return (vue.openBlock(), vue.createElementBlock("span", null, [
+      vue.renderSlot(_ctx.$slots, "default", {}, () => [
+        vue.createTextVNode(vue.toDisplayString($props.text), 1 /* TEXT */)
+      ]),
+      vue.createVNode(_component_qas_btn, {
+        class: "q-ml-xs",
+        color: "grey-5",
+        flat: "",
+        icon: $props.icon,
+        loading: $data.isLoading,
+        round: "",
+        size: $props.size,
+        onClick: $options.copy
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_q_tooltip, null, {
+            default: vue.withCtx(() => [
+              _hoisted_1$9
+            ]),
+            _: 1 /* STABLE */
+          })
+        ]),
+        _: 1 /* STABLE */
+      }, 8 /* PROPS */, ["icon", "loading", "size", "onClick"])
+    ]))
+  }
+
+  script$f.render = render$f;
+  script$f.__file = "src/components/copy/QasCopy.vue";
+
+  var script$e = {
+    name: 'QasDebugger',
+
+    props: {
+      inspect: {
+        default: () => [],
+        required: true,
+        type: Array
+      }
+    }
+  };
+
+  const _hoisted_1$8 = { class: "bg-grey-3 q-my-md q-pa-md rounded-borders" };
+  const _hoisted_2$4 = /*#__PURE__*/vue.createElementVNode("summary", null, "Debugger", -1 /* HOISTED */);
+  const _hoisted_3$1 = { class: "row" };
+
+  function render$e(_ctx, _cache, $props, $setup, $data, $options) {
+    return (vue.openBlock(), vue.createElementBlock("details", _hoisted_1$8, [
+      _hoisted_2$4,
+      vue.createElementVNode("div", _hoisted_3$1, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($props.inspect, (item, index) => {
+          return (vue.openBlock(), vue.createElementBlock("pre", {
+            key: index,
+            class: "col q-pa-sm scroll",
+            style: {"max-height":"300px"}
+          }, vue.toDisplayString(item), 1 /* TEXT */))
+        }), 128 /* KEYED_FRAGMENT */))
+      ])
+    ]))
+  }
+
+  script$e.render = render$e;
+  script$e.__file = "src/components/debugger/QasDebugger.vue";
+
+  var script$d = {
+    name: 'QasDialog',
+
+    components: {
+      QasBtn: script$p,
+      QasActions: script$q
+    },
+
+    mixins: [screenMixin],
+
+    props: {
+      btnActionsProps: {
+        default: () => ({}),
+        type: Object
+      },
+
+      cancel: {
+        default: () => ({}),
+        type: [Object, Boolean]
+      },
+
+      card: {
+        default: () => ({}),
+        type: Object
+      },
+
+      cardProps: {
+        default: () => ({}),
+        type: Object
+      },
+
+      maxWidth: {
+        default: '',
+        type: String
+      },
+
+      minWidth: {
+        default: '',
+        type: String
+      },
+
+      ok: {
+        default: () => ({}),
+        type: [Object, Boolean]
+      },
+
+      persistent: {
+        default: true,
+        type: Boolean
+      },
+
+      useForm: {
+        type: Boolean
+      },
+
+      modelValue: {
+        type: Boolean
+      },
+
+      usePlugin: {
+        type: Boolean
+      }
+    },
+
+    emits: [
+      'update:modelValue',
+      'validate',
+      'ok',
+      'hide',
+      'update:open'
+    ],
+
+    computed: {
+      defaultCancel () {
+        return {
+          ...this.cancel?.events,
+            label: 'Cancelar',
+            outline: true,
+            ...this.cancel?.props
+        }
+      },
+
+      defaultOk () {
+        return {
+          ...this.ok?.events,
+          label: 'Ok',
+          type: this.ok?.props?.type || this.useForm ? 'submit' : 'button',
+          ...this.ok?.props
+        }
+      },
+
+      style () {
+        return {
+          maxWidth: this.maxWidth || (this.$_isSmall ? '' : '600px'),
+          minWidth: this.minWidth || (this.$_isSmall ? '' : '400px')
+        }
+      },
+
+      componentTag () {
+        return this.useForm ? 'q-form' : 'div'
+      },
+
+      dialogProps () {
+        return {
+          ...(!this.usePlugin && { modelValue: this.modelValue }),
+          ...this.$attrs
+        }
+      }
+    },
+
+    methods: {
+      async submitHandler () {
+        this.useForm && this.$emit('validate', await this.$refs.form.validate());
+      },
+
+      // metodo para funcionar como plugin
+      show () {
+        this.$refs.dialog.show();
+      },
+
+      // metodo para funcionar como plugin
+      hide () {
+        this.$refs.dialog.hide();
+      },
+
+      // metodo para funcionar como plugin
+      onDialogHide () {
+        this.$emit('hide');
+      },
+
+      updateModelValue (value) {
+        this.$emit('update:modelValue', value);
+      }
+    }
+  };
+
+  const _hoisted_1$7 = { class: "text-bold text-h6" };
+  const _hoisted_2$3 = { key: 0 };
+
+  function render$d(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_card_section = vue.resolveComponent("q-card-section");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+    const _component_qas_actions = vue.resolveComponent("qas-actions");
+    const _component_q_card = vue.resolveComponent("q-card");
+    const _component_q_dialog = vue.resolveComponent("q-dialog");
+    const _directive_close_popup = vue.resolveDirective("close-popup");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_dialog, vue.mergeProps({
+      ref: "dialog",
+      persistent: $props.persistent
+    }, $options.dialogProps, {
+      onHide: $options.onDialogHide,
+      "onUpdate:modelValue": $options.updateModelValue
+    }), {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_q_card, vue.mergeProps($props.cardProps, {
+          class: "q-pa-sm",
+          style: $options.style
+        }), {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_q_card_section, null, {
+              default: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "header", {}, () => [
+                  vue.createElementVNode("div", _hoisted_1$7, vue.toDisplayString($props.card.title), 1 /* TEXT */)
+                ])
+              ]),
+              _: 3 /* FORWARDED */
+            }),
+            vue.createVNode(_component_q_card_section, { class: "q-pt-none" }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($options.componentTag), { ref: "form" }, {
+                  default: vue.withCtx(() => [
+                    vue.renderSlot(_ctx.$slots, "description", {}, () => [
+                      ($props.card.description)
+                        ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$3, vue.toDisplayString($props.card.description), 1 /* TEXT */))
+                        : vue.createCommentVNode("v-if", true)
+                    ])
+                  ]),
+                  _: 3 /* FORWARDED */
+                }, 512 /* NEED_PATCH */))
+              ]),
+              _: 3 /* FORWARDED */
+            }),
+            vue.createVNode(_component_q_card_section, null, {
+              default: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "actions", {}, () => [
+                  vue.createVNode(_component_qas_actions, vue.normalizeProps(vue.guardReactiveProps($props.btnActionsProps)), {
+                    primary: vue.withCtx(() => [
+                      ($props.ok)
+                        ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_qas_btn, vue.mergeProps({
+                            key: 0,
+                            class: "full-width"
+                          }, $options.defaultOk, { onClick: $options.submitHandler }), null, 16 /* FULL_PROPS */, ["onClick"])), [
+                            [_directive_close_popup, !$props.useForm]
+                          ])
+                        : vue.createCommentVNode("v-if", true)
+                    ]),
+                    secondary: vue.withCtx(() => [
+                      ($props.cancel)
+                        ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_qas_btn, vue.mergeProps({
+                            key: 0,
+                            class: "full-width"
+                          }, $options.defaultCancel), null, 16 /* FULL_PROPS */)), [
+                            [_directive_close_popup]
+                          ])
+                        : vue.createCommentVNode("v-if", true)
+                    ]),
+                    _: 1 /* STABLE */
+                  }, 16 /* FULL_PROPS */)
+                ])
+              ]),
+              _: 3 /* FORWARDED */
+            })
+          ]),
+          _: 3 /* FORWARDED */
+        }, 16 /* FULL_PROPS */, ["style"])
+      ]),
+      _: 3 /* FORWARDED */
+    }, 16 /* FULL_PROPS */, ["persistent", "onHide", "onUpdate:modelValue"]))
+  }
+
+  script$d.render = render$d;
+  script$d.__file = "src/components/dialog/QasDialog.vue";
+
+  var script$c = {
+    name: 'QasInput',
+
+    props: {
+      modelValue: {
+        default: '',
+        type: String
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    computed: {
+      hasError () {
+        return this.inputReference.hasError
+      },
+
+      inputReference () {
+        return this.$refs.input
+      },
+
+      mask () {
+        const { mask } = this.$attrs;
+        const hasDefaultMask = Object.prototype.hasOwnProperty.call(this.masks, mask);
+
+        return hasDefaultMask ? this.masks[mask]() : mask
+      },
+
+      masks () {
+        return {
+          'company-document': () => '##.###.###/####-##',
+          document: () => this.toggleMask('###.###.###-###', '##.###.###/####-##'),
+          'personal-document': () => '###.###.###-##',
+          phone: () => this.toggleMask('(##) ####-#####', '(##) #####-####'),
+          'postal-code': () => '#####-###'
+        }
+      },
+
+      model: {
+        get () {
+          return this.modelValue
+        },
+
+        set (value) {
+          return this.$emit('update:modelValue', value)
+        }
+      }
+    },
+
+    watch: {
+      mask () {
+        const input = this.inputReference.$el?.querySelector('input');
+
+        requestAnimationFrame(() => {
+          input.selectionStart = input.value ? input.value.length : '';
+        });
+      }
+    },
+
+    methods: {
+      focus () {
+        return this.inputReference.focus()
+      },
+
+      resetValidation () {
+        return this.inputReference.resetValidation()
+      },
+
+      toggleMask (first, second) {
+        const length = first.split('#').length - 2;
+        return this.modelValue?.length > length ? second : first
+      },
+
+      validate (value) {
+        return this.inputReference.validate(value)
+      }
+    }
+  };
+
+  function render$c(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_input = vue.resolveComponent("q-input");
+
+    return (vue.openBlock(), vue.createElementBlock("div", null, [
+      vue.createVNode(_component_q_input, vue.mergeProps({
+        ref: "input",
+        modelValue: $options.model,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($options.model) = $event)),
+        "bottom-slots": ""
+      }, _ctx.$attrs, {
+        mask: $options.mask,
+        "unmasked-value": ""
+      }), vue.createSlots({ _: 2 /* DYNAMIC */ }, [
+        vue.renderList(_ctx.$slots, (_, name) => {
+          return {
+            name: name,
+            fn: vue.withCtx((context) => [
+              vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(context || {})))
+            ])
+          }
+        })
+      ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["modelValue", "mask"])
+    ]))
+  }
+
+  script$c.render = render$c;
+  script$c.__file = "src/components/input/QasInput.vue";
+
+  var script$b = {
+    name: 'QasLabel',
+
+    props: {
+      count: {
+        default: 0,
+        type: [Number, String]
+      },
+
+      label: {
+        default: '',
+        type: String
+      },
+
+      margin: {
+        default: 'sm',
+        type: String
+      }
+    },
+
+    computed: {
+      labelClass () {
+        return `q-mb-${this.margin}`
+      },
+
+      labelWithSuffix () {
+        return addCounterSuffix(this.label, parseFloat(this.count))
+      }
+    }
+  };
+
+  function render$b(_ctx, _cache, $props, $setup, $data, $options) {
+    return (vue.openBlock(), vue.createElementBlock("div", {
+      class: vue.normalizeClass(["text-bold text-subtitle2", $options.labelClass])
+    }, [
+      vue.renderSlot(_ctx.$slots, "default", { labelWithSuffix: $options.labelWithSuffix }, () => [
+        vue.createTextVNode(vue.toDisplayString($options.labelWithSuffix), 1 /* TEXT */)
+      ])
+    ], 2 /* CLASS */))
+  }
+
+  script$b.render = render$b;
+  script$b.__file = "src/components/label/QasLabel.vue";
+
+  var script$a = {
+    name: 'QasListItems',
+
+    components: {
+      QasBtn: script$p
+    },
+
+    props: {
+      iconProps: {
+        default: () => ({ color: 'primary', name: 'o_chevron_right' }),
+        type: Object
+      },
+
+      list: {
+        default: () => [],
+        type: Array
+      },
+
+      redirectKey: {
+        default: 'uuid',
+        type: String
+      },
+
+      redirectOnIcon: {
+        default: true,
+        type: Boolean
+      },
+
+      to: {
+        default: () => ({}),
+        type: Object
+      },
+
+      useSectionActions: {
+        default: true,
+        type: Boolean
+      }
+    },
+
+    methods: {
+      getRedirectPayload (item) {
+        return {
+          params: { [this.redirectKey]: item[this.redirectKey] },
+          ...this.to
+        }
+      },
+
+      redirect (item) {
+        return this.redirectOnIcon ? undefined : this.getRedirectPayload(item)
+      }
+    }
+  };
+
+  const _hoisted_1$6 = { class: "qas-list-items shadow-primary" };
+
+  function render$a(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_item_section = vue.resolveComponent("q-item-section");
+    const _component_q_icon = vue.resolveComponent("q-icon");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+    const _component_q_item = vue.resolveComponent("q-item");
+    const _component_q_list = vue.resolveComponent("q-list");
+    const _directive_ripple = vue.resolveDirective("ripple");
+
+    return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$6, [
+      vue.createVNode(_component_q_list, {
+        bordered: "",
+        class: "rounded-borders",
+        separator: ""
+      }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($props.list, (item, index) => {
+            return vue.withDirectives((vue.openBlock(), vue.createBlock(_component_q_item, {
+              key: index,
+              clickable: !$props.redirectOnIcon,
+              to: $options.redirect(item)
+            }, {
+              default: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, "item", {
+                  index: index,
+                  item: item
+                }, () => [
+                  vue.createVNode(_component_q_item_section, null, {
+                    default: vue.withCtx(() => [
+                      vue.renderSlot(_ctx.$slots, "item-section-left", {
+                        index: index,
+                        item: item
+                      })
+                    ]),
+                    _: 2 /* DYNAMIC */
+                  }, 1024 /* DYNAMIC_SLOTS */),
+                  ($props.useSectionActions)
+                    ? (vue.openBlock(), vue.createBlock(_component_q_item_section, {
+                        key: 0,
+                        side: ""
+                      }, {
+                        default: vue.withCtx(() => [
+                          vue.renderSlot(_ctx.$slots, "item-section-side", {
+                            index: index,
+                            item: item
+                          }, () => [
+                            vue.createVNode(_component_qas_btn, {
+                              flat: "",
+                              round: "",
+                              to: $options.getRedirectPayload(item)
+                            }, {
+                              default: vue.withCtx(() => [
+                                vue.createVNode(_component_q_icon, vue.normalizeProps(vue.guardReactiveProps($props.iconProps)), null, 16 /* FULL_PROPS */)
+                              ]),
+                              _: 2 /* DYNAMIC */
+                            }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["to"])
+                          ])
+                        ]),
+                        _: 2 /* DYNAMIC */
+                      }, 1024 /* DYNAMIC_SLOTS */))
+                    : vue.createCommentVNode("v-if", true)
+                ])
+              ]),
+              _: 2 /* DYNAMIC */
+            }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["clickable", "to"])), [
+              [_directive_ripple]
+            ])
+          }), 128 /* KEYED_FRAGMENT */))
+        ]),
+        _: 3 /* FORWARDED */
+      })
+    ]))
+  }
+
+  script$a.render = render$a;
+  script$a.__file = "src/components/list-items/QasListItems.vue";
+
+  const defaultModes = {
+    decimal: 'commaDecimalCharDotSeparator',
+    integer: ['commaDecimalCharDotSeparator', 'integer'],
+    money: 'Brazilian',
+    percent: 'percentageEU2dec'
+  };
+
+  var script$9 = {
+    name: 'QasNumericInput',
+
+    props: {
+      allowNegative: {
+        default: true,
+        type: Boolean
+      },
+
+      allowPositive: {
+        default: true,
+        type: Boolean
+      },
+
+      autonumericProps: {
+        default: () => ({}),
+        type: Object
+      },
+
+      decimalPlaces: {
+        default: 2,
+        type: Number
+      },
+
+      mode: {
+        default: 'integer',
+        type: String,
+        validator: value => ['integer', 'decimal', 'percent', 'money'].includes(value)
+      },
+
+      modelValue: {
+        default: '',
+        validator (value) {
+          return typeof value === 'number' || typeof value === 'string' || value === '' || value === null
+        }
+      },
+
+      preset: {
+        default: false,
+        type: [Boolean, String]
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    data () {
+      return {
+        autoNumeric: null
+      }
+    },
+
+    computed: {
+      defaultMode () {
+        return defaultModes[this.mode]
+      },
+
+      model: {
+        get () {
+          return this.modelValue
+        },
+
+        set () {
+          this.$emit('update:modelValue', this.autoNumeric.getNumber());
+        }
+      }
+    },
+
+    async created () {
+      const autoNumericPredefinedOptions = AutoNumeric__default["default"].getPredefinedOptions();
+
+      let option = this.preset || this.defaultMode;
+
+      if (!Array.isArray(option)) {
+        option = [option];
+      }
+
+      const options = {};
+
+      for (const value of option) {
+        Object.assign(options, autoNumericPredefinedOptions[value]);
+      }
+
+      if (!this.allowNegative) {
+        options.minimumValue = 0;
+      }
+
+      if (!this.allowPositive) {
+        options.maximumValue = 0;
+      }
+
+      if (this.mode !== 'integer') {
+        options.decimalPlaces = this.decimalPlaces;
+      }
+
+      Object.assign(options, this.autonumericProps);
+
+      this.$nextTick(() => {
+        this.$refs.input.value = this.modelValue;
+        this.autoNumeric = new AutoNumeric__default["default"](this.$refs.input, options);
+      });
+    },
+
+    beforeUnmount () {
+      this.autoNumeric.remove();
+    }
+  };
+
+  const _hoisted_1$5 = ["id", "model-value", "onInput"];
+
+  function render$9(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_field = vue.resolveComponent("q-field");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_field, {
+      modelValue: $options.model,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($options.model) = $event))
+    }, {
+      control: vue.withCtx(({ emitValue, floatingLabel, id, value }) => [
+        vue.withDirectives(vue.createElementVNode("input", {
+          id: id,
+          ref: "input",
+          class: "q-field__input",
+          "model-value": value,
+          onInput: $event => (emitValue($event.target.value))
+        }, null, 40 /* PROPS, HYDRATE_EVENTS */, _hoisted_1$5), [
+          [vue.vShow, floatingLabel]
+        ])
+      ]),
+      _: 1 /* STABLE */
+    }, 8 /* PROPS */, ["modelValue"]))
+  }
+
+  script$9.render = render$9;
+  script$9.__file = "src/components/numeric-input/QasNumericInput.vue";
+
+  var script$8 = {
+    name: 'QasPasswordStrengthChecker',
+
+    mixins: [passwordMixin],
+
+    props: {
+      modelValue: {
+        default: false,
+        type: Boolean
+      },
+
+      password: {
+        default: '',
+        type: String
+      }
+    },
+
+    emits: ['update:model-value'],
+
+    computed: {
+      length () {
+        return this.password.length
+      },
+
+      level () {
+        return this.levelsValues[this.score]
+      },
+
+      levelsValues () {
+        return Object.values(this.levels)
+      },
+
+      score () {
+        let score = 0;
+
+        if (this.length >= parseInt(this.minlength)) {
+          score += this.useLowercase
+            ? (this.password.match(/[a-z]/g) ? 1 : 0)
+            : 1;
+
+          score += this.useNumbers
+            ? (this.password.match(/[0-9]/g) ? 1 : 0)
+            : 1;
+
+          score += this.useSpecial
+            ? (this.password.match(this.specials) ? 1 : 0)
+            : 1;
+
+          score += this.useUppercase
+            ? (this.password.match(/[A-Z]/g) ? 1 : 0)
+            : 1;
+        }
+
+        return score
+      }
+    },
+
+    watch: {
+      password () {
+        this.emitValue();
+      }
+    },
+
+    created () {
+      this.emitValue();
+    },
+
+    methods: {
+      emitValue () {
+        this.$emit('update:model-value', this.score === 4);
+      }
+    }
+  };
+
+  const _hoisted_1$4 = { key: 0 };
+
+  function render$8(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_linear_progress = vue.resolveComponent("q-linear-progress");
+
+    return ($options.length)
+      ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$4, [
+          vue.renderSlot(_ctx.$slots, "default", { level: $options.level }, () => [
+            vue.createVNode(_component_q_linear_progress, {
+              color: $options.level.color,
+              "track-color": _ctx.trackColor,
+              value: $options.level.progress
+            }, null, 8 /* PROPS */, ["color", "track-color", "value"]),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(["text-caption", $options.level.textClass])
+            }, vue.toDisplayString($options.level.label), 3 /* TEXT, CLASS */)
+          ])
+        ]))
+      : vue.createCommentVNode("v-if", true)
+  }
+
+  script$8.render = render$8;
+  script$8.__file = "src/components/password-strength-checker/QasPasswordStrengthChecker.vue";
+
+  var script$7 = {
+    name: 'QasPasswordInput',
+
+    components: {
+      QasPasswordStrengthChecker: script$8
+    },
+
+    mixins: [passwordMixin],
+
+    props: {
+      hideStrengthChecker: {
+        type: Boolean
+      },
+
+      iconColor: {
+        type: String,
+        default: 'primary'
+      },
+
+      modelValue: {
+        type: String,
+        default: ''
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    data () {
+      return {
+        key: 'error',
+        toggleType: true
+      }
+    },
+
+    computed: {
+      icon () {
+        return this.toggleType ? 'o_visibility_off' : 'o_visibility'
+      },
+
+      model: {
+        get () {
+          return this.modelValue
+        },
+
+        set (value) {
+          return this.$emit('update:modelValue', value)
+        }
+      },
+
+      strengthCheckerProps () {
+        const { modelValue, ...props } = this.$props;
+        return props
+      },
+
+      type () {
+        return this.toggleType ? 'password' : 'text'
+      }
+    },
+
+    watch: {
+      modelValue () {
+        if (this.$attrs.error) {
+          this.$attrs.error = false;
+          this.$attrs.errorMessage = '';
+        }
+      }
+    },
+
+    methods: {
+      toggle () {
+        this.toggleType = !this.toggleType;
+      }
+    }
+  };
+
+  function render$7(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_icon = vue.resolveComponent("q-icon");
+    const _component_qas_password_strength_checker = vue.resolveComponent("qas-password-strength-checker");
+    const _component_q_input = vue.resolveComponent("q-input");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_input, {
+      modelValue: $options.model,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($options.model) = $event)),
+      "bottom-slots": "",
+      type: $options.type
+    }, vue.createSlots({
+      append: vue.withCtx(() => [
+        vue.createVNode(_component_q_icon, {
+          class: "cursor-pointer",
+          color: $props.iconColor,
+          name: $options.icon,
+          onClick: $options.toggle
+        }, null, 8 /* PROPS */, ["color", "name", "onClick"])
+      ]),
+      _: 2 /* DYNAMIC */
+    }, [
+      vue.renderList(_ctx.$slots, (_, name) => {
+        return {
+          name: name,
+          fn: vue.withCtx((context) => [
+            vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(context || {})))
+          ])
+        }
+      }),
+      (!$props.hideStrengthChecker)
+        ? {
+            name: "hint",
+            fn: vue.withCtx(() => [
+              vue.createVNode(_component_qas_password_strength_checker, vue.mergeProps($options.strengthCheckerProps, { password: $options.model }), null, 16 /* FULL_PROPS */, ["password"])
+            ])
+          }
+        : undefined
+    ]), 1032 /* PROPS, DYNAMIC_SLOTS */, ["modelValue", "type"]))
+  }
+
+  script$7.render = render$7;
+  script$7.__file = "src/components/password-input/QasPasswordInput.vue";
+
+  var script$6 = {
+    name: 'QasSearchBox',
+
+    components: {
+      QasBox: script$h
+    },
+
+    props: {
+      emptyListHeight: {
+        default: '100px',
+        type: String
+      },
+
+      fuseOptions: {
+        default: () => ({}),
+        type: Object
+      },
+
+      height: {
+        default: '300px',
+        type: String
+      },
+
+      list: {
+        default: () => [],
+        type: Array
+      },
+
+      modelValue: {
+        default: '',
+        type: String
+      },
+
+      placeholder: {
+        default: 'Pesquisar',
+        type: String
+      },
+
+      useEmptySlot: {
+        default: true,
+        type: Boolean
+      }
+    },
+
+    emits: ['empty-result', 'update:modelValue'],
+
+    data () {
+      return {
+        fuse: null,
+        results: this.list,
+        search: ''
+      }
+    },
+
+    computed: {
+      contentStyle () {
+        return { height: this.list.length ? this.height : this.emptyListHeight }
+      },
+
+      defaultFuseOptions () {
+        return {
+          distance: 100,
+          location: 0,
+          maxPatternLength: 32,
+          minMatchCharLength: 1,
+          shouldSort: true,
+          threshold: 0.1,
+          tokenize: true,
+
+          ...this.fuseOptions
+        }
+      },
+
+      hasResults () {
+        return !!this.results.length
+      },
+
+      normalizedResults () {
+        return this.results.map(result => result?.item) || []
+      }
+    },
+
+    watch: {
+      defaultFuseOptions (value) {
+        this.fuse.options = { ...this.fuse.options, ...value };
+      },
+
+      hasResults (value) {
+        !value && this.$emit('empty-result');
+      },
+
+      list: {
+        handler (value) {
+          this.fuse.list = value;
+          this.setResults(this.search);
+        },
+
+        deep: true
+      },
+
+      search: {
+        handler (value) {
+          this.setResults(value);
+          this.$emit('update:modelValue', value);
+        },
+
+        immediate: true
+      }
+    },
+
+    async created () {
+      this.search = this.modelValue;
+      this.fuse = new Fuse__default["default"](this.list, this.defaultFuseOptions);
+      this.setResults();
+    },
+
+    methods: {
+      setResults (value) {
+        this.results = value
+          ? this.fuse.search(value)
+          : this.list.map(listItem => ({ item: listItem }));
+      }
+    }
+  };
+
+  const _hoisted_1$3 = { class: "absolute-center text-center" };
+  const _hoisted_2$2 = /*#__PURE__*/vue.createElementVNode("div", null, "Não há resultados disponíveis.", -1 /* HOISTED */);
+
+  function render$6(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_icon = vue.resolveComponent("q-icon");
+    const _component_q_input = vue.resolveComponent("q-input");
+    const _component_qas_box = vue.resolveComponent("qas-box");
+
+    return (vue.openBlock(), vue.createBlock(_component_qas_box, null, {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_q_input, {
+          modelValue: $data.search,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($data.search) = $event)),
+          clearable: "",
+          disable: !$props.list.length,
+          outlined: "",
+          placeholder: $props.placeholder
+        }, {
+          append: vue.withCtx(() => [
+            vue.createVNode(_component_q_icon, {
+              color: "primary",
+              name: "o_search"
+            })
+          ]),
+          _: 1 /* STABLE */
+        }, 8 /* PROPS */, ["modelValue", "disable", "placeholder"]),
+        vue.createElementVNode("div", {
+          class: "overflow-auto q-mt-xs relative-position",
+          style: vue.normalizeStyle($options.contentStyle)
+        }, [
+          ($options.hasResults)
+            ? vue.renderSlot(_ctx.$slots, "default", {
+                key: 0,
+                results: $options.normalizedResults
+              })
+            : ($props.useEmptySlot)
+              ? vue.renderSlot(_ctx.$slots, "empty-result", { key: 1 }, () => [
+                  vue.createElementVNode("div", _hoisted_1$3, [
+                    vue.createVNode(_component_q_icon, {
+                      class: "q-mb-sm text-center",
+                      color: "primary",
+                      name: "o_search",
+                      size: "38px"
+                    }),
+                    _hoisted_2$2
+                  ])
+                ])
+              : vue.createCommentVNode("v-if", true)
+        ], 4 /* STYLE */)
+      ]),
+      _: 3 /* FORWARDED */
+    }))
+  }
+
+  script$6.render = render$6;
+  script$6.__file = "src/components/search-box/QasSearchBox.vue";
+
+  var script$5 = {
+    name: 'QasSelect',
+
+    props: {
+      fuseOptions: {
+        default: () => ({}),
+        type: Object
+      },
+
+      labelKey: {
+        default: '',
+        type: String
+      },
+
+      modelValue: {
+        default: () => [],
+        type: [Array, Object, String, Number]
+      },
+
+      noOptionLabel: {
+        default: 'Nenhum resultado foi encontrado.',
+        type: String
+      },
+
+      options: {
+        default: () => [],
+        type: Array
+      },
+
+      searchable: {
+        type: Boolean
+      },
+
+      valueKey: {
+        default: '',
+        type: String
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    data () {
+      return {
+        filteredOptions: [],
+        fuse: null
+      }
+    },
+
+    computed: {
+      attributes () {
+        return {
+          clearable: this.searchable,
+          emitValue: true,
+          mapOptions: true,
+          outlined: true,
+
+          ...this.$attrs,
+
+          options: this.filteredOptions,
+          useInput: this.searchable
+        }
+      },
+
+      defaultFuseOptions () {
+        return {
+          distance: 100,
+          includeScore: true,
+          keys: ['label', 'value'],
+          location: 0,
+          maxPatternLength: 32,
+          minMatchCharLength: 1,
+          shouldSort: true,
+          threshold: 0.1,
+          tokenize: true,
+
+          ...this.fuseOptions
+        }
+      },
+
+      formattedResult () {
+        if (!this.labelKey && !this.valueKey) {
+          return this.options
+        }
+
+        return this.options.map(item => this.renameKey(item))
+      },
+
+      model: {
+        get () {
+          return this.modelValue
+        },
+
+        set (value) {
+          this.$emit('update:modelValue', value);
+        }
+      }
+    },
+
+    watch: {
+      defaultFuseOptions (value) {
+        this.fuse.options = { ...this.fuse.options, ...value };
+      },
+
+      options: {
+        handler () {
+          if (this.fuse) {
+            this.fuse.list = this.formattedResult;
+          }
+
+          this.filteredOptions = this.formattedResult;
+        },
+
+        immediate: true
+      }
+    },
+
+    async created () {
+      if (this.searchable) {
+        this.fuse = new Fuse__default["default"](this.options, this.defaultFuseOptions);
+      }
+    },
+
+    methods: {
+      filterOptions (value, update) {
+        update(() => {
+          if (!this.searchable) return
+
+          if (value === '') {
+            this.filteredOptions = this.formattedResult;
+          } else {
+            const results = this.fuse.search(value);
+            this.filteredOptions = results.map(item => item.item);
+          }
+        });
+      },
+
+      renameKey (item) {
+        const mapKeys = {
+          label: this.labelKey,
+          value: this.valueKey
+        };
+
+        for (const newKey in mapKeys) {
+          if (!item.hasOwnProperty.call(newKey)) {
+            item[newKey] = item[mapKeys[newKey]];
+            delete item[mapKeys[newKey]];
+          }
+        }
+
+        return item
+      }
+    }
+  };
+
+  function render$5(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_icon = vue.resolveComponent("q-icon");
+    const _component_q_item_section = vue.resolveComponent("q-item-section");
+    const _component_q_item = vue.resolveComponent("q-item");
+    const _component_q_select = vue.resolveComponent("q-select");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_select, vue.mergeProps({
+      modelValue: $options.model,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($options.model) = $event))
+    }, $options.attributes, { onFilter: $options.filterOptions }), vue.createSlots({
+      append: vue.withCtx(() => [
+        vue.renderSlot(_ctx.$slots, "append", {}, () => [
+          ($props.searchable)
+            ? (vue.openBlock(), vue.createBlock(_component_q_icon, {
+                key: 0,
+                name: "o_search"
+              }))
+            : vue.createCommentVNode("v-if", true)
+        ])
+      ]),
+      "no-option": vue.withCtx(() => [
+        vue.renderSlot(_ctx.$slots, "no-option", {}, () => [
+          vue.createVNode(_component_q_item, null, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_q_item_section, { class: "text-grey" }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(vue.toDisplayString($props.noOptionLabel), 1 /* TEXT */)
+                ]),
+                _: 1 /* STABLE */
+              })
+            ]),
+            _: 1 /* STABLE */
+          })
+        ])
+      ]),
+      _: 2 /* DYNAMIC */
+    }, [
+      vue.renderList(_ctx.$slots, (_, name) => {
+        return {
+          name: name,
+          fn: vue.withCtx((context) => [
+            vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(context || {})))
+          ])
+        }
+      })
+    ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["modelValue", "onFilter"]))
+  }
+
+  script$5.render = render$5;
+  script$5.__file = "src/components/select/QasSelect.vue";
+
+  var script$4 = {
+    name: 'QasSelectList',
+
+    components: {
+      QasBtn: script$p,
+      QasSearchBox: script$6
+    },
+
+    mixins: [screenMixin],
+
+    props: {
+      deleteOnly: {
+        type: Boolean
+      },
+
+      fuseOptions: {
+        default: () => ({ keys: ['label'] }),
+        type: Object
+      },
+
+      list: {
+        default: () => [],
+        type: Array
+      },
+
+      modelValue: {
+        type: Array,
+        default: () => []
+      },
+
+      to: {
+        default: () => ({}),
+        type: Object
+      },
+
+      toIdentifier: {
+        default: 'value',
+        type: String
+      }
+    },
+
+    emits: [
+      'added',
+      'update:modelValue',
+      'removed'
+    ],
+
+    data () {
+      return {
+        sortedList: [],
+        values: []
+      }
+    },
+
+    computed: {
+      isRedirectEnabled () {
+        return Object.keys(this.to).length
+      },
+
+      labelClass () {
+        return this.isRedirectEnabled ? 'cursor-pointer' : ''
+      },
+
+      slotData () {
+        return {
+          add: this.add,
+          handleClick: this.handleClick,
+          remove: this.remove,
+          updateModel: this.updateModel
+        }
+      }
+    },
+
+    watch: {
+      list: {
+        handler (value) {
+          if (!this.sortedList.length) {
+            this.sortedList = value;
+          }
+        },
+
+        immediate: true
+      },
+
+      modelValue (value) {
+        this.values = [...value];
+      }
+    },
+
+    created () {
+      this.values = [...this.modelValue];
+
+      this.handleOptions();
+    },
+
+    methods: {
+      add (item) {
+        this.values.push(item.value);
+        this.updateModel();
+
+        this.$emit('added', item);
+      },
+
+      getButtonProps ({ value }) {
+        const isSelected = this.values.includes(value);
+
+        return {
+          dense: this.$_isSmall,
+          hideLabelOnSmallScreen: true,
+          icon: !this.$_isSmall ? undefined : isSelected ? 'o_close' : 'o_add',
+          label: isSelected ? 'Remover' : 'Adicionar',
+          outline: isSelected,
+          size: 'sm'
+        }
+      },
+
+      handleClick (item) {
+        return this.values.includes(item.value) ? this.remove(item) : this.add(item)
+      },
+
+      handleOptions () {
+        if (this.modelValue.length) {
+          return this.sortList()
+        }
+
+        const unwatch = this.$watch('modelValue', () => {
+          if (!this.sortedList.length) {
+            this.sortList();
+            unwatch();
+          }
+        });
+      },
+
+      redirectRoute (item) {
+        return this.isRedirectEnabled && this.$router.push({
+          params: { id: item[this.toIdentifier] },
+          ...this.to
+        })
+      },
+
+      remove (item) {
+        const index = this.values.findIndex(value => value === item.value);
+
+        this.values.splice(index, 1);
+        this.updateModel();
+
+        this.$emit('removed', item, index);
+      },
+
+      sortList () {
+        this.sortedList = this.deleteOnly
+          ? this.options.filter(option => this.modelValue.includes(option.value))
+          : lodashEs.sortBy(this.options, option => !this.modelValue.includes(option.value));
+      },
+
+      updateModel (model) {
+        this.$emit('update:modelValue', model || this.values);
+      }
+    }
+  };
+
+  const _hoisted_1$2 = ["onClick"];
+
+  function render$4(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_item_section = vue.resolveComponent("q-item-section");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+    const _component_q_item = vue.resolveComponent("q-item");
+    const _component_q_list = vue.resolveComponent("q-list");
+    const _component_qas_search_box = vue.resolveComponent("qas-search-box");
+
+    return (vue.openBlock(), vue.createBlock(_component_qas_search_box, {
+      class: "q-pa-md",
+      "fuse-options": $props.fuseOptions,
+      list: $data.sortedList
+    }, {
+      default: vue.withCtx(({ results }) => [
+        vue.createVNode(_component_q_list, { separator: "" }, {
+          default: vue.withCtx(() => [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(results, (result) => {
+              return (vue.openBlock(), vue.createBlock(_component_q_item, {
+                key: result.value
+              }, {
+                default: vue.withCtx(() => [
+                  vue.renderSlot(_ctx.$slots, "item", vue.normalizeProps(vue.guardReactiveProps($options.slotData)), () => [
+                    vue.renderSlot(_ctx.$slots, "item-section", { result: result }, () => [
+                      vue.createVNode(_component_q_item_section, { class: "items-start text-bold" }, {
+                        default: vue.withCtx(() => [
+                          vue.createElementVNode("div", {
+                            class: vue.normalizeClass($options.labelClass),
+                            onClick: $event => ($options.redirectRoute(result))
+                          }, vue.toDisplayString(result.label), 11 /* TEXT, CLASS, PROPS */, _hoisted_1$2)
+                        ]),
+                        _: 2 /* DYNAMIC */
+                      }, 1024 /* DYNAMIC_SLOTS */)
+                    ]),
+                    vue.createVNode(_component_q_item_section, { avatar: "" }, {
+                      default: vue.withCtx(() => [
+                        vue.renderSlot(_ctx.$slots, "item-action", vue.normalizeProps(vue.guardReactiveProps($options.slotData)), () => [
+                          vue.createVNode(_component_qas_btn, vue.mergeProps($options.getButtonProps(result), {
+                            onClick: $event => ($options.handleClick(result))
+                          }), null, 16 /* FULL_PROPS */, ["onClick"])
+                        ])
+                      ]),
+                      _: 2 /* DYNAMIC */
+                    }, 1024 /* DYNAMIC_SLOTS */)
+                  ])
+                ]),
+                _: 2 /* DYNAMIC */
+              }, 1024 /* DYNAMIC_SLOTS */))
+            }), 128 /* KEYED_FRAGMENT */))
+          ]),
+          _: 2 /* DYNAMIC */
+        }, 1024 /* DYNAMIC_SLOTS */)
+      ]),
+      _: 3 /* FORWARDED */
+    }, 8 /* PROPS */, ["fuse-options", "list"]))
+  }
+
+  script$4.render = render$4;
+  script$4.__file = "src/components/select-list/QasSelectList.vue";
+
+  var script$3 = {
+    name: 'QasSignaturePad',
+
+    components: {
+      QasBtn: script$p
+    },
+
+    props: {
+      emptyModel: {
+        type: Boolean,
+        default: true
+      },
+
+      height: {
+        default: '250',
+        type: String
+      },
+
+      signatureOptions: {
+        default: () => ({}),
+        type: Object
+      },
+
+      type: {
+        default: 'image/png',
+        type: String
+      }
+    },
+
+    emits: ['update:emptyModel'],
+
+    expose: ['clearSignature', 'saveSignature', 'updateEmptyModel'],
+
+    data () {
+      return {
+        canvasId: quasar.uid(),
+        hasEndStrokeEvent: false,
+        signaturePad: null,
+        SignaturePad: null
+      }
+    },
+
+    watch: {
+      async signatureOptions (newValue, oldValue) {
+        if (lodashEs.isEqual(newValue, oldValue)) return
+
+        await this.setupSignaturePad();
+        this.updateEmptyModel();
+      }
+    },
+
+    async mounted () {
+      window.addEventListener('resize', this.setCanvasWidth);
+      this.setCanvasWidth();
+
+      this.setupSignaturePad();
+    },
+
+    unmounted () {
+      window.removeEventListener('resize', this.setCanvasWidth);
+      this.signaturePad.off();
+    },
+
+    methods: {
+      clearSignature () {
+        this.signaturePad.clear();
+        this.updateEmptyModel();
+      },
+
+      saveSignature () {
+        return this.signaturePad.toDataURL(this.type)
+      },
+
+      setCanvasWidth () {
+        const signatureContainer = this.$refs.signatureContainer;
+        const canvasElement = signatureContainer.querySelector('canvas');
+        canvasElement.setAttribute('width', signatureContainer.offsetWidth);
+      },
+
+      setupSignaturePad () {
+        const canvasElement = document.getElementById(this.canvasId);
+        this.signaturePad = new SignaturePad__default["default"](canvasElement, this.signatureOptions);
+
+        if (!this.hasEndStrokeEvent) {
+          this.signaturePad.addEventListener('endStroke', this.updateEmptyModel);
+        }
+
+        this.hasEndStrokeEvent = true;
+        this.clearSignature();
+      },
+
+      updateEmptyModel () {
+        this.$emit('update:emptyModel', this.signaturePad.isEmpty());
+      }
+    }
+  };
+
+  const _hoisted_1$1 = {
+    ref: "signatureContainer",
+    class: "qas-signature-pad relative-position"
+  };
+  const _hoisted_2$1 = ["id", "height"];
+
+  function render$3(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+
+    return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
+      vue.createElementVNode("canvas", {
+        id: $data.canvasId,
+        ref: _ctx.$attrs.ref,
+        class: "qas-signature-pad__canvas rounded-borders vertical-bottom",
+        height: $props.height
+      }, null, 8 /* PROPS */, _hoisted_2$1),
+      (!$props.emptyModel)
+        ? (vue.openBlock(), vue.createBlock(_component_qas_btn, {
+            key: 0,
+            class: "absolute-bottom-right q-mb-sm q-mr-sm",
+            color: "primary",
+            dense: "",
+            icon: "o_delete",
+            round: "",
+            onClick: $options.clearSignature
+          }, null, 8 /* PROPS */, ["onClick"]))
+        : vue.createCommentVNode("v-if", true)
+    ], 512 /* NEED_PATCH */))
+  }
+
+  script$3.render = render$3;
+  script$3.__file = "src/components/signature-pad/QasSignaturePad.vue";
+
+  /**
+   * @param {object} componentProps={}
+   *
+   * @example Dialog({ card: { title: 'Esse é o meu titulo!' } })
+   */
+  var Dialog = (componentProps = {}) => {
+    quasar.Dialog.create({
+      component: script$d,
+      componentProps: { ...componentProps, usePlugin: true }
+    });
+  };
+
+  quasar.Notify.registerType('error', {
+    color: 'negative',
+    progress: true
+  });
+
+  var NotifyError = (message, caption) => {
+    quasar.Notify.create({ caption, message, type: 'error' });
+  };
+
+  quasar.Notify.registerType('success', {
+    icon: 'o_check',
+    progress: true
+  });
+
+  var NotifySuccess = (message, caption) => {
+    quasar.Notify.create({ caption, message, type: 'success' });
+  };
+
+  var script$2 = {
+    name: 'QasSortable',
+
+    props: {
+      entity: {
+        default: '',
+        type: String
+      },
+
+      sortableOptions: {
+        default: () => ({ animation: 500 }),
+        type: Object
+      },
+
+      results: {
+        default: () => [],
+        type: Array
+      },
+
+      tag: {
+        default: 'div',
+        type: String
+      },
+
+      url: {
+        default: '',
+        type: String
+      },
+
+      sortedModel: {
+        default: () => [],
+        type: Array
+      }
+    },
+
+    emits: [
+      'update:sortedModel',
+      'sort',
+      'success'
+    ],
+
+    data () {
+      return {
+        sortable: null,
+        sorted: null
+      }
+    },
+
+    computed: {
+      identifiers () {
+        return this.sorted.map(({ id }) => id)
+      }
+    },
+
+    watch: {
+      sortableOptions (value) {
+        this.sortable.options = { ...this.sortable.options, ...value };
+      },
+
+      results (value) {
+        this.setSortedValue(value);
+        this.sortable.sort(this.sortable.toArray());
+      }
+    },
+
+    created () {
+      this.setSortedValue();
+    },
+
+    async mounted () {
+      this.sortable = new Sortable__default["default"](this.$refs.sortableItems, {
+        ...this.sortableOptions,
+
+        onUpdate: event => {
+          this.updateOrder(event);
+          this.$emit('sort', event);
+        }
+      });
+    },
+
+    unmounted () {
+      this.sortable.destroy();
+    },
+
+    methods: {
+      setError (error) {
+        const { response } = error;
+        const exception = response?.data?.exception || error.message;
+
+        NotifyError('Ops! Erro ao ordernar itens.', exception);
+      },
+
+      // TODO precisa testar este metodo quando tivermos uma API para teste.
+      async replace () {
+        quasar.Loading.show();
+
+        try {
+          const response = await this.$store.dispatch(`${this.entity}/replace`, {
+            payload: { order: this.identifiers },
+            url: this.url || `${this.entity}/sort`
+          });
+
+          this.$emit('success', response);
+        } catch (error) {
+          this.setError(error);
+        } finally {
+          quasar.Loading.hide();
+        }
+      },
+
+      updateOrder ({ newIndex, oldIndex }) {
+        const deleted = this.sorted.splice(oldIndex, 1);
+        this.sorted.splice(newIndex, 0, deleted[0]);
+
+        this.replace();
+      },
+
+      setSortedValue (value) {
+        this.sorted = quasar.extend(true, [], value || this.results);
+        this.updateSortedModel();
+      },
+
+      updateSortedModel () {
+        return this.$emit('update:sortedModel', this.sorted)
+      }
+    }
+  };
+
+  function render$2(_ctx, _cache, $props, $setup, $data, $options) {
+    return (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.tag), { ref: "sortableItems" }, {
+      default: vue.withCtx(() => [
+        vue.renderSlot(_ctx.$slots, "default")
+      ]),
+      _: 3 /* FORWARDED */
+    }, 512 /* NEED_PATCH */))
+  }
+
+  script$2.render = render$2;
+  script$2.__file = "src/components/sortable/QasSortable.vue";
+
+  var script$1 = {
+    name: 'QasTabsGenerator',
+
+    props: {
+      activeColor: {
+        default: 'primary',
+        type: String
+      },
+
+      counterProps: {
+        default: () => ({}),
+        type: Object
+      },
+
+      counters: {
+        default: () => ({}),
+        type: Object
+      },
+
+      indicatorColor: {
+        default: 'primary',
+        type: String
+      },
+
+      modelValue: {
+        default: '',
+        type: String
+      },
+
+      tabClass: {
+        default: 'text-primary',
+        type: String
+      },
+
+      tabs: {
+        default: () => ({}),
+        required: true,
+        type: Object
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    computed: {
+      defaultCounterProps () {
+        return {
+          color: 'negative',
+          floating: true,
+          ...this.counterProps
+        }
+      },
+
+      formattedTabs () {
+        const tabs = quasar.extend(true, {}, this.tabs);
+
+        for (const key in tabs) {
+          if (typeof tabs[key] === 'string') {
+            tabs[key] = { label: tabs[key] };
+          }
+        }
+
+        return tabs
+      },
+
+      model: {
+        get () {
+          return this.modelValue
+        },
+
+        set (value) {
+          this.$emit('update:modelValue', value);
+        }
+      }
+    }
+  };
+
+  function render$1(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_q_badge = vue.resolveComponent("q-badge");
+    const _component_q_tab = vue.resolveComponent("q-tab");
+    const _component_q_tabs = vue.resolveComponent("q-tabs");
+
+    return (vue.openBlock(), vue.createBlock(_component_q_tabs, {
+      modelValue: $options.model,
+      "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($options.model) = $event)),
+      "active-color": $props.activeColor,
+      "indicator-color": $props.indicatorColor,
+      "outside-arrows": ""
+    }, {
+      default: vue.withCtx(() => [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($options.formattedTabs, (tab, key) => {
+          return vue.renderSlot(_ctx.$slots, `tab-${tab.value}`, { item: tab }, () => [
+            (vue.openBlock(), vue.createBlock(_component_q_tab, vue.mergeProps({ key: key }, tab, {
+              class: $props.tabClass,
+              label: tab.label,
+              name: key
+            }), {
+              default: vue.withCtx(() => [
+                vue.renderSlot(_ctx.$slots, `tab-after-${tab.value}`, { item: tab }, () => [
+                  ($props.counters[key])
+                    ? (vue.openBlock(), vue.createBlock(_component_q_badge, vue.mergeProps({
+                        key: 0,
+                        label: $props.counters[key]
+                      }, $options.defaultCounterProps), null, 16 /* FULL_PROPS */, ["label"]))
+                    : vue.createCommentVNode("v-if", true)
+                ])
+              ]),
+              _: 2 /* DYNAMIC */
+            }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["class", "label", "name"]))
+          ])
+        }), 256 /* UNKEYED_FRAGMENT */))
+      ]),
+      _: 3 /* FORWARDED */
+    }, 8 /* PROPS */, ["modelValue", "active-color", "indicator-color"]))
+  }
+
+  script$1.render = render$1;
+  script$1.__file = "src/components/tabs-generator/QasTabsGenerator.vue";
+
+  var script = {
+    name: 'QasTransfer',
+
+    components: {
+      QasBtn: script$p,
+      QasLabel: script$b,
+      QasSearchBox: script$6
+    },
+
+    mixins: [screenMixin],
+
+    props: {
+      emitValue: {
+        type: Boolean
+      },
+
+      fuseOptions: {
+        default: () => ({ keys: ['label'] }),
+        type: Object
+      },
+
+      label: {
+        default: '',
+        required: true,
+        type: String
+      },
+
+      labelKey: {
+        default: 'label',
+        type: String
+      },
+
+      modelValue: {
+        default: () => [],
+        type: Array
+      },
+
+      options: {
+        default: () => [],
+        type: Array
+      },
+
+      useEmptySlot: {
+        default: true,
+        type: Boolean
+      },
+
+      valueKey: {
+        default: 'value',
+        type: String
+      }
+    },
+
+    emits: ['update:modelValue'],
+
+    data () {
+      return {
+        firstQueue: [],
+        optionsList: [],
+        secondQueue: [],
+        selectedList: []
+      }
+    },
+
+    computed: {
+      actionsClass () {
+        return !this.$_isSmall && 'column'
+      },
+
+      gutterClass () {
+        return `q-col-gutter-${this.$_untilLarge ? 'md' : 'xl'}`
+      },
+
+      iconClass () {
+        return !this.$_isSmall && 'qas-transfer__icon'
+      },
+
+      searchBoxProps () {
+        return {
+          fuseOptions: this.fuseOptions,
+          useEmptySlot: this.useEmptySlot
+        }
+      }
+    },
+
+    watch: {
+      modelValue: {
+        handler () {
+          this.setSelectedFromValue(true);
+        },
+
+        immediate: true
+      },
+
+      options: {
+        handler (value) {
+          this.optionsList = quasar.extend(true, [], value);
+        },
+
+        immediate: true
+      },
+
+      selectedList: {
+        handler () {
+          this.updateModelValue();
+        }
+      }
+    },
+
+    methods: {
+      deleteItemsFromList (isFirst) {
+        this[isFirst ? 'firstQueue' : 'secondQueue'].forEach(item => {
+          const model = isFirst ? 'optionsList' : 'selectedList';
+          const index = this[model].findIndex(itemValue => {
+            return (itemValue[this.valueKey] || itemValue) === item[this.valueKey]
+          });
+
+          if (~index) {
+            this[model].splice(index, 1);
+          }
+        });
+      },
+
+      getItemClass (object, isFirst) {
+        return this[isFirst
+          ? 'firstQueue'
+          : 'secondQueue'
+        ].some(item => item[this.valueKey] === object[this.valueKey]) && 'bg-secondary'
+      },
+
+      getItemLabel (item) {
+        return item?.[this.labelKey]
+      },
+
+      getModelValue () {
+        const selectedList = quasar.extend(true, [], this.selectedList);
+        return this.emitValue ? selectedList.map(item => item[this.valueKey]) : selectedList
+      },
+
+      handleSelectedList (isFirst) {
+        const model = isFirst ? 'firstQueue' : 'secondQueue';
+
+        this[isFirst ? 'selectedList' : 'optionsList'].push(...this[model]);
+        this.deleteItemsFromList(isFirst);
+        this[model] = [];
+      },
+
+      onSelectQueue (item, isFirst) {
+        const model = isFirst ? 'firstQueue' : 'secondQueue';
+        const index = this[model].findIndex(selected => selected[this.valueKey] === item[this.valueKey]);
+
+        ~index ? this[model].splice(index, 1) : this[model].push(item);
+      },
+
+      setSelectedFromClick (isFirst) {
+        this.handleSelectedList(isFirst);
+      },
+
+      setSelectedFromValue (isFirst) {
+        this.modelValue.forEach(item => {
+          const selected = this.optionsList.find(option => {
+            return option[this.valueKey] === (this.emitValue ? item : item[this.valueKey])
+          });
+
+          if (selected) {
+            this.firstQueue.push(quasar.extend(true, {}, selected));
+          }
+        });
+
+        this.handleSelectedList(isFirst);
+      },
+
+      updateModelValue () {
+        return this.$emit('update:modelValue', this.getModelValue())
+      }
+    }
+  };
+
+  const _hoisted_1 = /*#__PURE__*/vue.createElementVNode("div", { class: "col-12" }, null, -1 /* HOISTED */);
+  const _hoisted_2 = { class: "col-12 col-sm" };
+  const _hoisted_3 = /*#__PURE__*/vue.createTextVNode("Selecionar");
+  const _hoisted_4 = /*#__PURE__*/vue.createTextVNode("Remover");
+  const _hoisted_5 = { class: "col-12 col-sm" };
+
+  function render(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_qas_label = vue.resolveComponent("qas-label");
+    const _component_q_item_section = vue.resolveComponent("q-item-section");
+    const _component_q_item = vue.resolveComponent("q-item");
+    const _component_q_list = vue.resolveComponent("q-list");
+    const _component_qas_search_box = vue.resolveComponent("qas-search-box");
+    const _component_qas_btn = vue.resolveComponent("qas-btn");
+    const _component_q_tooltip = vue.resolveComponent("q-tooltip");
+
+    return (vue.openBlock(), vue.createElementBlock("div", {
+      class: vue.normalizeClass(["qas-transfer row", $options.gutterClass])
+    }, [
+      _hoisted_1,
+      vue.createElementVNode("div", _hoisted_2, [
+        vue.createVNode(_component_qas_label, {
+          label: $props.label,
+          quantity: $data.optionsList.length
+        }, null, 8 /* PROPS */, ["label", "quantity"]),
+        vue.createVNode(_component_qas_search_box, vue.mergeProps({
+          "form-mode": "",
+          list: $data.optionsList
+        }, $options.searchBoxProps), {
+          default: vue.withCtx(({ results }) => [
+            vue.createVNode(_component_q_list, { separator: "" }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(results, (item, index) => {
+                  return (vue.openBlock(), vue.createBlock(_component_q_item, {
+                    key: index,
+                    class: vue.normalizeClass($options.getItemClass(item, true)),
+                    clickable: "",
+                    onClick: $event => ($options.onSelectQueue(item, true))
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.renderSlot(_ctx.$slots, "item-first-column", {}, () => [
+                        vue.createVNode(_component_q_item_section, null, {
+                          default: vue.withCtx(() => [
+                            vue.createTextVNode(vue.toDisplayString($options.getItemLabel(item)), 1 /* TEXT */)
+                          ]),
+                          _: 2 /* DYNAMIC */
+                        }, 1024 /* DYNAMIC_SLOTS */)
+                      ])
+                    ]),
+                    _: 2 /* DYNAMIC */
+                  }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["class", "onClick"]))
+                }), 128 /* KEYED_FRAGMENT */))
+              ]),
+              _: 2 /* DYNAMIC */
+            }, 1024 /* DYNAMIC_SLOTS */)
+          ]),
+          _: 3 /* FORWARDED */
+        }, 16 /* FULL_PROPS */, ["list"])
+      ]),
+      vue.createElementVNode("div", {
+        class: vue.normalizeClass(["col-12 col-sm-auto items-center justify-center q-col-gutter-md row", $options.actionsClass])
+      }, [
+        vue.createElementVNode("div", null, [
+          vue.createVNode(_component_qas_btn, {
+            class: vue.normalizeClass($options.iconClass),
+            dense: "",
+            disabled: !$data.firstQueue.length,
+            flat: "",
+            icon: "o_arrow_circle_down",
+            rounded: "",
+            onClick: _cache[0] || (_cache[0] = $event => ($options.setSelectedFromClick(true)))
+          }, null, 8 /* PROPS */, ["class", "disabled"]),
+          vue.createVNode(_component_q_tooltip, {
+            anchor: "top middle",
+            self: "center middle"
+          }, {
+            default: vue.withCtx(() => [
+              _hoisted_3
+            ]),
+            _: 1 /* STABLE */
+          })
+        ]),
+        vue.createElementVNode("div", null, [
+          vue.createElementVNode("div", null, [
+            vue.createVNode(_component_qas_btn, {
+              class: vue.normalizeClass($options.iconClass),
+              dense: "",
+              disabled: !$data.secondQueue.length,
+              flat: "",
+              icon: "o_arrow_circle_up",
+              rounded: "",
+              onClick: _cache[1] || (_cache[1] = $event => ($options.setSelectedFromClick()))
+            }, null, 8 /* PROPS */, ["class", "disabled"]),
+            vue.createVNode(_component_q_tooltip, {
+              anchor: "bottom middle",
+              self: "center middle"
+            }, {
+              default: vue.withCtx(() => [
+                _hoisted_4
+              ]),
+              _: 1 /* STABLE */
+            })
+          ])
+        ])
+      ], 2 /* CLASS */),
+      vue.createElementVNode("div", _hoisted_5, [
+        vue.createVNode(_component_qas_label, {
+          label: "Selecionadas",
+          quantity: $data.selectedList.length
+        }, null, 8 /* PROPS */, ["quantity"]),
+        vue.createVNode(_component_qas_search_box, vue.mergeProps($options.searchBoxProps, {
+          "empty-list-height": "300px",
+          "form-mode": "",
+          label: "Selecionadas",
+          list: $data.selectedList
+        }), {
+          default: vue.withCtx(({ results }) => [
+            vue.createVNode(_component_q_list, { separator: "" }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(results, (item, index) => {
+                  return (vue.openBlock(), vue.createBlock(_component_q_item, {
+                    key: index,
+                    class: vue.normalizeClass($options.getItemClass(item)),
+                    clickable: "",
+                    onClick: $event => ($options.onSelectQueue(item))
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.renderSlot(_ctx.$slots, "item-second-column", {}, () => [
+                        vue.createVNode(_component_q_item_section, null, {
+                          default: vue.withCtx(() => [
+                            vue.createTextVNode(vue.toDisplayString($options.getItemLabel(item)), 1 /* TEXT */)
+                          ]),
+                          _: 2 /* DYNAMIC */
+                        }, 1024 /* DYNAMIC_SLOTS */)
+                      ])
+                    ]),
+                    _: 2 /* DYNAMIC */
+                  }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["class", "onClick"]))
+                }), 128 /* KEYED_FRAGMENT */))
+              ]),
+              _: 2 /* DYNAMIC */
+            }, 1024 /* DYNAMIC_SLOTS */)
+          ]),
+          _: 3 /* FORWARDED */
+        }, 16 /* FULL_PROPS */, ["list"])
+      ])
+    ], 2 /* CLASS */))
+  }
+
+  script.render = render;
+  script.__file = "src/components/transfer/QasTransfer.vue";
+
+  const version = '3.0.0-alpha.2';
+
+  function install (app) {
+    app.component('QasActions', script$q);
+    app.component('QasActionsMenu', script$o);
+    app.component('QasAlert', script$m);
+    app.component('QasAppBar', script$l);
+    app.component('QasAppMenu', script$k);
+    app.component('QasAppsMenu', script$j);
+    app.component('QasAvatar', script$i);
+    app.component('QasBox', script$h);
+    app.component('QasBreakline', script$n);
+    app.component('QasBtn', script$p);
+    app.component('QasCard', script$g);
+    app.component('QasCopy', script$f);
+    app.component('QasDebugger', script$e);
+    app.component('QasDialog', script$d);
+    app.component('QasInput', script$c);
+    app.component('QasLabel', script$b);
+    app.component('QasListItems', script$a);
+    app.component('QasNumericInput', script$9);
+    app.component('QasPasswordInput', script$7);
+    app.component('QasPasswordStrengthChecker', script$8);
+    app.component('QasSearchBox', script$6);
+    app.component('QasSelect', script$5);
+    app.component('QasSelectList', script$4);
+    app.component('QasSignaturePad', script$3);
+    app.component('QasSortable', script$2);
+    app.component('QasTabsGenerator', script$1);
+    app.component('QasTransfer', script);
+
+    app.config.globalProperties.$qas = {
+      error: NotifyError,
+      success: NotifySuccess,
+      dialog: Dialog
+    };
+  }
+
+  var VuePlugin = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    version: version,
+    QasActions: script$q,
+    QasActionsMenu: script$o,
+    QasAlert: script$m,
+    QasAppBar: script$l,
+    QasAppMenu: script$k,
+    QasAppsMenu: script$j,
+    QasAvatar: script$i,
+    QasBox: script$h,
+    QasBreakline: script$n,
+    QasBtn: script$p,
+    QasCard: script$g,
+    QasCopy: script$f,
+    QasDebugger: script$e,
+    QasDialog: script$d,
+    QasInput: script$c,
+    QasLabel: script$b,
+    QasListItems: script$a,
+    QasNumericInput: script$9,
+    QasPasswordInput: script$7,
+    QasPasswordStrengthChecker: script$8,
+    QasSearchBox: script$6,
+    QasSelect: script$5,
+    QasSelectList: script$4,
+    QasSignaturePad: script$3,
+    QasSortable: script$2,
+    QasTabsGenerator: script$1,
+    QasTransfer: script,
+    Dialog: Dialog,
+    NotifyError: NotifyError,
+    NotifySuccess: NotifySuccess,
+    install: install
+  });
+
+  return VuePlugin;
+
+}));