@youcan/celeste 0.6.30 → 0.6.32

package/dist/cjs/select-icon.js

@@ -21,5 +21,5 @@ const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
     };
   }
 });
-const selectIcon = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-5c4a7fcf"]]);
-module.exports = selectIcon;
+const SelectIcon = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-5c4a7fcf"]]);
+module.exports = SelectIcon;

package/dist/cjs/sonner-alert.js

@@ -0,0 +1,41 @@
+"use strict";
+const Mo = require("vue");
+const alert = require("./alert.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "sonner-alert",
+  props: {
+    title: {},
+    description: {},
+    onDismiss: {}
+  },
+  setup(__props) {
+    const props = __props;
+    function handleDismiss() {
+      if (props.onDismiss) {
+        props.onDismiss();
+      }
+    }
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(alert), Mo.mergeProps(props, {
+        class: "sonner-alert",
+        onDismiss: handleDismiss
+      }), Mo.createSlots({
+        title: Mo.withCtx(() => [
+          Mo.createTextVNode(Mo.toDisplayString(props.title), 1)
+        ]),
+        _: 2
+      }, [
+        props.description ? {
+          name: "description",
+          fn: Mo.withCtx(() => [
+            Mo.createTextVNode(Mo.toDisplayString(props.description), 1)
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1040);
+    };
+  }
+});
+const SonnerAlert = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-c8bb23e0"]]);
+module.exports = SonnerAlert;

package/dist/cjs/sonner.js

@@ -0,0 +1,3 @@
+"use strict";
+const sonner_vue_vue_type_script_setup_true_lang = require("./chunks/sonner.js");
+module.exports = sonner_vue_vue_type_script_setup_true_lang._sfc_main;

package/dist/cjs/text-input-affix.js

@@ -23,5 +23,5 @@ const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
     };
   }
 });
-const textInputAffix = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-2d8a1dbc"]]);
-module.exports = textInputAffix;
+const TextInputAffix = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-2d8a1dbc"]]);
+module.exports = TextInputAffix;

package/dist/cjs/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/components/index.d.ts

@@ -10,10 +10,12 @@ export * from './hint-text';
 export * from './label';
 export * from './modal';
 export * from './popover';
+export * from './rich-editor';
 export * from './scroll-area';
 export * from './segmented-control';
 export * from './select';
 export * from './slider';
+export * from './sonner';
 export * from './switch';
 export * from './tab-menu';
 export * from './text-input';

package/dist/components/rich-editor/config.d.ts

@@ -0,0 +1,33 @@
+import { Editor } from '@tiptap/vue-3';
+import { ToolbarChildOption, ToolbarItem } from './types';
+export declare const fullToolbar: import('vue').Ref<({
+    type?: "action" | undefined;
+    slug: string;
+    name?: string | undefined;
+    icon?: string | undefined;
+    active?: (string | Record<string, unknown>) | undefined;
+    children?: {
+        option: string;
+        name: string;
+        icon?: string | undefined;
+        active: string | Record<string, unknown>;
+    }[] | undefined;
+} | {
+    type: "divider";
+})[], ToolbarItem[] | ({
+    type?: "action" | undefined;
+    slug: string;
+    name?: string | undefined;
+    icon?: string | undefined;
+    active?: (string | Record<string, unknown>) | undefined;
+    children?: {
+        option: string;
+        name: string;
+        icon?: string | undefined;
+        active: string | Record<string, unknown>;
+    }[] | undefined;
+} | {
+    type: "divider";
+})[]>;
+export declare function onActionClick(editor: Editor, slug: string, option?: string | null, showLinkBubble?: () => void): void;
+export declare function selectedOption(editor: Editor, children: ToolbarChildOption[]): string;

package/dist/components/rich-editor/extra-settings.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/vue-3';
+type __VLS_Props = {
+    editor: Editor;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/rich-editor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rich-editor';
+export { default as RichEditor } from './rich-editor';

package/dist/components/rich-editor/link-bubble.d.ts

@@ -0,0 +1,11 @@
+import { Editor } from '@tiptap/vue-3';
+type __VLS_Props = {
+    editor: Editor;
+    showSetLinkFromToolbar: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "set-link-closed": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onSet-link-closed"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/rich-editor/rich-editor.d.ts

@@ -0,0 +1,55 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    customToolbar: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    maxLimit: {
+        type: NumberConstructor;
+        default: null;
+    };
+    showExtraSettings: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    customToolbar: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    maxLimit: {
+        type: NumberConstructor;
+        default: null;
+    };
+    showExtraSettings: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: string;
+    placeholder: string;
+    customToolbar: string[];
+    maxLimit: number;
+    showExtraSettings: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/rich-editor/types.d.ts

@@ -0,0 +1,19 @@
+export interface ToolbarChildOption {
+    option: string;
+    name: string;
+    icon?: string;
+    active: string | Record<string, unknown>;
+}
+interface ToolbarAction {
+    type?: 'action';
+    slug: string;
+    name?: string;
+    icon?: string;
+    active?: string | Record<string, unknown>;
+    children?: ToolbarChildOption[];
+}
+interface ToolbarDivider {
+    type: 'divider';
+}
+export type ToolbarItem = ToolbarAction | ToolbarDivider;
+export {};

package/dist/components/sonner/index.d.ts

@@ -0,0 +1,4 @@
+export { default as SonnerAlert } from './sonner-alert';
+export * from './sonner-alert';
+export { default as Sonner } from './sonner';
+export * from './sonner';

package/dist/components/sonner/sonner-alert.d.ts

@@ -0,0 +1,13 @@
+import { AlertProps } from '../alert';
+export interface SonnerAlertProps extends /* @vue-ignore */ Partial<AlertProps> {
+    title: string;
+    description?: string;
+    onDismiss?: () => void;
+}
+declare const _default: import('vue').DefineComponent<SonnerAlertProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SonnerAlertProps> & Readonly<{}>, {
+    size: "xs" | "sm" | "lg";
+    variant: "fill" | "light" | "lighter" | "stroke";
+    state: "information" | "success" | "warning" | "error" | "feature";
+    dismissable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/sonner/sonner.d.ts

@@ -0,0 +1,5 @@
+import { ToasterProps } from 'vue-sonner';
+export interface SonnerProps extends ToasterProps {
+}
+declare const _default: import('vue').DefineComponent<SonnerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SonnerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/es/alert.js

@@ -106,7 +106,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const alert = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a07f0877"]]);
+const Alert = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a07f0877"]]);
 export {
-  alert as default
+  Alert as default
 };

package/dist/es/checkbox-label.js

@@ -1,7 +1,7 @@
 import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, createVNode, renderSlot, createElementVNode, createCommentVNode } from "vue";
 import { useDelegatedProps } from "./use-delegated-props.js";
 import { c as clsx } from "./chunks/clsx.js";
-import { B as Oh, f as O } from "./chunks/index.js";
+import { S as Oh, f as O } from "./chunks/index.js";
 import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
 const _hoisted_1 = { role: "presentation" };
 const _hoisted_2 = {

package/dist/es/chunks/index.js

@@ -1,6 +1,8 @@
 import * as Mo from "vue";
 import { computed, ref, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly, unref, getCurrentInstance, toRef, camelize, defineComponent, Comment, mergeProps, cloneVNode, h, toRefs, renderSlot, onMounted, openBlock, createBlock, withCtx, normalizeProps, guardReactiveProps, reactive, createVNode, createCommentVNode, createElementBlock, Fragment, withKeys, withModifiers, watchEffect, markRaw, nextTick, watchSyncEffect, withDirectives, vShow, createTextVNode, toDisplayString, isRef, resolveDynamicComponent, normalizeStyle, createElementVNode, onUnmounted, renderList, Teleport, onBeforeUnmount, useSlots, onBeforeMount, toHandlers, effectScope, readonly, toHandlerKey, vModelSelect, toRaw, inject, provide, customRef, onBeforeUpdate, onUpdated, mergeDefaults, watchPostEffect } from "vue";
 const sides = ["top", "right", "bottom", "left"];
+const alignments = ["start", "end"];
+const placements = /* @__PURE__ */ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
 const min = Math.min;
 const max = Math.max;
 const round = Math.round;
@@ -385,6 +387,102 @@ const arrow$2 = (options) => ({
     };
   }
 });
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter((placement) => getAlignment(placement) === alignment), ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment)] : allowedPlacements.filter((placement) => getSide(placement) === placement);
+  return allowedPlacementsSortedByAlignment.filter((placement) => {
+    if (alignment) {
+      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);
+    }
+    return true;
+  });
+}
+const autoPlacement$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "autoPlacement",
+    options,
+    async fn(state) {
+      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
+      const {
+        rects,
+        middlewareData,
+        placement,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        crossAxis = false,
+        alignment,
+        allowedPlacements = placements,
+        autoAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const placements$1 = alignment !== void 0 || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
+      const currentPlacement = placements$1[currentIndex];
+      if (currentPlacement == null) {
+        return {};
+      }
+      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)));
+      if (placement !== currentPlacement) {
+        return {
+          reset: {
+            placement: placements$1[0]
+          }
+        };
+      }
+      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
+      const allOverflows = [...((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || [], {
+        placement: currentPlacement,
+        overflows: currentOverflows
+      }];
+      const nextPlacement = placements$1[currentIndex + 1];
+      if (nextPlacement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: nextPlacement
+          }
+        };
+      }
+      const placementsSortedByMostSpace = allOverflows.map((d) => {
+        const alignment2 = getAlignment(d.placement);
+        return [d.placement, alignment2 && crossAxis ? (
+          // Check along the mainAxis and main crossAxis side.
+          d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0)
+        ) : (
+          // Check only the mainAxis.
+          d.overflows[0]
+        ), d.overflows];
+      }).sort((a2, b) => a2[1] - b[1]);
+      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter((d) => d[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        getAlignment(d[0]) ? 2 : 3
+      ).every((v) => v <= 0));
+      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
+      if (resetPlacement !== placement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: resetPlacement
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
 const flip$1 = function(options) {
   if (options === void 0) {
     options = {};
@@ -423,7 +521,7 @@ const flip$1 = function(options) {
       if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
         fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
-      const placements = [initialPlacement, ...fallbackPlacements];
+      const placements2 = [initialPlacement, ...fallbackPlacements];
       const overflow = await detectOverflow(state, detectOverflowOptions);
       const overflows = [];
       let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
@@ -441,7 +539,7 @@ const flip$1 = function(options) {
       if (!overflows.every((side2) => side2 <= 0)) {
         var _middlewareData$flip2, _overflowsData$filter;
         const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
-        const nextPlacement = placements[nextIndex];
+        const nextPlacement = placements2[nextIndex];
         if (nextPlacement) {
           return {
             data: {
@@ -549,6 +647,124 @@ const hide$1 = function(options) {
     }
   };
 };
+function getBoundingRect(rects) {
+  const minX = min(...rects.map((rect) => rect.left));
+  const minY = min(...rects.map((rect) => rect.top));
+  const maxX = max(...rects.map((rect) => rect.right));
+  const maxY = max(...rects.map((rect) => rect.bottom));
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function getRectsByLine(rects) {
+  const sortedRects = rects.slice().sort((a2, b) => a2.y - b.y);
+  const groups = [];
+  let prevRect = null;
+  for (let i = 0; i < sortedRects.length; i++) {
+    const rect = sortedRects[i];
+    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {
+      groups.push([rect]);
+    } else {
+      groups[groups.length - 1].push(rect);
+    }
+    prevRect = rect;
+  }
+  return groups.map((rect) => rectToClientRect(getBoundingRect(rect)));
+}
+const inline$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "inline",
+    options,
+    async fn(state) {
+      const {
+        placement,
+        elements,
+        rects,
+        platform: platform2,
+        strategy
+      } = state;
+      const {
+        padding = 2,
+        x,
+        y
+      } = evaluate(options, state);
+      const nativeClientRects = Array.from(await (platform2.getClientRects == null ? void 0 : platform2.getClientRects(elements.reference)) || []);
+      const clientRects = getRectsByLine(nativeClientRects);
+      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));
+      const paddingObject = getPaddingObject(padding);
+      function getBoundingClientRect2() {
+        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {
+          return clientRects.find((rect) => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
+        }
+        if (clientRects.length >= 2) {
+          if (getSideAxis(placement) === "y") {
+            const firstRect = clientRects[0];
+            const lastRect = clientRects[clientRects.length - 1];
+            const isTop = getSide(placement) === "top";
+            const top2 = firstRect.top;
+            const bottom2 = lastRect.bottom;
+            const left2 = isTop ? firstRect.left : lastRect.left;
+            const right2 = isTop ? firstRect.right : lastRect.right;
+            const width2 = right2 - left2;
+            const height2 = bottom2 - top2;
+            return {
+              top: top2,
+              bottom: bottom2,
+              left: left2,
+              right: right2,
+              width: width2,
+              height: height2,
+              x: left2,
+              y: top2
+            };
+          }
+          const isLeftSide = getSide(placement) === "left";
+          const maxRight = max(...clientRects.map((rect) => rect.right));
+          const minLeft = min(...clientRects.map((rect) => rect.left));
+          const measureRects = clientRects.filter((rect) => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
+          const top = measureRects[0].top;
+          const bottom = measureRects[measureRects.length - 1].bottom;
+          const left = minLeft;
+          const right = maxRight;
+          const width = right - left;
+          const height = bottom - top;
+          return {
+            top,
+            bottom,
+            left,
+            right,
+            width,
+            height,
+            x: left,
+            y: top
+          };
+        }
+        return fallback;
+      }
+      const resetRects = await platform2.getElementRects({
+        reference: {
+          getBoundingClientRect: getBoundingClientRect2
+        },
+        floating: elements.floating,
+        strategy
+      });
+      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {
+        return {
+          reset: {
+            rects: resetRects
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
 async function convertValueToCoords(state, options) {
   const {
     placement,
@@ -1548,11 +1764,13 @@ function autoUpdate(reference, floating, update, options) {
   };
 }
 const offset = offset$1;
+const autoPlacement = autoPlacement$1;
 const shift = shift$1;
 const flip = flip$1;
 const size = size$1;
 const hide = hide$1;
 const arrow$1 = arrow$2;
+const inline = inline$1;
 const limitShift = limitShift$1;
 const computePosition = (reference, floating, options) => {
   const cache = /* @__PURE__ */ new Map();
@@ -8975,82 +9193,91 @@ const av = /* @__PURE__ */ defineComponent({
   }
 });
 export {
-  rh as $,
+  Xv as $,
   At as A,
-  Oh as B,
+  hide as B,
   Ch as C,
-  qv as D,
-  Wv as E,
+  inline as D,
+  computePosition as E,
   Fy as F,
   Gy as G,
-  Qv as H,
-  nm as I,
-  Jv as J,
+  yg as H,
+  gg as I,
+  Cg as J,
   Kv as K,
-  Hv as L,
-  My as M,
+  bg as L,
+  lv as M,
   Ny as N,
   Oy as O,
-  tm as P,
+  sv as P,
   Qf as Q,
-  fh as R,
-  ch as S,
-  hh as T,
-  Uv as U,
+  My as R,
+  Oh as S,
+  qv as T,
+  Wv as U,
   Vy as V,
   Wy as W,
-  Xv as X,
+  Qv as X,
   Yv as Y,
   Zv as Z,
-  ph as _,
+  nm as _,
   Gl as a,
-  sh as a0,
-  Dv as a1,
-  Eu as a2,
-  xu as a3,
-  Pu as a4,
-  Du as a5,
-  bs as a6,
-  ws as a7,
-  _s as a8,
-  xs as a9,
-  gs as aa,
-  zy as ab,
-  Ky as ac,
-  Xy as ad,
-  jy as ae,
-  Yy as af,
-  Uy as ag,
-  Ly as ah,
-  eg as ai,
-  Qy as aj,
-  Lg as ak,
-  zg as al,
-  Kg as am,
-  jg as an,
-  Hg as ao,
-  Wg as ap,
+  Jv as a0,
+  Hv as a1,
+  tm as a2,
+  Uv as a3,
+  fh as a4,
+  ch as a5,
+  hh as a6,
+  ph as a7,
+  rh as a8,
+  sh as a9,
+  Dv as aa,
+  Eu as ab,
+  xu as ac,
+  Pu as ad,
+  Du as ae,
+  bs as af,
+  ws as ag,
+  _s as ah,
+  xs as ai,
+  gs as aj,
+  zy as ak,
+  Ky as al,
+  Xy as am,
+  jy as an,
+  Yy as ao,
+  Uy as ap,
+  Ly as aq,
+  eg as ar,
+  Qy as as,
+  Lg as at,
+  zg as au,
+  Kg as av,
+  jg as aw,
+  Hg as ax,
+  Wg as ay,
   bh as b,
   tg as c,
   ag as d,
   eu as e,
   O as f,
-  yg as g,
+  flip as g,
   hg as h,
   ih as i,
   jv as j,
   ky as k,
-  gg as l,
+  offset as l,
   mg as m,
   ng as n,
   og as o,
-  Cg as p,
+  arrow$1 as p,
   qy as q,
-  bg as r,
-  lv as s,
+  size as r,
+  shift as s,
   tu as t,
   uh as u,
-  sv as v,
+  autoPlacement as v,
   wh as w,
   xe as x,
   ys as y,