unslash 1.0.1 → 2.0.0

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
@@ -12,55 +13,94 @@ npm install unslash
 ## Usage
 
 ```ts
-import { slash } from 'unslash';
+import { s, slash } from 'unslash';
+
+// Just join some paths. No magic.
+s('path', 'to', 'file');
+// → 'path/to/file'
 
 // Need a trailing slash? Done.
-slash('t', 'path', 'to', 'file');
+s(/t/, 'path', 'to', 'file');
 // → 'path/to/file/'
 
 // Don’t want it? Gone.
-slash('!t', 'path/to/file/');
+s(/!t/, 'path/to/file/');
 // → 'path/to/file'
 
 // Want a leading slash? Here you go.
-slash('l', 'path', 'to', 'file');
+s(/l/, 'path', 'to', 'file');
 // → '/path/to/file'
 
 // Need to collapse that mess? Fixed.
-slash('c', 'path///to', 'this//file');
+s(/c/, 'path///to', 'this//file');
 // → 'path/to/this/file'
 
 // Want to force forward slashes? Me too.
-slash('f', 'path\\to', 'this/file');
+s(/f/, 'path\\to', 'this/file');
 // → 'path/to/this/file'
 
 // Need Windows paths? What is wrong with you?!
-slash('!f', 'path', 'to', 'file');
+s(/!f/, 'path', 'to', 'file');
 // → 'path\to\file'
 
 // Combine them. Because you can.
-slash('tlfc', 'path\\\\to\\file');
+s(/tlfc/, 'path\\\\to\\file');
 // → '/path/to/file/'
-slash('!t!l!fc', '/path///to/file/');
+s(/!t!l!fc/, '/path///to/file/');
 // → 'path\to\file'
 
 // Your precious protocols are safe — don’t worry.
-slash('tlfc', 'http://example.com', 'path', 'to', 'file');
+s(/tlfc/, 'http://example.com', 'path', 'to', 'file');
 // → 'http://example.com/path/to/file/'
 ```
 
+There are three ways to use the library:
+
+```ts
+import unslash, { s, slash } from 'unslash';
+```
+
+For all DRY lovers like me, you can create reusable formatters:
+
+```ts
+// Create a formatter
+const normalize = s(/fc/); // Force forward, collapse
+
+// Use it
+normalize('path\\to\\file');
+// → 'path/to/file'
+
+// Extend it on the fly if you're feeling spicy
+normalize(/t/, 'path\\to\\file');
+// → 'path/to/file/'
+```
+
+For the lazy ones, `snormalize` (or `sn`) is already pre-configured with `/fc/` (Force forward + Collapse):
+
+```ts
+import { sn } from 'unslash';
+
+sn('path\\to//file');
+// → 'path/to/file'
+
+sn(/t/, 'path\\to//file');
+// → 'path/to/file/'
+```
+
 ## Pattern Flags
 
+Use these in your regex literal (e.g., `/tfc/`):
+
 - `t` / `!t` — Add/remove **T**railing slash
 - `l` / `!l` — Add/remove **L**eading slash
 - `f` / `!f` — Force **F**orward slashes / backward slashes
-- `c` — **C**ollapse multiple slashes (yes, you’re right — `!c` doesn’t do shit)
+- `c` / `!c` — **C**ollapse multiple slashes / Don't collapse
 
 ## But Gwynerva, there are libraries for this
 
 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,38 @@
-export * from './pattern.js';
-export * from './slash.js';
+declare function _slash(pattern: RegExp): SlashFormatter;
+declare function _slash(pattern: RegExp, ...parts: string[]): string;
+declare function _slash(...parts: string[]): string;
+type SlashFormatter = {
+    (pattern: RegExp): SlashFormatter;
+    (...parts: string[]): string;
+    (pattern: RegExp, ...parts: string[]): string;
+};
+/**
+ * Creates a slash formatter or formats strings directly.
+ *
+ * The formatter is configured using a RegExp pattern whose source consists of
+ * single-letter flags and their negations (`!x`). Flags are evaluated
+ * left-to-right; later flags override earlier ones (e.g. `c!c` disables
+ * collapsing even if `c` appeared before).
+ *
+ * Supported flags:
+ * - `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 | do not collapse
+ *
+ * Calling with a RegExp returns a reusable formatter.
+ * Calling a formatter with another RegExp appends flags to the existing pattern.
+ *
+ * @example
+ * const normalize = slasher(/fc/); // Force forward slashes, collapse multiple slashes
+ * normalize(/t/, 'my\\long\\\\path'); // `fc` flags + force trailing slash and apply formatting
+ * // → 'my/long/path/'
+ */
+export declare const slash: typeof _slash;
+/** Short version of `slash`. */
+export declare const s: typeof _slash;
+/** Convert to forward slashes + collapse multiple adjacent slashes. */
+export declare const snormalize: SlashFormatter;
+/** Short version of `snormalize`. */
+export declare const sn: SlashFormatter;
+export default slash;

package/dist/index.js

@@ -1,2 +1,2 @@
-export * from './pattern.js';
-export * from './slash.js';
+function h(...s){const[n,...e]=s;if(typeof n=="string")return s.join("/");if(n instanceof RegExp&&e.length===0){const t=o(n);return g(t)}return n instanceof RegExp?l(o(n),e):""}function g(s){return((...e)=>{const[t,...i]=e;if(t instanceof RegExp){const r=o(t),a=p(s,r);return i.length>0?l(a,i):g(a)}return l(s,e)})}function o(s){const n=s.source,e={};for(let t=0;t<n.length;t++){const i=n[t],r=i==="!",a=r?n[t+1]:i;switch(r&&t++,a){case"f":case"c":case"t":case"l":e[a]=!r;break}}return e}function p(s,n){return{...s,...n}}function l(s,n){const e=s.f===!1?"\\":"/";let t=n.join(e);const i=/^([a-zA-Z][a-zA-Z\d+\-.]*:)(\/\/)?/;let r="";const a=t.match(i);if(a&&(r=a[0],t=t.slice(r.length)),s.f===!1?t=t.replace(/\//g,"\\"):s.f===!0&&(t=t.replace(/\\/g,"/")),s.c){const c=s.f===!1?/\\+/g:/\/+/g;t=t.replace(c,e)}if(s.t)t.endsWith(e)||(t+=e);else if(s.t===!1)for(;t.endsWith("/")||t.endsWith("\\");)t=t.slice(0,-1);if(s.l)t.startsWith(e)||(t=e+t);else if(s.l===!1)for(;t.startsWith("/")||t.startsWith("\\");)t=t.slice(1);return r+t}const f=h,x=f,u=f(/fc/),m=u;var S=f;export{S as default,x as s,f as slash,m as sn,u as snormalize};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["// #region Slash\n//\n\nfunction _slash(pattern: RegExp): SlashFormatter;\nfunction _slash(pattern: RegExp, ...parts: string[]): string;\nfunction _slash(...parts: string[]): string;\nfunction _slash(\n  ...args: [RegExp | string, ...string[]] | string[]\n): string | SlashFormatter {\n  const [first, ...rest] = args;\n\n  //\n  // slash(\"a\", \"b\")\n  //\n\n  if (typeof first === 'string') {\n    return (args as string[]).join('/');\n  }\n\n  //\n  // slash(/pattern/)\n  //\n\n  if (first instanceof RegExp && rest.length === 0) {\n    const config = parsePattern(first);\n    return createFormatter(config);\n  }\n\n  //\n  // slash(/pattern/, \"a\", \"b\")\n  //\n\n  if (first instanceof RegExp) {\n    return applyConfig(parsePattern(first), rest as string[]);\n  }\n\n  return '';\n}\n\n//\n// #endregion\n\n// #region Helpers\n//\n\ntype SlashFormatter = {\n  (pattern: RegExp): SlashFormatter;\n  (...parts: string[]): string;\n  (pattern: RegExp, ...parts: string[]): string;\n};\n\ntype SlashConfig = {\n  f?: boolean;\n  c?: boolean;\n  t?: boolean;\n  l?: boolean;\n};\n\nfunction createFormatter(config: SlashConfig): SlashFormatter {\n  const formatter = ((\n    ...inner: [RegExp | string, ...string[]] | string[]\n  ): string | SlashFormatter => {\n    const [head, ...tail] = inner;\n\n    // Append pattern\n    if (head instanceof RegExp) {\n      const nextConfig = parsePattern(head);\n      const combined = mergeConfigs(config, nextConfig);\n\n      // pattern + strings \u2192 evaluate immediately\n      if (tail.length > 0) {\n        return applyConfig(combined, tail as string[]);\n      }\n\n      // pattern only \u2192 return new formatter\n      return createFormatter(combined);\n    }\n\n    // formatter(\"a\", \"b\")\n    return applyConfig(config, inner as string[]);\n  }) as SlashFormatter;\n\n  return formatter;\n}\n\nfunction parsePattern(pattern: RegExp): SlashConfig {\n  const source = pattern.source;\n  const config: SlashConfig = {};\n\n  for (let i = 0; i < source.length; i++) {\n    const char = source[i];\n    const negated = char === '!';\n    const flag = negated ? source[i + 1] : char;\n\n    if (negated) i++;\n\n    switch (flag) {\n      case 'f':\n      case 'c':\n      case 't':\n      case 'l':\n        config[flag] = !negated;\n        break;\n    }\n  }\n\n  return config;\n}\n\nfunction mergeConfigs(a: SlashConfig, b: SlashConfig): SlashConfig {\n  return { ...a, ...b };\n}\n\nfunction applyConfig(config: SlashConfig, parts: string[]): string {\n  const slashChar = config.f === false ? '\\\\' : '/';\n  //\n  // Protocol-safe join\n  //\n\n  let joined = parts.join(slashChar);\n\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\n  //\n\n  if (config.f === false) {\n    joined = joined.replace(/\\//g, '\\\\');\n  } else if (config.f === true) {\n    joined = joined.replace(/\\\\/g, '/');\n  }\n\n  //\n  // Collapse multiple slashes\n  //\n\n  if (config.c) {\n    const slashRegex = config.f === false ? /\\\\+/g : /\\/+/g;\n    joined = joined.replace(slashRegex, slashChar);\n  }\n\n  //\n  // Trailing slash\n  //\n\n  if (config.t) {\n    if (!joined.endsWith(slashChar)) {\n      joined += slashChar;\n    }\n  } else if (config.t === false) {\n    // Explicitly removed (!t)\n    while (joined.endsWith('/') || joined.endsWith('\\\\')) {\n      joined = joined.slice(0, -1);\n    }\n  }\n\n  //\n  // Leading slash\n  //\n\n  if (config.l) {\n    if (!joined.startsWith(slashChar)) {\n      joined = slashChar + joined;\n    }\n  } else if (config.l === false) {\n    // Explicitly removed (!l)\n    while (joined.startsWith('/') || joined.startsWith('\\\\')) {\n      joined = joined.slice(1);\n    }\n  }\n\n  return protocol + joined;\n}\n\n//\n// #endregion\n\n// #region Exports\n//\n\n/**\n * Creates a slash formatter or formats strings directly.\n *\n * The formatter is configured using a RegExp pattern whose source consists of\n * single-letter flags and their negations (`!x`). Flags are evaluated\n * left-to-right; later flags override earlier ones (e.g. `c!c` disables\n * collapsing even if `c` appeared before).\n *\n * Supported flags:\n * - `t` | `!t` \u2014 ensure trailing slash is added | removed\n * - `l` | `!l` \u2014 ensure leading slash is added | removed\n * - `f` | `!f` \u2014 force forward | backward slashes\n * - `c` | `!c` \u2014 collapse multiple slashes | do not collapse\n *\n * Calling with a RegExp returns a reusable formatter.\n * Calling a formatter with another RegExp appends flags to the existing pattern.\n *\n * @example\n * const normalize = slasher(/fc/); // Force forward slashes, collapse multiple slashes\n * normalize(/t/, 'my\\\\long\\\\\\\\path'); // `fc` flags + force trailing slash and apply formatting\n * // \u2192 'my/long/path/'\n */\nexport const slash = _slash;\n\n/** Short version of `slash`. */\nexport const s = slash;\n\n/** Convert to forward slashes + collapse multiple adjacent slashes. */\nexport const snormalize = slash(/fc/);\n\n/** Short version of `snormalize`. */\nexport const sn = snormalize;\n\nexport default slash;\n\n//\n// #endregion\n"],
+  "mappings": "AAMA,SAASA,KACJC,EACsB,CACzB,KAAM,CAACC,EAAO,GAAGC,CAAI,EAAIF,EAMzB,GAAI,OAAOC,GAAU,SACnB,OAAQD,EAAkB,KAAK,GAAG,EAOpC,GAAIC,aAAiB,QAAUC,EAAK,SAAW,EAAG,CAChD,MAAMC,EAASC,EAAaH,CAAK,EACjC,OAAOI,EAAgBF,CAAM,CAC/B,CAMA,OAAIF,aAAiB,OACZK,EAAYF,EAAaH,CAAK,EAAGC,CAAgB,EAGnD,EACT,CAqBA,SAASG,EAAgBF,EAAqC,CAwB5D,OAvBmB,IACdI,IACyB,CAC5B,KAAM,CAACC,EAAM,GAAGC,CAAI,EAAIF,EAGxB,GAAIC,aAAgB,OAAQ,CAC1B,MAAME,EAAaN,EAAaI,CAAI,EAC9BG,EAAWC,EAAaT,EAAQO,CAAU,EAGhD,OAAID,EAAK,OAAS,EACTH,EAAYK,EAAUF,CAAgB,EAIxCJ,EAAgBM,CAAQ,CACjC,CAGA,OAAOL,EAAYH,EAAQI,CAAiB,CAC9C,EAGF,CAEA,SAASH,EAAaS,EAA8B,CAClD,MAAMC,EAASD,EAAQ,OACjBV,EAAsB,CAAC,EAE7B,QAASY,EAAI,EAAGA,EAAID,EAAO,OAAQC,IAAK,CACtC,MAAMC,EAAOF,EAAOC,CAAC,EACfE,EAAUD,IAAS,IACnBE,EAAOD,EAAUH,EAAOC,EAAI,CAAC,EAAIC,EAIvC,OAFIC,GAASF,IAELG,EAAM,CACZ,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACHf,EAAOe,CAAI,EAAI,CAACD,EAChB,KACJ,CACF,CAEA,OAAOd,CACT,CAEA,SAASS,EAAaO,EAAgBC,EAA6B,CACjE,MAAO,CAAE,GAAGD,EAAG,GAAGC,CAAE,CACtB,CAEA,SAASd,EAAYH,EAAqBkB,EAAyB,CACjE,MAAMC,EAAYnB,EAAO,IAAM,GAAQ,KAAO,IAK9C,IAAIoB,EAASF,EAAM,KAAKC,CAAS,EAEjC,MAAME,EAAc,qCAEpB,IAAIC,EAAW,GACf,MAAMC,EAAQH,EAAO,MAAMC,CAAW,EAqBtC,GAnBIE,IACFD,EAAWC,EAAM,CAAC,EAClBH,EAASA,EAAO,MAAME,EAAS,MAAM,GAOnCtB,EAAO,IAAM,GACfoB,EAASA,EAAO,QAAQ,MAAO,IAAI,EAC1BpB,EAAO,IAAM,KACtBoB,EAASA,EAAO,QAAQ,MAAO,GAAG,GAOhCpB,EAAO,EAAG,CACZ,MAAMwB,EAAaxB,EAAO,IAAM,GAAQ,OAAS,OACjDoB,EAASA,EAAO,QAAQI,EAAYL,CAAS,CAC/C,CAMA,GAAInB,EAAO,EACJoB,EAAO,SAASD,CAAS,IAC5BC,GAAUD,WAEHnB,EAAO,IAAM,GAEtB,KAAOoB,EAAO,SAAS,GAAG,GAAKA,EAAO,SAAS,IAAI,GACjDA,EAASA,EAAO,MAAM,EAAG,EAAE,EAQ/B,GAAIpB,EAAO,EACJoB,EAAO,WAAWD,CAAS,IAC9BC,EAASD,EAAYC,WAEdpB,EAAO,IAAM,GAEtB,KAAOoB,EAAO,WAAW,GAAG,GAAKA,EAAO,WAAW,IAAI,GACrDA,EAASA,EAAO,MAAM,CAAC,EAI3B,OAAOE,EAAWF,CACpB,CA8BO,MAAMK,EAAQ7B,EAGR8B,EAAID,EAGJE,EAAaF,EAAM,IAAI,EAGvBG,EAAKD,EAElB,IAAOE,EAAQJ",
+  "names": ["_slash", "args", "first", "rest", "config", "parsePattern", "createFormatter", "applyConfig", "inner", "head", "tail", "nextConfig", "combined", "mergeConfigs", "pattern", "source", "i", "char", "negated", "flag", "a", "b", "parts", "slashChar", "joined", "PROTOCOL_RE", "protocol", "match", "slashRegex", "slash", "s", "snormalize", "sn", "index_default"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unslash",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "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,12 +32,14 @@
     "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"
   },
   "devDependencies": {
+    "@types/node": "^25.1.0",
+    "esbuild": "^0.27.2",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"

package/dist/pattern.d.ts

@@ -1,14 +0,0 @@
-export type SlashFlag = 't' | 'l' | 'f' | 'c';
-export declare const unslash: unique symbol;
-type link = 'https://github.com/Gwynerva/unslash';
-export type UnknownFlagError<C extends string> = {
-    readonly [unslash]: link;
-    SlashPatternError: `Character "${C}" is not a valid SlashFlag (allowed: t l f c, optionally prefixed with "!")`;
-};
-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 SlashPattern<S extends string> = ValidateSlashPattern<S> extends string ? S : ValidateSlashPattern<S>;
-export {};

package/dist/pattern.js

@@ -1 +0,0 @@
-export {};

package/dist/slash.d.ts

@@ -1,23 +0,0 @@
-import type { SlashPattern } from './pattern.js';
-/**
- * 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 declare function slash<S extends string>(pattern: SlashPattern<S>, ...parts: string[]): string;

package/dist/slash.js

@@ -1,95 +0,0 @@
-/**
- * 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;
-}