@stryke/string-format 0.12.24 → 0.12.26

package/dist/package-o2QJauB-.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"package-o2QJauB-.d.cts","names":[],"sources":["../src/package.ts"],"sourcesContent":[],"mappings":";;AA4CA;AA8BA;AAgCA;AAgCA;;;;;;;;;;;;;;;;;;;;;;iBA9FgB,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BA,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCA,iBAAA"}

package/dist/pad-7O_mbugy.cjs

@@ -1 +0,0 @@
-function e(e,t,n=` `){return e.padStart(Math.floor((t-e.length)/2)+e.length,n).padEnd(t,n)}Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});

package/dist/pad-B___Grg_.mjs

@@ -1,2 +0,0 @@
-function e(e,t,n=` `){return e.padStart(Math.floor((t-e.length)/2)+e.length,n).padEnd(t,n)}export{e as t};
-//# sourceMappingURL=pad-B___Grg_.mjs.map

package/dist/pad-B___Grg_.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"pad-B___Grg_.mjs","names":[],"sources":["../src/pad.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\n/**\n * Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length.\n * If the length is less than or equal to the original string's length, or if the padding character is an empty string, the original string is returned unchanged.\n *\n * @param str - The string to pad.\n * @param length - The length of the resulting string once padded.\n * @param chars - The character(s) to use for padding.\n * @returns The padded string, or the original string if padding is not required.\n *\n * @example\n * ```ts\n * const result1 = pad('abc', 8);         // result will be '  abc   '\n * const result2 = pad('abc', 8, '_-');   // result will be '_-abc_-_'\n * const result3 = pad('abc', 3);         // result will be 'abc'\n * const result4 = pad('abc', 2);         // result will be 'abc'\n * ```\n */\nexport function pad(str: string, length: number, chars = \" \"): string {\n  return str\n    .padStart(Math.floor((length - str.length) / 2) + str.length, chars)\n    .padEnd(length, chars);\n}\n"],"mappings":"AAmCA,SAAgB,EAAI,EAAa,EAAgB,EAAQ,IAAa,CACpE,OAAO,EACJ,SAAS,KAAK,OAAO,EAAS,EAAI,QAAU,EAAE,CAAG,EAAI,OAAQ,EAAM,CACnE,OAAO,EAAQ,EAAM"}

package/dist/pad-C-Y_3U-y.d.cts

@@ -1,22 +0,0 @@
-//#region src/pad.d.ts
-/**
- * Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length.
- * If the length is less than or equal to the original string's length, or if the padding character is an empty string, the original string is returned unchanged.
- *
- * @param str - The string to pad.
- * @param length - The length of the resulting string once padded.
- * @param chars - The character(s) to use for padding.
- * @returns The padded string, or the original string if padding is not required.
- *
- * @example
- * ```ts
- * const result1 = pad('abc', 8);         // result will be '  abc   '
- * const result2 = pad('abc', 8, '_-');   // result will be '_-abc_-_'
- * const result3 = pad('abc', 3);         // result will be 'abc'
- * const result4 = pad('abc', 2);         // result will be 'abc'
- * ```
- */
-declare function pad(str: string, length: number, chars?: string): string;
-//#endregion
-export { pad as t };
-//# sourceMappingURL=pad-C-Y_3U-y.d.cts.map

package/dist/pad-C-Y_3U-y.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pad-C-Y_3U-y.d.cts","names":[],"sources":["../src/pad.ts"],"sourcesContent":[],"mappings":";;AAmCA;;;;;;;;;;;;;;;;iBAAgB,GAAA"}

package/dist/pad-mujSKqwW.d.mts

@@ -1,22 +0,0 @@
-//#region src/pad.d.ts
-/**
- * Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length.
- * If the length is less than or equal to the original string's length, or if the padding character is an empty string, the original string is returned unchanged.
- *
- * @param str - The string to pad.
- * @param length - The length of the resulting string once padded.
- * @param chars - The character(s) to use for padding.
- * @returns The padded string, or the original string if padding is not required.
- *
- * @example
- * ```ts
- * const result1 = pad('abc', 8);         // result will be '  abc   '
- * const result2 = pad('abc', 8, '_-');   // result will be '_-abc_-_'
- * const result3 = pad('abc', 3);         // result will be 'abc'
- * const result4 = pad('abc', 2);         // result will be 'abc'
- * ```
- */
-declare function pad(str: string, length: number, chars?: string): string;
-//#endregion
-export { pad as t };
-//# sourceMappingURL=pad-mujSKqwW.d.mts.map

package/dist/pad-mujSKqwW.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pad-mujSKqwW.d.mts","names":[],"sources":["../src/pad.ts"],"sourcesContent":[],"mappings":";;AAmCA;;;;;;;;;;;;;;;;iBAAgB,GAAA"}

package/dist/pascal-case-BNtNlP7E.mjs

@@ -1,2 +0,0 @@
-import{i as e,t}from"./acronyms-CqHURYjd.mjs";import{r as n}from"./get-words-vlruPM_Q.mjs";function r(t){return t?/^[A-Z][A-Z0-9]*$/.test(t)&&e.includes(t.trim().toUpperCase())||/^(?:[A-Z][A-Z0-9]*[a-z]+)*$/.test(t):!1}function i(i){return r(i)||i===void 0?i:n(i).map(n=>e.includes(n.trim().toUpperCase())?t[n.trim().toUpperCase()]?.display||n.trim().toUpperCase():n.trim().charAt(0).toUpperCase()+n.trim().slice(1).toLowerCase()).join(``)}export{i as n,r as t};
-//# sourceMappingURL=pascal-case-BNtNlP7E.mjs.map

package/dist/pascal-case-BNtNlP7E.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"pascal-case-BNtNlP7E.mjs","names":[],"sources":["../src/pascal-case.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { ACRONYM_LIST, ACRONYMS } from \"./acronyms\";\nimport { getWords } from \"./get-words\";\n\n/**\n * Check if the input string is in pascal case.\n *\n * @remarks\n * Pascal case is defined as an uppercase first letter followed by any number of lowercase letters and digits - \"ThisIsAnExample\".\n *\n * @param input - The input string to check.\n * @returns True if the input is in pascal case, false otherwise.\n */\nexport function isPascalCase(input: string | undefined): boolean {\n  return input\n    ? (/^[A-Z][A-Z0-9]*$/.test(input) &&\n        ACRONYM_LIST.includes(input.trim().toUpperCase())) ||\n        /^(?:[A-Z][A-Z0-9]*[a-z]+)*$/.test(input)\n    : false;\n}\n\n/**\n * Convert the input string to pascal case.\n *\n *  @remarks\n * Pascal case is defined as an uppercase first letter followed by any number of lowercase letters and digits - \"ThisIsAnExample\".\n *\n * @param input - The input string.\n * @returns The pascal-cased string.\n */\nexport function pascalCase<T extends string | undefined>(input?: T): T {\n  return (\n    isPascalCase(input) || input === undefined\n      ? input\n      : getWords(input)\n          .map(word =>\n            ACRONYM_LIST.includes(word.trim().toUpperCase())\n              ? ACRONYMS[word.trim().toUpperCase()]?.display ||\n                word.trim().toUpperCase()\n              : word.trim().charAt(0).toUpperCase() +\n                word.trim().slice(1).toLowerCase()\n          )\n          .join(\"\")\n  ) as T;\n}\n"],"mappings":"2FA8BA,SAAgB,EAAa,EAAoC,CAC/D,OAAO,EACF,mBAAmB,KAAK,EAAM,EAC7B,EAAa,SAAS,EAAM,MAAM,CAAC,aAAa,CAAC,EACjD,8BAA8B,KAAK,EAAM,CAC3C,GAYN,SAAgB,EAAyC,EAAc,CACrE,OACE,EAAa,EAAM,EAAI,IAAU,IAAA,GAC7B,EACA,EAAS,EAAM,CACZ,IAAI,GACH,EAAa,SAAS,EAAK,MAAM,CAAC,aAAa,CAAC,CAC5C,EAAS,EAAK,MAAM,CAAC,aAAa,GAAG,SACrC,EAAK,MAAM,CAAC,aAAa,CACzB,EAAK,MAAM,CAAC,OAAO,EAAE,CAAC,aAAa,CACnC,EAAK,MAAM,CAAC,MAAM,EAAE,CAAC,aAAa,CACvC,CACA,KAAK,GAAG"}

package/dist/pascal-case-BQIXhOgM.cjs

@@ -1 +0,0 @@
-const e=require(`./acronyms-DiyHB1FK.cjs`),t=require(`./get-words-IF97Rpfr.cjs`);function n(t){return t?/^[A-Z][A-Z0-9]*$/.test(t)&&e.i.includes(t.trim().toUpperCase())||/^(?:[A-Z][A-Z0-9]*[a-z]+)*$/.test(t):!1}function r(r){return n(r)||r===void 0?r:t.r(r).map(t=>e.i.includes(t.trim().toUpperCase())?e.t[t.trim().toUpperCase()]?.display||t.trim().toUpperCase():t.trim().charAt(0).toUpperCase()+t.trim().slice(1).toLowerCase()).join(``)}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return r}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return n}});

package/dist/pascal-case-DpwdMyIR.d.mts

@@ -1,24 +0,0 @@
-//#region src/pascal-case.d.ts
-/**
- * Check if the input string is in pascal case.
- *
- * @remarks
- * Pascal case is defined as an uppercase first letter followed by any number of lowercase letters and digits - "ThisIsAnExample".
- *
- * @param input - The input string to check.
- * @returns True if the input is in pascal case, false otherwise.
- */
-declare function isPascalCase(input: string | undefined): boolean;
-/**
- * Convert the input string to pascal case.
- *
- *  @remarks
- * Pascal case is defined as an uppercase first letter followed by any number of lowercase letters and digits - "ThisIsAnExample".
- *
- * @param input - The input string.
- * @returns The pascal-cased string.
- */
-declare function pascalCase<T extends string | undefined>(input?: T): T;
-//#endregion
-export { pascalCase as n, isPascalCase as t };
-//# sourceMappingURL=pascal-case-DpwdMyIR.d.mts.map

package/dist/pascal-case-DpwdMyIR.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pascal-case-DpwdMyIR.d.mts","names":[],"sources":["../src/pascal-case.ts"],"sourcesContent":[],"mappings":";;AA8BA;AAiBA;;;;;;;iBAjBgB,YAAA;;;;;;;;;;iBAiBA,iDAAiD,IAAI"}

package/dist/pascal-case-KPXemzHF.d.cts

@@ -1,24 +0,0 @@
-//#region src/pascal-case.d.ts
-/**
- * Check if the input string is in pascal case.
- *
- * @remarks
- * Pascal case is defined as an uppercase first letter followed by any number of lowercase letters and digits - "ThisIsAnExample".
- *
- * @param input - The input string to check.
- * @returns True if the input is in pascal case, false otherwise.
- */
-declare function isPascalCase(input: string | undefined): boolean;
-/**
- * Convert the input string to pascal case.
- *
- *  @remarks
- * Pascal case is defined as an uppercase first letter followed by any number of lowercase letters and digits - "ThisIsAnExample".
- *
- * @param input - The input string.
- * @returns The pascal-cased string.
- */
-declare function pascalCase<T extends string | undefined>(input?: T): T;
-//#endregion
-export { pascalCase as n, isPascalCase as t };
-//# sourceMappingURL=pascal-case-KPXemzHF.d.cts.map

package/dist/pascal-case-KPXemzHF.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pascal-case-KPXemzHF.d.cts","names":[],"sources":["../src/pascal-case.ts"],"sourcesContent":[],"mappings":";;AA8BA;AAiBA;;;;;;;iBAjBgB,YAAA;;;;;;;;;;iBAiBA,iDAAiD,IAAI"}

package/dist/period-split-BN6zXi_S.cjs

@@ -1 +0,0 @@
-const e=require(`./base-DdjslzIj.cjs`),t=require(`./upper-case-first-IJMSoKjS.cjs`);function n(e){return e?/^[a-z]+(?:\.[a-z0-9]+)*$/.test(e):!1}function r(r){if(!r||n(r))return r;let i=r?.replace(/[A-Z]+/g,n=>t.t(n)??e.t)?.split(/(?=[A-Z])|[\s._-]/).map(e=>e.toLowerCase())??[];return i.length===0?``:i.length===1?i[0]:i.reduce((e,t)=>`${e}.${t.toLowerCase()}`.toLowerCase())}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return r}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return n}});

package/dist/period-split-C2v7R4SQ.d.cts

@@ -1,24 +0,0 @@
-//#region src/period-split.d.ts
-/**
- * Check if the input string is in snake case.
- *
- * @remarks
- * Snake case is defined as all lowercase letters with underscores separating words - "this_is_an_example"
- *
- * @param input - The input string to check.
- * @returns True if the input is in snake case, false otherwise.
- */
-declare function isPeriodSplit(input: string | undefined): boolean;
-/**
- * Make all characters lowercase and add a period in between each word
- *
- * @remarks
- * "this.is.an.example"
- *
- * @param input - The input string.
- * @returns The period-split string.
- */
-declare function periodSplit<T extends string | undefined>(input?: T): T;
-//#endregion
-export { periodSplit as n, isPeriodSplit as t };
-//# sourceMappingURL=period-split-C2v7R4SQ.d.cts.map

package/dist/period-split-C2v7R4SQ.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"period-split-C2v7R4SQ.d.cts","names":[],"sources":["../src/period-split.ts"],"sourcesContent":[],"mappings":";;AA8BA;AAaA;;;;;;;iBAbgB,aAAA;;;;;;;;;;iBAaA,kDAAkD,IAAI"}

package/dist/period-split-CBVGYrUw.d.mts

@@ -1,24 +0,0 @@
-//#region src/period-split.d.ts
-/**
- * Check if the input string is in snake case.
- *
- * @remarks
- * Snake case is defined as all lowercase letters with underscores separating words - "this_is_an_example"
- *
- * @param input - The input string to check.
- * @returns True if the input is in snake case, false otherwise.
- */
-declare function isPeriodSplit(input: string | undefined): boolean;
-/**
- * Make all characters lowercase and add a period in between each word
- *
- * @remarks
- * "this.is.an.example"
- *
- * @param input - The input string.
- * @returns The period-split string.
- */
-declare function periodSplit<T extends string | undefined>(input?: T): T;
-//#endregion
-export { periodSplit as n, isPeriodSplit as t };
-//# sourceMappingURL=period-split-CBVGYrUw.d.mts.map

package/dist/period-split-CBVGYrUw.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"period-split-CBVGYrUw.d.mts","names":[],"sources":["../src/period-split.ts"],"sourcesContent":[],"mappings":";;AA8BA;AAaA;;;;;;;iBAbgB,aAAA;;;;;;;;;;iBAaA,kDAAkD,IAAI"}

package/dist/period-split-PMoklYb7.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./base-BHbehXQX.mjs";import{t}from"./upper-case-first-Ca89zvpr.mjs";function n(e){return e?/^[a-z]+(?:\.[a-z0-9]+)*$/.test(e):!1}function r(r){if(!r||n(r))return r;let i=r?.replace(/[A-Z]+/g,n=>t(n)??e)?.split(/(?=[A-Z])|[\s._-]/).map(e=>e.toLowerCase())??[];return i.length===0?``:i.length===1?i[0]:i.reduce((e,t)=>`${e}.${t.toLowerCase()}`.toLowerCase())}export{r as n,n as t};
-//# sourceMappingURL=period-split-PMoklYb7.mjs.map

package/dist/period-split-PMoklYb7.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"period-split-PMoklYb7.mjs","names":["input"],"sources":["../src/period-split.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { EMPTY_STRING } from \"@stryke/types\";\nimport { upperCaseFirst } from \"./upper-case-first\";\n\n/**\n * Check if the input string is in snake case.\n *\n * @remarks\n * Snake case is defined as all lowercase letters with underscores separating words - \"this_is_an_example\"\n *\n * @param input - The input string to check.\n * @returns True if the input is in snake case, false otherwise.\n */\nexport function isPeriodSplit(input: string | undefined): boolean {\n  return input ? /^[a-z]+(?:\\.[a-z0-9]+)*$/.test(input) : false;\n}\n\n/**\n * Make all characters lowercase and add a period in between each word\n *\n * @remarks\n * \"this.is.an.example\"\n *\n * @param input - The input string.\n * @returns The period-split string.\n */\nexport function periodSplit<T extends string | undefined>(input?: T): T {\n  if (!input || isPeriodSplit(input)) {\n    return input as T;\n  }\n\n  const parts =\n    input\n      ?.replace(\n        /[A-Z]+/g,\n        (input?: string) => upperCaseFirst(input) ?? EMPTY_STRING\n      )\n      ?.split(/(?=[A-Z])|[\\s._-]/)\n      .map(x => x.toLowerCase()) ?? [];\n  if (parts.length === 0) {\n    return \"\" as T;\n  }\n  if (parts.length === 1) {\n    return parts[0] as T;\n  }\n\n  return parts.reduce((ret: string, part: string) => {\n    return `${ret}.${part.toLowerCase()}`.toLowerCase();\n  }) as T;\n}\n"],"mappings":"uFA8BA,SAAgB,EAAc,EAAoC,CAChE,OAAO,EAAQ,2BAA2B,KAAK,EAAM,CAAG,GAY1D,SAAgB,EAA0C,EAAc,CACtE,GAAI,CAAC,GAAS,EAAc,EAAM,CAChC,OAAO,EAGT,IAAM,EACJ,GACI,QACA,UACC,GAAmB,EAAeA,EAAM,EAAI,EAC9C,EACC,MAAM,oBAAoB,CAC3B,IAAI,GAAK,EAAE,aAAa,CAAC,EAAI,EAAE,CAQpC,OAPI,EAAM,SAAW,EACZ,GAEL,EAAM,SAAW,EACZ,EAAM,GAGR,EAAM,QAAQ,EAAa,IACzB,GAAG,EAAI,GAAG,EAAK,aAAa,GAAG,aAAa,CACnD"}

package/dist/prepositions-BOeFQ28J.mjs

@@ -1,2 +0,0 @@
-const e=`about.above.across.after.against.along.among.around.at.because of.before.behind.below.beneath.beside.besides.between.beyond.but.by.concerning.despite.down.during.except.excepting.for.from.in.in front of.inside.in spite of.instead of.into.like.near.of.off.on.onto.out.outside.over.past.regarding.since.through.throughout.to.toward.under.underneath.until.up.upon.up to.with.within.without.with regard to.with respect to`.split(`.`);export{e as t};
-//# sourceMappingURL=prepositions-BOeFQ28J.mjs.map

package/dist/prepositions-BOeFQ28J.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepositions-BOeFQ28J.mjs","names":[],"sources":["../src/prepositions.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nexport const PREPOSITIONS = [\n  \"about\",\n  \"above\",\n  \"across\",\n  \"after\",\n  \"against\",\n  \"along\",\n  \"among\",\n  \"around\",\n  \"at\",\n  \"because of\",\n  \"before\",\n  \"behind\",\n  \"below\",\n  \"beneath\",\n  \"beside\",\n  \"besides\",\n  \"between\",\n  \"beyond\",\n  \"but\",\n  \"by\",\n  \"concerning\",\n  \"despite\",\n  \"down\",\n  \"during\",\n  \"except\",\n  \"excepting\",\n  \"for\",\n  \"from\",\n  \"in\",\n  \"in front of\",\n  \"inside\",\n  \"in spite of\",\n  \"instead of\",\n  \"into\",\n  \"like\",\n  \"near\",\n  \"of\",\n  \"off\",\n  \"on\",\n  \"onto\",\n  \"out\",\n  \"outside\",\n  \"over\",\n  \"past\",\n  \"regarding\",\n  \"since\",\n  \"through\",\n  \"throughout\",\n  \"to\",\n  \"toward\",\n  \"under\",\n  \"underneath\",\n  \"until\",\n  \"up\",\n  \"upon\",\n  \"up to\",\n  \"with\",\n  \"within\",\n  \"without\",\n  \"with regard to\",\n  \"with respect to\"\n];\n"],"mappings":"AAkBA,MAAa,EAAe,8aA8D3B"}

package/dist/prepositions-Bp1VMgpn.cjs

@@ -1 +0,0 @@
-const e=`about.above.across.after.against.along.among.around.at.because of.before.behind.below.beneath.beside.besides.between.beyond.but.by.concerning.despite.down.during.except.excepting.for.from.in.in front of.inside.in spite of.instead of.into.like.near.of.off.on.onto.out.outside.over.past.regarding.since.through.throughout.to.toward.under.underneath.until.up.upon.up to.with.within.without.with regard to.with respect to`.split(`.`);Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return e}});

package/dist/prepositions-By1zoaRG.d.cts

@@ -1,5 +0,0 @@
-//#region src/prepositions.d.ts
-declare const PREPOSITIONS: string[];
-//#endregion
-export { PREPOSITIONS as t };
-//# sourceMappingURL=prepositions-By1zoaRG.d.cts.map

package/dist/prepositions-By1zoaRG.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepositions-By1zoaRG.d.cts","names":[],"sources":["../src/prepositions.ts"],"sourcesContent":[],"mappings":";cAkBa"}

package/dist/prepositions-DHokBFOW.d.mts

@@ -1,5 +0,0 @@
-//#region src/prepositions.d.ts
-declare const PREPOSITIONS: string[];
-//#endregion
-export { PREPOSITIONS as t };
-//# sourceMappingURL=prepositions-DHokBFOW.d.mts.map

package/dist/prepositions-DHokBFOW.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepositions-DHokBFOW.d.mts","names":[],"sources":["../src/prepositions.ts"],"sourcesContent":[],"mappings":";cAkBa"}

package/dist/pretty-bytes-Dam2n54B.d.mts

@@ -1,152 +0,0 @@
-//#region src/pretty-bytes.d.ts
-interface Options {
-  /**
-   * Include plus sign for positive numbers. If the difference is exactly zero a space character will be prepended instead for better alignment.
-   *
-   * @defaultValue false
-   */
-  readonly signed?: boolean;
-  /**
-   * - If `false`: Output won't be localized.
-   * - If `true`: Localize the output using the system/browser locale.
-   * - If `string`: Expects a [BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
-   * - If `string[]`: Expects a list of [BCP 47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
-   *
-   * @defaultValue false
-   */
-  readonly locale?: boolean | string | readonly string[];
-  /**
-   * Format the number as [bits](https://en.wikipedia.org/wiki/Bit) instead of [bytes](https://en.wikipedia.org/wiki/Byte). This can be useful when, for example, referring to [bit rate](https://en.wikipedia.org/wiki/Bit_rate).
-   *
-   * @defaultValue false
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * prettyBytes(1337, {bits: true});
-   * //=> '1.34 kbit'
-   * ```
-   */
-  readonly bits?: boolean;
-  /**
-   * Format the number using the [Binary Prefix](https://en.wikipedia.org/wiki/Binary_prefix) instead of the [SI Prefix](https://en.wikipedia.org/wiki/SI_prefix). This can be useful for presenting memory amounts. However, this should not be used for presenting file sizes.
-   *
-   * @defaultValue false
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * prettyBytes(1000, {binary: true});
-   * //=> '1000 bit'
-   *
-   * prettyBytes(1024, {binary: true});
-   * //=> '1 kiB'
-   * ```
-   */
-  readonly binary?: boolean;
-  /**
-   * The minimum number of fraction digits to display.
-   *
-   * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
-   *
-   * @defaultValue undefined
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * // Show the number with at least 3 fractional digits
-   * prettyBytes(1900, {minimumFractionDigits: 3});
-   * //=> '1.900 kB'
-   *
-   * prettyBytes(1900);
-   * //=> '1.9 kB'
-   * ```
-   */
-  readonly minimumFractionDigits?: number;
-  /**
-   * The maximum number of fraction digits to display.
-   *
-   * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
-   *
-   * @defaultValue undefined
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * // Show the number with at most 1 fractional digit
-   * prettyBytes(1920, {maximumFractionDigits: 1});
-   * //=> '1.9 kB'
-   *
-   * prettyBytes(1920);
-   * //=> '1.92 kB'
-   * ```
-   */
-  readonly maximumFractionDigits?: number;
-  /**
-   * Put a space between the number and unit.
-   *
-   * @defaultValue true
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * prettyBytes(1920, {space: false});
-   * //=> '1.9kB'
-   *
-   * prettyBytes(1920);
-   * //=> '1.92 kB'
-   * ```
-   */
-  readonly space?: boolean;
-}
-/**
- * Formats the given number using `Number#toLocaleString`.
- *
- * @remarks
- * - If locale is a string, the value is expected to be a locale-key (for example: `de`).
- * - If locale is true, the system default locale is used for translation.
- * - If no value for locale is specified, the number is returned unmodified.
- *
- * @param number - The number to format.
- * @param locale - The locale to use for formatting the number.
- * @param options - The options to use for formatting the number.
- * @returns The formatted number.
- */
-declare const toLocaleString: (number?: number | string, locale?: string | readonly string[] | boolean, options?: Options) => string;
-/**
- * Convert bytes to a human readable string: `1337` → `1.34 kB`.
- *
- * @param number - The number to format.
- *
- * @example
- * ```ts
- * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
- *
- * prettyBytes(1337);
- * //=> '1.34 kB'
- *
- * prettyBytes(100);
- * //=> '100 B'
- *
- * // Display file size differences
- * prettyBytes(42, {signed: true});
- * //=> '+42 B'
- *
- * // Localized output using German locale
- * prettyBytes(1337, {locale: 'de'});
- * //=> '1,34 kB'
- * ```
- *
- * @param number - The number to format.
- * @param options - The options to use.
- * @returns The formatted string.
- */
-declare function prettyBytes(number: number, options?: Options): string;
-//#endregion
-export { prettyBytes as n, toLocaleString as r, Options as t };
-//# sourceMappingURL=pretty-bytes-Dam2n54B.d.mts.map

package/dist/pretty-bytes-Dam2n54B.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pretty-bytes-Dam2n54B.d.mts","names":[],"sources":["../src/pretty-bytes.ts"],"sourcesContent":[],"mappings":";UAkBiB,OAAA;EAAA;AAgKjB;AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAjDa,oGAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CK,WAAA,2BAAsC"}

package/dist/pretty-bytes-DmvsumO5.mjs

@@ -1,2 +0,0 @@
-const e=[`B`,`kB`,`MB`,`GB`,`TB`,`PB`,`EB`,`ZB`,`YB`],t=[`B`,`KiB`,`MiB`,`GiB`,`TiB`,`PiB`,`EiB`,`ZiB`,`YiB`],n=[`b`,`kbit`,`Mbit`,`Gbit`,`Tbit`,`Pbit`,`Ebit`,`Zbit`,`Ybit`],r=[`b`,`kibit`,`Mibit`,`Gibit`,`Tibit`,`Pibit`,`Eibit`,`Zibit`,`Yibit`],i=(e,t,n={})=>{let r=e,i=t;return typeof i==`string`?(i||=process.env.STORM_LOCALE||`en-US`,Array.isArray(i)&&(r=e?.toLocaleString(i,n))):(i===!0||n!==void 0)&&(r=e?.toLocaleString(void 0,n)),String(r)};function a(a,o){let s=a;if(!Number.isFinite(s))throw TypeError(`Expected a finite number, got ${typeof s}: ${s}`);let c={bits:!1,binary:!1,space:!0,...o},l=c.bits?c.binary?r:n:c.binary?t:e,u=c.space?` `:``;if(c.signed&&s===0)return` 0${u}${l[0]}`;let d=s<0,f=d?`-`:c.signed?`+`:``;d&&(s=-s);let p;if(c.minimumFractionDigits!==void 0&&(p={minimumFractionDigits:c.minimumFractionDigits}),c.maximumFractionDigits!==void 0&&(p={maximumFractionDigits:c.maximumFractionDigits,...p}),s<1)return f+i(s,c.locale,p)+u+l[0];let m=Math.min(Math.floor(c.binary?Math.log(s)/Math.log(1024):Math.log10(s)/3),l.length-1);s/=(c.binary?1024:1e3)**m,p||(s=s.toPrecision(3));let h=i(Number(s),c.locale,p),g=l[m];return f+h+u+g}export{i as n,a as t};
-//# sourceMappingURL=pretty-bytes-DmvsumO5.mjs.map

package/dist/pretty-bytes-DmvsumO5.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"pretty-bytes-DmvsumO5.mjs","names":["_number: string | number"],"sources":["../src/pretty-bytes.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nexport interface Options {\n  /**\n   * Include plus sign for positive numbers. If the difference is exactly zero a space character will be prepended instead for better alignment.\n   *\n   * @defaultValue false\n   */\n  readonly signed?: boolean;\n\n  /**\n   * - If `false`: Output won't be localized.\n   * - If `true`: Localize the output using the system/browser locale.\n   * - If `string`: Expects a [BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)\n   * - If `string[]`: Expects a list of [BCP 47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)\n   *\n   * @defaultValue false\n   */\n  readonly locale?: boolean | string | readonly string[];\n\n  /**\n   * Format the number as [bits](https://en.wikipedia.org/wiki/Bit) instead of [bytes](https://en.wikipedia.org/wiki/Byte). This can be useful when, for example, referring to [bit rate](https://en.wikipedia.org/wiki/Bit_rate).\n   *\n   * @defaultValue false\n   *\n   * @example\n   * ```ts\n   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';\n   *\n   * prettyBytes(1337, {bits: true});\n   * //=> '1.34 kbit'\n   * ```\n   */\n  readonly bits?: boolean;\n\n  /**\n   * Format the number using the [Binary Prefix](https://en.wikipedia.org/wiki/Binary_prefix) instead of the [SI Prefix](https://en.wikipedia.org/wiki/SI_prefix). This can be useful for presenting memory amounts. However, this should not be used for presenting file sizes.\n   *\n   * @defaultValue false\n   *\n   * @example\n   * ```ts\n   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';\n   *\n   * prettyBytes(1000, {binary: true});\n   * //=> '1000 bit'\n   *\n   * prettyBytes(1024, {binary: true});\n   * //=> '1 kiB'\n   * ```\n   */\n  readonly binary?: boolean;\n\n  /**\n   * The minimum number of fraction digits to display.\n   *\n   * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.\n   *\n   * @defaultValue undefined\n   *\n   * @example\n   * ```ts\n   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';\n   *\n   * // Show the number with at least 3 fractional digits\n   * prettyBytes(1900, {minimumFractionDigits: 3});\n   * //=> '1.900 kB'\n   *\n   * prettyBytes(1900);\n   * //=> '1.9 kB'\n   * ```\n   */\n  readonly minimumFractionDigits?: number;\n\n  /**\n   * The maximum number of fraction digits to display.\n   *\n   * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.\n   *\n   * @defaultValue undefined\n   *\n   * @example\n   * ```ts\n   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';\n   *\n   * // Show the number with at most 1 fractional digit\n   * prettyBytes(1920, {maximumFractionDigits: 1});\n   * //=> '1.9 kB'\n   *\n   * prettyBytes(1920);\n   * //=> '1.92 kB'\n   * ```\n   */\n  readonly maximumFractionDigits?: number;\n\n  /**\n   * Put a space between the number and unit.\n   *\n   * @defaultValue true\n   *\n   * @example\n   * ```ts\n   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';\n   *\n   * prettyBytes(1920, {space: false});\n   * //=> '1.9kB'\n   *\n   * prettyBytes(1920);\n   * //=> '1.92 kB'\n   * ```\n   */\n  readonly space?: boolean;\n}\n\nconst BYTE_UNITS = [\"B\", \"kB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\"];\nconst BIBYTE_UNITS = [\n  \"B\",\n  \"KiB\",\n  \"MiB\",\n  \"GiB\",\n  \"TiB\",\n  \"PiB\",\n  \"EiB\",\n  \"ZiB\",\n  \"YiB\"\n];\nconst BIT_UNITS = [\n  \"b\",\n  \"kbit\",\n  \"Mbit\",\n  \"Gbit\",\n  \"Tbit\",\n  \"Pbit\",\n  \"Ebit\",\n  \"Zbit\",\n  \"Ybit\"\n];\nconst BIBIT_UNITS = [\n  \"b\",\n  \"kibit\",\n  \"Mibit\",\n  \"Gibit\",\n  \"Tibit\",\n  \"Pibit\",\n  \"Eibit\",\n  \"Zibit\",\n  \"Yibit\"\n];\n\n/**\n * Formats the given number using `Number#toLocaleString`.\n *\n * @remarks\n * - If locale is a string, the value is expected to be a locale-key (for example: `de`).\n * - If locale is true, the system default locale is used for translation.\n * - If no value for locale is specified, the number is returned unmodified.\n *\n * @param number - The number to format.\n * @param locale - The locale to use for formatting the number.\n * @param options - The options to use for formatting the number.\n * @returns The formatted number.\n */\nexport const toLocaleString = (\n  number?: number | string,\n  locale?: string | readonly string[] | boolean,\n  options: Options = {}\n): string => {\n  let result = number;\n  let _locale = locale;\n  if (typeof _locale === \"string\") {\n    if (!_locale) {\n      _locale = process.env.STORM_LOCALE || \"en-US\";\n    }\n    if (Array.isArray(_locale)) {\n      result = number?.toLocaleString(_locale, options);\n    }\n  } else if (_locale === true || options !== undefined) {\n    result = number?.toLocaleString(undefined, options);\n  }\n\n  return String(result);\n};\n\n/**\n * Convert bytes to a human readable string: `1337` → `1.34 kB`.\n *\n * @param number - The number to format.\n *\n * @example\n * ```ts\n * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';\n *\n * prettyBytes(1337);\n * //=> '1.34 kB'\n *\n * prettyBytes(100);\n * //=> '100 B'\n *\n * // Display file size differences\n * prettyBytes(42, {signed: true});\n * //=> '+42 B'\n *\n * // Localized output using German locale\n * prettyBytes(1337, {locale: 'de'});\n * //=> '1,34 kB'\n * ```\n *\n * @param number - The number to format.\n * @param options - The options to use.\n * @returns The formatted string.\n */\nexport function prettyBytes(number: number, options?: Options): string {\n  let _number: string | number = number;\n  if (!Number.isFinite(_number)) {\n    throw new TypeError(\n      `Expected a finite number, got ${typeof _number}: ${_number}`\n    );\n  }\n\n  const opts = {\n    bits: false,\n    binary: false,\n    space: true,\n    ...options\n  };\n\n  const UNITS = opts.bits\n    ? opts.binary\n      ? BIBIT_UNITS\n      : BIT_UNITS\n    : opts.binary\n      ? BIBYTE_UNITS\n      : BYTE_UNITS;\n\n  const separator = opts.space ? \" \" : \"\";\n\n  if (opts.signed && _number === 0) {\n    return ` 0${separator}${UNITS[0]}`;\n  }\n\n  const isNegative = _number < 0;\n\n  const prefix = isNegative ? \"-\" : opts.signed ? \"+\" : \"\";\n\n  if (isNegative) {\n    _number = -_number;\n  }\n\n  let localeOptions;\n\n  if (opts.minimumFractionDigits !== undefined) {\n    localeOptions = { minimumFractionDigits: opts.minimumFractionDigits };\n  }\n\n  if (opts.maximumFractionDigits !== undefined) {\n    localeOptions = {\n      maximumFractionDigits: opts.maximumFractionDigits,\n      ...localeOptions\n    };\n  }\n\n  if (_number < 1) {\n    const numberString = toLocaleString(_number, opts.locale, localeOptions);\n\n    return prefix + numberString + separator + UNITS[0];\n  }\n\n  const exponent = Math.min(\n    Math.floor(\n      opts.binary ? Math.log(_number) / Math.log(1024) : Math.log10(_number) / 3\n    ),\n    UNITS.length - 1\n  );\n  _number /= (opts.binary ? 1024 : 1000) ** exponent;\n\n  if (!localeOptions) {\n    _number = _number.toPrecision(3);\n  }\n\n  const numberString = toLocaleString(\n    Number(_number),\n    opts.locale,\n    localeOptions\n  );\n\n  const unit = UNITS[exponent];\n\n  return prefix + numberString + separator + unit;\n}\n"],"mappings":"AAkIA,MAAM,EAAa,CAAC,IAAK,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,KAAK,CAClE,EAAe,CACnB,IACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACD,CACK,EAAY,CAChB,IACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACD,CACK,EAAc,CAClB,IACA,QACA,QACA,QACA,QACA,QACA,QACA,QACA,QACD,CAeY,GACX,EACA,EACA,EAAmB,EAAE,GACV,CACX,IAAI,EAAS,EACT,EAAU,EAYd,OAXI,OAAO,GAAY,UACrB,AACE,IAAU,QAAQ,IAAI,cAAgB,QAEpC,MAAM,QAAQ,EAAQ,GACxB,EAAS,GAAQ,eAAe,EAAS,EAAQ,IAE1C,IAAY,IAAQ,IAAY,IAAA,MACzC,EAAS,GAAQ,eAAe,IAAA,GAAW,EAAQ,EAG9C,OAAO,EAAO,EA+BvB,SAAgB,EAAY,EAAgB,EAA2B,CACrE,IAAIA,EAA2B,EAC/B,GAAI,CAAC,OAAO,SAAS,EAAQ,CAC3B,MAAU,UACR,iCAAiC,OAAO,EAAQ,IAAI,IACrD,CAGH,IAAM,EAAO,CACX,KAAM,GACN,OAAQ,GACR,MAAO,GACP,GAAG,EACJ,CAEK,EAAQ,EAAK,KACf,EAAK,OACH,EACA,EACF,EAAK,OACH,EACA,EAEA,EAAY,EAAK,MAAQ,IAAM,GAErC,GAAI,EAAK,QAAU,IAAY,EAC7B,MAAO,KAAK,IAAY,EAAM,KAGhC,IAAM,EAAa,EAAU,EAEvB,EAAS,EAAa,IAAM,EAAK,OAAS,IAAM,GAElD,IACF,EAAU,CAAC,GAGb,IAAI,EAaJ,GAXI,EAAK,wBAA0B,IAAA,KACjC,EAAgB,CAAE,sBAAuB,EAAK,sBAAuB,EAGnE,EAAK,wBAA0B,IAAA,KACjC,EAAgB,CACd,sBAAuB,EAAK,sBAC5B,GAAG,EACJ,EAGC,EAAU,EAGZ,OAAO,EAFc,EAAe,EAAS,EAAK,OAAQ,EAAc,CAEzC,EAAY,EAAM,GAGnD,IAAM,EAAW,KAAK,IACpB,KAAK,MACH,EAAK,OAAS,KAAK,IAAI,EAAQ,CAAG,KAAK,IAAI,KAAK,CAAG,KAAK,MAAM,EAAQ,CAAG,EAC1E,CACD,EAAM,OAAS,EAChB,CACD,IAAY,EAAK,OAAS,KAAO,MAAS,EAErC,IACH,EAAU,EAAQ,YAAY,EAAE,EAGlC,IAAM,EAAe,EACnB,OAAO,EAAQ,CACf,EAAK,OACL,EACD,CAEK,EAAO,EAAM,GAEnB,OAAO,EAAS,EAAe,EAAY"}

package/dist/pretty-bytes-Dv8t5D6N.d.cts

@@ -1,152 +0,0 @@
-//#region src/pretty-bytes.d.ts
-interface Options {
-  /**
-   * Include plus sign for positive numbers. If the difference is exactly zero a space character will be prepended instead for better alignment.
-   *
-   * @defaultValue false
-   */
-  readonly signed?: boolean;
-  /**
-   * - If `false`: Output won't be localized.
-   * - If `true`: Localize the output using the system/browser locale.
-   * - If `string`: Expects a [BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
-   * - If `string[]`: Expects a list of [BCP 47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
-   *
-   * @defaultValue false
-   */
-  readonly locale?: boolean | string | readonly string[];
-  /**
-   * Format the number as [bits](https://en.wikipedia.org/wiki/Bit) instead of [bytes](https://en.wikipedia.org/wiki/Byte). This can be useful when, for example, referring to [bit rate](https://en.wikipedia.org/wiki/Bit_rate).
-   *
-   * @defaultValue false
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * prettyBytes(1337, {bits: true});
-   * //=> '1.34 kbit'
-   * ```
-   */
-  readonly bits?: boolean;
-  /**
-   * Format the number using the [Binary Prefix](https://en.wikipedia.org/wiki/Binary_prefix) instead of the [SI Prefix](https://en.wikipedia.org/wiki/SI_prefix). This can be useful for presenting memory amounts. However, this should not be used for presenting file sizes.
-   *
-   * @defaultValue false
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * prettyBytes(1000, {binary: true});
-   * //=> '1000 bit'
-   *
-   * prettyBytes(1024, {binary: true});
-   * //=> '1 kiB'
-   * ```
-   */
-  readonly binary?: boolean;
-  /**
-   * The minimum number of fraction digits to display.
-   *
-   * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
-   *
-   * @defaultValue undefined
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * // Show the number with at least 3 fractional digits
-   * prettyBytes(1900, {minimumFractionDigits: 3});
-   * //=> '1.900 kB'
-   *
-   * prettyBytes(1900);
-   * //=> '1.9 kB'
-   * ```
-   */
-  readonly minimumFractionDigits?: number;
-  /**
-   * The maximum number of fraction digits to display.
-   *
-   * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
-   *
-   * @defaultValue undefined
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * // Show the number with at most 1 fractional digit
-   * prettyBytes(1920, {maximumFractionDigits: 1});
-   * //=> '1.9 kB'
-   *
-   * prettyBytes(1920);
-   * //=> '1.92 kB'
-   * ```
-   */
-  readonly maximumFractionDigits?: number;
-  /**
-   * Put a space between the number and unit.
-   *
-   * @defaultValue true
-   *
-   * @example
-   * ```ts
-   * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
-   *
-   * prettyBytes(1920, {space: false});
-   * //=> '1.9kB'
-   *
-   * prettyBytes(1920);
-   * //=> '1.92 kB'
-   * ```
-   */
-  readonly space?: boolean;
-}
-/**
- * Formats the given number using `Number#toLocaleString`.
- *
- * @remarks
- * - If locale is a string, the value is expected to be a locale-key (for example: `de`).
- * - If locale is true, the system default locale is used for translation.
- * - If no value for locale is specified, the number is returned unmodified.
- *
- * @param number - The number to format.
- * @param locale - The locale to use for formatting the number.
- * @param options - The options to use for formatting the number.
- * @returns The formatted number.
- */
-declare const toLocaleString: (number?: number | string, locale?: string | readonly string[] | boolean, options?: Options) => string;
-/**
- * Convert bytes to a human readable string: `1337` → `1.34 kB`.
- *
- * @param number - The number to format.
- *
- * @example
- * ```ts
- * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
- *
- * prettyBytes(1337);
- * //=> '1.34 kB'
- *
- * prettyBytes(100);
- * //=> '100 B'
- *
- * // Display file size differences
- * prettyBytes(42, {signed: true});
- * //=> '+42 B'
- *
- * // Localized output using German locale
- * prettyBytes(1337, {locale: 'de'});
- * //=> '1,34 kB'
- * ```
- *
- * @param number - The number to format.
- * @param options - The options to use.
- * @returns The formatted string.
- */
-declare function prettyBytes(number: number, options?: Options): string;
-//#endregion
-export { prettyBytes as n, toLocaleString as r, Options as t };
-//# sourceMappingURL=pretty-bytes-Dv8t5D6N.d.cts.map

package/dist/pretty-bytes-Dv8t5D6N.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pretty-bytes-Dv8t5D6N.d.cts","names":[],"sources":["../src/pretty-bytes.ts"],"sourcesContent":[],"mappings":";UAkBiB,OAAA;EAAA;AAgKjB;AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAjDa,oGAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CK,WAAA,2BAAsC"}

package/dist/pretty-bytes-aHFwwFbw.cjs

@@ -1 +0,0 @@
-const e=[`B`,`kB`,`MB`,`GB`,`TB`,`PB`,`EB`,`ZB`,`YB`],t=[`B`,`KiB`,`MiB`,`GiB`,`TiB`,`PiB`,`EiB`,`ZiB`,`YiB`],n=[`b`,`kbit`,`Mbit`,`Gbit`,`Tbit`,`Pbit`,`Ebit`,`Zbit`,`Ybit`],r=[`b`,`kibit`,`Mibit`,`Gibit`,`Tibit`,`Pibit`,`Eibit`,`Zibit`,`Yibit`],i=(e,t,n={})=>{let r=e,i=t;return typeof i==`string`?(i||=process.env.STORM_LOCALE||`en-US`,Array.isArray(i)&&(r=e?.toLocaleString(i,n))):(i===!0||n!==void 0)&&(r=e?.toLocaleString(void 0,n)),String(r)};function a(a,o){let s=a;if(!Number.isFinite(s))throw TypeError(`Expected a finite number, got ${typeof s}: ${s}`);let c={bits:!1,binary:!1,space:!0,...o},l=c.bits?c.binary?r:n:c.binary?t:e,u=c.space?` `:``;if(c.signed&&s===0)return` 0${u}${l[0]}`;let d=s<0,f=d?`-`:c.signed?`+`:``;d&&(s=-s);let p;if(c.minimumFractionDigits!==void 0&&(p={minimumFractionDigits:c.minimumFractionDigits}),c.maximumFractionDigits!==void 0&&(p={maximumFractionDigits:c.maximumFractionDigits,...p}),s<1)return f+i(s,c.locale,p)+u+l[0];let m=Math.min(Math.floor(c.binary?Math.log(s)/Math.log(1024):Math.log10(s)/3),l.length-1);s/=(c.binary?1024:1e3)**m,p||(s=s.toPrecision(3));let h=i(Number(s),c.locale,p),g=l[m];return f+h+u+g}Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return i}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return a}});

package/dist/snake-case-C5v7aTGP.d.cts

@@ -1,28 +0,0 @@
-//#region src/snake-case.d.ts
-interface SnakeCaseOptions {
-  splitOnNumber: boolean;
-}
-/**
- * Check if the input string is in snake case.
- *
- * @remarks
- * Snake case is defined as all lowercase letters with underscores separating words - "this_is_an_example"
- *
- * @param input - The input string to check.
- * @returns True if the input is in snake case, false otherwise.
- */
-declare function isSnakeCase(input: string | undefined): boolean;
-/**
- * Convert the input string to snake case.
- *
- *  @remarks
- * Snake case is defined as all lowercase letters with underscores separating words - "this_is_an_example"
- *
- * @param input - The input string.
- * @param options - Options to control the behavior of the function.
- * @returns The snake-cased string.
- */
-declare function snakeCase<T extends string | undefined>(input: T, options?: SnakeCaseOptions): T;
-//#endregion
-export { isSnakeCase as n, snakeCase as r, SnakeCaseOptions as t };
-//# sourceMappingURL=snake-case-C5v7aTGP.d.cts.map