@fecp/designer 5.6.6 → 5.6.8

package/es/node_modules/khroma/dist/utils/channel.mjs

@@ -0,0 +1,95 @@
+const Channel = {
+  /* CLAMP */
+  min: {
+    r: 0,
+    g: 0,
+    b: 0,
+    s: 0,
+    l: 0,
+    a: 0
+  },
+  max: {
+    r: 255,
+    g: 255,
+    b: 255,
+    h: 360,
+    s: 100,
+    l: 100,
+    a: 1
+  },
+  clamp: {
+    r: (r) => r >= 255 ? 255 : r < 0 ? 0 : r,
+    g: (g) => g >= 255 ? 255 : g < 0 ? 0 : g,
+    b: (b) => b >= 255 ? 255 : b < 0 ? 0 : b,
+    h: (h) => h % 360,
+    s: (s) => s >= 100 ? 100 : s < 0 ? 0 : s,
+    l: (l) => l >= 100 ? 100 : l < 0 ? 0 : l,
+    a: (a) => a >= 1 ? 1 : a < 0 ? 0 : a
+  },
+  /* CONVERSION */
+  //SOURCE: https://planetcalc.com/7779
+  toLinear: (c) => {
+    const n = c / 255;
+    return c > 0.03928 ? Math.pow((n + 0.055) / 1.055, 2.4) : n / 12.92;
+  },
+  //SOURCE: https://gist.github.com/mjackson/5311256
+  hue2rgb: (p, q, t) => {
+    if (t < 0)
+      t += 1;
+    if (t > 1)
+      t -= 1;
+    if (t < 1 / 6)
+      return p + (q - p) * 6 * t;
+    if (t < 1 / 2)
+      return q;
+    if (t < 2 / 3)
+      return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  },
+  hsl2rgb: ({ h, s, l }, channel) => {
+    if (!s)
+      return l * 2.55;
+    h /= 360;
+    s /= 100;
+    l /= 100;
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    switch (channel) {
+      case "r":
+        return Channel.hue2rgb(p, q, h + 1 / 3) * 255;
+      case "g":
+        return Channel.hue2rgb(p, q, h) * 255;
+      case "b":
+        return Channel.hue2rgb(p, q, h - 1 / 3) * 255;
+    }
+  },
+  rgb2hsl: ({ r, g, b }, channel) => {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    if (channel === "l")
+      return l * 100;
+    if (max === min)
+      return 0;
+    const d = max - min;
+    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    if (channel === "s")
+      return s * 100;
+    switch (max) {
+      case r:
+        return ((g - b) / d + (g < b ? 6 : 0)) * 60;
+      case g:
+        return ((b - r) / d + 2) * 60;
+      case b:
+        return ((r - g) / d + 4) * 60;
+      default:
+        return -1;
+    }
+  }
+};
+export {
+  Channel as default
+};

package/es/node_modules/khroma/dist/utils/index.mjs

@@ -0,0 +1,11 @@
+import Channel from "./channel.mjs";
+import Lang from "./lang.mjs";
+import Unit from "./unit.mjs";
+const Utils = {
+  channel: Channel,
+  lang: Lang,
+  unit: Unit
+};
+export {
+  Utils as default
+};

package/es/node_modules/khroma/dist/utils/lang.mjs

@@ -0,0 +1,14 @@
+const Lang = {
+  /* API */
+  clamp: (number, lower, upper) => {
+    if (lower > upper)
+      return Math.min(lower, Math.max(upper, number));
+    return Math.min(upper, Math.max(lower, number));
+  },
+  round: (number) => {
+    return Math.round(number * 1e10) / 1e10;
+  }
+};
+export {
+  Lang as default
+};

package/es/node_modules/khroma/dist/utils/unit.mjs

@@ -0,0 +1,10 @@
+const Unit = {
+  /* API */
+  dec2hex: (dec) => {
+    const hex = Math.round(dec).toString(16);
+    return hex.length > 1 ? hex : `0${hex}`;
+  }
+};
+export {
+  Unit as default
+};

package/es/node_modules/linkify-it/index.mjs

@@ -0,0 +1,388 @@
+import reFactory from "./lib/re.mjs";
+function assign(obj) {
+  const sources = Array.prototype.slice.call(arguments, 1);
+  sources.forEach(function(source) {
+    if (!source) {
+      return;
+    }
+    Object.keys(source).forEach(function(key) {
+      obj[key] = source[key];
+    });
+  });
+  return obj;
+}
+function _class(obj) {
+  return Object.prototype.toString.call(obj);
+}
+function isString(obj) {
+  return _class(obj) === "[object String]";
+}
+function isObject(obj) {
+  return _class(obj) === "[object Object]";
+}
+function isRegExp(obj) {
+  return _class(obj) === "[object RegExp]";
+}
+function isFunction(obj) {
+  return _class(obj) === "[object Function]";
+}
+function escapeRE(str) {
+  return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
+}
+const defaultOptions = {
+  fuzzyLink: true,
+  fuzzyEmail: true,
+  fuzzyIP: false
+};
+function isOptionsObj(obj) {
+  return Object.keys(obj || {}).reduce(function(acc, k) {
+    return acc || defaultOptions.hasOwnProperty(k);
+  }, false);
+}
+const defaultSchemas = {
+  "http:": {
+    validate: function(text, pos, self) {
+      const tail = text.slice(pos);
+      if (!self.re.http) {
+        self.re.http = new RegExp(
+          `^\\/\\/${self.re.src_auth}${self.re.src_host_port_strict}${self.re.src_path}`,
+          "i"
+        );
+      }
+      if (self.re.http.test(tail)) {
+        return tail.match(self.re.http)[0].length;
+      }
+      return 0;
+    }
+  },
+  "https:": "http:",
+  "ftp:": "http:",
+  "//": {
+    validate: function(text, pos, self) {
+      const tail = text.slice(pos);
+      if (!self.re.no_http) {
+        self.re.no_http = new RegExp(
+          "^" + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
+          // with code comments
+          `(?:localhost|(?:(?:${self.re.src_domain})\\.)+${self.re.src_domain_root})` + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
+          "i"
+        );
+      }
+      if (self.re.no_http.test(tail)) {
+        if (pos >= 3 && text[pos - 3] === ":") {
+          return 0;
+        }
+        if (pos >= 3 && text[pos - 3] === "/") {
+          return 0;
+        }
+        return tail.match(self.re.no_http)[0].length;
+      }
+      return 0;
+    }
+  },
+  "mailto:": {
+    validate: function(text, pos, self) {
+      const tail = text.slice(pos);
+      if (!self.re.mailto) {
+        self.re.mailto = new RegExp(
+          `^${self.re.src_email_name}@${self.re.src_host_strict}`,
+          "i"
+        );
+      }
+      if (self.re.mailto.test(tail)) {
+        return tail.match(self.re.mailto)[0].length;
+      }
+      return 0;
+    }
+  }
+};
+const tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
+const tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф".split("|");
+function createValidator(re) {
+  return function(text, pos) {
+    const tail = text.slice(pos);
+    if (re.test(tail)) {
+      return tail.match(re)[0].length;
+    }
+    return 0;
+  };
+}
+function createNormalizer() {
+  return function(match2, self) {
+    self.normalize(match2);
+  };
+}
+function compile(self) {
+  const re = self.re = reFactory(self.__opts__);
+  const tlds2 = self.__tlds__.slice();
+  self.onCompile();
+  if (!self.__tlds_replaced__) {
+    tlds2.push(tlds_2ch_src_re);
+  }
+  tlds2.push(re.src_xn);
+  re.src_tlds = tlds2.join("|");
+  function untpl(tpl) {
+    return tpl.replace("%TLDS%", re.src_tlds);
+  }
+  re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
+  re.email_fuzzy_global = RegExp(untpl(re.tpl_email_fuzzy), "ig");
+  re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
+  re.link_fuzzy_global = RegExp(untpl(re.tpl_link_fuzzy), "ig");
+  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
+  re.link_no_ip_fuzzy_global = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "ig");
+  re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
+  const aliases = [];
+  self.__compiled__ = {};
+  function schemaError(name, val) {
+    throw new Error(`(LinkifyIt) Invalid schema "${name}": ${val}`);
+  }
+  Object.keys(self.__schemas__).forEach(function(name) {
+    const val = self.__schemas__[name];
+    if (val === null) {
+      return;
+    }
+    const compiled = { validate: null, link: null };
+    self.__compiled__[name] = compiled;
+    if (isObject(val)) {
+      if (isRegExp(val.validate)) {
+        compiled.validate = createValidator(val.validate);
+      } else if (isFunction(val.validate)) {
+        compiled.validate = val.validate;
+      } else {
+        schemaError(name, val);
+      }
+      if (isFunction(val.normalize)) {
+        compiled.normalize = val.normalize;
+      } else if (!val.normalize) {
+        compiled.normalize = createNormalizer();
+      } else {
+        schemaError(name, val);
+      }
+      return;
+    }
+    if (isString(val)) {
+      aliases.push(name);
+      return;
+    }
+    schemaError(name, val);
+  });
+  aliases.forEach(function(alias) {
+    if (!self.__compiled__[self.__schemas__[alias]]) {
+      return;
+    }
+    self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
+    self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
+  });
+  self.__compiled__[""] = { validate: null, normalize: createNormalizer() };
+  const slist = Object.keys(self.__compiled__).filter(function(name) {
+    return name.length > 0 && self.__compiled__[name];
+  }).map(escapeRE).join("|");
+  self.re.schema_test = RegExp(`(^|(?!_)(?:[><｜]|${re.src_ZPCc}))(${slist})`, "i");
+  self.re.schema_search = RegExp(`(^|(?!_)(?:[><｜]|${re.src_ZPCc}))(${slist})`, "ig");
+  self.re.schema_at_start = RegExp(`^${self.re.schema_search.source}`, "i");
+  self.re.pretest = RegExp(
+    `(${self.re.schema_test.source})|(${self.re.host_fuzzy_test.source})|@`,
+    "i"
+  );
+}
+function Match(text, schema, index, lastIndex) {
+  const raw = text.slice(index, lastIndex);
+  this.schema = schema.toLowerCase();
+  this.index = index;
+  this.lastIndex = lastIndex;
+  this.raw = raw;
+  this.text = raw;
+  this.url = raw;
+}
+function LinkifyIt(schemas, options) {
+  if (!(this instanceof LinkifyIt)) {
+    return new LinkifyIt(schemas, options);
+  }
+  if (!options) {
+    if (isOptionsObj(schemas)) {
+      options = schemas;
+      schemas = {};
+    }
+  }
+  this.__opts__ = assign({}, defaultOptions, options);
+  this.__schemas__ = assign({}, defaultSchemas, schemas);
+  this.__compiled__ = {};
+  this.__tlds__ = tlds_default;
+  this.__tlds_replaced__ = false;
+  this.re = {};
+  compile(this);
+}
+LinkifyIt.prototype.add = function add(schema, definition) {
+  this.__schemas__[schema] = definition;
+  compile(this);
+  return this;
+};
+LinkifyIt.prototype.set = function set(options) {
+  this.__opts__ = assign(this.__opts__, options);
+  return this;
+};
+LinkifyIt.prototype.test = function test(text) {
+  if (!text.length) {
+    return false;
+  }
+  let m, re;
+  if (this.re.schema_test.test(text)) {
+    re = this.re.schema_search;
+    re.lastIndex = 0;
+    while ((m = re.exec(text)) !== null) {
+      if (this.testSchemaAt(text, m[2], re.lastIndex)) {
+        return true;
+      }
+    }
+  }
+  if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
+    if (text.search(this.re.host_fuzzy_test) >= 0) {
+      if (text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy) !== null) {
+        return true;
+      }
+    }
+  }
+  if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
+    if (text.indexOf("@") >= 0) {
+      if (text.match(this.re.email_fuzzy) !== null) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+LinkifyIt.prototype.pretest = function pretest(text) {
+  return this.re.pretest.test(text);
+};
+LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
+  if (!this.__compiled__[schema.toLowerCase()]) {
+    return 0;
+  }
+  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
+};
+LinkifyIt.prototype.match = function match(text) {
+  const result = [];
+  const type_schemed = [];
+  const type_fuzzy_link = [];
+  const type_fuzzy_email = [];
+  let m, len, re;
+  function choose(a, b) {
+    if (!a) {
+      return b;
+    }
+    if (!b) {
+      return a;
+    }
+    if (a.index !== b.index) {
+      return a.index < b.index ? a : b;
+    }
+    return a.lastIndex >= b.lastIndex ? a : b;
+  }
+  if (!text.length) {
+    return null;
+  }
+  if (this.re.schema_test.test(text)) {
+    re = this.re.schema_search;
+    re.lastIndex = 0;
+    while ((m = re.exec(text)) !== null) {
+      len = this.testSchemaAt(text, m[2], re.lastIndex);
+      if (len) {
+        type_schemed.push({
+          schema: m[2],
+          index: m.index + m[1].length,
+          lastIndex: m.index + m[0].length + len
+        });
+      }
+    }
+  }
+  if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
+    re = this.__opts__.fuzzyIP ? this.re.link_fuzzy_global : this.re.link_no_ip_fuzzy_global;
+    re.lastIndex = 0;
+    while ((m = re.exec(text)) !== null) {
+      type_fuzzy_link.push({
+        schema: "",
+        index: m.index + m[1].length,
+        lastIndex: m.index + m[0].length
+      });
+    }
+  }
+  if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
+    re = this.re.email_fuzzy_global;
+    re.lastIndex = 0;
+    while ((m = re.exec(text)) !== null) {
+      type_fuzzy_email.push({
+        schema: "mailto:",
+        index: m.index + m[1].length,
+        lastIndex: m.index + m[0].length
+      });
+    }
+  }
+  const indexes = [0, 0, 0];
+  let lastIndex = 0;
+  for (; ; ) {
+    const candidates = [
+      type_schemed[indexes[0]],
+      type_fuzzy_email[indexes[1]],
+      type_fuzzy_link[indexes[2]]
+    ];
+    const candidate = choose(choose(candidates[0], candidates[1]), candidates[2]);
+    if (!candidate) {
+      break;
+    }
+    if (candidate === candidates[0]) {
+      indexes[0]++;
+    } else if (candidate === candidates[1]) {
+      indexes[1]++;
+    } else {
+      indexes[2]++;
+    }
+    if (candidate.index < lastIndex) {
+      continue;
+    }
+    const match2 = new Match(text, candidate.schema, candidate.index, candidate.lastIndex);
+    this.__compiled__[match2.schema].normalize(match2, this);
+    result.push(match2);
+    lastIndex = candidate.lastIndex;
+  }
+  if (result.length) {
+    return result;
+  }
+  return null;
+};
+LinkifyIt.prototype.matchAtStart = function matchAtStart(text) {
+  if (!text.length) return null;
+  const m = this.re.schema_at_start.exec(text);
+  if (!m) return null;
+  const len = this.testSchemaAt(text, m[2], m[0].length);
+  if (!len) return null;
+  const match2 = new Match(text, m[2], m.index + m[1].length, m.index + m[0].length + len);
+  this.__compiled__[match2.schema].normalize(match2, this);
+  return match2;
+};
+LinkifyIt.prototype.tlds = function tlds(list, keepOld) {
+  list = Array.isArray(list) ? list : [list];
+  if (!keepOld) {
+    this.__tlds__ = list.slice();
+    this.__tlds_replaced__ = true;
+    compile(this);
+    return this;
+  }
+  this.__tlds__ = this.__tlds__.concat(list).sort().filter(function(el, idx, arr) {
+    return el !== arr[idx - 1];
+  }).reverse();
+  compile(this);
+  return this;
+};
+LinkifyIt.prototype.normalize = function normalize(match2) {
+  if (!match2.schema) {
+    match2.url = `http://${match2.url}`;
+  }
+  if (match2.schema === "mailto:" && !/^mailto:/i.test(match2.url)) {
+    match2.url = `mailto:${match2.url}`;
+  }
+};
+LinkifyIt.prototype.onCompile = function onCompile() {
+};
+export {
+  LinkifyIt as default
+};

package/es/node_modules/linkify-it/lib/re.mjs

@@ -0,0 +1,47 @@
+import Any from "../../uc.micro/properties/Any/regex.mjs";
+import Cc from "../../uc.micro/categories/Cc/regex.mjs";
+import P from "../../uc.micro/categories/P/regex.mjs";
+import Z from "../../uc.micro/categories/Z/regex.mjs";
+function reFactory(opts) {
+  const re = {};
+  opts = opts || {};
+  re.src_Any = Any.source;
+  re.src_Cc = Cc.source;
+  re.src_Z = Z.source;
+  re.src_P = P.source;
+  re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
+  re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
+  const text_separators = "[><｜]";
+  re.src_pseudo_letter = `(?:(?!${text_separators}|${re.src_ZPCc})${re.src_Any})`;
+  re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
+  re.src_auth = `(?:(?:(?!${re.src_ZCc}|[@/\\[\\]()]).){1,50}@)?`;
+  re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
+  re.src_host_terminator = `(?=$|${text_separators}|${re.src_ZPCc})(?!${opts["---"] ? "-(?!--)|" : "-|"}_|:\\d|\\.-|\\.(?!$|${re.src_ZPCc}))`;
+  re.src_path = `(?:[/?#](?:(?!${re.src_ZCc}|${text_separators}|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!${re.src_ZCc}|\\]).)*\\]|\\((?:(?!${re.src_ZCc}|[)]).)*\\)|\\{(?:(?!${re.src_ZCc}|[}]).)*\\}|\\"(?:(?!${re.src_ZCc}|["]).)+\\"|\\'(?:(?!${re.src_ZCc}|[']).)+\\'|\\'(?=${re.src_pseudo_letter}|[-])|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!${re.src_ZCc}|[.]|$)|` + (opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + // allow `,,,` in paths
+  `,(?!${re.src_ZCc}|$)|;(?!${re.src_ZCc}|$)|\\!+(?!${re.src_ZCc}|[!]|$)|\\?(?!${re.src_ZCc}|[?]|$))+|\\/)?`;
+  re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]{0,63}';
+  re.src_xn = "xn--[a-z0-9\\-]{1,59}";
+  re.src_domain_root = // Allow letters & digits (http://test1)
+  "(?:" + re.src_xn + `|${re.src_pseudo_letter}{1,63})`;
+  re.src_domain = "(?:" + re.src_xn + `|(?:${re.src_pseudo_letter})|(?:${re.src_pseudo_letter}(?:-|${re.src_pseudo_letter}){0,61}${re.src_pseudo_letter}))`;
+  re.src_host = `(?:(?:(?:(?:${re.src_domain})\\.)*${re.src_domain}))`;
+  re.tpl_host_fuzzy = "(?:" + re.src_ip4 + `|(?:(?:(?:${re.src_domain})\\.)+(?:%TLDS%)))`;
+  re.tpl_host_no_ip_fuzzy = `(?:(?:(?:${re.src_domain})\\.)+(?:%TLDS%))`;
+  re.src_host_strict = re.src_host + re.src_host_terminator;
+  re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
+  re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
+  re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
+  re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
+  re.tpl_host_fuzzy_test = `localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:${re.src_ZPCc}|>|$))`;
+  re.tpl_email_fuzzy = `(^|${text_separators}|"|\\(|${re.src_ZCc})(${re.src_email_name}@${re.tpl_host_fuzzy_strict})`;
+  re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
+  // but can start with > (markdown blockquote)
+  `(^|(?![.:/\\-_@])(?:[$+<=>^\`|｜]|${re.src_ZPCc}))((?![$+<=>^\`|｜])${re.tpl_host_port_fuzzy_strict}${re.src_path})`;
+  re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
+  // but can start with > (markdown blockquote)
+  `(^|(?![.:/\\-_@])(?:[$+<=>^\`|｜]|${re.src_ZPCc}))((?![$+<=>^\`|｜])${re.tpl_host_port_no_ip_fuzzy_strict}${re.src_path})`;
+  return re;
+}
+export {
+  reFactory as default
+};

package/es/node_modules/lodash-es/_arrayReduce.mjs

@@ -0,0 +1,13 @@
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+  var index = -1, length = array == null ? 0 : array.length;
+  if (initAccum && length) {
+    accumulator = array[++index];
+  }
+  while (++index < length) {
+    accumulator = iteratee(accumulator, array[index], index, array);
+  }
+  return accumulator;
+}
+export {
+  arrayReduce as default
+};

package/es/node_modules/lodash-es/_baseExtremum.mjs

@@ -0,0 +1,14 @@
+import isSymbol from "./isSymbol.mjs";
+function baseExtremum(array, iteratee, comparator) {
+  var index = -1, length = array.length;
+  while (++index < length) {
+    var value = array[index], current = iteratee(value);
+    if (current != null && (computed === void 0 ? current === current && !isSymbol(current) : comparator(current, computed))) {
+      var computed = current, result = value;
+    }
+  }
+  return result;
+}
+export {
+  baseExtremum as default
+};

package/es/node_modules/lodash-es/_baseFilter.mjs

@@ -0,0 +1,13 @@
+import baseEach from "./_baseEach.mjs";
+function baseFilter(collection, predicate) {
+  var result = [];
+  baseEach(collection, function(value, index, collection2) {
+    if (predicate(value, index, collection2)) {
+      result.push(value);
+    }
+  });
+  return result;
+}
+export {
+  baseFilter as default
+};

package/es/node_modules/lodash-es/_baseGt.mjs

@@ -0,0 +1,6 @@
+function baseGt(value, other) {
+  return value > other;
+}
+export {
+  baseGt as default
+};

package/es/node_modules/lodash-es/_baseHas.mjs

@@ -0,0 +1,8 @@
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseHas(object, key) {
+  return object != null && hasOwnProperty.call(object, key);
+}
+export {
+  baseHas as default
+};

package/es/node_modules/lodash-es/_baseLt.mjs

@@ -0,0 +1,6 @@
+function baseLt(value, other) {
+  return value < other;
+}
+export {
+  baseLt as default
+};

package/es/node_modules/lodash-es/_baseOrderBy.mjs

@@ -0,0 +1,37 @@
+import arrayMap from "./_arrayMap.mjs";
+import baseGet from "./_baseGet.mjs";
+import baseIteratee from "./_baseIteratee.mjs";
+import baseMap from "./_baseMap.mjs";
+import baseSortBy from "./_baseSortBy.mjs";
+import baseUnary from "./_baseUnary.mjs";
+import compareMultiple from "./_compareMultiple.mjs";
+import identity from "./identity.mjs";
+import isArray from "./isArray.mjs";
+function baseOrderBy(collection, iteratees, orders) {
+  if (iteratees.length) {
+    iteratees = arrayMap(iteratees, function(iteratee) {
+      if (isArray(iteratee)) {
+        return function(value) {
+          return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+        };
+      }
+      return iteratee;
+    });
+  } else {
+    iteratees = [identity];
+  }
+  var index = -1;
+  iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
+  var result = baseMap(collection, function(value, key, collection2) {
+    var criteria = arrayMap(iteratees, function(iteratee) {
+      return iteratee(value);
+    });
+    return { "criteria": criteria, "index": ++index, "value": value };
+  });
+  return baseSortBy(result, function(object, other) {
+    return compareMultiple(object, other, orders);
+  });
+}
+export {
+  baseOrderBy as default
+};

package/es/node_modules/lodash-es/_baseRange.mjs

@@ -0,0 +1,12 @@
+var nativeCeil = Math.ceil, nativeMax = Math.max;
+function baseRange(start, end, step, fromRight) {
+  var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result = Array(length);
+  while (length--) {
+    result[++index] = start;
+    start += step;
+  }
+  return result;
+}
+export {
+  baseRange as default
+};