@mxfb/tools 0.3.0 → 1.0.0

package/chunks/chunk-KIONYWA7.js

@@ -1,168 +0,0 @@
-import {
-  isValidClassName
-} from "./chunk-W5A2TON3.js";
-import {
-  isFalsy
-} from "./chunk-QXAJXTXV.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
-};

package/chunks/chunk-KQT5CTGF.js

@@ -1,21 +0,0 @@
-import {
-  Crossenv
-} from "./chunk-GJOU3UAL.js";
-import {
-  Errors
-} from "./chunk-MT74WIQR.js";
-
-// src/shared/errors/index.ts
-var register = new Errors.Register({
-  ["no-window-document-on-runtime" /* NO_DOCUMENT */]: {
-    message: `Runtime '${Crossenv.detectRuntime()}' does not provide a Document object, cannot complete.`
-  },
-  ["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()}'`,
-    makeDetails: (tips) => tips
-  }
-});
-
-export {
-  register
-};

package/chunks/chunk-LEXQ6E6L.js

@@ -1,31 +0,0 @@
-// src/node/process/on-exit/index.ts
-var forceExitEvents = ["SIGINT", "SIGTERM", "uncaughtException"];
-function beforeForcedExit(callback) {
-  forceExitEvents.forEach((ev) => process.on(ev, callback));
-}
-function beforeExit(callback) {
-  process.on("beforeExit", callback);
-}
-function onExit(callback) {
-  process.on("exit", callback);
-}
-function onAllExits(callback) {
-  let alreadyCalled = false;
-  const actualCallback = () => {
-    if (!alreadyCalled) {
-      alreadyCalled = true;
-      callback();
-    }
-  };
-  beforeForcedExit(actualCallback);
-  beforeExit(actualCallback);
-  onExit(actualCallback);
-}
-
-export {
-  forceExitEvents,
-  beforeForcedExit,
-  beforeExit,
-  onExit,
-  onAllExits
-};

package/chunks/chunk-LQFKUNVQ.js

@@ -1,19 +0,0 @@
-// src/agnostic/strings/matches/index.ts
-function matches(input, matcher) {
-  if (typeof matcher === "string") return input === matcher;
-  return input.match(matcher) !== null;
-}
-function matchesSome(input, matchers) {
-  if (!Array.isArray(matchers)) return matches(input, matchers);
-  return matchers.some((matcher) => matches(input, matcher));
-}
-function matchesEvery(input, matchers) {
-  if (!Array.isArray(matchers)) return matches(input, matchers);
-  return matchers.every((matcher) => matches(input, matcher));
-}
-
-export {
-  matches,
-  matchesSome,
-  matchesEvery
-};

package/chunks/chunk-MF56TTC5.js

@@ -1,15 +0,0 @@
-// src/agnostic/strings/replace-all/index.ts
-function replaceAll(input, pattern, replacer, maxOps = 1e3) {
-  let output = input;
-  let opsCnt = 0;
-  while (output.match(pattern) && opsCnt < maxOps) {
-    opsCnt++;
-    if (typeof replacer === "function") output = output.replace(pattern, replacer);
-    else output = output.replace(pattern, replacer);
-  }
-  return output;
-}
-
-export {
-  replaceAll
-};

package/chunks/chunk-MT74WIQR.js

@@ -1,41 +0,0 @@
-// src/agnostic/errors/index.ts
-var Errors;
-((Errors2) => {
-  class CustomError extends Error {
-    code;
-    details;
-    constructor(data) {
-      const { code, message, details } = data;
-      super(message);
-      this.code = code;
-      this.details = details;
-    }
-  }
-  Errors2.CustomError = CustomError;
-  class Register {
-    _source;
-    constructor(source) {
-      this._source = source;
-    }
-    getFactory(code) {
-      return this._source[code];
-    }
-    getData(code, ...params) {
-      const core = this.getFactory(code);
-      const { message, makeDetails } = core;
-      return {
-        code,
-        message,
-        details: makeDetails?.(...params)
-      };
-    }
-    getError(code, ...params) {
-      return new CustomError(this.getData(code, ...params));
-    }
-  }
-  Errors2.Register = Register;
-})(Errors || (Errors = {}));
-
-export {
-  Errors
-};

package/chunks/chunk-NRITRUZW.js

@@ -1,10 +0,0 @@
-// src/node/files/is-in-directory/index.ts
-import path from "node:path";
-function isInDirectory(childPath, parentPath) {
-  const rel = path.relative(parentPath, childPath);
-  return rel !== "" && !rel.startsWith("..");
-}
-
-export {
-  isInDirectory
-};

package/chunks/chunk-NRJQKVQV.js

@@ -1,31 +0,0 @@
-import {
-  Sanitize
-} from "./chunk-IFD7GSGK.js";
-import {
-  register
-} from "./chunk-KQT5CTGF.js";
-import {
-  Crossenv
-} from "./chunk-GJOU3UAL.js";
-
-// src/agnostic/html/string-to-nodes/index.ts
-function stringToNodes(dirtyStr, options) {
-  const actualDocument = options?.documentObj ?? Crossenv.getDocument();
-  if (actualDocument === null) throw register.getError("no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */, "See documentObj in the options object");
-  const sanitizeOptions = {
-    ...options?.sanitize,
-    documentObj: options?.sanitize?.documentObj ?? options?.documentObj
-  };
-  const str = options?.sanitize !== void 0 ? Sanitize.sanitize(dirtyStr, sanitizeOptions) : dirtyStr;
-  const wrapperDiv = actualDocument.createElement("div");
-  wrapperDiv.innerHTML = str;
-  const nodes = Array.from(wrapperDiv.childNodes).filter((node) => {
-    const allowedNodeTypes = [Node.ELEMENT_NODE, Node.TEXT_NODE];
-    return allowedNodeTypes.includes(node.nodeType);
-  });
-  return nodes;
-}
-
-export {
-  stringToNodes
-};

package/chunks/chunk-OSAXBA7G.js

@@ -1,10 +0,0 @@
-// src/agnostic/numbers/clamp/index.ts
-function clamp(num, bound1, bound2) {
-  const min = Math.min(bound1, bound2);
-  const max = Math.max(bound1, bound2);
-  return Math.min(Math.max(num, min), max);
-}
-
-export {
-  clamp
-};

package/chunks/chunk-PO3V3I57.js

@@ -1,23 +0,0 @@
-import {
-  Cast
-} from "./chunk-4QQBKBYH.js";
-
-// src/agnostic/objects/flatten-getters/index.ts
-function flattenGetters(obj) {
-  try {
-    const { entries, getOwnPropertyDescriptors } = Object;
-    const properties = Cast.toRecord(obj);
-    const getters = entries(getOwnPropertyDescriptors(obj)).filter(([_, desc]) => typeof desc.get === "function").map(([key]) => key);
-    const returned = { ...properties };
-    getters.forEach((getter) => {
-      returned[getter] = obj[getter];
-    });
-    return returned;
-  } catch (err) {
-    return {};
-  }
-}
-
-export {
-  flattenGetters
-};

package/chunks/chunk-QXAJXTXV.js

@@ -1,19 +0,0 @@
-import {
-  nullishValues
-} from "./chunk-HC6ZOHCS.js";
-
-// src/agnostic/booleans/is-falsy/index.ts
-var falsyValues = [...nullishValues, false, "", 0, -0, NaN];
-if (typeof BigInt === "function") falsyValues.push(BigInt(0));
-function isFalsy(val) {
-  return falsyValues.includes(val);
-}
-function isNotFalsy(val) {
-  return !isFalsy(val);
-}
-
-export {
-  falsyValues,
-  isFalsy,
-  isNotFalsy
-};

package/chunks/chunk-RCO57B6F.js

@@ -1,9 +0,0 @@
-// src/agnostic/misc/is-constructor-function/index.ts
-function isConstructorFunction(input) {
-  if (typeof input !== "function") return false;
-  return "prototype" in input && "constructor" in input.prototype;
-}
-
-export {
-  isConstructorFunction
-};

package/chunks/chunk-SQZGZ3VT.js

@@ -1,15 +0,0 @@
-// src/agnostic/html/get-node-ancestors/index.ts
-function getNodeAncestors(node) {
-  const returned = [];
-  let currentElement = node.parentElement;
-  while (currentElement !== null) {
-    returned.push(currentElement);
-    const newCurrentElement = currentElement.parentElement;
-    currentElement = newCurrentElement;
-  }
-  return returned;
-}
-
-export {
-  getNodeAncestors
-};

package/chunks/chunk-TTZHPIH7.js

@@ -1,237 +0,0 @@
-// src/agnostic/misc/tennis/index.ts
-var Tennis;
-((Tennis2) => {
-  let Score;
-  ((Score2) => {
-    class Game {
-      format;
-      pointsSequence = [];
-      constructor(format) {
-        this.format = format;
-      }
-      add(point) {
-        if (!this.isFinished()) this.pointsSequence.push(point);
-        return this;
-      }
-      getNumericScore() {
-        const { pointsSequence, format } = this;
-        const { upTo, diffToWin } = format;
-        return pointsSequence.reduce((reduced, point) => {
-          const [aScore, bScore] = reduced;
-          const aWon = aScore >= upTo && aScore - bScore >= diffToWin;
-          const bWon = bScore >= upTo && bScore - aScore >= diffToWin;
-          if (aWon || bWon) return reduced;
-          return point ? [aScore + 1, bScore] : [aScore, bScore + 1];
-        }, [0, 0]);
-      }
-      static numericToStringScoreValue(numScore) {
-        const [aScore, bScore] = numScore;
-        if (aScore >= 3 && bScore >= 3) {
-          if (aScore === bScore) return "deuce";
-          if (aScore < bScore) return "Ad/40";
-          return "40/Ad";
-        }
-        const strScoresList = ["0", "15", "30", "40"];
-        return `${strScoresList.at(aScore) ?? "?"}/${strScoresList.at(bScore) ?? "?"}`;
-      }
-      getScore() {
-        return Game.numericToStringScoreValue(this.getNumericScore());
-      }
-      isFinished() {
-        const { format } = this;
-        const { upTo, diffToWin } = format;
-        const [aScore, bScore] = this.getNumericScore();
-        const maxScoreReached = Math.max(aScore, bScore) >= upTo;
-        const diffReached = Math.abs(aScore - bScore) >= diffToWin;
-        if (maxScoreReached && diffReached) return true;
-        return false;
-      }
-      getWinner() {
-        if (!this.isFinished()) return null;
-        const [aScore, bScore] = this.getNumericScore();
-        return aScore > bScore;
-      }
-    }
-    Score2.Game = Game;
-    class Set {
-      format;
-      pointsSequence = [];
-      constructor(format) {
-        this.format = format;
-      }
-      add(point) {
-        this.pointsSequence.push(point);
-      }
-      getGames() {
-        const { format } = this;
-        const { upTo, diffToWin, gamesFormat, tieBreakFormat, tieBreakAt } = format;
-        let aGames = 0;
-        let bGames = 0;
-        const games = [];
-        const { pointsSequence } = this;
-        pointsSequence.forEach((point) => {
-          const maxGamesReached = Math.max(aGames, bGames) >= upTo;
-          const diffReached = Math.abs(aGames - bGames) >= diffToWin;
-          if (maxGamesReached && diffReached) return;
-          const lastGameInList = games.at(-1);
-          const lastGameIsFinished = lastGameInList?.isFinished();
-          if (lastGameInList === void 0 || lastGameIsFinished === true) {
-            const isTiebreak = aGames === bGames && aGames === tieBreakAt;
-            if (isTiebreak) games.push(new Game(tieBreakFormat));
-            else games.push(new Game(gamesFormat));
-          }
-          const currentGame = games.at(-1);
-          if (currentGame === void 0) throw "Something went wrong, this should't be undefined";
-          currentGame.add(point);
-          const currentGameWinner = currentGame.getWinner();
-          if (currentGameWinner === true) {
-            aGames += 1;
-          }
-          if (currentGameWinner === false) {
-            bGames += 1;
-          }
-        });
-        return games;
-      }
-      getNumericScore() {
-        const games = this.getGames();
-        let aScore = 0;
-        let bScore = 0;
-        games.forEach((game) => {
-          const winner = game.getWinner();
-          if (winner === true) {
-            aScore++;
-          }
-          if (winner === false) {
-            bScore++;
-          }
-        });
-        const lastGame = games.at(-1);
-        if (lastGame === void 0) return { games: [aScore, bScore] };
-        if (lastGame.isFinished() === false) return {
-          games: [aScore, bScore],
-          currentGame: lastGame.getNumericScore()
-        };
-        return { games: [aScore, bScore] };
-      }
-      getScore() {
-        const numericScore = this.getNumericScore();
-        const { games, currentGame } = numericScore;
-        if (currentGame === void 0) return `${games.join("/")}`;
-        return `${games.join("/")} ${Game.numericToStringScoreValue(currentGame)}`;
-      }
-      isFinished() {
-        const { format } = this;
-        const { upTo, diffToWin, tieBreakAt } = format;
-        const [aScore, bScore] = this.getNumericScore().games;
-        const maxGamesReached = Math.max(aScore, bScore) >= upTo;
-        const diffReached = Math.abs(aScore - bScore) >= diffToWin;
-        const tieBreakBeenPlayed = tieBreakAt !== null && Math.max(aScore, bScore) > tieBreakAt;
-        return tieBreakBeenPlayed || maxGamesReached && diffReached;
-      }
-      getWinner() {
-        if (!this.isFinished()) return null;
-        const [aScore, bScore] = this.getNumericScore().games;
-        return aScore > bScore;
-      }
-    }
-    Score2.Set = Set;
-    class Match {
-      format;
-      pointsSequence = [];
-      constructor(format) {
-        this.format = format;
-      }
-      add(point) {
-        this.pointsSequence.push(point);
-      }
-      getSets() {
-        const { format } = this;
-        const { upTo, setsFormat, lastSetFormat } = format;
-        let aSets = 0;
-        let bSets = 0;
-        const sets = [];
-        const { pointsSequence } = this;
-        pointsSequence.forEach((point) => {
-          const maxSetsReached = Math.max(aSets, bSets) >= upTo;
-          if (maxSetsReached) return;
-          const lastSetInList = sets.at(-1);
-          const lastSetIsFinished = lastSetInList?.isFinished();
-          if (lastSetInList === void 0 || lastSetIsFinished === true) {
-            const isLastSet = aSets === bSets && aSets === upTo - 1;
-            if (isLastSet) sets.push(new Set(lastSetFormat));
-            else sets.push(new Set(setsFormat));
-          }
-          const currentSet = sets.at(-1);
-          if (currentSet === void 0) throw "Something went wrong, this should't be undefined";
-          currentSet.add(point);
-          const currentSetWinner = currentSet.getWinner();
-          if (currentSetWinner === true) {
-            aSets += 1;
-          }
-          if (currentSetWinner === false) {
-            bSets += 1;
-          }
-        });
-        return sets;
-      }
-      getNumericScore() {
-        const sets = this.getSets();
-        const numericScore = {
-          sets: [],
-          currentGame: void 0
-        };
-        sets.forEach((set) => {
-          const setNumericScore = set.getNumericScore();
-          const { games, currentGame } = setNumericScore;
-          numericScore.sets.push(games);
-          if (currentGame !== void 0) {
-            numericScore.currentGame = currentGame;
-          }
-        });
-        return numericScore;
-      }
-      getScore() {
-        return this.getSets().map((set) => set.getScore()).join(" ");
-      }
-      isFinished() {
-        const { format } = this;
-        const { upTo } = format;
-        const sets = this.getSets();
-        let aSets = 0;
-        let bSets = 0;
-        sets.forEach((set) => {
-          const winner = set.getWinner();
-          if (winner === true) {
-            aSets++;
-          }
-          if (winner === false) {
-            bSets++;
-          }
-        });
-        return Math.max(aSets, bSets) >= upTo;
-      }
-      getWinner() {
-        if (!this.isFinished()) return null;
-        const sets = this.getSets();
-        let aSets = 0;
-        let bSets = 0;
-        sets.forEach((set) => {
-          const winner = set.getWinner();
-          if (winner === true) {
-            aSets++;
-          }
-          if (winner === false) {
-            bSets++;
-          }
-        });
-        return aSets > bSets;
-      }
-    }
-    Score2.Match = Match;
-  })(Score = Tennis2.Score || (Tennis2.Score = {}));
-})(Tennis || (Tennis = {}));
-
-export {
-  Tennis
-};