code:
/*! Element Plus v2.8.6 */

var uzUz = {
  name: "uz-uz",
  el: {
    breadcrumb: {
      label: "Breadcrumb"
    },
    colorpicker: {
      confirm: "Qabul qilish",
      clear: "Tozalash"
    },
    datepicker: {
      now: "Hozir",
      today: "Bugun",
      cancel: "Bekor qilish",
      clear: "Tozalash",
      confirm: "Qabul qilish",
      selectDate: "Kunni tanlash",
      selectTime: "Soatni tanlash",
      startDate: "Boshlanish sanasi",
      startTime: "Boshlanish vaqti",
      endDate: "Tugash sanasi",
      endTime: "Tugash vaqti",
      prevYear: "O\u02BBtgan yil",
      nextYear: "Kelgusi yil",
      prevMonth: "O\u02BBtgan oy",
      nextMonth: "Kelgusi oy",
      year: "Yil",
      month1: "Yanvar",
      month2: "Fevral",
      month3: "Mart",
      month4: "Aprel",
      month5: "May",
      month6: "Iyun",
      month7: "Iyul",
      month8: "Avgust",
      month9: "Sentabr",
      month10: "Oktabr",
      month11: "Noyabr",
      month12: "Dekabr",
      week: "Hafta",
      weeks: {
        sun: "Yak",
        mon: "Dush",
        tue: "Sesh",
        wed: "Chor",
        thu: "Pay",
        fri: "Jum",
        sat: "Shan"
      },
      months: {
        jan: "Yan",
        feb: "Fev",
        mar: "Mar",
        apr: "Apr",
        may: "May",
        jun: "Iyun",
        jul: "Iyul",
        aug: "Avg",
        sep: "Sen",
        oct: "Okt",
        nov: "Noy",
        dec: "Dek"
      }
    },
    select: {
      loading: "Yuklanmoqda",
      noMatch: "Mos ma\u02BClumot yo\u02BBq",
      noData: "Ma\u02BClumot yo\u02BBq",
      placeholder: "Tanladizngiz"
    },
    mention: {
      loading: "Yuklanmoqda"
    },
    cascader: {
      noMatch: "Mos ma\u02BClumot topilmadi",
      loading: "Yuklanmoqda",
      placeholder: "Tanlash",
      noData: "Ma\u02BClumot yo\u02BBq"
    },
    pagination: {
      goto: "O\u02BBtish",
      pagesize: "/sahifa",
      total: "Barchasi {total} ta",
      pageClassifier: "",
      page: "Page",
      prev: "Go to previous page",
      next: "Go to next page",
      currentPage: "page {pager}",
      prevPages: "Previous {pager} pages",
      nextPages: "Next {pager} pages"
    },
    messagebox: {
      title: "Xabar",
      confirm: "Qabul qilish",
      cancel: "Bekor qilish",
      error: "Xatolik"
    },
    upload: {
      deleteTip: "O\u02BBchirish tugmasini bosib o\u02BBchiring",
      delete: "O\u02BBchirish",
      preview: "Oldin ko\u02BBrish",
      continue: "Davom qilish"
    },
    table: {
      emptyText: "Bo\u02BBsh",
      confirmFilter: "Qabul qilish",
      resetFilter: "Oldingi holatga qaytarish",
      clearFilter: "Jami",
      sumText: "Summasi"
    },
    tree: {
      emptyText: "Ma\u02BClumot yo\u02BBq"
    },
    transfer: {
      noMatch: "Mos ma\u02BClumot topilmadi",
      noData: "Ma\u02BClumot yo\u02BBq",
      titles: ["1-jadval", "2-jadval"],
      filterPlaceholder: "Kalit so\u02BBzni kiriting",
      noCheckedFormat: "{total} ta element",
      hasCheckedFormat: "{checked}/{total} ta belgilandi"
    },
    image: {
      error: "Xatolik"
    },
    pageHeader: {
      title: "Orqaga"
    },
    popconfirm: {
      confirmButtonText: "Yes",
      cancelButtonText: "No"
    },
    carousel: {
      leftArrow: "Carousel arrow left",
      rightArrow: "Carousel arrow right",
      indicator: "Carousel switch to index {index}"
    }
  }
};

export { uzUz as default };


code:
/*! Element Plus v2.8.6 */

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ElementPlusLocaleVi = factory());
})(this, (function () { 'use strict';

  var vi = {
    name: "vi",
    el: {
      breadcrumb: {
        label: "Breadcrumb"
      },
      colorpicker: {
        confirm: "OK",
        clear: "X\xF3a"
      },
      datepicker: {
        now: "Hi\u1EC7n t\u1EA1i",
        today: "H\xF4m nay",
        cancel: "H\u1EE7y",
        clear: "X\xF3a",
        confirm: "OK",
        selectDate: "Ch\u1ECDn ng\xE0y",
        selectTime: "Ch\u1ECDn gi\u1EDD",
        startDate: "Ng\xE0y b\u1EAFt \u0111\u1EA7u",
        startTime: "Th\u1EDDi gian b\u1EAFt \u0111\u1EA7u",
        endDate: "Ng\xE0y k\u1EBFt th\xFAc",
        endTime: "Th\u1EDDi gian k\u1EBFt th\xFAc",
        prevYear: "N\u0103m tr\u01B0\u1EDBc",
        nextYear: "N\u0103m t\u1EDBi",
        prevMonth: "Th\xE1ng tr\u01B0\u1EDBc",
        nextMonth: "Th\xE1ng t\u1EDBi",
        year: "N\u0103m",
        month1: "Th\xE1ng 1",
        month2: "Th\xE1ng 2",
        month3: "Th\xE1ng 3",
        month4: "Th\xE1ng 4",
        month5: "Th\xE1ng 5",
        month6: "Th\xE1ng 6",
        month7: "Th\xE1ng 7",
        month8: "Th\xE1ng 8",
        month9: "Th\xE1ng 9",
        month10: "Th\xE1ng 10",
        month11: "Th\xE1ng 11",
        month12: "Th\xE1ng 12",
        weeks: {
          sun: "CN",
          mon: "T2",
          tue: "T3",
          wed: "T4",
          thu: "T5",
          fri: "T6",
          sat: "T7"
        },
        months: {
          jan: "Th.1",
          feb: "Th.2",
          mar: "Th.3",
          apr: "Th.4",
          may: "Th.5",
          jun: "Th.6",
          jul: "Th.7",
          aug: "Th.8",
          sep: "Th.9",
          oct: "Th.10",
          nov: "Th.11",
          dec: "Th.12"
        }
      },
      select: {
        loading: "\u0110ang t\u1EA3i",
        noMatch: "D\u1EEF li\u1EC7u kh\xF4ng ph\xF9 h\u1EE3p",
        noData: "Kh\xF4ng t\xECm th\u1EA5y d\u1EEF li\u1EC7u",
        placeholder: "Ch\u1ECDn"
      },
      mention: {
        loading: "\u0110ang t\u1EA3i"
      },
      cascader: {
        noMatch: "D\u1EEF li\u1EC7u kh\xF4ng ph\xF9 h\u1EE3p",
        loading: "\u0110ang t\u1EA3i",
        placeholder: "Ch\u1ECDn",
        noData: "Kh\xF4ng t\xECm th\u1EA5y d\u1EEF li\u1EC7u"
      },
      pagination: {
        goto: "Nh\u1EA3y t\u1EDBi",
        pagesize: "/trang",
        total: "T\u1ED5ng {total}",
        pageClassifier: "",
        page: "Page",
        prev: "Go to previous page",
        next: "Go to next page",
        currentPage: "page {pager}",
        prevPages: "Previous {pager} pages",
        nextPages: "Next {pager} pages"
      },
      messagebox: {
        title: "Th\xF4ng b\xE1o",
        confirm: "OK",
        cancel: "H\u1EE7y",
        error: "D\u1EEF li\u1EC7u kh\xF4ng h\u1EE3p l\u1EC7"
      },
      upload: {
        deleteTip: "Nh\u1EA5n xo\xE1 \u0111\u1EC3 xo\xE1",
        delete: "X\xF3a",
        preview: "Xem tr\u01B0\u1EDBc",
        continue: "Ti\u1EBFp t\u1EE5c"
      },
      table: {
        emptyText: "Kh\xF4ng c\xF3 d\u1EEF li\u1EC7u",
        confirmFilter: "X\xE1c nh\u1EADn",
        resetFilter: "L\xE0m m\u1EDBi",
        clearFilter: "X\xF3a h\u1EBFt",
        sumText: "T\u1ED5ng"
      },
      tour: {
        next: "Ti\u1EBFp",
        previous: "Tr\u01B0\u1EDBc",
        finish: "Ho\xE0n th\xE0nh"
      },
      tree: {
        emptyText: "Kh\xF4ng c\xF3 d\u1EEF li\u1EC7u"
      },
      transfer: {
        noMatch: "D\u1EEF li\u1EC7u kh\xF4ng ph\xF9 h\u1EE3p",
        noData: "Kh\xF4ng t\xECm th\u1EA5y d\u1EEF li\u1EC7u",
        titles: ["Danh s\xE1ch 1", "Danh s\xE1ch 2"],
        filterPlaceholder: "Nh\u1EADp t\u1EEB kh\xF3a",
        noCheckedFormat: "{total} m\u1EE5c",
        hasCheckedFormat: "{checked}/{total} \u0111\xE3 ch\u1ECDn "
      },
      image: {
        error: "L\u1ED6I"
      },
      pageHeader: {
        title: "Quay l\u1EA1i"
      },
      popconfirm: {
        confirmButtonText: "Ok",
        cancelButtonText: "Hu\u1EF7"
      },
      carousel: {
        leftArrow: "Carousel arrow left",
        rightArrow: "Carousel arrow right",
        indicator: "Carousel switch to index {index}"
      }
    }
  };

  return vi;

}));

license: mit


code:
/*! Element Plus v2.8.6 */

var vi = {
  name: "vi",
  el: {
    breadcrumb: {
      label: "Breadcrumb"
    },
    colorpicker: {
      confirm: "OK",
      clear: "X\xF3a"
    },
    datepicker: {
      now: "Hi\u1EC7n t\u1EA1i",
      today: "H\xF4m nay",
      cancel: "H\u1EE7y",
      clear: "X\xF3a",
      confirm: "OK",
      selectDate: "Ch\u1ECDn ng\xE0y",
      selectTime: "Ch\u1ECDn gi\u1EDD",
      startDate: "Ng\xE0y b\u1EAFt \u0111\u1EA7u",
      startTime: "Th\u1EDDi gian b\u1EAFt \u0111\u1EA7u",
      endDate: "Ng\xE0y k\u1EBFt th\xFAc",
      endTime: "Th\u1EDDi gian k\u1EBFt th\xFAc",
      prevYear: "N\u0103m tr\u01B0\u1EDBc",
      nextYear: "N\u0103m t\u1EDBi",
      prevMonth: "Th\xE1ng tr\u01B0\u1EDBc",
      nextMonth: "Th\xE1ng t\u1EDBi",
      year: "N\u0103m",
      month1: "Th\xE1ng 1",
      month2: "Th\xE1ng 2",
      month3: "Th\xE1ng 3",
      month4: "Th\xE1ng 4",
      month5: "Th\xE1ng 5",
      month6: "Th\xE1ng 6",
      month7: "Th\xE1ng 7",
      month8: "Th\xE1ng 8",
      month9: "Th\xE1ng 9",
      month10: "Th\xE1ng 10",
      month11: "Th\xE1ng 11",
      month12: "Th\xE1ng 12",
      weeks: {
        sun: "CN",
        mon: "T2",
        tue: "T3",
        wed: "T4",
        thu: "T5",
        fri: "T6",
        sat: "T7"
      },
      months: {
        jan: "Th.1",
        feb: "Th.2",
        mar: "Th.3",
        apr: "Th.4",
        may: "Th.5",
        jun: "Th.6",
        jul: "Th.7",
        aug: "Th.8",
        sep: "Th.9",
        oct: "Th.10",
        nov: "Th.11",
        dec: "Th.12"
      }
    },
    select: {
      loading: "\u0110ang t\u1EA3i",
      noMatch: "D\u1EEF li\u1EC7u kh\xF4ng ph\xF9 h\u1EE3p",
      noData: "Kh\xF4ng t\xECm th\u1EA5y d\u1EEF li\u1EC7u",
      placeholder: "Ch\u1ECDn"
    },
    mention: {
      loading: "\u0110ang t\u1EA3i"
    },
    cascader: {
      noMatch: "D\u1EEF li\u1EC7u kh\xF4ng ph\xF9 h\u1EE3p",
      loading: "\u0110ang t\u1EA3i",
      placeholder: "Ch\u1ECDn",
      noData: "Kh\xF4ng t\xECm th\u1EA5y d\u1EEF li\u1EC7u"
    },
    pagination: {
      goto: "Nh\u1EA3y t\u1EDBi",
      pagesize: "/trang",
      total: "T\u1ED5ng {total}",
      pageClassifier: "",
      page: "Page",
      prev: "Go to previous page",
      next: "Go to next page",
      currentPage: "page {pager}",
      prevPages: "Previous {pager} pages",
      nextPages: "Next {pager} pages"
    },
    messagebox: {
      title: "Th\xF4ng b\xE1o",
      confirm: "OK",
      cancel: "H\u1EE7y",
      error: "D\u1EEF li\u1EC7u kh\xF4ng h\u1EE3p l\u1EC7"
    },
    upload: {
      deleteTip: "Nh\u1EA5n xo\xE1 \u0111\u1EC3 xo\xE1",
      delete: "X\xF3a",
      preview: "Xem tr\u01B0\u1EDBc",
      continue: "Ti\u1EBFp t\u1EE5c"
    },
    table: {
      emptyText: "Kh\xF4ng c\xF3 d\u1EEF li\u1EC7u",
      confirmFilter: "X\xE1c nh\u1EADn",
      resetFilter: "L\xE0m m\u1EDBi",
      clearFilter: "X\xF3a h\u1EBFt",
      sumText: "T\u1ED5ng"
    },
    tour: {
      next: "Ti\u1EBFp",
      previous: "Tr\u01B0\u1EDBc",
      finish: "Ho\xE0n th\xE0nh"
    },
    tree: {
      emptyText: "Kh\xF4ng c\xF3 d\u1EEF li\u1EC7u"
    },
    transfer: {
      noMatch: "D\u1EEF li\u1EC7u kh\xF4ng ph\xF9 h\u1EE3p",
      noData: "Kh\xF4ng t\xECm th\u1EA5y d\u1EEF li\u1EC7u",
      titles: ["Danh s\xE1ch 1", "Danh s\xE1ch 2"],
      filterPlaceholder: "Nh\u1EADp t\u1EEB kh\xF3a",
      noCheckedFormat: "{total} m\u1EE5c",
      hasCheckedFormat: "{checked}/{total} \u0111\xE3 ch\u1ECDn "
    },
    image: {
      error: "L\u1ED6I"
    },
    pageHeader: {
      title: "Quay l\u1EA1i"
    },
    popconfirm: {
      confirmButtonText: "Ok",
      cancelButtonText: "Hu\u1EF7"
    },
    carousel: {
      leftArrow: "Carousel arrow left",
      rightArrow: "Carousel arrow right",
      indicator: "Carousel switch to index {index}"
    }
  }
};

export { vi as default };


code:
/*! Element Plus v2.8.6 */

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ElementPlusLocaleZhCn = factory());
})(this, (function () { 'use strict';

  var zhCn = {
    name: "zh-cn",
    el: {
      breadcrumb: {
        label: "\u9762\u5305\u5C51"
      },
      colorpicker: {
        confirm: "\u786E\u5B9A",
        clear: "\u6E05\u7A7A",
        defaultLabel: "\u989C\u8272\u9009\u62E9\u5668",
        description: "\u5F53\u524D\u989C\u8272 {color}\uFF0C\u6309 Enter \u952E\u9009\u62E9\u65B0\u989C\u8272",
        alphaLabel: "\u9009\u62E9\u900F\u660E\u5EA6\u7684\u503C"
      },
      datepicker: {
        now: "\u6B64\u523B",
        today: "\u4ECA\u5929",
        cancel: "\u53D6\u6D88",
        clear: "\u6E05\u7A7A",
        confirm: "\u786E\u5B9A",
        dateTablePrompt: "\u4F7F\u7528\u65B9\u5411\u952E\u4E0E Enter \u952E\u53EF\u9009\u62E9\u65E5\u671F",
        monthTablePrompt: "\u4F7F\u7528\u65B9\u5411\u952E\u4E0E Enter \u952E\u53EF\u9009\u62E9\u6708\u4EFD",
        yearTablePrompt: "\u4F7F\u7528\u65B9\u5411\u952E\u4E0E Enter \u952E\u53EF\u9009\u62E9\u5E74\u4EFD",
        selectedDate: "\u5DF2\u9009\u65E5\u671F",
        selectDate: "\u9009\u62E9\u65E5\u671F",
        selectTime: "\u9009\u62E9\u65F6\u95F4",
        startDate: "\u5F00\u59CB\u65E5\u671F",
        startTime: "\u5F00\u59CB\u65F6\u95F4",
        endDate: "\u7ED3\u675F\u65E5\u671F",
        endTime: "\u7ED3\u675F\u65F6\u95F4",
        prevYear: "\u524D\u4E00\u5E74",
        nextYear: "\u540E\u4E00\u5E74",
        prevMonth: "\u4E0A\u4E2A\u6708",
        nextMonth: "\u4E0B\u4E2A\u6708",
        year: "\u5E74",
        month1: "1 \u6708",
        month2: "2 \u6708",
        month3: "3 \u6708",
        month4: "4 \u6708",
        month5: "5 \u6708",
        month6: "6 \u6708",
        month7: "7 \u6708",
        month8: "8 \u6708",
        month9: "9 \u6708",
        month10: "10 \u6708",
        month11: "11 \u6708",
        month12: "12 \u6708",
        weeks: {
          sun: "\u65E5",
          mon: "\u4E00",
          tue: "\u4E8C",
          wed: "\u4E09",
          thu: "\u56DB",
          fri: "\u4E94",
          sat: "\u516D"
        },
        weeksFull: {
          sun: "\u661F\u671F\u65E5",
          mon: "\u661F\u671F\u4E00",
          tue: "\u661F\u671F\u4E8C",
          wed: "\u661F\u671F\u4E09",
          thu: "\u661F\u671F\u56DB",
          fri: "\u661F\u671F\u4E94",
          sat: "\u661F\u671F\u516D"
        },
        months: {
          jan: "\u4E00\u6708",
          feb: "\u4E8C\u6708",
          mar: "\u4E09\u6708",
          apr: "\u56DB\u6708",
          may: "\u4E94\u6708",
          jun: "\u516D\u6708",
          jul: "\u4E03\u6708",
          aug: "\u516B\u6708",
          sep: "\u4E5D\u6708",
          oct: "\u5341\u6708",
          nov: "\u5341\u4E00\u6708",
          dec: "\u5341\u4E8C\u6708"
        }
      },
      inputNumber: {
        decrease: "\u51CF\u5C11\u6570\u503C",
        increase: "\u589E\u52A0\u6570\u503C"
      },
      select: {
        loading: "\u52A0\u8F7D\u4E2D",
        noMatch: "\u65E0\u5339\u914D\u6570\u636E",
        noData: "\u65E0\u6570\u636E",
        placeholder: "\u8BF7\u9009\u62E9"
      },
      dropdown: {
        toggleDropdown: "\u5207\u6362\u4E0B\u62C9\u9009\u9879"
      },
      mention: {
        loading: "\u52A0\u8F7D\u4E2D"
      },
      cascader: {
        noMatch: "\u65E0\u5339\u914D\u6570\u636E",
        loading: "\u52A0\u8F7D\u4E2D",
        placeholder: "\u8BF7\u9009\u62E9",
        noData: "\u6682\u65E0\u6570\u636E"
      },
      pagination: {
        goto: "\u524D\u5F80",
        pagesize: "\u6761/\u9875",
        total: "\u5171 {total} \u6761",
        pageClassifier: "\u9875",
        page: "\u9875",
        prev: "\u4E0A\u4E00\u9875",
        next: "\u4E0B\u4E00\u9875",
        currentPage: "\u7B2C {pager} \u9875",
        prevPages: "\u5411\u524D {pager} \u9875",
        nextPages: "\u5411\u540E {pager} \u9875",
        deprecationWarning: "\u4F60\u4F7F\u7528\u4E86\u4E00\u4E9B\u5DF2\u88AB\u5E9F\u5F03\u7684\u7528\u6CD5\uFF0C\u8BF7\u53C2\u8003 el-pagination \u7684\u5B98\u65B9\u6587\u6863"
      },
      dialog: {
        close: "\u5173\u95ED\u6B64\u5BF9\u8BDD\u6846"
      },
      drawer: {
        close: "\u5173\u95ED\u6B64\u5BF9\u8BDD\u6846"
      },
      messagebox: {
        title: "\u63D0\u793A",
        confirm: "\u786E\u5B9A",
        cancel: "\u53D6\u6D88",
        error: "\u8F93\u5165\u7684\u6570\u636E\u4E0D\u5408\u6CD5!",
        close: "\u5173\u95ED\u6B64\u5BF9\u8BDD\u6846"
      },
      upload: {
        deleteTip: "\u6309 delete \u952E\u53EF\u5220\u9664",
        delete: "\u5220\u9664",
        preview: "\u67E5\u770B\u56FE\u7247",
        continue: "\u7EE7\u7EED\u4E0A\u4F20"
      },
      slider: {
        defaultLabel: "\u6ED1\u5757\u4ECB\u4E8E {min} \u81F3 {max}",
        defaultRangeStartLabel: "\u9009\u62E9\u8D77\u59CB\u503C",
        defaultRangeEndLabel: "\u9009\u62E9\u7ED3\u675F\u503C"
      },
      table: {
        emptyText: "\u6682\u65E0\u6570\u636E",
        confirmFilter: "\u7B5B\u9009",
        resetFilter: "\u91CD\u7F6E",
        clearFilter: "\u5168\u90E8",
        sumText: "\u5408\u8BA1"
      },
      tour: {
        next: "\u4E0B\u4E00\u6B65",
        previous: "\u4E0A\u4E00\u6B65",
        finish: "\u7ED3\u675F\u5BFC\u89C8"
      },
      tree: {
        emptyText: "\u6682\u65E0\u6570\u636E"
      },
      transfer: {
        noMatch: "\u65E0\u5339\u914D\u6570\u636E",
        noData: "\u65E0\u6570\u636E",
        titles: ["\u5217\u8868 1", "\u5217\u8868 2"],
        filterPlaceholder: "\u8BF7\u8F93\u5165\u641C\u7D22\u5185\u5BB9",
        noCheckedFormat: "\u5171 {total} \u9879",
        hasCheckedFormat: "\u5DF2\u9009 {checked}/{total} \u9879"
      },
      image: {
        error: "\u52A0\u8F7D\u5931\u8D25"
      },
      pageHeader: {
        title: "\u8FD4\u56DE"
      },
      popconfirm: {
        confirmButtonText: "\u786E\u5B9A",
        cancelButtonText: "\u53D6\u6D88"
      },
      carousel: {
        leftArrow: "\u4E0A\u4E00\u5F20\u5E7B\u706F\u7247",
        rightArrow: "\u4E0B\u4E00\u5F20\u5E7B\u706F\u7247",
        indicator: "\u5E7B\u706F\u7247\u5207\u6362\u81F3\u7D22\u5F15 {index}"
      }
    }
  };

  return zhCn;

}));


code:
/*! Element Plus v2.8.6 */

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.ElementPlusLocaleZhTw = factory());
})(this, (function () { 'use strict';

  var zhTw = {
    name: "zh-tw",
    el: {
      breadcrumb: {
        label: "\u9762\u5305\u5C51"
      },
      colorpicker: {
        confirm: "\u78BA\u8A8D",
        clear: "\u6E05\u7A7A",
        defaultLabel: "\u8272\u5F69\u9078\u64C7\u5668",
        description: "\u76EE\u524D\u8272\u5F69\u70BA {color}\u3002\u6309\u4E00\u4E0B Enter \u4EE5\u9078\u64C7\u65B0\u8272\u5F69\u3002",
        alphaLabel: "\u9078\u64C7\u900F\u660E\u5EA6\u7684\u503C"
      },
      datepicker: {
        now: "\u73FE\u5728",
        today: "\u4ECA\u5929",
        cancel: "\u53D6\u6D88",
        clear: "\u6E05\u7A7A",
        confirm: "\u78BA\u8A8D",
        dateTablePrompt: "\u4F7F\u7528\u65B9\u5411\u9375\u8207 Enter \u9375\u4EE5\u9078\u64C7\u65E5\u671F",
        monthTablePrompt: "\u4F7F\u7528\u65B9\u5411\u9375\u8207 Enter \u9375\u4EE5\u9078\u64C7\u6708\u4EFD",
        yearTablePrompt: "\u4F7F\u7528\u65B9\u5411\u9375\u8207 Enter \u9375\u4EE5\u9078\u64C7\u5E74\u4EFD",
        selectedDate: "\u5DF2\u9078\u65E5\u671F",
        selectDate: "\u9078\u64C7\u65E5\u671F",
        selectTime: "\u9078\u64C7\u6642\u9593",
        startDate: "\u958B\u59CB\u65E5\u671F",
        startTime: "\u958B\u59CB\u6642\u9593",
        endDate: "\u7D50\u675F\u65E5\u671F",
        endTime: "\u7D50\u675F\u6642\u9593",
        prevYear: "\u524D\u4E00\u5E74",
        nextYear: "\u5F8C\u4E00\u5E74",
        prevMonth: "\u4E0A\u500B\u6708",
        nextMonth: "\u4E0B\u500B\u6708",
        year: "\u5E74",
        month1: "1 \u6708",
        month2: "2 \u6708",
        month3: "3 \u6708",
        month4: "4 \u6708",
        month5: "5 \u6708",
        month6: "6 \u6708",
        month7: "7 \u6708",
        month8: "8 \u6708",
        month9: "9 \u6708",
        month10: "10 \u6708",
        month11: "11 \u6708",
        month12: "12 \u6708",
        weeks: {
          sun: "\u65E5",
          mon: "\u4E00",
          tue: "\u4E8C",
          wed: "\u4E09",
          thu: "\u56DB",
          fri: "\u4E94",
          sat: "\u516D"
        },
        weeksFull: {
          sun: "\u661F\u671F\u65E5",
          mon: "\u661F\u671F\u4E00",
          tue: "\u661F\u671F\u4E8C",
          wed: "\u661F\u671F\u4E09",
          thu: "\u661F\u671F\u56DB",
          fri: "\u661F\u671F\u4E94",
          sat: "\u661F\u671F\u516D"
        },
        months: {
          jan: "\u4E00\u6708",
          feb: "\u4E8C\u6708",
          mar: "\u4E09\u6708",
          apr: "\u56DB\u6708",
          may: "\u4E94\u6708",
          jun: "\u516D\u6708",
          jul: "\u4E03\u6708",
          aug: "\u516B\u6708",
          sep: "\u4E5D\u6708",
          oct: "\u5341\u6708",
          nov: "\u5341\u4E00\u6708",
          dec: "\u5341\u4E8C\u6708"
        }
      },
      inputNumber: {
        decrease: "\u6E1B\u5C11\u6578\u503C",
        increase: "\u589E\u52A0\u6578\u503C"
      },
      select: {
        loading: "\u8F09\u5165\u4E2D",
        noMatch: "\u7121\u76F8\u7B26\u8CC7\u6599",
        noData: "\u7121\u8CC7\u6599",
        placeholder: "\u8ACB\u9078\u64C7"
      },
      mention: {
        loading: "\u8F09\u5165\u4E2D"
      },
      dropdown: {
        toggleDropdown: "\u5207\u63DB\u4E0B\u62C9\u9078\u55AE"
      },
      cascader: {
        noMatch: "\u7121\u76F8\u7B26\u8CC7\u6599",
        loading: "\u8F09\u5165\u4E2D",
        placeholder: "\u8ACB\u9078\u64C7",
        noData: "\u7121\u8CC7\u6599"
      },
      pagination: {
        goto: "\u524D\u5F80",
        pagesize: "\u9805/\u9801",
        total: "\u5171 {total} \u9805",
        pageClassifier: "\u9801",
        page: "\u9801",
        prev: "\u4E0A\u4E00\u9801",
        next: "\u4E0B\u4E00\u9801",
        currentPage: "\u7B2C {pager} \u9801",
        prevPages: "\u5411\u524D {pager} \u9801",
        nextPages: "\u5411\u5F8C {pager} \u9801",
        deprecationWarning: "\u5075\u6E2C\u5230\u5DF2\u904E\u6642\u7684\u4F7F\u7528\u65B9\u5F0F\uFF0C\u8ACB\u53C3\u95B1 el-pagination \u8AAA\u660E\u6587\u4EF6\u4EE5\u4E86\u89E3\u66F4\u591A\u8CC7\u8A0A"
      },
      dialog: {
        close: "\u95DC\u9589\u6B64\u5C0D\u8A71\u6846"
      },
      drawer: {
        close: "\u95DC\u9589\u6B64\u5C0D\u8A71\u6846"
      },
      messagebox: {
        title: "\u63D0\u793A",
        confirm: "\u78BA\u5B9A",
        cancel: "\u53D6\u6D88",
        error: "\u8F38\u5165\u7684\u8CC7\u6599\u4E0D\u7B26\u898F\u5B9A!",
        close: "\u95DC\u9589\u6B64\u5C0D\u8A71\u6846"
      },
      upload: {
        deleteTip: "\u6309\u4E00\u4E0B Delete \u9375\u4EE5\u522A\u9664",
        delete: "\u522A\u9664",
        preview: "\u67E5\u770B\u5716\u7247",
        continue: "\u7E7C\u7E8C\u4E0A\u50B3"
      },
      slider: {
        defaultLabel: "\u6ED1\u687F\u4ECB\u65BC {min} \u81F3 {max}",
        defaultRangeStartLabel: "\u9078\u64C7\u8D77\u59CB\u503C",
        defaultRangeEndLabel: "\u9078\u64C7\u7D50\u675F\u503C"
      },
      table: {
        emptyText: "\u66AB\u7121\u8CC7\u6599",
        confirmFilter: "\u7BE9\u9078",
        resetFilter: "\u91CD\u7F6E",
        clearFilter: "\u5168\u90E8",
        sumText: "\u5408\u8A08"
      },
      tour: {
        next: "\u4E0B\u4E00\u6B65",
        previous: "\u4E0A\u4E00\u6B65",
        finish: "\u7D50\u675F\u5C0E\u89BD"
      },
      tree: {
        emptyText: "\u66AB\u7121\u8CC7\u6599"
      },
      transfer: {
        noMatch: "\u7121\u76F8\u7B26\u8CC7\u6599",
        noData: "\u7121\u8CC7\u6599",
        titles: ["\u5217\u8868 1", "\u5217\u8868 2"],
        filterPlaceholder: "\u8ACB\u8F38\u5165\u641C\u5C0B\u5167\u5BB9",
        noCheckedFormat: "\u5171 {total} \u9805",
        hasCheckedFormat: "\u5DF2\u9078 {checked}/{total} \u9805"
      },
      image: {
        error: "\u8F09\u5165\u5931\u6557"
      },
      pageHeader: {
        title: "\u8FD4\u56DE"
      },
      popconfirm: {
        confirmButtonText: "\u78BA\u8A8D",
        cancelButtonText: "\u53D6\u6D88"
      },
      carousel: {
        leftArrow: "\u4E0A\u4E00\u5F35\u6295\u5F71\u7247",
        rightArrow: "\u4E0B\u4E00\u5F35\u6295\u5F71\u7247",
        indicator: "\u6295\u5F71\u7247\u5207\u63DB\u81F3\u7D22\u5F15 {index}"
      }
    }
  };

  return zhTw;

}));


code:
var _export_sfc = (sfc, props) => {
  const target = sfc.__vccOpts || sfc;
  for (const [key, val] of props) {
    target[key] = val;
  }
  return target;
};

export { _export_sfc as default };
//# sourceMappingURL=plugin-vue_export-helper.mjs.map


sourcesContent:
export default (sfc, props) => {
  const target = sfc.__vccOpts || sfc;
  for (const [key, val] of props) {
    target[key] = val;
  }
  return target;
}


code:
import type { Plugin } from 'vue';
declare const _default: Plugin[];
export default _default;


code:
import { ElAffix } from './components/affix/index.mjs';
import { ElAlert } from './components/alert/index.mjs';
import { ElAutocomplete } from './components/autocomplete/index.mjs';
import { ElAvatar } from './components/avatar/index.mjs';
import { ElBacktop } from './components/backtop/index.mjs';
import { ElBadge } from './components/badge/index.mjs';
import { ElBreadcrumb, ElBreadcrumbItem } from './components/breadcrumb/index.mjs';
import { ElButton, ElButtonGroup } from './components/button/index.mjs';
import { ElCalendar } from './components/calendar/index.mjs';
import { ElCard } from './components/card/index.mjs';
import { ElCarousel, ElCarouselItem } from './components/carousel/index.mjs';
import { ElCascader } from './components/cascader/index.mjs';
import { ElCascaderPanel } from './components/cascader-panel/index.mjs';
import { ElCheckTag } from './components/check-tag/index.mjs';
import { ElCheckbox, ElCheckboxButton, ElCheckboxGroup } from './components/checkbox/index.mjs';
import { ElCol } from './components/col/index.mjs';
import { ElCollapse, ElCollapseItem } from './components/collapse/index.mjs';
import { ElCollapseTransition } from './components/collapse-transition/index.mjs';
import { ElColorPicker } from './components/color-picker/index.mjs';
import { ElConfigProvider } from './components/config-provider/index.mjs';
import { ElContainer, ElAside, ElFooter, ElHeader, ElMain } from './components/container/index.mjs';
import { ElDatePicker } from './components/date-picker/index.mjs';
import { ElDescriptions, ElDescriptionsItem } from './components/descriptions/index.mjs';
import { ElDialog } from './components/dialog/index.mjs';
import { ElDivider } from './components/divider/index.mjs';
import { ElDrawer } from './components/drawer/index.mjs';
import { ElDropdown, ElDropdownItem, ElDropdownMenu } from './components/dropdown/index.mjs';
import { ElEmpty } from './components/empty/index.mjs';
import { ElForm, ElFormItem } from './components/form/index.mjs';
import { ElIcon } from './components/icon/index.mjs';
import { ElImage } from './components/image/index.mjs';
import { ElImageViewer } from './components/image-viewer/index.mjs';
import { ElInput } from './components/input/index.mjs';
import { ElInputNumber } from './components/input-number/index.mjs';
import { ElLink } from './components/link/index.mjs';
import { ElMenu, ElMenuItem, ElMenuItemGroup, ElSubMenu } from './components/menu/index.mjs';
import { ElPageHeader } from './components/page-header/index.mjs';
import { ElPagination } from './components/pagination/index.mjs';
import { ElPopconfirm } from './components/popconfirm/index.mjs';
import { ElPopover } from './components/popover/index.mjs';
import { ElPopper } from './components/popper/index.mjs';
import { ElProgress } from './components/progress/index.mjs';
import { ElRadio, ElRadioButton, ElRadioGroup } from './components/radio/index.mjs';
import { ElRate } from './components/rate/index.mjs';
import { ElResult } from './components/result/index.mjs';
import { ElRow } from './components/row/index.mjs';
import { ElScrollbar } from './components/scrollbar/index.mjs';
import { ElSelect, ElOption, ElOptionGroup } from './components/select/index.mjs';
import { ElSelectV2 } from './components/select-v2/index.mjs';
import { ElSkeleton, ElSkeletonItem } from './components/skeleton/index.mjs';
import { ElSlider } from './components/slider/index.mjs';
import { ElSpace } from './components/space/index.mjs';
import { ElStatistic } from './components/statistic/index.mjs';
import { ElCountdown } from './components/countdown/index.mjs';
import { ElSteps, ElStep } from './components/steps/index.mjs';
import { ElSwitch } from './components/switch/index.mjs';
import { ElTable, ElTableColumn } from './components/table/index.mjs';
import { ElAutoResizer, ElTableV2 } from './components/table-v2/index.mjs';
import { ElTabs, ElTabPane } from './components/tabs/index.mjs';
import { ElTag } from './components/tag/index.mjs';
import { ElText } from './components/text/index.mjs';
import { ElTimePicker } from './components/time-picker/index.mjs';
import { ElTimeSelect } from './components/time-select/index.mjs';
import { ElTimeline, ElTimelineItem } from './components/timeline/index.mjs';
import { ElTooltip } from './components/tooltip/index.mjs';
import { ElTooltipV2 } from './components/tooltip-v2/index.mjs';
import { ElTransfer } from './components/transfer/index.mjs';
import { ElTree } from './components/tree/index.mjs';
import { ElTreeSelect } from './components/tree-select/index.mjs';
import { ElTreeV2 } from './components/tree-v2/index.mjs';
import { ElUpload } from './components/upload/index.mjs';
import { ElWatermark } from './components/watermark/index.mjs';
import { ElTour, ElTourStep } from './components/tour/index.mjs';
import { ElAnchor, ElAnchorLink } from './components/anchor/index.mjs';
import { ElSegmented } from './components/segmented/index.mjs';
import { ElMention } from './components/mention/index.mjs';

var Components = [
  ElAffix,
  ElAlert,
  ElAutocomplete,
  ElAutoResizer,
  ElAvatar,
  ElBacktop,
  ElBadge,
  ElBreadcrumb,
  ElBreadcrumbItem,
  ElButton,
  ElButtonGroup,
  ElCalendar,
  ElCard,
  ElCarousel,
  ElCarouselItem,
  ElCascader,
  ElCascaderPanel,
  ElCheckTag,
  ElCheckbox,
  ElCheckboxButton,
  ElCheckboxGroup,
  ElCol,
  ElCollapse,
  ElCollapseItem,
  ElCollapseTransition,
  ElColorPicker,
  ElConfigProvider,
  ElContainer,
  ElAside,
  ElFooter,
  ElHeader,
  ElMain,
  ElDatePicker,
  ElDescriptions,
  ElDescriptionsItem,
  ElDialog,
  ElDivider,
  ElDrawer,
  ElDropdown,
  ElDropdownItem,
  ElDropdownMenu,
  ElEmpty,
  ElForm,
  ElFormItem,
  ElIcon,
  ElImage,
  ElImageViewer,
  ElInput,
  ElInputNumber,
  ElLink,
  ElMenu,
  ElMenuItem,
  ElMenuItemGroup,
  ElSubMenu,
  ElPageHeader,
  ElPagination,
  ElPopconfirm,
  ElPopover,
  ElPopper,
  ElProgress,
  ElRadio,
  ElRadioButton,
  ElRadioGroup,
  ElRate,
  ElResult,
  ElRow,
  ElScrollbar,
  ElSelect,
  ElOption,
  ElOptionGroup,
  ElSelectV2,
  ElSkeleton,
  ElSkeletonItem,
  ElSlider,
  ElSpace,
  ElStatistic,
  ElCountdown,
  ElSteps,
  ElStep,
  ElSwitch,
  ElTable,
  ElTableColumn,
  ElTableV2,
  ElTabs,
  ElTabPane,
  ElTag,
  ElText,
  ElTimePicker,
  ElTimeSelect,
  ElTimeline,
  ElTimelineItem,
  ElTooltip,
  ElTooltipV2,
  ElTransfer,
  ElTree,
  ElTreeSelect,
  ElTreeV2,
  ElUpload,
  ElWatermark,
  ElTour,
  ElTourStep,
  ElAnchor,
  ElAnchorLink,
  ElSegmented,
  ElMention
];

export { Components as default };
//# sourceMappingURL=component.mjs.map


code:
import Affix from './src/affix.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElAffix: SFCWithInstall<typeof Affix>;
export default ElAffix;
export * from './src/affix';


code:
import '../../utils/index.mjs';
import Affix from './src/affix2.mjs';
export { affixEmits, affixProps } from './src/affix.mjs';
import { withInstall } from '../../utils/vue/install.mjs';

const ElAffix = withInstall(Affix);

export { ElAffix, ElAffix as default };
//# sourceMappingURL=index.mjs.map


sourcesContent:
import { withInstall } from '@element-plus/utils'
import Affix from './src/affix.vue'
import type { SFCWithInstall } from '@element-plus/utils'
export const ElAffix: SFCWithInstall<typeof Affix> = withInstall(Affix)
export default ElAffix

export * from './src/affix'


code:
import type { ExtractPropTypes } from 'vue';
import type { ZIndexProperty } from 'csstype';
import type Affix from './affix.vue';
export declare const affixProps: {
    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ZIndexProperty & {}) | (() => ZIndexProperty) | ((new (...args: any[]) => ZIndexProperty & {}) | (() => ZIndexProperty))[], unknown, unknown, 100, boolean>;
    readonly target: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly position: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom", unknown, "top", boolean>;
};
export declare type AffixProps = ExtractPropTypes<typeof affixProps>;
export declare const affixEmits: {
    scroll: ({ scrollTop, fixed }: {
        scrollTop: number;
        fixed: boolean;
    }) => boolean;
    change: (fixed: boolean) => boolean;
};
export declare type AffixEmits = typeof affixEmits;
export declare type AffixInstance = InstanceType<typeof Affix>;


code:
import '../../../utils/index.mjs';
import '../../../constants/index.mjs';
import { buildProps, definePropType } from '../../../utils/vue/props/runtime.mjs';
import { isNumber, isBoolean } from '../../../utils/types.mjs';
import { CHANGE_EVENT } from '../../../constants/event.mjs';

const affixProps = buildProps({
  zIndex: {
    type: definePropType([Number, String]),
    default: 100
  },
  target: {
    type: String,
    default: ""
  },
  offset: {
    type: Number,
    default: 0
  },
  position: {
    type: String,
    values: ["top", "bottom"],
    default: "top"
  }
});
const affixEmits = {
  scroll: ({ scrollTop, fixed }) => isNumber(scrollTop) && isBoolean(fixed),
  [CHANGE_EVENT]: (fixed) => isBoolean(fixed)
};

export { affixEmits, affixProps };
//# sourceMappingURL=affix.mjs.map


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty) | ((new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty))[], unknown, unknown, 100, boolean>;
    readonly target: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly position: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom", unknown, "top", boolean>;
}, {
    /** @description update affix status */
    update: () => void;
    /** @description update rootRect info */
    updateRoot: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    scroll: (args_0: {
        scrollTop: number;
        fixed: boolean;
    }) => void;
    change: (fixed: boolean) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly zIndex: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty) | ((new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty))[], unknown, unknown, 100, boolean>;
    readonly target: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    readonly position: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "bottom", unknown, "top", boolean>;
}>> & {
    onScroll?: ((args_0: {
        scrollTop: number;
        fixed: boolean;
    }) => any) | undefined;
    onChange?: ((fixed: boolean) => any) | undefined;
}, {
    readonly position: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "bottom", unknown>;
    readonly zIndex: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty) | ((new (...args: any[]) => import("csstype").ZIndexProperty & {}) | (() => import("csstype").ZIndexProperty))[], unknown, unknown>;
    readonly offset: number;
    readonly target: string;
}>, {
    default?(_: {}): any;
}>;
export default _default;
declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};


code:
import { defineComponent, shallowRef, ref, computed, watch, onMounted, watchEffect, openBlock, createElementBlock, normalizeClass, unref, normalizeStyle, createElementVNode, renderSlot } from 'vue';
import { useWindowSize, useElementBounding, useEventListener } from '@vueuse/core';
import '../../../utils/index.mjs';
import '../../../hooks/index.mjs';
import { affixProps, affixEmits } from './affix.mjs';
import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
import { addUnit } from '../../../utils/dom/style.mjs';
import { throwError } from '../../../utils/error.mjs';
import { getScrollContainer } from '../../../utils/dom/scroll.mjs';

const COMPONENT_NAME = "ElAffix";
const __default__ = defineComponent({
  name: COMPONENT_NAME
});
const _sfc_main = /* @__PURE__ */ defineComponent({
  ...__default__,
  props: affixProps,
  emits: affixEmits,
  setup(__props, { expose, emit }) {
    const props = __props;
    const ns = useNamespace("affix");
    const target = shallowRef();
    const root = shallowRef();
    const scrollContainer = shallowRef();
    const { height: windowHeight } = useWindowSize();
    const {
      height: rootHeight,
      width: rootWidth,
      top: rootTop,
      bottom: rootBottom,
      update: updateRoot
    } = useElementBounding(root, { windowScroll: false });
    const targetRect = useElementBounding(target);
    const fixed = ref(false);
    const scrollTop = ref(0);
    const transform = ref(0);
    const rootStyle = computed(() => {
      return {
        height: fixed.value ? `${rootHeight.value}px` : "",
        width: fixed.value ? `${rootWidth.value}px` : ""
      };
    });
    const affixStyle = computed(() => {
      if (!fixed.value)
        return {};
      const offset = props.offset ? addUnit(props.offset) : 0;
      return {
        height: `${rootHeight.value}px`,
        width: `${rootWidth.value}px`,
        top: props.position === "top" ? offset : "",
        bottom: props.position === "bottom" ? offset : "",
        transform: transform.value ? `translateY(${transform.value}px)` : "",
        zIndex: props.zIndex
      };
    });
    const update = () => {
      if (!scrollContainer.value)
        return;
      scrollTop.value = scrollContainer.value instanceof Window ? document.documentElement.scrollTop : scrollContainer.value.scrollTop || 0;
      const { position, target: target2, offset } = props;
      const rootHeightOffset = offset + rootHeight.value;
      if (position === "top") {
        if (target2) {
          const difference = targetRect.bottom.value - rootHeightOffset;
          fixed.value = offset > rootTop.value && targetRect.bottom.value > 0;
          transform.value = difference < 0 ? difference : 0;
        } else {
          fixed.value = offset > rootTop.value;
        }
      } else if (target2) {
        const difference = windowHeight.value - targetRect.top.value - rootHeightOffset;
        fixed.value = windowHeight.value - offset < rootBottom.value && windowHeight.value > targetRect.top.value;
        transform.value = difference < 0 ? -difference : 0;
      } else {
        fixed.value = windowHeight.value - offset < rootBottom.value;
      }
    };
    const handleScroll = () => {
      updateRoot();
      emit("scroll", {
        scrollTop: scrollTop.value,
        fixed: fixed.value
      });
    };
    watch(fixed, (val) => emit("change", val));
    onMounted(() => {
      var _a;
      if (props.target) {
        target.value = (_a = document.querySelector(props.target)) != null ? _a : void 0;
        if (!target.value)
          throwError(COMPONENT_NAME, `Target does not exist: ${props.target}`);
      } else {
        target.value = document.documentElement;
      }
      scrollContainer.value = getScrollContainer(root.value, true);
      updateRoot();
    });
    useEventListener(scrollContainer, "scroll", handleScroll);
    watchEffect(update);
    expose({
      update,
      updateRoot
    });
    return (_ctx, _cache) => {
      return openBlock(), createElementBlock("div", {
        ref_key: "root",
        ref: root,
        class: normalizeClass(unref(ns).b()),
        style: normalizeStyle(unref(rootStyle))
      }, [
        createElementVNode("div", {
          class: normalizeClass({ [unref(ns).m("fixed")]: fixed.value }),
          style: normalizeStyle(unref(affixStyle))
        }, [
          renderSlot(_ctx.$slots, "default")
        ], 6)
      ], 6);
    };
  }
});
var Affix = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "affix.vue"]]);

export { Affix as default };
//# sourceMappingURL=affix2.mjs.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-affix.css';


code:
import '../../base/style/css.mjs';
import 'element-plus/theme-chalk/el-affix.css';
//# sourceMappingURL=css.mjs.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/affix.scss';


code:
import '../../base/style/index.mjs';
import 'element-plus/theme-chalk/src/affix.scss';
//# sourceMappingURL=index.mjs.map


code:
import Alert from './src/alert.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElAlert: SFCWithInstall<typeof Alert>;
export default ElAlert;
export * from './src/alert';
export type { AlertInstance } from './src/instance';


code:
import '../../utils/index.mjs';
import Alert from './src/alert2.mjs';
export { alertEffects, alertEmits, alertProps } from './src/alert.mjs';
import { withInstall } from '../../utils/vue/install.mjs';

const ElAlert = withInstall(Alert);

export { ElAlert, ElAlert as default };
//# sourceMappingURL=index.mjs.map


sourcesContent:
import { withInstall } from '@element-plus/utils'
import Alert from './src/alert.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElAlert: SFCWithInstall<typeof Alert> = withInstall(Alert)
export default ElAlert

export * from './src/alert'
export type { AlertInstance } from './src/instance'


code:
import type { ExtractPropTypes } from 'vue';
export declare const alertEffects: readonly ["light", "dark"];
export declare const alertProps: {
    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "success" | "warning" | "info", unknown, "info", boolean>;
    readonly closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly showIcon: BooleanConstructor;
    readonly center: BooleanConstructor;
    readonly effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dark" | "light", unknown, "light", boolean>;
};
export declare type AlertProps = ExtractPropTypes<typeof alertProps>;
export declare const alertEmits: {
    close: (evt: MouseEvent) => boolean;
};
export declare type AlertEmits = typeof alertEmits;


code:
import '../../../utils/index.mjs';
import { buildProps } from '../../../utils/vue/props/runtime.mjs';
import { keysOf } from '../../../utils/objects.mjs';
import { TypeComponentsMap } from '../../../utils/vue/icon.mjs';

const alertEffects = ["light", "dark"];
const alertProps = buildProps({
  title: {
    type: String,
    default: ""
  },
  description: {
    type: String,
    default: ""
  },
  type: {
    type: String,
    values: keysOf(TypeComponentsMap),
    default: "info"
  },
  closable: {
    type: Boolean,
    default: true
  },
  closeText: {
    type: String,
    default: ""
  },
  showIcon: Boolean,
  center: Boolean,
  effect: {
    type: String,
    values: alertEffects,
    default: "light"
  }
});
const alertEmits = {
  close: (evt) => evt instanceof MouseEvent
};

export { alertEffects, alertEmits, alertProps };
//# sourceMappingURL=alert.mjs.map


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "success" | "warning" | "info", unknown, "info", boolean>;
    readonly closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly showIcon: BooleanConstructor;
    readonly center: BooleanConstructor;
    readonly effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dark" | "light", unknown, "light", boolean>;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    close: (evt: MouseEvent) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    readonly title: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "error" | "success" | "warning" | "info", unknown, "info", boolean>;
    readonly closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly showIcon: BooleanConstructor;
    readonly center: BooleanConstructor;
    readonly effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "dark" | "light", unknown, "light", boolean>;
}>> & {
    onClose?: ((evt: MouseEvent) => any) | undefined;
}, {
    readonly title: string;
    readonly center: boolean;
    readonly type: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "error" | "success" | "warning" | "info", unknown>;
    readonly description: string;
    readonly effect: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "dark" | "light", unknown>;
    readonly closable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    readonly closeText: string;
    readonly showIcon: boolean;
}>, {
    title?(_: {}): any;
    default?(_: {}): any;
}>;
export default _default;
declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};


code:
import { defineComponent, useSlots, ref, computed, openBlock, createBlock, Transition, unref, withCtx, withDirectives, createElementVNode, normalizeClass, resolveDynamicComponent, createCommentVNode, createElementBlock, renderSlot, createTextVNode, toDisplayString, Fragment, createVNode, vShow } from 'vue';
import { ElIcon } from '../../icon/index.mjs';
import '../../../utils/index.mjs';
import '../../../hooks/index.mjs';
import { alertProps, alertEmits } from './alert.mjs';
import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
import { TypeComponents, TypeComponentsMap } from '../../../utils/vue/icon.mjs';
import { useNamespace } from '../../../hooks/use-namespace/index.mjs';

const __default__ = defineComponent({
  name: "ElAlert"
});
const _sfc_main = /* @__PURE__ */ defineComponent({
  ...__default__,
  props: alertProps,
  emits: alertEmits,
  setup(__props, { emit }) {
    const props = __props;
    const { Close } = TypeComponents;
    const slots = useSlots();
    const ns = useNamespace("alert");
    const visible = ref(true);
    const iconComponent = computed(() => TypeComponentsMap[props.type]);
    const iconClass = computed(() => [
      ns.e("icon"),
      { [ns.is("big")]: !!props.description || !!slots.default }
    ]);
    const withDescription = computed(() => {
      return { "with-description": props.description || slots.default };
    });
    const close = (evt) => {
      visible.value = false;
      emit("close", evt);
    };
    return (_ctx, _cache) => {
      return openBlock(), createBlock(Transition, {
        name: unref(ns).b("fade"),
        persisted: ""
      }, {
        default: withCtx(() => [
          withDirectives(createElementVNode("div", {
            class: normalizeClass([unref(ns).b(), unref(ns).m(_ctx.type), unref(ns).is("center", _ctx.center), unref(ns).is(_ctx.effect)]),
            role: "alert"
          }, [
            _ctx.showIcon && unref(iconComponent) ? (openBlock(), createBlock(unref(ElIcon), {
              key: 0,
              class: normalizeClass(unref(iconClass))
            }, {
              default: withCtx(() => [
                (openBlock(), createBlock(resolveDynamicComponent(unref(iconComponent))))
              ]),
              _: 1
            }, 8, ["class"])) : createCommentVNode("v-if", true),
            createElementVNode("div", {
              class: normalizeClass(unref(ns).e("content"))
            }, [
              _ctx.title || _ctx.$slots.title ? (openBlock(), createElementBlock("span", {
                key: 0,
                class: normalizeClass([unref(ns).e("title"), unref(withDescription)])
              }, [
                renderSlot(_ctx.$slots, "title", {}, () => [
                  createTextVNode(toDisplayString(_ctx.title), 1)
                ])
              ], 2)) : createCommentVNode("v-if", true),
              _ctx.$slots.default || _ctx.description ? (openBlock(), createElementBlock("p", {
                key: 1,
                class: normalizeClass(unref(ns).e("description"))
              }, [
                renderSlot(_ctx.$slots, "default", {}, () => [
                  createTextVNode(toDisplayString(_ctx.description), 1)
                ])
              ], 2)) : createCommentVNode("v-if", true),
              _ctx.closable ? (openBlock(), createElementBlock(Fragment, { key: 2 }, [
                _ctx.closeText ? (openBlock(), createElementBlock("div", {
                  key: 0,
                  class: normalizeClass([unref(ns).e("close-btn"), unref(ns).is("customed")]),
                  onClick: close
                }, toDisplayString(_ctx.closeText), 3)) : (openBlock(), createBlock(unref(ElIcon), {
                  key: 1,
                  class: normalizeClass(unref(ns).e("close-btn")),
                  onClick: close
                }, {
                  default: withCtx(() => [
                    createVNode(unref(Close))
                  ]),
                  _: 1
                }, 8, ["class"]))
              ], 64)) : createCommentVNode("v-if", true)
            ], 2)
          ], 2), [
            [vShow, visible.value]
          ])
        ]),
        _: 3
      }, 8, ["name"]);
    };
  }
});
var Alert = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "alert.vue"]]);

export { Alert as default };
//# sourceMappingURL=alert2.mjs.map


code:
import type Alert from './alert.vue';
export declare type AlertInstance = InstanceType<typeof Alert>;


code: //# sourceMappingURL=instance.mjs.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-alert.css';


code:
import '../../base/style/css.mjs';
import 'element-plus/theme-chalk/el-alert.css';
//# sourceMappingURL=css.mjs.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/alert.scss';


code:
import '../../base/style/index.mjs';
import 'element-plus/theme-chalk/src/alert.scss';
//# sourceMappingURL=index.mjs.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-anchor-link.css';


code:
import '../../base/style/css.mjs';
import 'element-plus/theme-chalk/el-anchor-link.css';
//# sourceMappingURL=css.mjs.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/anchor-link.scss';


code:
import '../../base/style/index.mjs';
import 'element-plus/theme-chalk/src/anchor-link.scss';
//# sourceMappingURL=index.mjs.map


code:
import Anchor from './src/anchor.vue';
import AnchorLink from './src/anchor-link.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElAnchor: SFCWithInstall<typeof Anchor> & {
    AnchorLink: typeof AnchorLink;
};
export declare const ElAnchorLink: SFCWithInstall<typeof AnchorLink>;
export default ElAnchor;
export * from './src/anchor';


code:
import '../../utils/index.mjs';
import Anchor from './src/anchor2.mjs';
import AnchorLink from './src/anchor-link2.mjs';
export { anchorEmits, anchorProps } from './src/anchor.mjs';
import { withInstall, withNoopInstall } from '../../utils/vue/install.mjs';

const ElAnchor = withInstall(Anchor, {
  AnchorLink
});
const ElAnchorLink = withNoopInstall(AnchorLink);

export { ElAnchor, ElAnchorLink, ElAnchor as default };
//# sourceMappingURL=index.mjs.map


sourcesContent:
import { withInstall, withNoopInstall } from '@element-plus/utils'
import Anchor from './src/anchor.vue'
import AnchorLink from './src/anchor-link.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElAnchor: SFCWithInstall<typeof Anchor> & {
  AnchorLink: typeof AnchorLink
} = withInstall(Anchor, {
  AnchorLink,
})
export const ElAnchorLink: SFCWithInstall<typeof AnchorLink> =
  withNoopInstall(AnchorLink)
export default ElAnchor

export * from './src/anchor'


code:
import type { ExtractPropTypes } from 'vue';
export declare const anchorLinkProps: {
    title: StringConstructor;
    href: StringConstructor;
};
export declare type AnchorLinkProps = ExtractPropTypes<typeof anchorLinkProps>;


code:
import '../../../utils/index.mjs';
import { buildProps } from '../../../utils/vue/props/runtime.mjs';

const anchorLinkProps = buildProps({
  title: String,
  href: String
});

export { anchorLinkProps };
//# sourceMappingURL=anchor-link.mjs.map


sourcesContent:
import { buildProps } from '@element-plus/utils'

import type { ExtractPropTypes } from 'vue'

export const anchorLinkProps = buildProps({
  /**
   * @description the text content of the anchor link
   */
  title: String,
  /**
   * @description The address of the anchor link
   */
  href: String,
})

export type AnchorLinkProps = ExtractPropTypes<typeof anchorLinkProps>


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    title: StringConstructor;
    href: StringConstructor;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    title: StringConstructor;
    href: StringConstructor;
}>>, {}>, {
    default?(_: {}): any;
    "sub-link"?(_: {}): any;
}>;
export default _default;
declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};


code:
import { defineComponent, ref, inject, computed, watch, nextTick, onMounted, onBeforeUnmount, openBlock, createElementBlock, normalizeClass, unref, createElementVNode, renderSlot, createTextVNode, toDisplayString, createCommentVNode } from 'vue';
import { anchorLinkProps } from './anchor-link.mjs';
import { anchorKey } from './constants.mjs';
import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';

const __default__ = defineComponent({
  name: "ElAnchorLink"
});
const _sfc_main = /* @__PURE__ */ defineComponent({
  ...__default__,
  props: anchorLinkProps,
  setup(__props) {
    const props = __props;
    const linkRef = ref(null);
    const {
      ns,
      direction,
      currentAnchor,
      addLink,
      removeLink,
      handleClick: contextHandleClick
    } = inject(anchorKey);
    const cls = computed(() => [
      ns.e("link"),
      ns.is("active", currentAnchor.value === props.href)
    ]);
    const handleClick = (e) => {
      contextHandleClick(e, props.href);
    };
    watch(() => props.href, (val, oldVal) => {
      nextTick(() => {
        if (oldVal)
          removeLink(oldVal);
        if (val) {
          addLink({
            href: val,
            el: linkRef.value
          });
        }
      });
    });
    onMounted(() => {
      const { href } = props;
      if (href) {
        addLink({
          href,
          el: linkRef.value
        });
      }
    });
    onBeforeUnmount(() => {
      const { href } = props;
      if (href) {
        removeLink(href);
      }
    });
    return (_ctx, _cache) => {
      return openBlock(), createElementBlock("div", {
        class: normalizeClass(unref(ns).e("item"))
      }, [
        createElementVNode("a", {
          ref_key: "linkRef",
          ref: linkRef,
          class: normalizeClass(unref(cls)),
          href: _ctx.href,
          onClick: handleClick
        }, [
          renderSlot(_ctx.$slots, "default", {}, () => [
            createTextVNode(toDisplayString(_ctx.title), 1)
          ])
        ], 10, ["href"]),
        _ctx.$slots["sub-link"] && unref(direction) === "vertical" ? (openBlock(), createElementBlock("div", {
          key: 0,
          class: normalizeClass(unref(ns).e("list"))
        }, [
          renderSlot(_ctx.$slots, "sub-link")
        ], 2)) : createCommentVNode("v-if", true)
      ], 2);
    };
  }
});
var AnchorLink = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "anchor-link.vue"]]);

export { AnchorLink as default };
//# sourceMappingURL=anchor-link2.mjs.map


code:
import type { ExtractPropTypes } from 'vue';
import type Anchor from './anchor.vue';
export declare const anchorProps: {
    container: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null) | ((new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bound: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    marker: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown, string, boolean>;
    direction: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown, string, boolean>;
};
export declare type AnchorProps = ExtractPropTypes<typeof anchorProps>;
export declare type AnchorInstance = InstanceType<typeof Anchor>;
export declare const anchorEmits: {
    change: (href: string) => boolean;
    click: (e: MouseEvent, href?: string) => boolean;
};
export declare type AnchorEmits = typeof anchorEmits;


code:
import '../../../utils/index.mjs';
import { buildProps, definePropType } from '../../../utils/vue/props/runtime.mjs';
import { isString } from '@vue/shared';
import { isUndefined } from '../../../utils/types.mjs';

const anchorProps = buildProps({
  container: {
    type: definePropType([
      String,
      Object
    ])
  },
  offset: {
    type: Number,
    default: 0
  },
  bound: {
    type: Number,
    default: 15
  },
  duration: {
    type: Number,
    default: 300
  },
  marker: {
    type: Boolean,
    default: true
  },
  type: {
    type: definePropType(String),
    default: "default"
  },
  direction: {
    type: definePropType(String),
    default: "vertical"
  }
});
const anchorEmits = {
  change: (href) => isString(href),
  click: (e, href) => e instanceof MouseEvent && (isString(href) || isUndefined(href))
};

export { anchorEmits, anchorProps };
//# sourceMappingURL=anchor.mjs.map


code:
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
    container: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null) | ((new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bound: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    marker: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown, string, boolean>;
    direction: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown, string, boolean>;
}, {
    scrollTo: (href?: string | undefined) => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    click: (e: MouseEvent, href?: string | undefined) => void;
    change: (href: string) => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    container: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null) | ((new (...args: any[]) => (string | HTMLElement | Window | null) & {}) | (() => string | HTMLElement | Window | null))[], unknown, unknown>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
    offset: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    bound: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    duration: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
    marker: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown, string, boolean>;
    direction: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown, string, boolean>;
}>> & {
    onChange?: ((href: string) => any) | undefined;
    onClick?: ((e: MouseEvent, href?: string | undefined) => any) | undefined;
}, {
    marker: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
    direction: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical") | ((new (...args: any[]) => ("horizontal" | "vertical") & {}) | (() => "horizontal" | "vertical"))[], unknown, unknown>;
    offset: number;
    type: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline") | ((new (...args: any[]) => ("default" | "underline") & {}) | (() => "default" | "underline"))[], unknown, unknown>;
    bound: number;
    duration: number;
}>, {
    default?(_: {}): any;
}>;
export default _default;
declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};


code:
import { defineComponent, ref, computed, onMounted, watch, provide, openBlock, createElementBlock, normalizeClass, unref, normalizeStyle, createCommentVNode, createElementVNode, renderSlot } from 'vue';
import { useEventListener } from '@vueuse/core';
import '../../../hooks/index.mjs';
import '../../../utils/index.mjs';
import { anchorProps, anchorEmits } from './anchor.mjs';
import { anchorKey } from './constants.mjs';
import _export_sfc from '../../../_virtual/plugin-vue_export-helper.mjs';
import { useNamespace } from '../../../hooks/use-namespace/index.mjs';
import { getElement } from '../../../utils/dom/element.mjs';
import { getScrollElement, animateScrollTo, getScrollTop } from '../../../utils/dom/scroll.mjs';
import { getOffsetTopDistance } from '../../../utils/dom/position.mjs';
import { throttleByRaf } from '../../../utils/throttleByRaf.mjs';
import { isUndefined, isWindow } from '../../../utils/types.mjs';

const __default__ = defineComponent({
  name: "ElAnchor"
});
const _sfc_main = /* @__PURE__ */ defineComponent({
  ...__default__,
  props: anchorProps,
  emits: anchorEmits,
  setup(__props, { expose, emit }) {
    const props = __props;
    const currentAnchor = ref("");
    const anchorRef = ref(null);
    const markerRef = ref(null);
    const containerEl = ref();
    const links = {};
    let isScrolling = false;
    let currentScrollTop = 0;
    const ns = useNamespace("anchor");
    const cls = computed(() => [
      ns.b(),
      props.type === "underline" ? ns.m("underline") : "",
      ns.m(props.direction)
    ]);
    const addLink = (state) => {
      links[state.href] = state.el;
    };
    const removeLink = (href) => {
      delete links[href];
    };
    const setCurrentAnchor = (href) => {
      const activeHref = currentAnchor.value;
      if (activeHref !== href) {
        currentAnchor.value = href;
        emit("change", href);
      }
    };
    let clearAnimate = null;
    const scrollToAnchor = (href) => {
      if (!containerEl.value)
        return;
      const target = getElement(href);
      if (!target)
        return;
      if (clearAnimate)
        clearAnimate();
      isScrolling = true;
      const scrollEle = getScrollElement(target, containerEl.value);
      const distance = getOffsetTopDistance(target, scrollEle);
      const max = scrollEle.scrollHeight - scrollEle.clientHeight;
      const to = Math.min(distance - props.offset, max);
      clearAnimate = animateScrollTo(containerEl.value, currentScrollTop, to, props.duration, () => {
        setTimeout(() => {
          isScrolling = false;
        }, 20);
      });
    };
    const scrollTo = (href) => {
      if (href) {
        setCurrentAnchor(href);
        scrollToAnchor(href);
      }
    };
    const handleClick = (e, href) => {
      emit("click", e, href);
      scrollTo(href);
    };
    const handleScroll = throttleByRaf(() => {
      if (containerEl.value) {
        currentScrollTop = getScrollTop(containerEl.value);
      }
      const currentHref = getCurrentHref();
      if (isScrolling || isUndefined(currentHref))
        return;
      setCurrentAnchor(currentHref);
    });
    const getCurrentHref = () => {
      if (!containerEl.value)
        return;
      const scrollTop = getScrollTop(containerEl.value);
      const anchorTopList = [];
      for (const href of Object.keys(links)) {
        const target = getElement(href);
        if (!target)
          continue;
        const scrollEle = getScrollElement(target, containerEl.value);
        const distance = getOffsetTopDistance(target, scrollEle);
        anchorTopList.push({
          top: distance - props.offset - props.bound,
          href
        });
      }
      anchorTopList.sort((prev, next) => prev.top - next.top);
      for (let i = 0; i < anchorTopList.length; i++) {
        const item = anchorTopList[i];
        const next = anchorTopList[i + 1];
        if (i === 0 && scrollTop === 0) {
          return "";
        }
        if (item.top <= scrollTop && (!next || next.top > scrollTop)) {
          return item.href;
        }
      }
    };
    const getContainer = () => {
      const el = getElement(props.container);
      if (!el || isWindow(el)) {
        containerEl.value = window;
      } else {
        containerEl.value = el;
      }
    };
    useEventListener(containerEl, "scroll", handleScroll);
    const markerStyle = computed(() => {
      if (!anchorRef.value || !markerRef.value || !currentAnchor.value)
        return {};
      const currentLinkEl = links[currentAnchor.value];
      if (!currentLinkEl)
        return {};
      const anchorRect = anchorRef.value.getBoundingClientRect();
      const markerRect = markerRef.value.getBoundingClientRect();
      const linkRect = currentLinkEl.getBoundingClientRect();
      if (props.direction === "horizontal") {
        const left = linkRect.left - anchorRect.left;
        return {
          left: `${left}px`,
          width: `${linkRect.width}px`,
          opacity: 1
        };
      } else {
        const top = linkRect.top - anchorRect.top + (linkRect.height - markerRect.height) / 2;
        return {
          top: `${top}px`,
          opacity: 1
        };
      }
    });
    onMounted(() => {
      getContainer();
      const hash = decodeURIComponent(window.location.hash);
      const target = getElement(hash);
      if (target) {
        scrollTo(hash);
      } else {
        handleScroll();
      }
    });
    watch(() => props.container, () => {
      getContainer();
    });
    provide(anchorKey, {
      ns,
      direction: props.direction,
      currentAnchor,
      addLink,
      removeLink,
      handleClick
    });
    expose({
      scrollTo
    });
    return (_ctx, _cache) => {
      return openBlock(), createElementBlock("div", {
        ref_key: "anchorRef",
        ref: anchorRef,
        class: normalizeClass(unref(cls))
      }, [
        _ctx.marker ? (openBlock(), createElementBlock("div", {
          key: 0,
          ref_key: "markerRef",
          ref: markerRef,
          class: normalizeClass(unref(ns).e("marker")),
          style: normalizeStyle(unref(markerStyle))
        }, null, 6)) : createCommentVNode("v-if", true),
        createElementVNode("div", {
          class: normalizeClass(unref(ns).e("list"))
        }, [
          renderSlot(_ctx.$slots, "default")
        ], 2)
      ], 2);
    };
  }
});
var Anchor = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "anchor.vue"]]);

export { Anchor as default };
//# sourceMappingURL=anchor2.mjs.map


code:
import type { InjectionKey, Ref } from 'vue';
import type { UseNamespaceReturn } from 'element-plus/es/hooks';
export interface AnchorLinkState {
    el: HTMLElement;
    href: string;
}
export interface AnchorContext {
    ns: UseNamespaceReturn;
    direction: string;
    currentAnchor: Ref<string>;
    addLink(state: AnchorLinkState): void;
    removeLink(href: string): void;
    handleClick(e: MouseEvent, href?: string): void;
}
export declare const anchorKey: InjectionKey<AnchorContext>;


code:
const anchorKey = Symbol("anchor");

export { anchorKey };
//# sourceMappingURL=constants.mjs.map


sourcesContent:
import type { InjectionKey, Ref } from 'vue'
import type { UseNamespaceReturn } from '@element-plus/hooks'

export interface AnchorLinkState {
  el: HTMLElement
  href: string
}

export interface AnchorContext {
  ns: UseNamespaceReturn
  direction: string
  currentAnchor: Ref<string>
  addLink(state: AnchorLinkState): void
  removeLink(href: string): void
  handleClick(e: MouseEvent, href?: string): void
}

export const anchorKey: InjectionKey<AnchorContext> = Symbol('anchor')

mappings: AAAY,MAAC,SAAS,GAAG,MAAM,CAAC,QAAQ;;;;


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-anchor.css';


code:
import '../../base/style/css.mjs';
import 'element-plus/theme-chalk/el-anchor.css';
//# sourceMappingURL=css.mjs.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/anchor.scss';


code:
import '../../base/style/index.mjs';
import 'element-plus/theme-chalk/src/anchor.scss';
//# sourceMappingURL=index.mjs.map


code:
import 'element-plus/es/components/base/style/css';
import 'element-plus/theme-chalk/el-aside.css';


code:
import '../../base/style/css.mjs';
import 'element-plus/theme-chalk/el-aside.css';
//# sourceMappingURL=css.mjs.map


code:
import 'element-plus/es/components/base/style';
import 'element-plus/theme-chalk/src/aside.scss';


code:
import '../../base/style/index.mjs';
import 'element-plus/theme-chalk/src/aside.scss';
//# sourceMappingURL=index.mjs.map


code:
import Autocomplete from './src/autocomplete.vue';
import type { SFCWithInstall } from 'element-plus/es/utils';
export declare const ElAutocomplete: SFCWithInstall<typeof Autocomplete>;
export default ElAutocomplete;
export * from './src/autocomplete';


code:
import '../../utils/index.mjs';
import Autocomplete from './src/autocomplete2.mjs';
export { autocompleteEmits, autocompleteProps } from './src/autocomplete.mjs';
import { withInstall } from '../../utils/vue/install.mjs';

const ElAutocomplete = withInstall(Autocomplete);

export { ElAutocomplete, ElAutocomplete as default };
//# sourceMappingURL=index.mjs.map


sourcesContent:
import { withInstall } from '@element-plus/utils'
import Autocomplete from './src/autocomplete.vue'
import type { SFCWithInstall } from '@element-plus/utils'

export const ElAutocomplete: SFCWithInstall<typeof Autocomplete> =
  withInstall(Autocomplete)

export default ElAutocomplete

export * from './src/autocomplete'


code:
import type { ExtractPropTypes } from 'vue';
import type Autocomplete from './autocomplete.vue';
import type { Placement } from 'element-plus/es/components/popper';
import type { Awaitable } from 'element-plus/es/utils';
export declare type AutocompleteData = Record<string, any>[];
export declare type AutocompleteFetchSuggestionsCallback = (data: AutocompleteData) => void;
export declare type AutocompleteFetchSuggestions = ((queryString: string, cb: AutocompleteFetchSuggestionsCallback) => Awaitable<AutocompleteData> | void) | AutocompleteData;
export declare const autocompleteProps: {
    readonly ariaLabel: StringConstructor;
    readonly valueKey: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
    readonly debounce: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
    readonly placement: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => Placement & {}) | (() => Placement) | ((new (...args: any[]) => Placement & {}) | (() => Placement))[], "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end", unknown, "bottom-start", boolean>;
    readonly fetchSuggestions: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => AutocompleteData | ((queryString: string, cb: AutocompleteFetchSuggestionsCallback) => Awaitable<AutocompleteData> | void)) | (() => AutocompleteFetchSuggestions) | ((new (...args: any[]) => AutocompleteData | ((queryString: string, cb: AutocompleteFetchSuggestionsCallback) => Awaitable<AutocompleteData> | void)) | (() => AutocompleteFetchSuggestions))[], unknown, unknown, () => void, boolean>;
    readonly popperClass: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    readonly triggerOnFocus: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly selectWhenUnmatched: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly hideLoading: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly teleported: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    readonly highlightFirstItem: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly fitInputWidth: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly disabled: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    readonly name: StringConstructor;
};
export declare type AutocompleteProps = ExtractPropTypes<typeof autocompleteProps>;
export declare const autocompleteEmits: {
    "update:modelValue": (value: string) => boolean;
    input: (value: string) => boolean;
    change: (value: string) => boolean;
    focus: (evt: FocusEvent) => boolean;
    blur: (evt: FocusEvent) => boolean;
    clear: () => boolean;
    select: (item: Record<string, any>) => boolean;
};
export declare type AutocompleteEmits = typeof autocompleteEmits;
export declare type AutocompleteInstance = InstanceType<typeof Autocomplete>;


code:
import '../../../utils/index.mjs';
import '../../tooltip/index.mjs';
import '../../../hooks/index.mjs';
import '../../../constants/index.mjs';
import { buildProps, definePropType } from '../../../utils/vue/props/runtime.mjs';
import { NOOP, isString, isObject } from '@vue/shared';
import { useTooltipContentProps } from '../../tooltip/src/content.mjs';
import { useAriaProps } from '../../../hooks/use-aria/index.mjs';
import { UPDATE_MODEL_EVENT, INPUT_EVENT, CHANGE_EVENT } from '../../../constants/event.mjs';

const autocompleteProps = buildProps({
  valueKey: {
    type: String,
    default: "value"
  },
  modelValue: {
    type: [String, Number],
    default: ""
  },
  debounce: {
    type: Number,
    default: 300
  },
  placement: {
    type: definePropType(String),
    values: [
      "top",
      "top-start",
      "top-end",
      "bottom",
      "bottom-start",
      "bottom-end"
    ],
    default: "bottom-start"
  },
  fetchSuggestions: {
    type: definePropType([Function, Array]),
    default: NOOP
  },
  popperClass: {
    type: String,
    default: ""
  },
  triggerOnFocus: {
    type: Boolean,
    default: true
  },
  selectWhenUnmatched: {
    type: Boolean,
    default: false
  },
  hideLoading: {
    type: Boolean,
    default: false
  },
  teleported: useTooltipContentProps.teleported,
  highlightFirstItem: {
    type: Boolean,
    default: false
  },
  fitInputWidth: {
    type: Boolean,
    default: false
  },
  clearable: {
    type: Boolean,
    default: false
  },
  disabled: {
    type: Boolean,
    default: false
  },
  name: String,
  ...useAriaProps(["ariaLabel"])
});
const autocompleteEmits = {
  [UPDATE_MODEL_EVENT]: (value) => isString(value),
  [INPUT_EVENT]: (value) => isString(value),
  [CHANGE_EVENT]: (value) => isString(value),
  focus: (evt) => evt instanceof FocusEvent,
  blur: (evt) => evt instanceof FocusEvent,
  clear: () => true,
  select: (item) => isObject(item)
};

export { autocompleteEmits, autocompleteProps };
//# sourceMappingURL=autocomplete.mjs.map