@stacksjs/strings 0.56.35 → 0.57.3

package/dist/case.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,18 @@
+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,136 +1,4 @@
-import pluralize from 'pluralize';
-import * as detect_indent from 'detect-indent';
-export { default as detectIndent } from 'detect-indent';
-import { Macroable } from 'macroable';
-export { detectNewline } from 'detect-newline';
-export { camelCase, capitalCase, constantCase, dotCase, headerCase, paramCase as kebabCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
-export { titleCase } from 'title-case';
-
-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'
- * ```
- */
-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'
- */
-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'
- * ```
- */
-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.
- * ```
- */
-declare function template(str: string, ...args: any[]): string;
-declare function truncate(str: string, length: number, end?: string): string;
-/**
- * Generate a random string
- * @category String
- */
-declare function randomStr(size?: number, dict?: string): string;
-/**
- * Slugify a string
- * @category string
- * @example
- * ```
- * slug('Hello World') => 'hello-world'
- * ```
- */
-declare function slug(str: string, options?: SlugOptions): string;
-
-/**
- * First letter uppercase, other lowercase
- * @category string
- * @example
- * ```
- * capitalize('hello world') => 'Hello world'
- * ```
- */
-declare function capitalize(str: string): string;
-
-declare const plural: typeof pluralize.plural;
-declare const singular: typeof pluralize.singular;
-declare const isPlural: typeof pluralize.isPlural;
-declare const isSingular: typeof pluralize.isSingular;
-declare const addPluralRule: typeof pluralize.addPluralRule;
-declare const addSingularRule: typeof pluralize.addSingularRule;
-declare const addIrregularRule: typeof pluralize.addIrregularRule;
-declare const addUncountableRule: typeof pluralize.addUncountableRule;
-
-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): 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): string;
-    singular(str: string): string;
-    isPlural(str: string): boolean;
-    isSingular(str: string): boolean;
-    addPluralRule(rule: string | RegExp, repl: string): void;
-    addSingularRule(rule: string | RegExp, repl: string): void;
-    addIrregularRule(single: string, plural: string): void;
-    addUncountableRule(word: string | RegExp): void;
-    static macros: {};
-    static getters: {};
-}
-declare const str: Str;
-
-export { Str, addIrregularRule, addPluralRule, addSingularRule, addUncountableRule, capitalize, ensurePrefix, ensureSuffix, isPlural, isSingular, plural, randomStr, singular, slash, slug, str, template, truncate };
+export * from './utils';
+export * from './case';
+export * from './pluralize';
+export * from './macro';

package/dist/index.mjs

@@ -1,165 +1,4 @@
-import slugify from 'slugify';
-import detectIndent from 'detect-indent';
-export { default as detectIndent } from 'detect-indent';
-import { detectNewline } from 'detect-newline';
-export { detectNewline } from 'detect-newline';
-import { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
-export { camelCase, capitalCase, constantCase, dotCase, headerCase, paramCase as kebabCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
-import { titleCase } from 'title-case';
-export { titleCase } from 'title-case';
-import pluralize from 'pluralize';
-import { Macroable } from 'macroable';
-
-const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-function slash(str) {
-  return str.replace(/\\/g, "/");
-}
-function ensurePrefix(prefix, str) {
-  if (!str.startsWith(prefix))
-    return prefix + str;
-  return str;
-}
-function ensureSuffix(suffix, str) {
-  if (!str.endsWith(suffix))
-    return str + suffix;
-  return str;
-}
-function template(str, ...args) {
-  return str.replace(/{(\d+)}/g, (match, key) => {
-    const index = Number(key);
-    if (Number.isNaN(index))
-      return match;
-    return args[index];
-  });
-}
-function truncate(str, length, end = "...") {
-  if (str.length <= length)
-    return str;
-  return str.slice(0, length - end.length) + end;
-}
-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;
-}
-function slug(str, options) {
-  if (options)
-    return slugify(str, options);
-  return slugify(str, {
-    lower: true,
-    strict: true
-  });
-}
-
-function capitalize(str) {
-  return str[0].toUpperCase() + str.slice(1).toLowerCase();
-}
-
-const { plural, singular, isPlural, isSingular, addPluralRule, addSingularRule, addIrregularRule, addUncountableRule } = pluralize;
-
-class Str extends Macroable {
-  slash(str2) {
-    return slash(str2);
-  }
-  ensurePrefix(prefix, str2) {
-    return ensurePrefix(prefix, str2);
-  }
-  ensureSuffix(suffix, str2) {
-    return ensureSuffix(suffix, str2);
-  }
-  template(str2, ...args) {
-    return template(str2, ...args);
-  }
-  /**
-   * Truncate a string
-   */
-  truncate(str2, length, end = "...") {
-    return truncate(str2, length, end);
-  }
-  random(length = 16) {
-    return randomStr(length);
-  }
-  capitalize(str2) {
-    return capitalize(str2);
-  }
-  slug(str2) {
-    return slug(str2);
-  }
-  detectIndent(str2) {
-    return detectIndent(str2);
-  }
-  detectNewline(str2) {
-    return detectNewline(str2);
-  }
-  camelCase(str2) {
-    return camelCase(str2);
-  }
-  capitalCase(str2) {
-    return capitalCase(str2);
-  }
-  constantCase(str2) {
-    return constantCase(str2);
-  }
-  dotCase(str2) {
-    return dotCase(str2);
-  }
-  headerCase(str2) {
-    return headerCase(str2);
-  }
-  noCase(str2) {
-    return noCase(str2);
-  }
-  paramCase(str2) {
-    return paramCase(str2);
-  }
-  pascalCase(str2) {
-    return pascalCase(str2);
-  }
-  pathCase(str2) {
-    return pathCase(str2);
-  }
-  sentenceCase(str2) {
-    return sentenceCase(str2);
-  }
-  snakeCase(str2) {
-    return snakeCase(str2);
-  }
-  titleCase(str2) {
-    return titleCase(str2);
-  }
-  kebabCase(str2) {
-    return paramCase(str2);
-  }
-  plural(str2) {
-    return plural(str2);
-  }
-  singular(str2) {
-    return singular(str2);
-  }
-  isPlural(str2) {
-    return isPlural(str2);
-  }
-  isSingular(str2) {
-    return isSingular(str2);
-  }
-  addPluralRule(rule, repl) {
-    return addPluralRule(rule, repl);
-  }
-  addSingularRule(rule, repl) {
-    return addSingularRule(rule, repl);
-  }
-  addIrregularRule(single, plural) {
-    return addIrregularRule(single, plural);
-  }
-  addUncountableRule(word) {
-    return addUncountableRule(word);
-  }
-}
-Str.macros = {};
-Str.getters = {};
-const str = new Str();
-
-export { Str, addIrregularRule, addPluralRule, addSingularRule, addUncountableRule, capitalize, ensurePrefix, ensureSuffix, isPlural, isSingular, plural, randomStr, singular, slash, slug, str, template, truncate };
+export * from "./utils.mjs";
+export * from "./case.mjs";
+export * from "./pluralize.mjs";
+export * from "./macro.mjs";

package/dist/is.d.ts

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,46 @@
+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";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@stacksjs/strings",
   "type": "module",
-  "version": "0.56.35",
-  "packageManager": "pnpm@8.6.5",
+  "version": "0.57.3",
+  "packageManager": "pnpm@8.6.6",
   "description": "The Stacks string utilities.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -60,14 +60,14 @@
     "slugify": "^1.6.6",
     "title-case": "^3.0.3",
     "validator": "^13.9.0",
-    "@stacksjs/alias": "0.56.35",
-    "@stacksjs/types": "0.56.35"
+    "@stacksjs/alias": "0.57.3",
+    "@stacksjs/types": "0.57.3"
   },
   "dependencies": {
     "macroable": "^7.0.2"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.56.35"
+    "@stacksjs/development": "0.57.3"
   },
   "scripts": {
     "build": "unbuild",