deghost 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,241 @@
+# deghost
+
+Strip invisible Unicode characters and normalize whitespace. Chainable, typesafe, zero dependencies.
+
+```
+npm install deghost
+```
+
+## Why
+
+Text from binary formats, APIs, and user input is full of invisible Unicode characters — non-breaking spaces, zero-width joiners, directional marks, BOM, control characters. They break string comparison, corrupt search indexes, and produce garbled output.
+
+Existing tools either strip everything indiscriminately or miss entire character categories. deghost gives you category-level control with a chainable API that distinguishes between _stripping_ (remove entirely) and _normalizing_ (replace with a visible substitute).
+
+## Quick start
+
+```typescript
+import { deghost } from 'deghost'
+
+// Sensible defaults — handles the common cases
+;`${deghost('Plant\u00a064\u00a0-\u00a0Woodbridge')}`
+// → 'Plant 64 - Woodbridge'
+
+`${deghost('hello\u200Bworld')}`
+// → 'helloworld'
+
+// Also works as a tagged template literal
+`${deghost`Plant\u00a064\u00a0-\u00a0Woodbridge`}`
+// → 'Plant 64 - Woodbridge'
+```
+
+## Chainable API
+
+Fine-grained control over what gets stripped vs. normalized:
+
+```typescript
+import { deghost } from 'deghost'
+
+deghost('text\u200B\u00a0here')
+  .strip('format') // zero-width joiners, directional marks, soft hyphens
+  .strip('control') // C0/C1 control characters
+  .normalize('spaces') // NBSP, en/em space → regular space
+  .trim()
+  .toString()
+// → 'text here'
+```
+
+The chain is immutable — each method returns a new instance, so you can branch without side effects.
+
+### Chain methods
+
+| Method                               | Returns        | Description                                                          |
+| ------------------------------------ | -------------- | -------------------------------------------------------------------- |
+| `.strip(category)`                   | `DeghostChain` | Remove all characters in a category                                  |
+| `.normalize(category, replacement?)` | `DeghostChain` | Replace characters with a substitute (default: `' '`)                |
+| `.replace(category, mapper)`         | `DeghostChain` | Replace characters using a function that receives detection metadata |
+| `.highlight(category?, formatter?)`  | `DeghostChain` | Replace ghosts with visible markers like `[U+200B]`                  |
+| `.collapse()`                        | `DeghostChain` | Collapse runs of whitespace into a single space                      |
+| `.trim()`                            | `DeghostChain` | Trim leading/trailing whitespace                                     |
+| `.clean()`                           | `DeghostChain` | Apply the default preset                                             |
+| `.detect(categories?)`               | `Detection[]`  | Return detections for the current value                              |
+| `.hasGhosts(categories?)`            | `boolean`      | Check if invisible characters remain                                 |
+| `.isClean(categories?)`              | `boolean`      | Inverse of `.hasGhosts()`                                            |
+| `.count(categories?)`                | `Record`       | Count ghosts by category                                             |
+| `.summary(categories?)`              | `string`       | Human-readable report of ghosts found                                |
+| `.toString()`                        | `string`       | Extract the string                                                   |
+
+**Categories:**
+
+| Category  | What it matches                                              | Default behavior   |
+| --------- | ------------------------------------------------------------ | ------------------ |
+| `format`  | Zero-width joiners, directional marks, soft hyphens (\p{Cf}) | Strip              |
+| `control` | C0/C1 control characters (\p{Cc})                            | Strip              |
+| `spaces`  | NBSP, en/em space, thin space, ideographic space (\p{Zs})    | Normalize to `' '` |
+| `bom`     | Byte order mark (U+FEFF)                                     | Strip              |
+| `tag`     | Unicode tag characters (U+E0001–U+E007F)                     | —                  |
+| `fillers` | Hangul, Khmer, Mongolian, Ogham fillers                      | —                  |
+| `math`    | Invisible math operators (U+2061–U+2064)                     | —                  |
+
+## Reusable cleaners
+
+Build a cleaning pipeline once, apply it to many strings with no per-call chain allocation:
+
+```typescript
+import { cleaner } from 'deghost'
+
+const clean = cleaner().strip('format').strip('control').normalize('spaces').trim().build()
+
+clean('dirty\u00a0string') // 'dirty string'
+clean('another\u200Bone') // 'anotherone'
+```
+
+Cleaners also support `.replace()` and `.highlight()` for dynamic transformations:
+
+```typescript
+const annotate = cleaner().highlight('format').normalize('spaces').build()
+
+annotate('a\u200Bb\u00a0c') // 'a[U+200B]b c'
+```
+
+## Detection
+
+Find out what's hiding in your strings:
+
+```typescript
+import { detect, hasGhosts, isClean, count, first, scan } from 'deghost'
+
+detect('sneaky\u200Btext')
+// [{
+//   char: '\u200B',
+//   codepoint: 'U+200B',
+//   name: 'ZERO WIDTH SPACE',
+//   category: 'format',
+//   offset: 6
+// }]
+
+hasGhosts('hello\u200Bworld') // true
+isClean('hello world') // true
+
+count('a\u00a0b\u200Bc\u200Bd')
+// { spaces: 1, format: 2 }
+
+// Get just the first detection (stops early)
+first('a\u200Bb\u00a0c')
+// { char: '\u200B', codepoint: 'U+200B', ... }
+
+// Lazy iterator for large strings
+for (const d of scan(largeString)) {
+  if (d.category === 'format') break
+}
+```
+
+All detection functions accept an optional `categories` array to filter:
+
+```typescript
+detect('a\u200Bb\u00a0c', ['spaces'])
+// Only returns the NBSP detection
+```
+
+## Highlighting
+
+Make invisible characters visible for debugging:
+
+```typescript
+import { highlight } from 'deghost'
+
+highlight('hello\u200Bworld')
+// 'hello[U+200B]world'
+
+// Custom formatter
+highlight('a\u200Bb', (d) => `{${d.name}}`)
+// 'a{ZERO WIDTH SPACE}b'
+
+// Filter by category
+highlight('a\u00a0b\u200Bc', { categories: ['format'] })
+// 'a\u00a0b[U+200B]c'
+```
+
+## Summary
+
+Get a human-readable report of all invisible characters:
+
+```typescript
+import { summary } from 'deghost'
+
+summary('hello\u200Bworld\u00a0here')
+// 2 invisible characters found.
+//
+// By category:
+//   format: 1
+//   spaces: 1
+//
+// Details:
+//   U+200B  ZERO WIDTH SPACE  (format, offset 5)
+//   U+00A0  NO-BREAK SPACE  (spaces, offset 11)
+```
+
+## Character lookup
+
+Identify a single character or codepoint:
+
+```typescript
+import { identify } from 'deghost'
+
+identify('\u200B')
+// { codepoint: 'U+200B', name: 'ZERO WIDTH SPACE', category: 'format' }
+
+identify(0x00a0)
+// { codepoint: 'U+00A0', name: 'NO-BREAK SPACE', category: 'spaces' }
+
+identify('a') // undefined — not a ghost
+```
+
+## Presets
+
+```typescript
+import { presets } from 'deghost'
+
+// Default: strip format + control + BOM, normalize spaces
+presets.clean('text\u00a0with\u200Bghosts')
+// → 'text with ghosts'
+
+// Aggressive: strip everything invisible
+presets.aggressive('text\u2061with\u200Bghosts')
+// → 'textwithghosts'
+
+// Spaces only: just normalize whitespace
+presets.spaces('text\u00a0here')
+// → 'text here'
+```
+
+## How it works
+
+deghost uses [ES2018 Unicode property escapes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape) (`\p{Cf}`, `\p{Cc}`, `\p{Zs}`) for broad category matching, plus curated codepoint sets for categories not covered by a single Unicode general category (tag characters, script-specific fillers, invisible math operators).
+
+The key design choice: **strip vs. normalize**. A non-breaking space (U+00A0) _should_ become a regular space, not disappear — otherwise `"Plant\u00a064"` becomes `"Plant64"`. deghost handles this by default; `out-of-character` does not.
+
+## Comparison
+
+| Feature                         | deghost | out-of-character |
+| ------------------------------- | ------- | ---------------- |
+| Strip invisible chars           | yes     | yes              |
+| Normalize spaces (NBSP → space) | yes     | no (strips)      |
+| Chainable API                   | yes     | no               |
+| Reusable cleaners               | yes     | no               |
+| Detection with metadata         | yes     | yes              |
+| Category-level control          | yes     | no               |
+| Highlighting / debugging        | yes     | no               |
+| Tagged template literal         | yes     | no               |
+| TypeScript-native               | yes     | no               |
+| Presets                         | yes     | no               |
+| CLI                             | not yet | yes              |
+| Zero dependencies               | yes     | yes              |
+
+## Requirements
+
+Node.js >= 18. Uses ES2018 Unicode property escapes (supported in all modern runtimes).
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,433 @@
+'use strict';
+
+// src/categories.ts
+var patterns = {
+  /** Format characters: zero-width joiners, directional marks, soft hyphens, etc. */
+  format: /\p{Cf}/gu,
+  /** Control characters: C0 (0x00–0x1F) and C1 (0x7F–0x9F) controls. */
+  control: /\p{Cc}/gu,
+  /**
+   * Space separators: NBSP, en/em/thin/hair/ideographic space, etc.
+   * Excludes U+0020 (regular ASCII space) — that's not a ghost.
+   */
+  spaces: /(?!\u0020)\p{Zs}/gu,
+  /** Tag characters: deprecated Unicode tag block (U+E0001–U+E007F). */
+  tag: /[\u{E0001}-\u{E007F}]/gu,
+  /** Byte order mark / zero-width no-break space. */
+  bom: /\uFEFF/gu,
+  /**
+   * Script-specific filler characters:
+   * - U+115F, U+1160: Hangul Choseong/Jungseong fillers
+   * - U+3164: Hangul filler
+   * - U+FFA0: Halfwidth Hangul filler
+   * - U+17B4, U+17B5: Khmer vowel inherent
+   * - U+180E: Mongolian vowel separator
+   * - U+1680: Ogham space mark
+   */
+  fillers: /[\u115F\u1160\u3164\uFFA0\u17B4\u17B5\u180E\u1680]/gu,
+  /**
+   * Invisible math operators:
+   * - U+2061: Function application
+   * - U+2062: Invisible times
+   * - U+2063: Invisible separator
+   * - U+2064: Invisible plus
+   */
+  math: /[\u2061-\u2064]/gu
+};
+var categories = Object.freeze(Object.keys(patterns));
+var descriptions = {
+  format: "Format characters (zero-width joiners, directional marks, soft hyphens)",
+  control: "Control characters (C0/C1 controls)",
+  spaces: "Space separators (NBSP, en/em space, thin space, ideographic space)",
+  tag: "Unicode tag characters",
+  bom: "Byte order mark",
+  fillers: "Script-specific filler characters (Hangul, Khmer, Mongolian, Ogham)",
+  math: "Invisible math operators"
+};
+var charNames = {
+  173: "SOFT HYPHEN",
+  847: "COMBINING GRAPHEME JOINER",
+  1564: "ARABIC LETTER MARK",
+  160: "NO-BREAK SPACE",
+  5760: "OGHAM SPACE MARK",
+  8192: "EN QUAD",
+  8193: "EM QUAD",
+  8194: "EN SPACE",
+  8195: "EM SPACE",
+  8196: "THREE-PER-EM SPACE",
+  8197: "FOUR-PER-EM SPACE",
+  8198: "SIX-PER-EM SPACE",
+  8199: "FIGURE SPACE",
+  8200: "PUNCTUATION SPACE",
+  8201: "THIN SPACE",
+  8202: "HAIR SPACE",
+  8203: "ZERO WIDTH SPACE",
+  8204: "ZERO WIDTH NON-JOINER",
+  8205: "ZERO WIDTH JOINER",
+  8206: "LEFT-TO-RIGHT MARK",
+  8207: "RIGHT-TO-LEFT MARK",
+  8232: "LINE SEPARATOR",
+  8233: "PARAGRAPH SEPARATOR",
+  8234: "LEFT-TO-RIGHT EMBEDDING",
+  8235: "RIGHT-TO-LEFT EMBEDDING",
+  8236: "POP DIRECTIONAL FORMATTING",
+  8237: "LEFT-TO-RIGHT OVERRIDE",
+  8238: "RIGHT-TO-LEFT OVERRIDE",
+  8239: "NARROW NO-BREAK SPACE",
+  8287: "MEDIUM MATHEMATICAL SPACE",
+  8288: "WORD JOINER",
+  8289: "FUNCTION APPLICATION",
+  8290: "INVISIBLE TIMES",
+  8291: "INVISIBLE SEPARATOR",
+  8292: "INVISIBLE PLUS",
+  8294: "LEFT-TO-RIGHT ISOLATE",
+  8295: "RIGHT-TO-LEFT ISOLATE",
+  8296: "FIRST STRONG ISOLATE",
+  8297: "POP DIRECTIONAL ISOLATE",
+  12288: "IDEOGRAPHIC SPACE",
+  12644: "HANGUL FILLER",
+  65279: "ZERO WIDTH NO-BREAK SPACE",
+  65440: "HALFWIDTH HANGUL FILLER",
+  4447: "HANGUL CHOSEONG FILLER",
+  4448: "HANGUL JUNGSEONG FILLER",
+  6068: "KHMER VOWEL INHERENT AQ",
+  6069: "KHMER VOWEL INHERENT AA",
+  6158: "MONGOLIAN VOWEL SEPARATOR"
+};
+var fillerSet = /* @__PURE__ */ new Set([4447, 4448, 12644, 65440, 6068, 6069, 6158, 5760]);
+var isZs = /^\p{Zs}$/u;
+var isCf = /^\p{Cf}$/u;
+var isCc = /^\p{Cc}$/u;
+function categorize(codepoint) {
+  if (codepoint === 65279) return "bom";
+  if (codepoint >= 917505 && codepoint <= 917631) return "tag";
+  if (codepoint >= 8289 && codepoint <= 8292) return "math";
+  if (fillerSet.has(codepoint)) return "fillers";
+  if (codepoint === 32) return void 0;
+  const char = String.fromCodePoint(codepoint);
+  if (isZs.test(char)) return "spaces";
+  if (isCf.test(char)) return "format";
+  if (isCc.test(char)) return "control";
+  return void 0;
+}
+
+// src/detect.ts
+var formatHex = (cp) => `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+var regexCache = /* @__PURE__ */ new Map();
+function getRegex(categories2) {
+  const cats = categories2 ?? Object.keys(patterns);
+  const key = [...cats].sort().join(",");
+  let cached = regexCache.get(key);
+  if (!cached) {
+    cached = new RegExp(cats.map((c) => patterns[c].source).join("|"), "gu");
+    regexCache.set(key, cached);
+  }
+  return cached;
+}
+function* scan(input, categories2) {
+  const regex = getRegex(categories2);
+  regex.lastIndex = 0;
+  for (const match of input.matchAll(regex)) {
+    const char = match[0];
+    const cp = char.codePointAt(0);
+    const category = categorize(cp);
+    if (category === void 0) continue;
+    const hex = formatHex(cp);
+    yield {
+      char,
+      codepoint: hex,
+      name: charNames[cp] ?? hex,
+      category,
+      offset: match.index
+    };
+  }
+}
+function detect(input, categories2) {
+  return [...scan(input, categories2)];
+}
+function first(input, categories2) {
+  for (const d of scan(input, categories2)) return d;
+  return void 0;
+}
+function hasGhosts(input, categories2) {
+  const regex = getRegex(categories2);
+  regex.lastIndex = 0;
+  return regex.test(input);
+}
+function isClean(input, categories2) {
+  return !hasGhosts(input, categories2);
+}
+function count(input, categories2) {
+  const result = {};
+  for (const d of detect(input, categories2)) {
+    result[d.category] = (result[d.category] ?? 0) + 1;
+  }
+  return result;
+}
+function identify(input) {
+  const cp = typeof input === "number" ? input : input.codePointAt(0);
+  const category = categorize(cp);
+  if (category === void 0) return void 0;
+  const hex = formatHex(cp);
+  return {
+    codepoint: hex,
+    name: charNames[cp] ?? hex,
+    category
+  };
+}
+
+// src/replace.ts
+var defaultFormatter = (d) => `[${d.codepoint}]`;
+function replaceDetections(input, detections, mapper) {
+  if (detections.length === 0) return input;
+  const parts = [];
+  let cursor = 0;
+  for (const d of detections) {
+    parts.push(input.slice(cursor, d.offset));
+    parts.push(mapper(d));
+    cursor = d.offset + d.char.length;
+  }
+  parts.push(input.slice(cursor));
+  return parts.join("");
+}
+
+// src/summary.ts
+function summary(input, categories2) {
+  const detections = detect(input, categories2);
+  if (detections.length === 0) return "No invisible characters found.";
+  const counts = {};
+  for (const d of detections) {
+    counts[d.category] = (counts[d.category] ?? 0) + 1;
+  }
+  const total = detections.length;
+  const header = `${total} invisible character${total === 1 ? "" : "s"} found.`;
+  const byCategory = Object.entries(counts).sort(([a], [b]) => a.localeCompare(b)).map(([cat, n]) => `  ${cat}: ${n}`).join("\n");
+  const details = detections.map((d) => `  ${d.codepoint}  ${d.name}  (${d.category}, offset ${d.offset})`).join("\n");
+  return `${header}
+
+By category:
+${byCategory}
+
+Details:
+${details}`;
+}
+
+// src/chain.ts
+var DeghostChain = class _DeghostChain {
+  #value;
+  constructor(value) {
+    this.#value = value;
+  }
+  /** Remove all characters in the given category. */
+  strip(category) {
+    return new _DeghostChain(this.#value.replace(patterns[category], ""));
+  }
+  /** Replace all characters in the given category with a substitute. */
+  normalize(category, replacement = " ") {
+    return new _DeghostChain(this.#value.replace(patterns[category], replacement));
+  }
+  /** Replace matched ghosts in a category using a mapper function. */
+  replace(category, mapper) {
+    const result = replaceDetections(this.#value, detect(this.#value, [category]), mapper);
+    return result === this.#value ? this : new _DeghostChain(result);
+  }
+  /** Replace ghosts with visible markers like `[U+200B]`. */
+  highlight(category, formatter = defaultFormatter) {
+    const categories2 = category ? [category] : void 0;
+    const result = replaceDetections(
+      this.#value,
+      detect(this.#value, categories2),
+      formatter
+    );
+    return result === this.#value ? this : new _DeghostChain(result);
+  }
+  /** Return detections for the current chain value. */
+  detect(categories2) {
+    return detect(this.#value, categories2);
+  }
+  /** Check if the current chain value contains invisible characters. */
+  hasGhosts(categories2) {
+    return hasGhosts(this.#value, categories2);
+  }
+  /** Count invisible characters by category in the current chain value. */
+  count(categories2) {
+    return count(this.#value, categories2);
+  }
+  /** Returns true if the current chain value has no invisible characters. */
+  isClean(categories2) {
+    return isClean(this.#value, categories2);
+  }
+  /** Return a human-readable report of ghosts in the current chain value. */
+  summary(categories2) {
+    return summary(this.#value, categories2);
+  }
+  /** Collapse runs of whitespace into a single space. */
+  collapse() {
+    return new _DeghostChain(this.#value.replace(/ {2,}/g, " "));
+  }
+  /** Trim leading and trailing whitespace. */
+  trim() {
+    return new _DeghostChain(this.#value.trim());
+  }
+  /** Apply the default cleaning preset: strip format + control, normalize spaces, trim. */
+  clean() {
+    return this.strip("format").strip("control").strip("bom").normalize("spaces").collapse().trim();
+  }
+  /** Extract the cleaned string. */
+  toString() {
+    return this.#value;
+  }
+  /** Extract the cleaned string (alias for toString). */
+  valueOf() {
+    return this.#value;
+  }
+  /** Support JSON.stringify. */
+  toJSON() {
+    return this.#value;
+  }
+};
+
+// src/cleaner.ts
+var CleanerBuilder = class {
+  #rules = [];
+  #trim = false;
+  #collapse = false;
+  /** Add a strip rule — remove all characters in this category. */
+  strip(category) {
+    this.#rules.push({ category, action: "strip" });
+    return this;
+  }
+  /** Add a normalize rule — replace characters in this category. */
+  normalize(category, replacement = " ") {
+    this.#rules.push({ category, action: "normalize", replacement });
+    return this;
+  }
+  /** Add a replace rule — transform characters using detection metadata. */
+  replace(category, mapper) {
+    this.#rules.push({ category, action: "replace", mapper });
+    return this;
+  }
+  /** Add a highlight step — annotate characters with visible markers. */
+  highlight(category, formatter = defaultFormatter) {
+    this.#rules.push({ category, action: "replace", mapper: formatter });
+    return this;
+  }
+  /** Enable whitespace trimming as a final step. */
+  trim() {
+    this.#trim = true;
+    return this;
+  }
+  /** Enable collapsing runs of whitespace as a final step. */
+  collapse() {
+    this.#collapse = true;
+    return this;
+  }
+  /** Compile the pipeline into a reusable function. */
+  build() {
+    const steps = this.#rules.map((rule) => {
+      if (rule.action === "replace") {
+        const { mapper, category } = rule;
+        return (s) => replaceDetections(s, detect(s, [category]), mapper);
+      }
+      const pattern = patterns[rule.category];
+      if (rule.action === "strip") {
+        return (s) => s.replace(pattern, "");
+      }
+      const replacement = rule.replacement ?? " ";
+      return (s) => s.replace(pattern, replacement);
+    });
+    const doCollapse = this.#collapse;
+    const doTrim = this.#trim;
+    return (input) => {
+      let result = input;
+      for (const step of steps) {
+        result = step(result);
+      }
+      if (doCollapse) result = result.replace(/ {2,}/g, " ");
+      if (doTrim) result = result.trim();
+      return result;
+    };
+  }
+};
+function cleaner() {
+  return new CleanerBuilder();
+}
+
+// src/presets.ts
+var presets = {
+  /**
+   * Default clean: strip format + control + BOM, normalize spaces, collapse, trim.
+   *
+   * The right choice for most text processing — catches invisible chars from
+   * binary formats (Garmin FIT, PDFs), APIs, and copy-paste while preserving
+   * word boundaries.
+   */
+  clean: cleaner().strip("format").strip("control").strip("bom").normalize("spaces").collapse().trim().build(),
+  /**
+   * Aggressive: strip everything invisible, including fillers, math operators, and tags.
+   *
+   * Use when you want maximally clean output and don't need to preserve any
+   * invisible Unicode semantics (ligature joiners, bidi marks, etc.).
+   */
+  aggressive: cleaner().strip("format").strip("control").strip("bom").strip("tag").strip("fillers").strip("math").normalize("spaces").collapse().trim().build(),
+  /**
+   * Spaces only: normalize Unicode whitespace to ASCII space.
+   *
+   * Leaves format/control characters alone. Useful when you only care about
+   * NBSP and exotic spaces (common in data from Garmin, Strava, etc.).
+   */
+  spaces: cleaner().normalize("spaces").collapse().trim().build()
+};
+
+// src/highlight.ts
+function highlight(input, options) {
+  const formatter = typeof options === "function" ? options : options?.formatter ?? defaultFormatter;
+  const categories2 = typeof options === "object" ? options.categories : void 0;
+  return replaceDetections(input, detect(input, categories2), formatter);
+}
+
+// src/index.ts
+function deghost(input, ...rest) {
+  let raw;
+  if (typeof input === "string") {
+    raw = input;
+  } else {
+    raw = input[0] ?? "";
+    for (let i = 0; i < rest.length; i++) {
+      raw += String(rest[i]) + (input[i + 1] ?? "");
+    }
+  }
+  const options = typeof input === "string" && rest.length <= 1 ? rest[0] : void 0;
+  const chain = new DeghostChain(raw);
+  const cleaned = presets.clean(raw);
+  const trimmed = options?.trim ?? true ? cleaned.trim() : cleaned;
+  return new Proxy(chain, {
+    get(target, prop, receiver) {
+      if (prop === Symbol.toPrimitive) return () => trimmed;
+      if (prop === "length") return trimmed.length;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+exports.CleanerBuilder = CleanerBuilder;
+exports.DeghostChain = DeghostChain;
+exports.categories = categories;
+exports.categorize = categorize;
+exports.charNames = charNames;
+exports.cleaner = cleaner;
+exports.count = count;
+exports.deghost = deghost;
+exports.descriptions = descriptions;
+exports.detect = detect;
+exports.first = first;
+exports.hasGhosts = hasGhosts;
+exports.highlight = highlight;
+exports.identify = identify;
+exports.isClean = isClean;
+exports.patterns = patterns;
+exports.presets = presets;
+exports.scan = scan;
+exports.summary = summary;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map