@stacksjs/strings 0.57.4 → 0.58.19

package/README.md

@@ -10,7 +10,7 @@ Easily manipulate & work with strings.
 ## 🤖 Usage
 
 ```bash
-pnpm i -D @stacksjs/strings
+bun install -d @stacksjs/strings
 ```
 
 Now, you can use it in your project:
@@ -18,28 +18,88 @@ Now, you can use it in your project:
 ```js
 import {
   // pluralize
-  isPlural, isSingular, singular, plural,
-  addIrregularRule, addPluralRule, addSingularRule, addUncountableRule,
+  addIrregularRule,
+  addPluralRule,
+  addSingularRule,
+  addUncountableRule,
+  isPlural,
+  isSingular,
+  singular,
+  plural,
 
   // case
-  camelCase, capitalCase, constantCase, dotCase
-  headerCase, kebabCase, noCase, paramCase, pascalCase,
-  pathCase, sentenceCase , snakeCase, titleCase
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  headerCase,
+  kebabCase,
+  noCase,
+  paramCase,
+  pascalCase,
+  pathCase,
+  sentenceCase,
+  snakeCase,
+  titleCase,
 
   // validation
-  isEmail, isStrongPassword, isAlphanumeric, validateUsername, isURL, isMobilePhone, isAlpha, isPostalCode, isDate, isNumeric, isBoolean, isHexColor, isHexadecimal, isBase64, isUUID, isJSON, isCreditCard, isISBN, isIP, isIPRange, isMACAddress, isLatLong, isLatitude, isLongitude, isCurrency, isDataURI, isMimeType, isJWT, isMongoId, isAscii, isBase32, isByteLength, isFQDN, isFullWidth, isHalfWidth, isHash, isHSL, isIBAN, isIdentityCard, isISIN, isISO8601, isISRC, isISSN, isISO31661Alpha2, isISO31661Alpha3
+  isEmail,
+  isStrongPassword,
+  isAlphanumeric,
+  validateUsername,
+  isURL,
+  isMobilePhone,
+  isAlpha,
+  isPostalCode,
+  isDate,
+  isNumeric,
+  isBoolean,
+  isHexColor,
+  isHexadecimal,
+  isBase64,
+  isUUID,
+  isJSON,
+  isCreditCard,
+  isISBN,
+  isIP,
+  isIPRange,
+  isMACAddress,
+  isLatLong,
+  isLatitude,
+  isLongitude,
+  isCurrency,
+  isDataURI,
+  isMimeType,
+  isJWT,
+  isMongoId,
+  isAscii,
+  isBase32,
+  isByteLength,
+  isFQDN,
+  isFullWidth,
+  isHalfWidth,
+  isHash,
+  isHSL,
+  isIBAN,
+  isIdentityCard,
+  isISIN,
+  isISO8601,
+  isISRC,
+  isISSN,
+  isISO31661Alpha2,
+  isISO31661Alpha3
 } from '@stacksjs/strings'
 
-console.log(camelCase('hello world')) //=> "helloWorld"
-console.log(plural('dog')) //=> "dogs"
+console.log(camelCase('hello world')) // => "helloWorld"
+console.log(plural('dog')) // => "dogs"
 ```
 
-To view the full documentation, please visit [https://stacksjs.dev/strings](https://stacksjs.dev/strings).
+To view the full documentation, please visit [https://stacksjs.org/strings](https://stacksjs.org/strings).
 
 ## 🧪 Testing
 
 ```bash
-pnpm test
+bun test
 ```
 
 ## 📈 Changelog
@@ -58,7 +118,7 @@ For help, discussion about best practices, or any other conversation that would
 
 For casual chit-chat with others using this package:
 
-[Join the Stacks Discord Server](https://discord.ow3.org)
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
 
 ## 🙏🏼 Credits
 
@@ -74,4 +134,4 @@ Many thanks to the following core technologies & people who have contributed to
 
 The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
 
-Made with ❤️
+Made with 💙

package/dist/index.js

@@ -0,0 +1,393 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/string.ts
+var exports_string = {};
+__export(exports_string, {
+  truncate: () => {
+    {
+      return truncate;
+    }
+  },
+  toString: () => {
+    {
+      return toString;
+    }
+  },
+  titleCase: () => {
+    {
+      return titleCase;
+    }
+  },
+  template: () => {
+    {
+      return template;
+    }
+  },
+  str: () => {
+    {
+      return str;
+    }
+  },
+  split: () => {
+    {
+      return split;
+    }
+  },
+  snakeCase: () => {
+    {
+      return snakeCase;
+    }
+  },
+  slug: () => {
+    {
+      return slug;
+    }
+  },
+  slash: () => {
+    {
+      return slash;
+    }
+  },
+  singular: () => {
+    {
+      return singular2;
+    }
+  },
+  sentenceCase: () => {
+    {
+      return sentenceCase;
+    }
+  },
+  random: () => {
+    {
+      return random;
+    }
+  },
+  plural: () => {
+    {
+      return plural2;
+    }
+  },
+  pathCase: () => {
+    {
+      return pathCase;
+    }
+  },
+  pascalCase: () => {
+    {
+      return pascalCase;
+    }
+  },
+  paramCase: () => {
+    {
+      return kebabCase2;
+    }
+  },
+  noCase: () => {
+    {
+      return noCase;
+    }
+  },
+  kebabCase: () => {
+    {
+      return kebabCase;
+    }
+  },
+  isSingular: () => {
+    {
+      return isSingular2;
+    }
+  },
+  isPlural: () => {
+    {
+      return isPlural2;
+    }
+  },
+  ensureSuffix: () => {
+    {
+      return ensureSuffix;
+    }
+  },
+  ensurePrefix: () => {
+    {
+      return ensurePrefix;
+    }
+  },
+  dotCase: () => {
+    {
+      return dotCase;
+    }
+  },
+  detectNewline: () => {
+    {
+      return detectNewline;
+    }
+  },
+  detectIndent: () => {
+    {
+      return default2;
+    }
+  },
+  constantCase: () => {
+    {
+      return constantCase;
+    }
+  },
+  capitalize: () => {
+    {
+      return capitalize;
+    }
+  },
+  capitalCase: () => {
+    {
+      return capitalCase;
+    }
+  },
+  camelCase: () => {
+    {
+      return camelCase;
+    }
+  },
+  addUncountableRule: () => {
+    {
+      return addUncountableRule2;
+    }
+  },
+  addSingularRule: () => {
+    {
+      return addSingularRule2;
+    }
+  },
+  addPluralRule: () => {
+    {
+      return addPluralRule2;
+    }
+  },
+  addIrregularRule: () => {
+    {
+      return addIrregularRule2;
+    }
+  },
+  Str: () => {
+    {
+      return Str;
+    }
+  }
+});
+
+// src/utils.ts
+import slugify from "slugify";
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function ensurePrefix(prefix, str) {
+  if (!str.startsWith(prefix))
+    return prefix + str;
+  return str;
+}
+function ensureSuffix(suffix, str) {
+  return str.endsWith(suffix) ? str : str + suffix;
+}
+function template(str, ...args) {
+  return str.replace(/{(\d+)}/g, (match, key) => {
+    const index = Number(key);
+    return Number.isNaN(index) ? match : args[index];
+  });
+}
+function truncate(str, length, end = "...") {
+  if (str.length <= length)
+    return str;
+  return str.slice(0, length - end.length) + end;
+}
+function random(size = 16, dict = urlAlphabet) {
+  let id = "";
+  let i = size;
+  const len = dict.length;
+  while (i--)
+    id += dict[Math.random() * len | 0];
+  return id;
+}
+function slug(str, options) {
+  if (options)
+    return slugify(str, options);
+  return slugify(str, {
+    lower: true,
+    strict: true
+  });
+}
+import {default as default2} from "detect-indent";
+import {detectNewline} from "detect-newline";
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+// src/case.ts
+function capitalize(str) {
+  return str[0] ? str[0].toUpperCase() + str.slice(1).toLowerCase() : "";
+}
+import {
+camelCase,
+capitalCase,
+constantCase,
+dotCase,
+noCase,
+kebabCase,
+kebabCase as kebabCase2,
+pascalCase,
+pathCase,
+sentenceCase,
+snakeCase,
+split
+} from "change-case";
+import {titleCase} from "title-case";
+// src/pluralize.ts
+import * as pluralize from "pluralize";
+var plural2 = (...args) => pluralize.plural(...args);
+var singular2 = (...args) => pluralize.singular(...args);
+var isPlural2 = (...args) => pluralize.isPlural(...args);
+var isSingular2 = (...args) => pluralize.isSingular(...args);
+var addPluralRule2 = (...args) => pluralize.addPluralRule(...args);
+var addSingularRule2 = (...args) => pluralize.addSingularRule(...args);
+var addIrregularRule2 = (...args) => pluralize.addIrregularRule(...args);
+var addUncountableRule2 = (...args) => pluralize.addUncountableRule(...args);
+// src/macro.ts
+var Str = {
+  slash(str) {
+    return slash(str);
+  },
+  ensurePrefix(prefix, str) {
+    return ensurePrefix(prefix, str);
+  },
+  ensureSuffix(suffix, str) {
+    return ensureSuffix(suffix, str);
+  },
+  template(str, ...args) {
+    return template(str, ...args);
+  },
+  truncate(str, length, end = "...") {
+    return truncate(str, length, end);
+  },
+  random(length = 16) {
+    return random(length);
+  },
+  capitalize(str) {
+    return capitalize(str);
+  },
+  slug(str) {
+    return slug(str);
+  },
+  detectIndent(str) {
+    return default2(str);
+  },
+  detectNewline(str) {
+    return detectNewline(str);
+  },
+  camelCase(str) {
+    return camelCase(str);
+  },
+  capitalCase(str) {
+    return capitalCase(str);
+  },
+  constantCase(str) {
+    return constantCase(str);
+  },
+  dotCase(str) {
+    return dotCase(str);
+  },
+  noCase(str) {
+    return noCase(str);
+  },
+  paramCase(str) {
+    return kebabCase2(str);
+  },
+  pascalCase(str) {
+    return pascalCase(str);
+  },
+  pathCase(str) {
+    return pathCase(str);
+  },
+  sentenceCase(str) {
+    return sentenceCase(str);
+  },
+  snakeCase(str) {
+    return snakeCase(str);
+  },
+  titleCase(str) {
+    return titleCase(str);
+  },
+  kebabCase(str) {
+    return kebabCase(str);
+  },
+  plural(str) {
+    return plural2(str);
+  },
+  singular(str) {
+    return singular2(str);
+  },
+  isPlural(str) {
+    return isPlural2(str);
+  },
+  isSingular(str) {
+    return isSingular2(str);
+  },
+  addPluralRule(rule, repl) {
+    return addPluralRule2(rule, repl);
+  },
+  addSingularRule(rule, repl) {
+    return addSingularRule2(rule, repl);
+  },
+  addIrregularRule(single, plural3) {
+    return addIrregularRule2(single, plural3);
+  },
+  addUncountableRule(word) {
+    return addUncountableRule2(word);
+  }
+};
+var str = Str;
+// src/helpers.ts
+function toString(v) {
+  return Object.prototype.toString.call(v);
+}
+export {
+  truncate,
+  toString,
+  titleCase,
+  template,
+  exports_string as string,
+  str,
+  split,
+  snakeCase,
+  slug,
+  slash,
+  singular2 as singular,
+  sentenceCase,
+  random,
+  plural2 as plural,
+  pathCase,
+  pascalCase,
+  kebabCase2 as paramCase,
+  noCase,
+  kebabCase,
+  isSingular2 as isSingular,
+  isPlural2 as isPlural,
+  ensureSuffix,
+  ensurePrefix,
+  dotCase,
+  detectNewline,
+  default2 as detectIndent,
+  constantCase,
+  capitalize,
+  capitalCase,
+  camelCase,
+  addUncountableRule2 as addUncountableRule,
+  addSingularRule2 as addSingularRule,
+  addPluralRule2 as addPluralRule,
+  addIrregularRule2 as addIrregularRule,
+  Str
+};

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.57.4",
-  "packageManager": "pnpm@8.6.6",
+  "version": "0.58.19",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/.stacks/core/strings#readme",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/src/strings#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./.stacks/core/strings"
+    "directory": "./storage/framework/core/src/strings"
   },
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
@@ -36,42 +35,47 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "bun": "./src/*",
+      "import": "./dist/*"
     }
   },
-  "module": "dist/index.mjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "contributors": [
-    "Chris Breuer <chris@ow3.org>"
+    "Chris Breuer <chris@stacksjs.org>"
   ],
   "files": [
-    "dist",
-    "README.md"
+    "README.md",
+    "dist"
   ],
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun --bun run build"
+  },
   "peerDependencies": {
-    "@types/pluralize": "^0.0.29",
-    "@types/validator": "^13.7.17",
-    "change-case": "^4.1.2",
+    "@stacksjs/alias": "workspace:*",
+    "@stacksjs/types": "workspace:*"
+  },
+  "dependencies": {
+    "@stacksjs/alias": "workspace:*",
+    "@stacksjs/types": "workspace:*",
+    "change-case": "^5.4.1",
     "detect-indent": "^7.0.1",
-    "detect-newline": "^4.0.0",
+    "detect-newline": "^4.0.1",
     "macroable": "^7.0.2",
     "pluralize": "^8.0.0",
     "slugify": "^1.6.6",
-    "title-case": "^3.0.3",
-    "validator": "^13.9.0",
-    "@stacksjs/alias": "0.57.4",
-    "@stacksjs/types": "0.57.4"
-  },
-  "dependencies": {
-    "macroable": "^7.0.2"
+    "string-ts": "^2.0.0",
+    "title-case": "^4.3.0",
+    "validator": "^13.11.0"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.57.4"
-  },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub",
-    "typecheck": "tsc --noEmit"
+    "@stacksjs/development": "workspace:*",
+    "@types/validator": "^13.11.8"
   }
-}
+}

package/LICENSE.md

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2022 Open Web Foundation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/case.d.ts

@@ -1,11 +0,0 @@
-/**
- * First letter uppercase, other lowercase
- * @category string
- * @example
- * ```
- * capitalize('hello world') => 'Hello world'
- * ```
- */
-export declare function capitalize(str: string): string;
-export { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, paramCase as kebabCase, pascalCase, pathCase, sentenceCase, snakeCase, } from 'change-case';
-export { titleCase } from 'title-case';

package/dist/case.mjs

@@ -1,18 +0,0 @@
-export function capitalize(str) {
-  return str[0].toUpperCase() + str.slice(1).toLowerCase();
-}
-export {
-  camelCase,
-  capitalCase,
-  constantCase,
-  dotCase,
-  headerCase,
-  noCase,
-  paramCase,
-  paramCase as kebabCase,
-  pascalCase,
-  pathCase,
-  sentenceCase,
-  snakeCase
-} from "change-case";
-export { titleCase } from "title-case";

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from './utils';
-export * from './case';
-export * from './pluralize';
-export * from './macro';

package/dist/index.mjs

@@ -1,4 +0,0 @@
-export * from "./utils.mjs";
-export * from "./case.mjs";
-export * from "./pluralize.mjs";
-export * from "./macro.mjs";

package/dist/is.d.ts

@@ -1,43 +0,0 @@
-import type { HashAlgorithm } from '@stacksjs/types';
-export declare function isEmail(email: string): boolean;
-export declare function isStrongPassword(password: string): boolean;
-export declare function isAlphanumeric(username: string): boolean;
-export declare function validateUsername(username: string): boolean;
-export declare function isURL(url: string): boolean;
-export declare function isMobilePhone(phoneNumber: string): boolean;
-export declare function isAlpha(name: string): boolean;
-export declare function isPostalCode(zipCode: string): boolean;
-export declare function isNumeric(number: string): boolean;
-export declare function isHexColor(color: string): boolean;
-export declare function isHexadecimal(hex: string): boolean;
-export declare function isBase64(base64: string): boolean;
-export declare function isUUID(uuid: string): boolean;
-export declare function isJSON(json: string): boolean;
-export declare function isCreditCard(creditCard: string): boolean;
-export declare function isISBN(isbn: string): boolean;
-export declare function isIP(ip: string): boolean;
-export declare function isIPRange(ip: string): boolean;
-export declare function isMACAddress(macAddress: string): boolean;
-export declare function isLatLong(latitude: string): boolean;
-export declare function isLatitude(longitude: string): boolean;
-export declare function isLongitude(longitude: string): boolean;
-export declare function isCurrency(currency: string): boolean;
-export declare function isDataURI(dataURI: string): boolean;
-export declare function isMimeType(mimeType: string): boolean;
-export declare function isJWT(jwt: string): boolean;
-export declare function isAscii(ascii: string): boolean;
-export declare function isBase32(base32: string): boolean;
-export declare function isByteLength(byteLength: string): boolean;
-export declare function isFQDN(fqdn: string): boolean;
-export declare function isFullWidth(fullWidth: string): boolean;
-export declare function isHalfWidth(halfWidth: string): boolean;
-export declare function isHash(hash: string, algorithm: HashAlgorithm): boolean;
-export declare function isHSL(hsl: string): boolean;
-export declare function isIBAN(iban: string): boolean;
-export declare function isIdentityCard(identityCard: string): boolean;
-export declare function isISIN(isin: string): boolean;
-export declare function isISO8601(iso8601: string): boolean;
-export declare function isISRC(isrc: string): boolean;
-export declare function isISSN(issn: string): boolean;
-export declare function isISO31661Alpha2(iso31661Alpha2: string): boolean;
-export declare function isISO31661Alpha3(iso31661Alpha3: string): boolean;

package/dist/is.mjs

@@ -1,127 +0,0 @@
-import v from "validator";
-export function isEmail(email) {
-  return v.isEmail(email);
-}
-export function isStrongPassword(password) {
-  return v.isStrongPassword(password);
-}
-export function isAlphanumeric(username) {
-  return v.isAlphanumeric(username);
-}
-export function validateUsername(username) {
-  return isAlphanumeric(username);
-}
-export function isURL(url) {
-  return v.isURL(url);
-}
-export function isMobilePhone(phoneNumber) {
-  return v.isMobilePhone(phoneNumber);
-}
-export function isAlpha(name) {
-  return v.isAlpha(name);
-}
-export function isPostalCode(zipCode) {
-  return v.isPostalCode(zipCode, "any");
-}
-export function isNumeric(number) {
-  return v.isNumeric(number);
-}
-export function isHexColor(color) {
-  return v.isHexColor(color);
-}
-export function isHexadecimal(hex) {
-  return v.isHexadecimal(hex);
-}
-export function isBase64(base64) {
-  return v.isBase64(base64);
-}
-export function isUUID(uuid) {
-  return v.isUUID(uuid);
-}
-export function isJSON(json) {
-  return v.isJSON(json);
-}
-export function isCreditCard(creditCard) {
-  return v.isCreditCard(creditCard);
-}
-export function isISBN(isbn) {
-  return v.isISBN(isbn);
-}
-export function isIP(ip) {
-  return v.isIP(ip);
-}
-export function isIPRange(ip) {
-  return v.isIPRange(ip);
-}
-export function isMACAddress(macAddress) {
-  return v.isMACAddress(macAddress);
-}
-export function isLatLong(latitude) {
-  return v.isLatLong(latitude);
-}
-export function isLatitude(longitude) {
-  return v.isLatLong(longitude);
-}
-export function isLongitude(longitude) {
-  return v.isLatLong(longitude);
-}
-export function isCurrency(currency) {
-  return v.isCurrency(currency);
-}
-export function isDataURI(dataURI) {
-  return v.isDataURI(dataURI);
-}
-export function isMimeType(mimeType) {
-  return v.isMimeType(mimeType);
-}
-export function isJWT(jwt) {
-  return v.isJWT(jwt);
-}
-export function isAscii(ascii) {
-  return v.isAscii(ascii);
-}
-export function isBase32(base32) {
-  return v.isBase32(base32);
-}
-export function isByteLength(byteLength) {
-  return v.isByteLength(byteLength);
-}
-export function isFQDN(fqdn) {
-  return v.isFQDN(fqdn);
-}
-export function isFullWidth(fullWidth) {
-  return v.isFullWidth(fullWidth);
-}
-export function isHalfWidth(halfWidth) {
-  return v.isHalfWidth(halfWidth);
-}
-export function isHash(hash, algorithm) {
-  return v.isHash(hash, algorithm);
-}
-export function isHSL(hsl) {
-  return v.isHSL(hsl);
-}
-export function isIBAN(iban) {
-  return v.isIBAN(iban);
-}
-export function isIdentityCard(identityCard) {
-  return v.isIdentityCard(identityCard);
-}
-export function isISIN(isin) {
-  return v.isISIN(isin);
-}
-export function isISO8601(iso8601) {
-  return v.isISO8601(iso8601);
-}
-export function isISRC(isrc) {
-  return v.isISRC(isrc);
-}
-export function isISSN(issn) {
-  return v.isISSN(issn);
-}
-export function isISO31661Alpha2(iso31661Alpha2) {
-  return v.isISO31661Alpha2(iso31661Alpha2);
-}
-export function isISO31661Alpha3(iso31661Alpha3) {
-  return v.isISO31661Alpha3(iso31661Alpha3);
-}

package/dist/macro.d.ts

@@ -1,40 +0,0 @@
-import { Macroable } from 'macroable';
-export declare class Str extends Macroable {
-    slash(str: string): string;
-    ensurePrefix(prefix: string, str: string): string;
-    ensureSuffix(suffix: string, str: string): string;
-    template(str: string, ...args: any[]): string;
-    /**
-     * Truncate a string
-     */
-    truncate(str: string, length: number, end?: string): string;
-    random(length?: number): string;
-    capitalize(str: string): string;
-    slug(str: string): string;
-    detectIndent(str: string): import("detect-indent").Indent;
-    detectNewline(str: string): "\r\n" | "\n" | undefined;
-    camelCase(str: string): string;
-    capitalCase(str: string): string;
-    constantCase(str: string): string;
-    dotCase(str: string): string;
-    headerCase(str: string): string;
-    noCase(str: string): string;
-    paramCase(str: string): string;
-    pascalCase(str: string): string;
-    pathCase(str: string): string;
-    sentenceCase(str: string): string;
-    snakeCase(str: string): string;
-    titleCase(str: string): string;
-    kebabCase(str: string): string;
-    plural(str: string): any;
-    singular(str: string): any;
-    isPlural(str: string): any;
-    isSingular(str: string): any;
-    addPluralRule(rule: string | RegExp, repl: string): any;
-    addSingularRule(rule: string | RegExp, repl: string): any;
-    addIrregularRule(single: string, plural: string): any;
-    addUncountableRule(word: string | RegExp): any;
-    static macros: {};
-    static getters: {};
-}
-export declare const str: Str;

package/dist/macro.mjs

@@ -1,105 +0,0 @@
-import { Macroable } from "macroable";
-import * as c from "./case.mjs";
-import * as p from "./pluralize.mjs";
-import * as u from "./utils.mjs";
-export class Str extends Macroable {
-  slash(str2) {
-    return u.slash(str2);
-  }
-  ensurePrefix(prefix, str2) {
-    return u.ensurePrefix(prefix, str2);
-  }
-  ensureSuffix(suffix, str2) {
-    return u.ensureSuffix(suffix, str2);
-  }
-  template(str2, ...args) {
-    return u.template(str2, ...args);
-  }
-  /**
-   * Truncate a string
-   */
-  truncate(str2, length, end = "...") {
-    return u.truncate(str2, length, end);
-  }
-  random(length = 16) {
-    return u.randomStr(length);
-  }
-  capitalize(str2) {
-    return c.capitalize(str2);
-  }
-  slug(str2) {
-    return u.slug(str2);
-  }
-  detectIndent(str2) {
-    return u.detectIndent(str2);
-  }
-  detectNewline(str2) {
-    return u.detectNewline(str2);
-  }
-  camelCase(str2) {
-    return c.camelCase(str2);
-  }
-  capitalCase(str2) {
-    return c.capitalCase(str2);
-  }
-  constantCase(str2) {
-    return c.constantCase(str2);
-  }
-  dotCase(str2) {
-    return c.dotCase(str2);
-  }
-  headerCase(str2) {
-    return c.headerCase(str2);
-  }
-  noCase(str2) {
-    return c.noCase(str2);
-  }
-  paramCase(str2) {
-    return c.paramCase(str2);
-  }
-  pascalCase(str2) {
-    return c.pascalCase(str2);
-  }
-  pathCase(str2) {
-    return c.pathCase(str2);
-  }
-  sentenceCase(str2) {
-    return c.sentenceCase(str2);
-  }
-  snakeCase(str2) {
-    return c.snakeCase(str2);
-  }
-  titleCase(str2) {
-    return c.titleCase(str2);
-  }
-  kebabCase(str2) {
-    return c.kebabCase(str2);
-  }
-  plural(str2) {
-    return p.plural(str2);
-  }
-  singular(str2) {
-    return p.singular(str2);
-  }
-  isPlural(str2) {
-    return p.isPlural(str2);
-  }
-  isSingular(str2) {
-    return p.isSingular(str2);
-  }
-  addPluralRule(rule, repl) {
-    return p.addPluralRule(rule, repl);
-  }
-  addSingularRule(rule, repl) {
-    return p.addSingularRule(rule, repl);
-  }
-  addIrregularRule(single, plural) {
-    return p.addIrregularRule(single, plural);
-  }
-  addUncountableRule(word) {
-    return p.addUncountableRule(word);
-  }
-}
-Str.macros = {};
-Str.getters = {};
-export const str = new Str();

package/dist/pluralize.d.ts

@@ -1,2 +0,0 @@
-declare const plural: any, singular: any, isPlural: any, isSingular: any, addPluralRule: any, addSingularRule: any, addIrregularRule: any, addUncountableRule: any;
-export { plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule };

package/dist/pluralize.mjs

@@ -1,3 +0,0 @@
-import pluralize from "pluralize";
-const { plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule } = pluralize;
-export { plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule };

package/dist/utils.d.ts

@@ -1,69 +0,0 @@
-interface SlugOptions {
-    replacement?: string;
-    remove?: RegExp;
-    lower?: boolean;
-    strict?: boolean;
-    locale?: string;
-    trim?: boolean;
-}
-/**
- * Replace backslash to slash
- *
- * @category String
- * @example
- * ```
- * slash('C:\\Users\\Chris') => 'C:/Users/Chris'
- * ```
- */
-export declare function slash(str: string): string;
-/**
- * Ensure prefix of a string
- *
- * @category String
- * @example
- * ```
- * ensurePrefix('https://', 'google.com') => 'https://google.com'
- * ensurePrefix('https://', 'http://google.com') => 'https://google.com'
- */
-export declare function ensurePrefix(prefix: string, str: string): string;
-/**
- * Ensure suffix of a string
- *
- * @category String
- * @example
- * ```
- * ensureSuffix('.js', 'index') => 'index.js'
- * ensureSuffix('.js', 'index.js') => 'index.js'
- * ```
- */
-export declare function ensureSuffix(suffix: string, str: string): string;
-/**
- * Dead simple template engine, just like Python's `.format()`
- *
- * @category String
- * @example
- * ```
- * const result = template('Hello {0}! My name is {1}.',
- *   'Buddy',
- *   'Chris'
- * ) // Hello Buddy! My name is Chris.
- * ```
- */
-export declare function template(str: string, ...args: any[]): string;
-export declare function truncate(str: string, length: number, end?: string): string;
-/**
- * Generate a random string
- * @category String
- */
-export declare function randomStr(size?: number, dict?: string): string;
-/**
- * Slugify a string
- * @category string
- * @example
- * ```
- * slug('Hello World') => 'hello-world'
- * ```
- */
-export declare function slug(str: string, options?: SlugOptions): string;
-export { default as detectIndent } from 'detect-indent';
-export { detectNewline } from 'detect-newline';

package/dist/utils.mjs

@@ -1,46 +0,0 @@
-import slugify from "slugify";
-const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-export function slash(str) {
-  return str.replace(/\\/g, "/");
-}
-export function ensurePrefix(prefix, str) {
-  if (!str.startsWith(prefix))
-    return prefix + str;
-  return str;
-}
-export function ensureSuffix(suffix, str) {
-  if (!str.endsWith(suffix))
-    return str + suffix;
-  return str;
-}
-export function template(str, ...args) {
-  return str.replace(/{(\d+)}/g, (match, key) => {
-    const index = Number(key);
-    if (Number.isNaN(index))
-      return match;
-    return args[index];
-  });
-}
-export function truncate(str, length, end = "...") {
-  if (str.length <= length)
-    return str;
-  return str.slice(0, length - end.length) + end;
-}
-export function randomStr(size = 16, dict = urlAlphabet) {
-  let id = "";
-  let i = size;
-  const len = dict.length;
-  while (i--)
-    id += dict[Math.random() * len | 0];
-  return id;
-}
-export function slug(str, options) {
-  if (options)
-    return slugify(str, options);
-  return slugify(str, {
-    lower: true,
-    strict: true
-  });
-}
-export { default as detectIndent } from "detect-indent";
-export { detectNewline } from "detect-newline";