unslash 1.0.1 → 1.0.2

package/README.md

@@ -1,6 +1,7 @@
 # `/` unslash
 
 Stop wasting your life on slash normalization.<br />
+Works everywhere ("everywhere" means in browsers too).<br />
 Zero dependencies because why would I need any?
 
 ## Install
@@ -49,6 +50,25 @@ slash('tlfc', 'http://example.com', 'path', 'to', 'file');
 // → 'http://example.com/path/to/file/'
 ```
 
+You can import shorthand `s` versions (as default or named):
+
+```ts
+import s, { s } from 'unslash';
+
+s('t', 'path', 'to', 'file');
+// → 'path/to/file/'
+```
+
+If you need to create a reusable function with a fixed pattern, use `slashFn` or `sfn`:
+
+```ts
+import { slashFn, sfn } from 'unslash';
+const normalizePath = sfn('tlfc');
+
+normalizePath('path\\to\\file');
+// → '/path/to/file/'
+```
+
 ## Pattern Flags
 
 - `t` / `!t` — Add/remove **T**railing slash
@@ -61,6 +81,6 @@ slash('tlfc', 'http://example.com', 'path', 'to', 'file');
 Yeah, I know.<br/>
 I don’t give a shit.<br />
 I was too lazy to look for them and made my own.<br />
-Made with GPT help. Cry about it.
+Created with GPT help. Cry about it.
 
 _It’d be cool if this package got popular and made me rich._

package/dist/index.d.ts

@@ -1,2 +1,5 @@
 export * from './pattern.js';
-export * from './slash.js';
+import { slash, s } from './slash.js';
+import { slashFn, sfn } from './slashFn.js';
+export default s;
+export { slash, s, slashFn, sfn };

package/dist/index.js

@@ -1,2 +1,2 @@
-export * from './pattern.js';
-export * from './slash.js';
+export*from"./pattern.js";import{slash as r,s as o}from"./slash.js";import{slashFn as s,sfn as t}from"./slashFn.js";var p=o;export{p as default,o as s,t as sfn,r as slash,s as slashFn};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["export * from './pattern.js';\nimport { slash, s } from './slash.js';\nimport { slashFn, sfn } from './slashFn.js';\n\nexport default s;\nexport { slash, s, slashFn, sfn };\n"],
+  "mappings": "AAAA,WAAc,eACd,OAAS,SAAAA,EAAO,KAAAC,MAAS,aACzB,OAAS,WAAAC,EAAS,OAAAC,MAAW,eAE7B,IAAOC,EAAQH",
+  "names": ["slash", "s", "slashFn", "sfn", "index_default"]
+}

package/dist/pattern.d.ts

@@ -1,4 +1,6 @@
-export type SlashFlag = 't' | 'l' | 'f' | 'c';
+export type SlashBooleanFlag = 't' | 'l' | 'f';
+export type SlashPlainFlag = 'c';
+export type SlashFlag = SlashBooleanFlag | SlashPlainFlag;
 export declare const unslash: unique symbol;
 type link = 'https://github.com/Gwynerva/unslash';
 export type UnknownFlagError<C extends string> = {
@@ -9,6 +11,10 @@ export type DuplicateFlagError<F extends string> = {
     readonly [unslash]: link;
     SlashPatternError: `Flag "${F}" is used more than once or both negated and non-negated`;
 };
-export type ValidateSlashPattern<S extends string, Pos extends string = never, Neg extends string = never> = S extends `!${infer L}${infer R}` ? L extends SlashFlag ? L extends Pos | Neg ? DuplicateFlagError<L> : ValidateSlashPattern<R, Pos, Neg | L> : UnknownFlagError<`!${L}`> : S extends `${infer L}${infer R}` ? L extends SlashFlag ? L extends Pos | Neg ? DuplicateFlagError<L> : ValidateSlashPattern<R, Pos | L, Neg> : UnknownFlagError<L> : S;
+export type InvalidNegationError<F extends string> = {
+    readonly [unslash]: link;
+    SlashPatternError: `Flag "${F}" cannot be negated`;
+};
+export type ValidateSlashPattern<S extends string, Pos extends string = never, Neg extends string = never> = S extends `!${infer L}${infer R}` ? L extends SlashFlag ? L extends SlashBooleanFlag ? L extends Pos | Neg ? DuplicateFlagError<L> : ValidateSlashPattern<R, Pos, Neg | L> : InvalidNegationError<L> : UnknownFlagError<`!${L}`> : S extends `${infer L}${infer R}` ? L extends SlashFlag ? L extends Pos | Neg ? DuplicateFlagError<L> : ValidateSlashPattern<R, Pos | L, Neg> : UnknownFlagError<L> : S;
 export type SlashPattern<S extends string> = ValidateSlashPattern<S> extends string ? S : ValidateSlashPattern<S>;
 export {};

package/dist/pattern.js

@@ -1 +1 @@
-export {};
+//# sourceMappingURL=pattern.js.map

package/dist/pattern.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/slash.d.ts

@@ -1,13 +1,13 @@
 import type { SlashPattern } from './pattern.js';
 /**
- * Creates a string formatter based on the given slash pattern.
+ * Formats a string based on the given slash pattern.
  * @param pattern
  * A string of letters or their negations (prefixed with "!").
  * Each letter represents a specific formatting rule:
  * - `t` | `!t`: Ensure trailing slash is added | removed.
  * - `l` | `!l`: Ensure leading slash is added | removed.
  * - `f` | `!f`: Force forward | backward slashes.
- * - `c` | `!c`: Collapse multiple slashes into a single slash | Does nothing.
+ * - `c` Collapse multiple adjacent slashes into a single slash.
  *
  * Example patterns:
  * - `"tlfc"`: Ensure leading and trailing slashes, force forward slashes, collapse multiple slashes.
@@ -21,3 +21,7 @@ import type { SlashPattern } from './pattern.js';
  * Protocols (like `http://`) are preserved and not altered by the formatting.
  */
 export declare function slash<S extends string>(pattern: SlashPattern<S>, ...parts: string[]): string;
+/**
+ * Shortened version of `slash`.
+ */
+export declare const s: typeof slash;

package/dist/slash.js

@@ -1,95 +1,2 @@
-/**
- * Creates a string formatter based on the given slash pattern.
- * @param pattern
- * A string of letters or their negations (prefixed with "!").
- * Each letter represents a specific formatting rule:
- * - `t` | `!t`: Ensure trailing slash is added | removed.
- * - `l` | `!l`: Ensure leading slash is added | removed.
- * - `f` | `!f`: Force forward | backward slashes.
- * - `c` | `!c`: Collapse multiple slashes into a single slash | Does nothing.
- *
- * Example patterns:
- * - `"tlfc"`: Ensure leading and trailing slashes, force forward slashes, collapse multiple slashes.
- * - `"lf"`: Force forward slashes and ensure leading slash (trailing might be present or absent).
- * - `tl!f`: Ensure leading and trailing slashes, force backward slashes.
- * @param parts
- * The string parts to be formatted according to the specified pattern.
- * They will be joined together using forward slashes by default (or backward slashes if `!f` is specified in the pattern).
- * @returns
- * The formatted string with slash-concatenated parts according to the specified slash pattern.
- * Protocols (like `http://`) are preserved and not altered by the formatting.
- */
-export function slash(pattern, ...parts) {
-    const flags = {};
-    // @ts-expect-error Pattern is validated at compile-time
-    pattern = pattern;
-    for (let i = 0; i < pattern.length; i++) {
-        const char = pattern[i];
-        const negated = char === '!';
-        const flag = negated ? pattern[i + 1] : char;
-        flags[flag] = !negated;
-        if (negated) {
-            i++;
-        }
-    }
-    const slashChar = flags['f'] === false ? '\\' : '/';
-    // ------------------------------------------------------------
-    // Protocol-safe join
-    // ------------------------------------------------------------
-    let joined = parts.join(slashChar);
-    // Matches: scheme: or scheme://
-    // Examples: http://, file://, mailto:
-    const PROTOCOL_RE = /^([a-zA-Z][a-zA-Z\d+\-.]*:)(\/\/)?/;
-    let protocol = '';
-    const match = joined.match(PROTOCOL_RE);
-    if (match) {
-        protocol = match[0];
-        joined = joined.slice(protocol.length);
-    }
-    // ------------------------------------------------------------
-    // Force slash type (convert all slashes)
-    // ------------------------------------------------------------
-    if (flags['f'] === false) {
-        // Force backward slashes: convert all / to \
-        joined = joined.replace(/\//g, '\\');
-    }
-    else if (flags['f'] === true) {
-        // Force forward slashes: convert all \ to /
-        joined = joined.replace(/\\/g, '/');
-    }
-    // ------------------------------------------------------------
-    // Collapse multiple slashes
-    // ------------------------------------------------------------
-    if (flags['c']) {
-        const slashRegex = flags['f'] === false ? /\\+/g : /\/+/g;
-        const replacement = flags['f'] === false ? '\\' : '/';
-        joined = joined.replace(slashRegex, replacement);
-    }
-    // ------------------------------------------------------------
-    // Leading slash handling
-    // ------------------------------------------------------------
-    if (flags['l']) {
-        if (!joined.startsWith(slashChar)) {
-            joined = slashChar + joined;
-        }
-    }
-    else {
-        while (joined.startsWith('\\') || joined.startsWith('/')) {
-            joined = joined.slice(1);
-        }
-    }
-    // ------------------------------------------------------------
-    // Trailing slash handling
-    // ------------------------------------------------------------
-    if (flags['t']) {
-        if (!joined.endsWith(slashChar)) {
-            joined = joined + slashChar;
-        }
-    }
-    else {
-        while (joined.endsWith('\\') || joined.endsWith('/')) {
-            joined = joined.slice(0, -1);
-        }
-    }
-    return protocol + joined;
-}
+function g(l,...f){const e={};l=l;for(let t=0;t<l.length;t++){const n=l[t],c=n==="!",h=c?l[t+1]:n;e[h]=!c,c&&t++}const i=e.f===!1?"\\":"/";let s=f.join(i);const r=/^([a-zA-Z][a-zA-Z\d+\-.]*:)(\/\/)?/;let a="";const o=s.match(r);if(o&&(a=o[0],s=s.slice(a.length)),e.f===!1?s=s.replace(/\//g,"\\"):e.f===!0&&(s=s.replace(/\\/g,"/")),e.c){const t=e.f===!1?/\\+/g:/\/+/g,n=e.f===!1?"\\":"/";s=s.replace(t,n)}if(e.l)s.startsWith(i)||(s=i+s);else for(;s.startsWith("\\")||s.startsWith("/");)s=s.slice(1);if(e.t)s.endsWith(i)||(s=s+i);else for(;s.endsWith("\\")||s.endsWith("/");)s=s.slice(0,-1);return a+s}const d=g;export{d as s,g as slash};
+//# sourceMappingURL=slash.js.map

package/dist/slash.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/slash.ts"],
+  "sourcesContent": ["import type { SlashPattern } from './pattern.js';\n\n/**\n * Formats a string based on the given slash pattern.\n * @param pattern\n * A string of letters or their negations (prefixed with \"!\").\n * Each letter represents a specific formatting rule:\n * - `t` | `!t`: Ensure trailing slash is added | removed.\n * - `l` | `!l`: Ensure leading slash is added | removed.\n * - `f` | `!f`: Force forward | backward slashes.\n * - `c` Collapse multiple adjacent slashes into a single slash.\n *\n * Example patterns:\n * - `\"tlfc\"`: Ensure leading and trailing slashes, force forward slashes, collapse multiple slashes.\n * - `\"lf\"`: Force forward slashes and ensure leading slash (trailing might be present or absent).\n * - `tl!f`: Ensure leading and trailing slashes, force backward slashes.\n * @param parts\n * The string parts to be formatted according to the specified pattern.\n * They will be joined together using forward slashes by default (or backward slashes if `!f` is specified in the pattern).\n * @returns\n * The formatted string with slash-concatenated parts according to the specified slash pattern.\n * Protocols (like `http://`) are preserved and not altered by the formatting.\n */\nexport function slash<S extends string>(\n  pattern: SlashPattern<S>,\n  ...parts: string[]\n): string {\n  const flags: Record<string, boolean> = {};\n\n  // @ts-expect-error Pattern is validated at compile-time\n  pattern = pattern as string;\n\n  for (let i = 0; i < pattern.length; i++) {\n    const char = pattern[i];\n    const negated = char === '!';\n    const flag = negated ? pattern[i + 1] : char;\n\n    flags[flag] = !negated;\n\n    if (negated) {\n      i++;\n    }\n  }\n\n  const slashChar = flags['f'] === false ? '\\\\' : '/';\n\n  // ------------------------------------------------------------\n  // Protocol-safe join\n  // ------------------------------------------------------------\n\n  let joined = parts.join(slashChar);\n\n  // Matches: scheme: or scheme://\n  // Examples: http://, file://, mailto:\n  const PROTOCOL_RE = /^([a-zA-Z][a-zA-Z\\d+\\-.]*:)(\\/\\/)?/;\n\n  let protocol = '';\n  const match = joined.match(PROTOCOL_RE);\n\n  if (match) {\n    protocol = match[0];\n    joined = joined.slice(protocol.length);\n  }\n\n  // ------------------------------------------------------------\n  // Force slash type (convert all slashes)\n  // ------------------------------------------------------------\n\n  if (flags['f'] === false) {\n    // Force backward slashes: convert all / to \\\n    joined = joined.replace(/\\//g, '\\\\');\n  } else if (flags['f'] === true) {\n    // Force forward slashes: convert all \\ to /\n    joined = joined.replace(/\\\\/g, '/');\n  }\n\n  // ------------------------------------------------------------\n  // Collapse multiple slashes\n  // ------------------------------------------------------------\n\n  if (flags['c']) {\n    const slashRegex = flags['f'] === false ? /\\\\+/g : /\\/+/g;\n    const replacement = flags['f'] === false ? '\\\\' : '/';\n    joined = joined.replace(slashRegex, replacement);\n  }\n\n  // ------------------------------------------------------------\n  // Leading slash handling\n  // ------------------------------------------------------------\n\n  if (flags['l']) {\n    if (!joined.startsWith(slashChar)) {\n      joined = slashChar + joined;\n    }\n  } else {\n    while (joined.startsWith('\\\\') || joined.startsWith('/')) {\n      joined = joined.slice(1);\n    }\n  }\n\n  // ------------------------------------------------------------\n  // Trailing slash handling\n  // ------------------------------------------------------------\n\n  if (flags['t']) {\n    if (!joined.endsWith(slashChar)) {\n      joined = joined + slashChar;\n    }\n  } else {\n    while (joined.endsWith('\\\\') || joined.endsWith('/')) {\n      joined = joined.slice(0, -1);\n    }\n  }\n\n  return protocol + joined;\n}\n\n/**\n * Shortened version of `slash`.\n */\nexport const s = slash;\n"],
+  "mappings": "AAuBO,SAASA,EACdC,KACGC,EACK,CACR,MAAMC,EAAiC,CAAC,EAGxCF,EAAUA,EAEV,QAASG,EAAI,EAAGA,EAAIH,EAAQ,OAAQG,IAAK,CACvC,MAAMC,EAAOJ,EAAQG,CAAC,EAChBE,EAAUD,IAAS,IACnBE,EAAOD,EAAUL,EAAQG,EAAI,CAAC,EAAIC,EAExCF,EAAMI,CAAI,EAAI,CAACD,EAEXA,GACFF,GAEJ,CAEA,MAAMI,EAAYL,EAAM,IAAS,GAAQ,KAAO,IAMhD,IAAIM,EAASP,EAAM,KAAKM,CAAS,EAIjC,MAAME,EAAc,qCAEpB,IAAIC,EAAW,GACf,MAAMC,EAAQH,EAAO,MAAMC,CAAW,EAuBtC,GArBIE,IACFD,EAAWC,EAAM,CAAC,EAClBH,EAASA,EAAO,MAAME,EAAS,MAAM,GAOnCR,EAAM,IAAS,GAEjBM,EAASA,EAAO,QAAQ,MAAO,IAAI,EAC1BN,EAAM,IAAS,KAExBM,EAASA,EAAO,QAAQ,MAAO,GAAG,GAOhCN,EAAM,EAAM,CACd,MAAMU,EAAaV,EAAM,IAAS,GAAQ,OAAS,OAC7CW,EAAcX,EAAM,IAAS,GAAQ,KAAO,IAClDM,EAASA,EAAO,QAAQI,EAAYC,CAAW,CACjD,CAMA,GAAIX,EAAM,EACHM,EAAO,WAAWD,CAAS,IAC9BC,EAASD,EAAYC,OAGvB,MAAOA,EAAO,WAAW,IAAI,GAAKA,EAAO,WAAW,GAAG,GACrDA,EAASA,EAAO,MAAM,CAAC,EAQ3B,GAAIN,EAAM,EACHM,EAAO,SAASD,CAAS,IAC5BC,EAASA,EAASD,OAGpB,MAAOC,EAAO,SAAS,IAAI,GAAKA,EAAO,SAAS,GAAG,GACjDA,EAASA,EAAO,MAAM,EAAG,EAAE,EAI/B,OAAOE,EAAWF,CACpB,CAKO,MAAMM,EAAIf",
+  "names": ["slash", "pattern", "parts", "flags", "i", "char", "negated", "flag", "slashChar", "joined", "PROTOCOL_RE", "protocol", "match", "slashRegex", "replacement", "s"]
+}

package/dist/slashFn.d.ts

@@ -0,0 +1,9 @@
+import type { SlashPattern } from './pattern.js';
+/**
+ * Creates a slash formatter with a fixed pattern for multiple uses.
+ * @param pattern
+ * See `slash` function for pattern documentation.
+ */
+export declare function slashFn<S extends string>(pattern: SlashPattern<S>): (...parts: string[]) => string;
+/** Shortened version of `slashFn`. */
+export declare const sfn: typeof slashFn;

package/dist/slashFn.js

@@ -0,0 +1,2 @@
+import{slash as n}from"./slash.js";function s(t){return(...r)=>n(t,...r)}const o=s;export{o as sfn,s as slashFn};
+//# sourceMappingURL=slashFn.js.map

package/dist/slashFn.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/slashFn.ts"],
+  "sourcesContent": ["import type { SlashPattern } from './pattern.js';\r\nimport { slash } from './slash.js';\r\n\r\n/**\r\n * Creates a slash formatter with a fixed pattern for multiple uses.\r\n * @param pattern\r\n * See `slash` function for pattern documentation.\r\n */\r\nexport function slashFn<S extends string>(pattern: SlashPattern<S>) {\r\n  return (...parts: string[]) => slash(pattern, ...parts);\r\n}\r\n\r\n/** Shortened version of `slashFn`. */\r\nexport const sfn = slashFn;\r\n"],
+  "mappings": "AACA,OAAS,SAAAA,MAAa,aAOf,SAASC,EAA0BC,EAA0B,CAClE,MAAO,IAAIC,IAAoBH,EAAME,EAAS,GAAGC,CAAK,CACxD,CAGO,MAAMC,EAAMH",
+  "names": ["slash", "slashFn", "pattern", "parts", "sfn"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unslash",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "description": "🤬 No more pain with slashes!",
   "keywords": [
@@ -11,10 +11,8 @@
     "url",
     "trailing-slash",
     "leading-slash",
-    "router",
     "base-path",
     "cross-platform",
-    "windows",
     "utilities"
   ],
   "license": "MIT",
@@ -34,7 +32,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc --project ./tsconfig.src.json",
+    "build": "rm -rf dist && tsc -p ./tsconfig.src.json && esbuild src/**/*.ts --outdir=dist --minify --sourcemap --format=esm",
     "prepack": "bun run build",
     "format": "bun prettier --write .",
     "test": "bun vitest run"
@@ -42,6 +40,7 @@
   "devDependencies": {
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.18",
+    "esbuild": "^0.27.2"
   }
 }