@design-edito/tools 0.1.51 → 0.1.53

package/chunks/chunk-KEYRP27F.js

@@ -0,0 +1,191 @@
+import {
+  Arrays
+} from "./chunk-ZS5OHINP.js";
+import {
+  Random
+} from "./chunk-OVG5RGI3.js";
+
+// src/agnostic/misc/lorem-ipsum/index.ts
+var LoremIpsum;
+((LoremIpsum2) => {
+  LoremIpsum2.words = [
+    "a",
+    "ac",
+    "accumsan",
+    "adipiscing",
+    "aenean",
+    "aliquam",
+    "aliquet",
+    "amet",
+    "ante",
+    "arcu",
+    "at",
+    "auctor",
+    "augue",
+    "bibendum",
+    "blandit",
+    "condimentum",
+    "consectetur",
+    "consequat",
+    "convallis",
+    "cras",
+    "curabitur",
+    "cursus",
+    "dapibus",
+    "diam",
+    "dictum",
+    "dictumst",
+    "dignissim",
+    "dolor",
+    "donec",
+    "dui",
+    "duis",
+    "efficitur",
+    "egestas",
+    "eget",
+    "eleifend",
+    "elementum",
+    "elit",
+    "enim",
+    "erat",
+    "eros",
+    "est",
+    "et",
+    "eu",
+    "euismod",
+    "ex",
+    "facilisis",
+    "faucibus",
+    "felis",
+    "feugiat",
+    "finibus",
+    "fringilla",
+    "fusce",
+    "gravida",
+    "habitasse",
+    "hac",
+    "hendrerit",
+    "iaculis",
+    "id",
+    "imperdiet",
+    "in",
+    "integer",
+    "interdum",
+    "ipsum",
+    "justo",
+    "lacinia",
+    "lacus",
+    "laoreet",
+    "lectus",
+    "leo",
+    "libero",
+    "ligula",
+    "lobortis",
+    "lorem",
+    "luctus",
+    "maecenas",
+    "magna",
+    "malesuada",
+    "massa",
+    "mattis",
+    "mauris",
+    "maximus",
+    "metus",
+    "mi",
+    "molestie",
+    "mollis",
+    "morbi",
+    "nam",
+    "nec",
+    "neque",
+    "nibh",
+    "nisi",
+    "nisl",
+    "non",
+    "nulla",
+    "nullam",
+    "nunc",
+    "odio",
+    "orci",
+    "ornare",
+    "pellentesque",
+    "pharetra",
+    "phasellus",
+    "placerat",
+    "platea",
+    "porta",
+    "porttitor",
+    "posuere",
+    "praesent",
+    "pulvinar",
+    "purus",
+    "quam",
+    "quis",
+    "quisque",
+    "risus",
+    "rutrum",
+    "sagittis",
+    "sapien",
+    "sed",
+    "sem",
+    "semper",
+    "sit",
+    "sodales",
+    "sollicitudin",
+    "suscipit",
+    "suspendisse",
+    "tellus",
+    "tempor",
+    "tempus",
+    "tincidunt",
+    "tortor",
+    "tristique",
+    "turpis",
+    "ultrices",
+    "ultricies",
+    "urna",
+    "ut",
+    "vehicula",
+    "vel",
+    "velit",
+    "venenatis",
+    "vestibulum",
+    "vitae",
+    "vivamus",
+    "viverra",
+    "volutpat",
+    "vulputate"
+  ];
+  LoremIpsum2.generateSentence = (wordCount) => {
+    const resultArr = [];
+    let currentWordCound = wordCount;
+    for (let i = 0; i < currentWordCound; i++) {
+      const picked = Arrays.randomPick(LoremIpsum2.words);
+      if (typeof picked === "string") resultArr.push(picked);
+      else {
+        currentWordCound += 1;
+      }
+    }
+    const [firstWord, ...otherWords] = resultArr;
+    if (firstWord === void 0) return "";
+    const capFirstLetter = firstWord?.charAt(0).toUpperCase();
+    const restOfFirstWord = firstWord?.slice(1);
+    const sentence = [
+      `${capFirstLetter}${restOfFirstWord}`,
+      ...otherWords
+    ].join(" ");
+    return `${sentence}.`;
+  };
+  LoremIpsum2.generateSentences = (sentencesCount, maxSentenceLength = 12, minSentenceLength = 4) => {
+    const sentences = [];
+    for (let i = 0; i < sentencesCount; i++) {
+      const length = Random.randomInt(maxSentenceLength, minSentenceLength) ?? 8;
+      sentences.push((0, LoremIpsum2.generateSentence)(length));
+    }
+    return sentences;
+  };
+})(LoremIpsum || (LoremIpsum = {}));
+
+export {
+  LoremIpsum
+};

package/chunks/chunk-KYMCGWPM.js

@@ -0,0 +1,31 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/@google-cloud/storage/bucket/list/index.ts
+var list_exports = {};
+__export(list_exports, {
+  list: () => list
+});
+async function list(bucket, options) {
+  const { getFileOptions } = options ?? {};
+  try {
+    const [files] = await bucket.getFiles(getFileOptions);
+    const fileNames = files.map((file) => file.name);
+    return Outcome.makeSuccess(fileNames);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  list,
+  list_exports
+};

package/chunks/chunk-L5JWJRZ7.js

@@ -0,0 +1,484 @@
+import {
+  __commonJS,
+  __export,
+  __toESM
+} from "./chunk-XCBH6NLF.js";
+
+// node_modules/quantize/quantize.js
+var require_quantize = __commonJS({
+  "node_modules/quantize/quantize.js"(exports, module) {
+    if (!pv) {
+      pv = {
+        map: function(array, f) {
+          var o = {};
+          return f ? array.map(function(d, i) {
+            o.index = i;
+            return f.call(o, d);
+          }) : array.slice();
+        },
+        naturalOrder: function(a, b) {
+          return a < b ? -1 : a > b ? 1 : 0;
+        },
+        sum: function(array, f) {
+          var o = {};
+          return array.reduce(f ? function(p, d, i) {
+            o.index = i;
+            return p + f.call(o, d);
+          } : function(p, d) {
+            return p + d;
+          }, 0);
+        },
+        max: function(array, f) {
+          return Math.max.apply(null, f ? pv.map(array, f) : array);
+        }
+      };
+    }
+    var pv;
+    var MMCQ = function() {
+      var sigbits = 5, rshift = 8 - sigbits, maxIterations = 1e3, fractByPopulations = 0.75;
+      function getColorIndex(r, g, b) {
+        return (r << 2 * sigbits) + (g << sigbits) + b;
+      }
+      function PQueue(comparator) {
+        var contents = [], sorted = false;
+        function sort() {
+          contents.sort(comparator);
+          sorted = true;
+        }
+        return {
+          push: function(o) {
+            contents.push(o);
+            sorted = false;
+          },
+          peek: function(index) {
+            if (!sorted) sort();
+            if (index === void 0) index = contents.length - 1;
+            return contents[index];
+          },
+          pop: function() {
+            if (!sorted) sort();
+            return contents.pop();
+          },
+          size: function() {
+            return contents.length;
+          },
+          map: function(f) {
+            return contents.map(f);
+          },
+          debug: function() {
+            if (!sorted) sort();
+            return contents;
+          }
+        };
+      }
+      function VBox(r1, r2, g1, g2, b1, b2, histo) {
+        var vbox = this;
+        vbox.r1 = r1;
+        vbox.r2 = r2;
+        vbox.g1 = g1;
+        vbox.g2 = g2;
+        vbox.b1 = b1;
+        vbox.b2 = b2;
+        vbox.histo = histo;
+      }
+      VBox.prototype = {
+        volume: function(force) {
+          var vbox = this;
+          if (!vbox._volume || force) {
+            vbox._volume = (vbox.r2 - vbox.r1 + 1) * (vbox.g2 - vbox.g1 + 1) * (vbox.b2 - vbox.b1 + 1);
+          }
+          return vbox._volume;
+        },
+        count: function(force) {
+          var vbox = this, histo = vbox.histo;
+          if (!vbox._count_set || force) {
+            var npix = 0, i, j, k, index;
+            for (i = vbox.r1; i <= vbox.r2; i++) {
+              for (j = vbox.g1; j <= vbox.g2; j++) {
+                for (k = vbox.b1; k <= vbox.b2; k++) {
+                  index = getColorIndex(i, j, k);
+                  npix += histo[index] || 0;
+                }
+              }
+            }
+            vbox._count = npix;
+            vbox._count_set = true;
+          }
+          return vbox._count;
+        },
+        copy: function() {
+          var vbox = this;
+          return new VBox(vbox.r1, vbox.r2, vbox.g1, vbox.g2, vbox.b1, vbox.b2, vbox.histo);
+        },
+        avg: function(force) {
+          var vbox = this, histo = vbox.histo;
+          if (!vbox._avg || force) {
+            var ntot = 0, mult = 1 << 8 - sigbits, rsum = 0, gsum = 0, bsum = 0, hval, i, j, k, histoindex;
+            for (i = vbox.r1; i <= vbox.r2; i++) {
+              for (j = vbox.g1; j <= vbox.g2; j++) {
+                for (k = vbox.b1; k <= vbox.b2; k++) {
+                  histoindex = getColorIndex(i, j, k);
+                  hval = histo[histoindex] || 0;
+                  ntot += hval;
+                  rsum += hval * (i + 0.5) * mult;
+                  gsum += hval * (j + 0.5) * mult;
+                  bsum += hval * (k + 0.5) * mult;
+                }
+              }
+            }
+            if (ntot) {
+              vbox._avg = [~~(rsum / ntot), ~~(gsum / ntot), ~~(bsum / ntot)];
+            } else {
+              vbox._avg = [~~(mult * (vbox.r1 + vbox.r2 + 1) / 2), ~~(mult * (vbox.g1 + vbox.g2 + 1) / 2), ~~(mult * (vbox.b1 + vbox.b2 + 1) / 2)];
+            }
+          }
+          return vbox._avg;
+        },
+        contains: function(pixel) {
+          var vbox = this, rval = pixel[0] >> rshift;
+          gval = pixel[1] >> rshift;
+          bval = pixel[2] >> rshift;
+          return rval >= vbox.r1 && rval <= vbox.r2 && gval >= vbox.g1 && gval <= vbox.g2 && bval >= vbox.b1 && bval <= vbox.b2;
+        }
+      };
+      function CMap() {
+        this.vboxes = new PQueue(function(a, b) {
+          return pv.naturalOrder(
+            a.vbox.count() * a.vbox.volume(),
+            b.vbox.count() * b.vbox.volume()
+          );
+        });
+        ;
+      }
+      CMap.prototype = {
+        push: function(vbox) {
+          this.vboxes.push({
+            vbox,
+            color: vbox.avg()
+          });
+        },
+        palette: function() {
+          return this.vboxes.map(function(vb) {
+            return vb.color;
+          });
+        },
+        size: function() {
+          return this.vboxes.size();
+        },
+        map: function(color) {
+          var vboxes = this.vboxes;
+          for (var i = 0; i < vboxes.size(); i++) {
+            if (vboxes.peek(i).vbox.contains(color)) {
+              return vboxes.peek(i).color;
+            }
+          }
+          return this.nearest(color);
+        },
+        nearest: function(color) {
+          var vboxes = this.vboxes, d1, d2, pColor;
+          for (var i = 0; i < vboxes.size(); i++) {
+            d2 = Math.sqrt(
+              Math.pow(color[0] - vboxes.peek(i).color[0], 2) + Math.pow(color[1] - vboxes.peek(i).color[1], 2) + Math.pow(color[2] - vboxes.peek(i).color[2], 2)
+            );
+            if (d2 < d1 || d1 === void 0) {
+              d1 = d2;
+              pColor = vboxes.peek(i).color;
+            }
+          }
+          return pColor;
+        },
+        forcebw: function() {
+          var vboxes = this.vboxes;
+          vboxes.sort(function(a, b) {
+            return pv.naturalOrder(pv.sum(a.color), pv.sum(b.color));
+          });
+          var lowest = vboxes[0].color;
+          if (lowest[0] < 5 && lowest[1] < 5 && lowest[2] < 5)
+            vboxes[0].color = [0, 0, 0];
+          var idx = vboxes.length - 1, highest = vboxes[idx].color;
+          if (highest[0] > 251 && highest[1] > 251 && highest[2] > 251)
+            vboxes[idx].color = [255, 255, 255];
+        }
+      };
+      function getHisto(pixels) {
+        var histosize = 1 << 3 * sigbits, histo = new Array(histosize), index, rval, gval2, bval2;
+        pixels.forEach(function(pixel) {
+          rval = pixel[0] >> rshift;
+          gval2 = pixel[1] >> rshift;
+          bval2 = pixel[2] >> rshift;
+          index = getColorIndex(rval, gval2, bval2);
+          histo[index] = (histo[index] || 0) + 1;
+        });
+        return histo;
+      }
+      function vboxFromPixels(pixels, histo) {
+        var rmin = 1e6, rmax = 0, gmin = 1e6, gmax = 0, bmin = 1e6, bmax = 0, rval, gval2, bval2;
+        pixels.forEach(function(pixel) {
+          rval = pixel[0] >> rshift;
+          gval2 = pixel[1] >> rshift;
+          bval2 = pixel[2] >> rshift;
+          if (rval < rmin) rmin = rval;
+          else if (rval > rmax) rmax = rval;
+          if (gval2 < gmin) gmin = gval2;
+          else if (gval2 > gmax) gmax = gval2;
+          if (bval2 < bmin) bmin = bval2;
+          else if (bval2 > bmax) bmax = bval2;
+        });
+        return new VBox(rmin, rmax, gmin, gmax, bmin, bmax, histo);
+      }
+      function medianCutApply(histo, vbox) {
+        if (!vbox.count()) return;
+        var rw = vbox.r2 - vbox.r1 + 1, gw = vbox.g2 - vbox.g1 + 1, bw = vbox.b2 - vbox.b1 + 1, maxw = pv.max([rw, gw, bw]);
+        if (vbox.count() == 1) {
+          return [vbox.copy()];
+        }
+        var total = 0, partialsum = [], lookaheadsum = [], i, j, k, sum, index;
+        if (maxw == rw) {
+          for (i = vbox.r1; i <= vbox.r2; i++) {
+            sum = 0;
+            for (j = vbox.g1; j <= vbox.g2; j++) {
+              for (k = vbox.b1; k <= vbox.b2; k++) {
+                index = getColorIndex(i, j, k);
+                sum += histo[index] || 0;
+              }
+            }
+            total += sum;
+            partialsum[i] = total;
+          }
+        } else if (maxw == gw) {
+          for (i = vbox.g1; i <= vbox.g2; i++) {
+            sum = 0;
+            for (j = vbox.r1; j <= vbox.r2; j++) {
+              for (k = vbox.b1; k <= vbox.b2; k++) {
+                index = getColorIndex(j, i, k);
+                sum += histo[index] || 0;
+              }
+            }
+            total += sum;
+            partialsum[i] = total;
+          }
+        } else {
+          for (i = vbox.b1; i <= vbox.b2; i++) {
+            sum = 0;
+            for (j = vbox.r1; j <= vbox.r2; j++) {
+              for (k = vbox.g1; k <= vbox.g2; k++) {
+                index = getColorIndex(j, k, i);
+                sum += histo[index] || 0;
+              }
+            }
+            total += sum;
+            partialsum[i] = total;
+          }
+        }
+        partialsum.forEach(function(d, i2) {
+          lookaheadsum[i2] = total - d;
+        });
+        function doCut(color) {
+          var dim1 = color + "1", dim2 = color + "2", left, right, vbox1, vbox2, d2, count2 = 0;
+          for (i = vbox[dim1]; i <= vbox[dim2]; i++) {
+            if (partialsum[i] > total / 2) {
+              vbox1 = vbox.copy();
+              vbox2 = vbox.copy();
+              left = i - vbox[dim1];
+              right = vbox[dim2] - i;
+              if (left <= right)
+                d2 = Math.min(vbox[dim2] - 1, ~~(i + right / 2));
+              else d2 = Math.max(vbox[dim1], ~~(i - 1 - left / 2));
+              while (!partialsum[d2]) d2++;
+              count2 = lookaheadsum[d2];
+              while (!count2 && partialsum[d2 - 1]) count2 = lookaheadsum[--d2];
+              vbox1[dim2] = d2;
+              vbox2[dim1] = vbox1[dim2] + 1;
+              return [vbox1, vbox2];
+            }
+          }
+        }
+        return maxw == rw ? doCut("r") : maxw == gw ? doCut("g") : doCut("b");
+      }
+      function quantize2(pixels, maxcolors) {
+        if (!pixels.length || maxcolors < 2 || maxcolors > 256) {
+          return false;
+        }
+        var histo = getHisto(pixels), histosize = 1 << 3 * sigbits;
+        var nColors = 0;
+        histo.forEach(function() {
+          nColors++;
+        });
+        if (nColors <= maxcolors) {
+        }
+        var vbox = vboxFromPixels(pixels, histo), pq = new PQueue(function(a, b) {
+          return pv.naturalOrder(a.count(), b.count());
+        });
+        pq.push(vbox);
+        function iter(lh, target) {
+          var ncolors = 1, niters = 0, vbox2;
+          while (niters < maxIterations) {
+            vbox2 = lh.pop();
+            if (!vbox2.count()) {
+              lh.push(vbox2);
+              niters++;
+              continue;
+            }
+            var vboxes = medianCutApply(histo, vbox2), vbox1 = vboxes[0], vbox22 = vboxes[1];
+            if (!vbox1) {
+              return;
+            }
+            lh.push(vbox1);
+            if (vbox22) {
+              lh.push(vbox22);
+              ncolors++;
+            }
+            if (ncolors >= target) return;
+            if (niters++ > maxIterations) {
+              return;
+            }
+          }
+        }
+        iter(pq, fractByPopulations * maxcolors);
+        var pq2 = new PQueue(function(a, b) {
+          return pv.naturalOrder(a.count() * a.volume(), b.count() * b.volume());
+        });
+        while (pq.size()) {
+          pq2.push(pq.pop());
+        }
+        iter(pq2, maxcolors - pq2.size());
+        var cmap = new CMap();
+        while (pq2.size()) {
+          cmap.push(pq2.pop());
+        }
+        return cmap;
+      }
+      return {
+        quantize: quantize2
+      };
+    }();
+    module.exports = MMCQ.quantize;
+  }
+});
+
+// src/node/@design-edito/thumbnails/colors/index.ts
+var colors_exports = {};
+__export(colors_exports, {
+  HEXToRGB: () => HEXToRGB,
+  HSLToRGB: () => HSLToRGB,
+  RGBToHSL: () => RGBToHSL,
+  RGBToHex: () => RGBToHex,
+  complementColor: () => complementColor,
+  extractPaletteFromImage: () => extractPaletteFromImage,
+  getPalette: () => getPalette,
+  getPixel: () => getPixel,
+  getPixels: () => getPixels,
+  ligthenColor: () => ligthenColor,
+  saturateColor: () => saturateColor,
+  toHex: () => toHex
+});
+var import_quantize = __toESM(require_quantize(), 1);
+function extractPaletteFromImage(data, imageDimensions, options) {
+  const pixels = getPixels(data, imageDimensions.w, imageDimensions.h);
+  const palette = getPalette(pixels, options.extractPaletteDensity);
+  const complementaryPalette = palette.map((color) => complementColor(color));
+  return {
+    default: {
+      default: palette,
+      saturate: palette.map((color) => saturateColor(color, options.saturateIntensity)),
+      lighten: palette.map((color) => ligthenColor(color, options.lightenIntensity))
+    },
+    complementary: {
+      default: complementaryPalette,
+      saturate: complementaryPalette.map((color) => saturateColor(color, options.saturateIntensity)),
+      lighten: complementaryPalette.map((color) => ligthenColor(color, options.lightenIntensity))
+    }
+  };
+}
+var getPixel = (data, x, y, width, nbChannels) => {
+  const index = nbChannels * (width * y + x);
+  const r = data[index] || 0;
+  const g = data[index + 1] || 0;
+  const b = data[index + 2] || 0;
+  return [r, g, b];
+};
+var getPixels = (data, width, height, nbChannels = 3) => {
+  const pixels = [];
+  for (let i = 0; i < width; i++) {
+    for (let j = 0; j < height; j++) {
+      const pixel = getPixel(data, i, j, width, nbChannels);
+      pixels.push(pixel);
+    }
+  }
+  return pixels;
+};
+var getPalette = (pixels, paletteDensity) => {
+  const _paletteDensity = paletteDensity < 5 ? paletteDensity - 1 : paletteDensity;
+  const colorMap = (0, import_quantize.default)(pixels, _paletteDensity);
+  const palette = colorMap ? colorMap.palette() : [];
+  return palette;
+};
+var toHex = (c) => {
+  const hex = c.toString(16);
+  return hex.length === 1 ? `0${hex}` : hex;
+};
+var RGBToHSL = (color) => {
+  const r = color[0] / 255;
+  const g = color[1] / 255;
+  const b = color[2] / 255;
+  const l = Math.max(r, g, b);
+  const s = l - Math.min(r, g, b);
+  const h = s ? l === r ? (g - b) / s : l === g ? 2 + (b - r) / s : 4 + (r - g) / s : 0;
+  const outputH = 60 * h < 0 ? 60 * h + 360 : 60 * h;
+  const outputS = 100 * (s ? l <= 0.5 ? s / (2 * l - s) : s / (2 - (2 * l - s)) : 0);
+  const outputL = 100 * (2 * l - s) / 2;
+  return [outputH, outputS, outputL];
+};
+var HSLToRGB = (color) => {
+  const h = color[0];
+  const s = color[1] / 100;
+  const l = color[2] / 100;
+  const k = (n) => (n + h / 30) % 12;
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  const r = Math.round(255 * f(0));
+  const g = Math.round(255 * f(8));
+  const b = Math.round(255 * f(4));
+  return [r, g, b];
+};
+var HEXToRGB = (hexColor) => {
+  const _hexColor = hexColor.replace("#", "");
+  const r = Math.max(0, Math.min(255, parseInt(_hexColor.substring(0, 2), 16)));
+  const g = Math.max(0, Math.min(255, parseInt(_hexColor.substring(2, 4), 16)));
+  const b = Math.max(0, Math.min(255, parseInt(_hexColor.substring(4, 6), 16)));
+  return [r, g, b];
+};
+var RGBToHex = (color) => {
+  return `#${toHex(color[0])}${toHex(color[1])}${toHex(color[2])}`;
+};
+var complementColor = (color) => {
+  const [r, g, b] = color;
+  const m = Math.min(r, g, b) + Math.max(r, g, b);
+  return [m - r, m - g, m - b];
+};
+var ligthenColor = (color, intensity = 20) => {
+  const [h, s, l] = RGBToHSL(color);
+  const rgb = HSLToRGB([h, s, Math.min(100, l + intensity)]);
+  return rgb;
+};
+var saturateColor = (color, intensity = 20) => {
+  const [h, s, l] = RGBToHSL(color);
+  const rgb = HSLToRGB([h, Math.min(100, s + intensity), l]);
+  return rgb;
+};
+
+export {
+  extractPaletteFromImage,
+  getPixel,
+  getPixels,
+  getPalette,
+  toHex,
+  RGBToHSL,
+  HSLToRGB,
+  HEXToRGB,
+  RGBToHex,
+  complementColor,
+  ligthenColor,
+  saturateColor,
+  colors_exports
+};