@design-edito/tools 0.1.60 → 0.1.62

package/chunks/chunk-7NO34XJI.js

@@ -1,26 +0,0 @@
-import {
-  Crossenv
-} from "./chunk-GGT2PUZH.js";
-import {
-  Errors
-} from "./chunk-2KT7AKRW.js";
-
-// src/shared/errors/index.ts
-var register = Errors.Register.from({
-  ["no-window-document-on-runtime" /* NO_DOCUMENT */]: {
-    message: `Runtime '${Crossenv.detectRuntime()}' does not provide a Document object, cannot complete.`,
-    detailsMaker: () => void 0
-  },
-  ["no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */]: {
-    message: `Please provide a Document object since none are found on runtime '${Crossenv.detectRuntime()}'`,
-    detailsMaker: (tips) => tips
-  },
-  ["impossible-to-pick-in-array" /* IMPOSSIBLE_TO_PICK_IN_ARRAY */]: {
-    message: "Impossible to pick",
-    detailsMaker: (array) => array.length === 0 ? "Array cannot be empty" : "Too many exclusions"
-  }
-});
-
-export {
-  register
-};

package/chunks/chunk-7QIYI4CK.js

@@ -1,209 +0,0 @@
-import {
-  require_lib
-} from "./chunk-53MBV4TG.js";
-import {
-  thumbnails_exports
-} from "./chunk-PPK2JEO6.js";
-import {
-  __toESM
-} from "./chunk-XCBH6NLF.js";
-
-// src/node/images/transform/area-composition/index.ts
-var import_sharp = __toESM(require_lib(), 1);
-var DEFAULT_GENERATE_OPTIONS = {
-  formats: ["jpeg"],
-  nbOutputs: 1,
-  imagePosition: "center",
-  imageOccupation: 60,
-  dimensions: { w: 300, h: 500 },
-  palette: ["default"],
-  maxPaletteDensity: 100,
-  extractPaletteDensity: 8,
-  lightenIntensity: 20,
-  saturateIntensity: 20,
-  colorFilterApply: "all",
-  tileDensityA: { min: 1, max: 1 },
-  tileDensityB: { min: 1, max: 1 },
-  tileCoverage: 50,
-  tileFormat: "default",
-  tileXEasing: "none",
-  tileYEasing: "none"
-};
-async function areaCompose(inputSharp, customOptions) {
-  const options = getOptions(customOptions);
-  const inputMetadata = await inputSharp.metadata();
-  const initialDimensions = {
-    w: inputMetadata.width || 0,
-    h: inputMetadata.height || 0
-  };
-  const inputBufferData = await inputSharp.raw().toBuffer();
-  const imagePalette = thumbnails_exports.Colors.extractPaletteFromImage(inputBufferData, initialDimensions, options);
-  const composedPalette = composePalette(imagePalette, options.palette, options.maxPaletteDensity);
-  inputSharp.png({ quality: 100 });
-  const outputDimensions = {
-    w: options.dimensions.w,
-    h: options.dimensions.h
-  };
-  const resizeInputDimensions = getNewInputImageDimensions(outputDimensions, options.imageOccupation);
-  const resizedInput = inputSharp.resize({
-    width: resizeInputDimensions.w,
-    height: resizeInputDimensions.h,
-    fit: "contain",
-    background: { r: 255, g: 255, b: 255, alpha: 0 }
-    // Add a transparent background
-  }).toFormat("png");
-  const resizedInputPositions = getImagePositions(options.imagePosition, resizeInputDimensions, resizeInputDimensions, outputDimensions);
-  const shapesLayout = thumbnails_exports.Layout.packAreasAndTiles(
-    {
-      ...resizedInputPositions,
-      ...resizeInputDimensions
-    },
-    outputDimensions,
-    options.tileCoverage,
-    { A: options.tileDensityA, B: options.tileDensityB },
-    { X: options.tileXEasing, Y: options.tileYEasing }
-  );
-  const sharpShapes = getSharpTilesInputs(shapesLayout, composedPalette);
-  const sharpShapesForComposite = [];
-  for await (const sharpShape of sharpShapes) {
-    ;
-    sharpShapesForComposite.push({
-      input: await sharpShape.input.toFormat("png").toBuffer(),
-      left: sharpShape.left,
-      top: sharpShape.top
-    });
-  }
-  const background = composedPalette[0] || [255, 255, 255];
-  const outputSharp = await createSharpShape(outputDimensions, background).toFormat("webp");
-  const composedSharp = outputSharp.composite([
-    {
-      input: await resizedInput.toFormat("webp").toBuffer(),
-      /* Converting to png to handle alpha */
-      left: Math.round(resizedInputPositions.x),
-      top: Math.round(resizedInputPositions.y)
-    },
-    ...sharpShapesForComposite
-  ]);
-  return await composedSharp.flatten();
-}
-function getOptions(customOptions) {
-  if (!customOptions) {
-    return DEFAULT_GENERATE_OPTIONS;
-  }
-  ;
-  const options = {
-    ...DEFAULT_GENERATE_OPTIONS,
-    ...customOptions
-  };
-  return options;
-}
-function getNewInputImageDimensions(formatDimensions, imageOccupation) {
-  const placeRatio = imageOccupation / 100;
-  return {
-    w: Math.round(formatDimensions.w * placeRatio),
-    h: Math.round(formatDimensions.h * placeRatio)
-  };
-}
-function composePalette(palette, paletteOption, maxPaletteDensity) {
-  let composedPalette = [];
-  if (paletteOption.includes("default-lighten")) {
-    composedPalette = [...composedPalette, ...palette.default.lighten];
-  }
-  if (paletteOption.includes("default-saturate")) {
-    composedPalette = [...composedPalette, ...palette.default.saturate];
-  }
-  if (paletteOption.includes("complementary")) {
-    composedPalette = [...composedPalette, ...palette.complementary.default];
-  }
-  if (paletteOption.includes("complementary-lighten")) {
-    composedPalette = [...composedPalette, ...palette.complementary.lighten];
-  }
-  if (paletteOption.includes("complementary-saturate")) {
-    composedPalette = [...composedPalette, ...palette.complementary.saturate];
-  }
-  if (paletteOption.includes("default") || !composedPalette.length) {
-    composedPalette = [...composedPalette, ...palette.default.default];
-  }
-  const shuffledPalette = thumbnails_exports.Common.shuffleArray(composedPalette);
-  const outputPalette = composedPalette.length > maxPaletteDensity ? shuffledPalette.splice(0, maxPaletteDensity) : shuffledPalette;
-  return outputPalette;
-}
-function getImagePositions(position, resizedImageDimensions, containedImageDimensions, wrapperDimensions) {
-  switch (position) {
-    case "top-left":
-      return thumbnails_exports.Layout.alignTopLeft(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "top-center":
-      return thumbnails_exports.Layout.alignTopCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "top-right":
-      return thumbnails_exports.Layout.alignTopRight(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "left-center":
-      return thumbnails_exports.Layout.alignLeftCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "center":
-      return thumbnails_exports.Layout.alignCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "right-center":
-      return thumbnails_exports.Layout.alignRightCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "bottom-left":
-      return thumbnails_exports.Layout.alignBottomLeft(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "bottom-center":
-      return thumbnails_exports.Layout.alignBottomCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "bottom-right":
-      return thumbnails_exports.Layout.alignBottomRight(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    default:
-      return { x: 0, y: 0 };
-  }
-}
-function createSharpShape(dimensions, background) {
-  return (0, import_sharp.default)(
-    {
-      create: getCreateSharpShape(dimensions, background)
-    }
-  );
-}
-function getCreateSharpShape(dimensions, background) {
-  return {
-    width: Math.round(dimensions.w),
-    height: Math.round(dimensions.h),
-    channels: 4,
-    background: { r: background[0], g: background[1], b: background[2], alpha: 1 }
-  };
-}
-function getSharpTilesInputs(tiles, palette) {
-  let usedColorsIndexes = [];
-  const paletteLength = palette.length;
-  const getUnusedColorIndex = () => {
-    const paletteIndex = thumbnails_exports.Common.randomInt(paletteLength);
-    resetUnusedColorIndexesIfNeeded();
-    if (usedColorsIndexes.includes(paletteIndex)) {
-      return getUnusedColorIndex();
-    }
-    usedColorsIndexes.push(paletteIndex);
-    return paletteIndex;
-  };
-  const resetUnusedColorIndexesIfNeeded = () => {
-    if (usedColorsIndexes.length !== paletteLength) {
-      return;
-    }
-    usedColorsIndexes = [];
-  };
-  return tiles.map((tile) => {
-    const paletteIndex = getUnusedColorIndex();
-    const color = palette[paletteIndex];
-    if (!color) {
-      return;
-    }
-    return {
-      top: Math.round(tile.y),
-      left: Math.round(tile.x),
-      input: (0, import_sharp.default)(
-        {
-          create: getCreateSharpShape(tile, color)
-        }
-      )
-    };
-  }).filter((sharpShape) => sharpShape !== void 0);
-}
-
-export {
-  areaCompose,
-  getSharpTilesInputs
-};

package/chunks/chunk-7VL2O6SQ.js

@@ -1,211 +0,0 @@
-import {
-  RANDOM_PICK_ERR_SYMBOL,
-  randomPick
-} from "./chunk-FCU6IHKD.js";
-import {
-  Random
-} from "./chunk-S32K7POB.js";
-import {
-  make
-} from "./chunk-RLAZR3NL.js";
-import {
-  findDuplicates
-} from "./chunk-YS6WMSWC.js";
-import {
-  isArrayOf
-} from "./chunk-6RGDWX4A.js";
-
-// src/agnostic/arrays/index.tsx
-var Arrays;
-((Arrays2) => {
-  Arrays2.findDuplicates = findDuplicates;
-  Arrays2.isArrayOf = isArrayOf;
-  Arrays2.make = make;
-  Arrays2.RANDOM_PICK_ERR_SYMBOL = RANDOM_PICK_ERR_SYMBOL;
-  Arrays2.randomPick = randomPick;
-})(Arrays || (Arrays = {}));
-
-// 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-7VTVA56L.js

@@ -1,37 +0,0 @@
-import {
-  Cast,
-  Tree,
-  Utils
-} from "./chunk-WYY3N6PO.js";
-import {
-  Serialize
-} from "./chunk-SXRWMH3U.js";
-import {
-  SmartTags
-} from "./chunk-UT2J62LH.js";
-import {
-  Transformer
-} from "./chunk-BKO7GLC2.js";
-import {
-  Method
-} from "./chunk-RW7VAKJW.js";
-import {
-  Types
-} from "./chunk-XEQ2PBT2.js";
-
-// src/agnostic/html/hyper-json/index.ts
-var HyperJson;
-((HyperJson2) => {
-  HyperJson2.Cast = Cast;
-  HyperJson2.Method = Method;
-  HyperJson2.Serialize = Serialize;
-  HyperJson2.SmartTags = SmartTags;
-  HyperJson2.Transformer = Transformer;
-  HyperJson2.Tree = Tree;
-  HyperJson2.Types = Types;
-  HyperJson2.Utils = Utils;
-})(HyperJson || (HyperJson = {}));
-
-export {
-  HyperJson
-};

package/chunks/chunk-7W5LABV2.js

@@ -1,37 +0,0 @@
-import {
-  Cast,
-  Tree,
-  Utils
-} from "./chunk-42ZKFWKF.js";
-import {
-  Types
-} from "./chunk-XEQ2PBT2.js";
-import {
-  SmartTags
-} from "./chunk-UT2J62LH.js";
-import {
-  Serialize
-} from "./chunk-SXRWMH3U.js";
-import {
-  Transformer
-} from "./chunk-BKO7GLC2.js";
-import {
-  Method
-} from "./chunk-RW7VAKJW.js";
-
-// src/agnostic/html/hyper-json/index.ts
-var HyperJson;
-((HyperJson2) => {
-  HyperJson2.Cast = Cast;
-  HyperJson2.Method = Method;
-  HyperJson2.Serialize = Serialize;
-  HyperJson2.SmartTags = SmartTags;
-  HyperJson2.Transformer = Transformer;
-  HyperJson2.Tree = Tree;
-  HyperJson2.Types = Types;
-  HyperJson2.Utils = Utils;
-})(HyperJson || (HyperJson = {}));
-
-export {
-  HyperJson
-};

package/chunks/chunk-7YW5HL6N.js

@@ -1,168 +0,0 @@
-import {
-  isFalsy
-} from "./chunk-QXAJXTXV.js";
-import {
-  isValidClassName
-} from "./chunk-W5A2TON3.js";
-
-// src/agnostic/css/bem/getNamesArr.ts
-function getNamesArr(arg) {
-  const returned = [];
-  if (typeof arg === "string") {
-    arg.trim().split(/\s+/gm).forEach((name) => {
-      if (isValidClassName(name)) returned.push(name);
-    });
-  } else if (Array.isArray(arg)) {
-    arg.forEach((elt) => returned.push(...getNamesArr(elt)));
-  } else if (typeof arg === "object" && arg !== null) {
-    Object.entries(arg).forEach(([key, val]) => {
-      if (!isFalsy(val)) returned.push(...getNamesArr(key));
-    });
-  }
-  return returned;
-}
-var getNamesArr_default = getNamesArr;
-
-// src/agnostic/css/bem/BEM.ts
-var BEM = class _BEM {
-  constructor() {
-    this.findBlockByName = this.findBlockByName.bind(this);
-    this.addBlock = this.addBlock.bind(this);
-    this.addElement = this.addElement.bind(this);
-    this.addModifier = this.addModifier.bind(this);
-    this.copy = this.copy.bind(this);
-    this.block = this.block.bind(this);
-    this.element = this.element.bind(this);
-    this.modifier = this.modifier.bind(this);
-    this.blk = this.blk.bind(this);
-    this.elt = this.elt.bind(this);
-    this.mod = this.mod.bind(this);
-    this.cp = this.cp.bind(this);
-    this.addSingleBlock = this.addSingleBlock.bind(this);
-    this.addSingleElement = this.addSingleElement.bind(this);
-    this.addSingleModifier = this.addSingleModifier.bind(this);
-    this.setCurrentBlockByName = this.setCurrentBlockByName.bind(this);
-    this.createBlockByName = this.createBlockByName.bind(this);
-    this.getCurrentBlock = this.getCurrentBlock.bind(this);
-  }
-  addBlock(blockNameArg) {
-    const blocksNames = getNamesArr_default(blockNameArg);
-    blocksNames.forEach(this.addSingleBlock);
-    return this;
-  }
-  addElement(elementNameArg) {
-    const elementsNames = getNamesArr_default(elementNameArg);
-    elementsNames.forEach(this.addSingleElement);
-    return this;
-  }
-  addModifier(modifierNameArg) {
-    const currentBlock = this.getCurrentBlock();
-    if (currentBlock === void 0) return this;
-    const modifiersNames = getNamesArr_default(modifierNameArg);
-    modifiersNames.forEach(this.addSingleModifier);
-    return this;
-  }
-  copy() {
-    const copy = new _BEM();
-    this.blocks.forEach((block) => {
-      copy.addBlock(block.name);
-      block.modifiers.forEach(copy.addModifier);
-    });
-    return copy;
-  }
-  block(blockNameArg) {
-    return this.copy().addBlock(blockNameArg);
-  }
-  element(elementNameArg) {
-    return this.copy().addElement(elementNameArg);
-  }
-  modifier(modifierNameArg) {
-    return this.copy().addModifier(modifierNameArg);
-  }
-  blk(blockNameArg) {
-    return this.block(blockNameArg);
-  }
-  elt(elementNameArg) {
-    return this.element(elementNameArg);
-  }
-  mod(modifierNameArg) {
-    return this.modifier(modifierNameArg);
-  }
-  cp() {
-    return this.copy();
-  }
-  get value() {
-    return this.blocks.map((block) => {
-      return [block.name, ...block.modifiers.map((modifier) => {
-        return `${block.name}_${modifier}`;
-      })].join(" ");
-    }).join(" ");
-  }
-  get val() {
-    return this.value;
-  }
-  blocks = [];
-  findBlockByName(name) {
-    return this.blocks.find((block) => block.name === name);
-  }
-  addSingleBlock(blockName) {
-    if (this.findBlockByName(blockName) !== void 0) {
-      this.setCurrentBlockByName(blockName);
-    } else {
-      const block = this.createBlockByName(blockName);
-      this.blocks.push(block);
-    }
-    return this;
-  }
-  addSingleElement(elementName) {
-    const currentBlock = this.getCurrentBlock();
-    if (currentBlock === void 0) this.addBlock(elementName);
-    else {
-      currentBlock.name = currentBlock.name + "__" + elementName;
-    }
-    return this;
-  }
-  addSingleModifier(modifierName) {
-    const currentBlock = this.getCurrentBlock();
-    if (currentBlock !== void 0) {
-      currentBlock.modifiers.push(modifierName);
-    }
-    return this;
-  }
-  setCurrentBlockByName(blockName) {
-    const block = this.findBlockByName(blockName);
-    if (block !== void 0) {
-      const blockPos = this.blocks.indexOf(block);
-      this.blocks = [
-        ...this.blocks.slice(0, blockPos),
-        ...this.blocks.slice(blockPos + 1),
-        block
-      ];
-    }
-    return this;
-  }
-  createBlockByName(blockName) {
-    return { name: blockName, modifiers: [] };
-  }
-  getCurrentBlock() {
-    return this.blocks.slice(-1)[0];
-  }
-};
-var BEM_default = BEM;
-
-// src/agnostic/css/bem/index.ts
-var Bem;
-((Bem2) => {
-  Bem2.BEM = BEM_default;
-  function bem(blockNameArg) {
-    const bem2 = new BEM_default();
-    if (blockNameArg instanceof BEM_default) return blockNameArg.copy();
-    return bem2.addBlock(blockNameArg);
-  }
-  Bem2.bem = bem;
-  Bem2.getNamesArr = getNamesArr_default;
-})(Bem || (Bem = {}));
-
-export {
-  Bem
-};