lorem-ipsum/dist/index.cjs

Generates lorem ipsum placeholder text for Node.js, Deno, browsers, and React Native. Developed with Bun.

var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __hasOwnProp = Object.prototype.hasOwnProperty;
function __accessProp(key) {
  return this[key];
}
var __toCommonJS = (from) => {
  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
  if (entry)
    return entry;
  entry = __defProp({}, "__esModule", { value: true });
  if (from && typeof from === "object" || typeof from === "function") {
    for (var key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(entry, key))
        __defProp(entry, key, {
          get: __accessProp.bind(from, key),
          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
        });
  }
  __moduleCache.set(from, entry);
  return entry;
};
var __moduleCache;
var __returnValue = (v) => v;
function __exportSetter(name, newValue) {
  this[name] = __returnValue.bind(null, newValue);
}
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, {
      get: all[name],
      enumerable: true,
      configurable: true,
      set: __exportSetter.bind(all, name)
    });
};

// src/index.js
var exports_src = {};
__export(exports_src, {
  loremIpsum: () => loremIpsum,
  LoremIpsum: () => LoremIpsum,
  Generator: () => Generator
});
module.exports = __toCommonJS(exports_src);

// src/constants.js
var FORMAT_HTML = "html";
var FORMAT_PLAIN = "plain";
var FORMATS = [FORMAT_HTML, FORMAT_PLAIN];
var UNIT_WORDS = "words";
var UNIT_WORD = "word";
var UNIT_SENTENCES = "sentences";
var UNIT_SENTENCE = "sentence";
var UNIT_PARAGRAPHS = "paragraphs";
var UNIT_PARAGRAPH = "paragraph";
var LINE_ENDINGS = {
  POSIX: `
`,
  WIN32: `\r
`
};

// src/words.js
var WORDS = [
  "ad",
  "adipisicing",
  "aliqua",
  "aliquip",
  "amet",
  "anim",
  "aute",
  "cillum",
  "commodo",
  "consectetur",
  "consequat",
  "culpa",
  "cupidatat",
  "deserunt",
  "do",
  "dolor",
  "dolore",
  "duis",
  "ea",
  "eiusmod",
  "elit",
  "enim",
  "esse",
  "est",
  "et",
  "eu",
  "ex",
  "excepteur",
  "exercitation",
  "fugiat",
  "id",
  "in",
  "incididunt",
  "ipsum",
  "irure",
  "labore",
  "laboris",
  "laborum",
  "Lorem",
  "magna",
  "minim",
  "mollit",
  "nisi",
  "non",
  "nostrud",
  "nulla",
  "occaecat",
  "officia",
  "pariatur",
  "proident",
  "qui",
  "quis",
  "reprehenderit",
  "sint",
  "sit",
  "sunt",
  "tempor",
  "ullamco",
  "ut",
  "velit",
  "veniam",
  "voluptate"
];

// src/generator.js
var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
var makeArrayOfLength = (length = 0) => Array.from({ length }, (_, index) => index);

class Generator {
  constructor({
    sentencesPerParagraph = { max: 7, min: 3 },
    wordsPerSentence = { max: 15, min: 5 },
    random,
    words = WORDS
  } = {}) {
    if (sentencesPerParagraph.min > sentencesPerParagraph.max) {
      throw new Error(`Minimum number of sentences per paragraph (${sentencesPerParagraph.min}) cannot exceed maximum (${sentencesPerParagraph.max}).`);
    }
    if (wordsPerSentence.min > wordsPerSentence.max) {
      throw new Error(`Minimum number of words per sentence (${wordsPerSentence.min}) cannot exceed maximum (${wordsPerSentence.max}).`);
    }
    this.sentencesPerParagraph = sentencesPerParagraph;
    this.words = words;
    this.wordsPerSentence = wordsPerSentence;
    this.random = random || Math.random;
  }
  generateRandomInteger(min, max) {
    return Math.floor(this.random() * (max - min + 1) + min);
  }
  generateRandomWords(num) {
    const { min, max } = this.wordsPerSentence;
    const length = num || this.generateRandomInteger(min, max);
    return makeArrayOfLength(length).reduce((accumulator) => `${this.pluckRandomWord()} ${accumulator}`, "").trim();
  }
  generateRandomSentence(num) {
    return `${capitalize(this.generateRandomWords(num))}.`;
  }
  generateRandomParagraph(num) {
    const { min, max } = this.sentencesPerParagraph;
    const length = num || this.generateRandomInteger(min, max);
    return makeArrayOfLength(length).reduce((accumulator) => `${this.generateRandomSentence()} ${accumulator}`, "").trim();
  }
  pluckRandomWord() {
    const index = this.generateRandomInteger(0, this.words.length - 1);
    return this.words[index];
  }
}
var generator_default = Generator;

// src/lorem-ipsum.js
var isReactNative = () => {
  try {
    return navigator.product === "ReactNative";
  } catch {
    return false;
  }
};
var isNodeCompatible = () => typeof process !== "undefined" && typeof process.platform === "string";
var isWindows = () => {
  try {
    return process.platform === "win32";
  } catch {
    return false;
  }
};

class LoremIpsum {
  constructor(options = {}, format = FORMAT_PLAIN, suffix) {
    if (FORMATS.indexOf(format.toLowerCase()) === -1) {
      throw new Error(`${format} is an invalid format. Please use ${FORMATS.join(" or ")}.`);
    }
    this.format = format;
    this.generator = new generator_default(options);
    this.suffix = suffix;
  }
  getLineEnding() {
    if (this.suffix) {
      return this.suffix;
    }
    if (!isReactNative() && isNodeCompatible() && isWindows()) {
      return LINE_ENDINGS.WIN32;
    }
    return LINE_ENDINGS.POSIX;
  }
  formatString(value) {
    if (this.format === FORMAT_HTML) {
      return `<p>${value}</p>`;
    }
    return value;
  }
  formatStrings(values) {
    return values.map((value) => this.formatString(value));
  }
  generateWords(num) {
    return this.formatString(this.generator.generateRandomWords(num));
  }
  generateSentences(num) {
    return this.formatString(this.generator.generateRandomParagraph(num));
  }
  generateParagraphs(num) {
    return this.formatStrings(Array.from({ length: num }, () => this.generator.generateRandomParagraph())).join(this.getLineEnding());
  }
}
var lorem_ipsum_default = LoremIpsum;

// src/index.js
var loremIpsum = ({
  count = 1,
  format = FORMAT_PLAIN,
  paragraphLowerBound = 3,
  paragraphUpperBound = 7,
  random,
  sentenceLowerBound = 5,
  sentenceUpperBound = 15,
  units = UNIT_SENTENCES,
  words = WORDS,
  suffix = ""
} = {}) => {
  const lorem = new lorem_ipsum_default({
    random,
    sentencesPerParagraph: {
      max: paragraphUpperBound,
      min: paragraphLowerBound
    },
    words,
    wordsPerSentence: {
      max: sentenceUpperBound,
      min: sentenceLowerBound
    }
  }, format, suffix);
  switch (units) {
    case UNIT_PARAGRAPHS:
    case UNIT_PARAGRAPH:
      return lorem.generateParagraphs(count);
    case UNIT_SENTENCES:
    case UNIT_SENTENCE:
      return lorem.generateSentences(count);
    case UNIT_WORDS:
    case UNIT_WORD:
      return lorem.generateWords(count);
    default:
      return "";
  }
};