@design-edito/tools 0.1.61 → 0.1.62

package/chunks/chunk-L5JWJRZ7.js

@@ -1,484 +0,0 @@
-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
-};

package/chunks/chunk-LAA2DQDK.js

@@ -1,31 +0,0 @@
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-XCBH6NLF.js";
-
-// src/node/@google-cloud/storage/file/download/index.ts
-var download_exports = {};
-__export(download_exports, {
-  download: () => download
-});
-async function download(sourcePath, bucket, options) {
-  const { fileOptions, downloadOptions } = options ?? {};
-  try {
-    const file = bucket.file(sourcePath, fileOptions);
-    const downloaded = await file.download(downloadOptions);
-    return Outcome.makeSuccess(downloaded[0]);
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return Outcome.makeFailure(errStr);
-  }
-}
-
-export {
-  download,
-  download_exports
-};

package/chunks/chunk-LATEK24U.js

@@ -1,31 +0,0 @@
-import {
-  randomPick,
-  randomPickMany
-} from "./chunk-AQBJ6HNB.js";
-import {
-  make
-} from "./chunk-RLAZR3NL.js";
-import {
-  isArrayOf
-} from "./chunk-6RGDWX4A.js";
-import {
-  findDuplicates
-} from "./chunk-YS6WMSWC.js";
-import {
-  shuffle
-} from "./chunk-VJJIYJMY.js";
-
-// src/agnostic/arrays/index.tsx
-var Arrays;
-((Arrays2) => {
-  Arrays2.findDuplicates = findDuplicates;
-  Arrays2.isArrayOf = isArrayOf;
-  Arrays2.make = make;
-  Arrays2.randomPick = randomPick;
-  Arrays2.randomPickMany = randomPickMany;
-  Arrays2.shuffle = shuffle;
-})(Arrays || (Arrays = {}));
-
-export {
-  Arrays
-};