@bildvitta/quasar-ui-asteroid 2.12.2 → 2.14.0

package/dist/asteroid.cjs.js

@@ -0,0 +1,3792 @@
+/*!
+* @bildvitta/quasar-ui-asteroid v3.0.0-alpha.2
+* (c) 2022 Bild & Vitta <systemteam@bild.com.br>
+* Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var quasar = require('quasar');
+var AutoNumeric = require('autonumeric');
+var Fuse = require('fuse.js');
+var lodashEs = require('lodash-es');
+var SignaturePad = require('signature_pad');
+var Sortable = require('sortablejs');
+
+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
+  };
+}
+
+exports.Dialog = Dialog;
+exports.NotifyError = NotifyError;
+exports.NotifySuccess = NotifySuccess;
+exports.QasActions = script$q;
+exports.QasActionsMenu = script$o;
+exports.QasAlert = script$m;
+exports.QasAppBar = script$l;
+exports.QasAppMenu = script$k;
+exports.QasAppsMenu = script$j;
+exports.QasAvatar = script$i;
+exports.QasBox = script$h;
+exports.QasBreakline = script$n;
+exports.QasBtn = script$p;
+exports.QasCard = script$g;
+exports.QasCopy = script$f;
+exports.QasDebugger = script$e;
+exports.QasDialog = script$d;
+exports.QasInput = script$c;
+exports.QasLabel = script$b;
+exports.QasListItems = script$a;
+exports.QasNumericInput = script$9;
+exports.QasPasswordInput = script$7;
+exports.QasPasswordStrengthChecker = script$8;
+exports.QasSearchBox = script$6;
+exports.QasSelect = script$5;
+exports.QasSelectList = script$4;
+exports.QasSignaturePad = script$3;
+exports.QasSortable = script$2;
+exports.QasTabsGenerator = script$1;
+exports.QasTransfer = script;
+exports.install = install;
+exports.version = version;