unicode-escaper 1.0.0 → 1.0.1

package/dist/index.browser.js

@@ -0,0 +1,591 @@
+// src/formats.ts
+function toHex(codePoint, minLength, uppercase) {
+  const hex = codePoint.toString(16);
+  const padded = hex.padStart(minLength, "0");
+  return uppercase ? padded.toUpperCase() : padded.toLowerCase();
+}
+function toSurrogatePair(codePoint) {
+  const offset = codePoint - 65536;
+  const highSurrogate = 55296 + (offset >> 10);
+  const lowSurrogate = 56320 + (offset & 1023);
+  return [highSurrogate, lowSurrogate];
+}
+var formatters = {
+  /**
+   * Unicode escape: \uXXXX for BMP, surrogate pairs for non-BMP
+   */
+  unicode: (codePoint, uppercase) => {
+    if (codePoint <= 65535) {
+      return `\\u${toHex(codePoint, 4, uppercase)}`;
+    }
+    const [high, low] = toSurrogatePair(codePoint);
+    return `\\u${toHex(high, 4, uppercase)}\\u${toHex(low, 4, uppercase)}`;
+  },
+  /**
+   * ES6 Unicode escape: \u{XXXXX} - supports full Unicode range
+   */
+  "unicode-es6": (codePoint, uppercase) => {
+    return `\\u{${toHex(codePoint, 1, uppercase)}}`;
+  },
+  /**
+   * Hex escape: \xNN - only valid for 0x00-0xFF
+   */
+  hex: (codePoint, uppercase) => {
+    if (codePoint > 255) {
+      return formatters.unicode(codePoint, uppercase);
+    }
+    return `\\x${toHex(codePoint, 2, uppercase)}`;
+  },
+  /**
+   * HTML hex entity: &#xNNNN;
+   */
+  "html-hex": (codePoint, uppercase) => {
+    return `&#x${toHex(codePoint, 1, uppercase)};`;
+  },
+  /**
+   * HTML decimal entity: &#NNNN;
+   */
+  "html-decimal": (codePoint, _uppercase) => {
+    return `&#${codePoint};`;
+  },
+  /**
+   * Code point notation: U+XXXX
+   */
+  codepoint: (codePoint, uppercase) => {
+    return `U+${toHex(codePoint, 4, uppercase)}`;
+  }
+};
+var unescapePatterns = {
+  // Matches \uXXXX including surrogate pairs
+  unicode: /\\u([0-9A-Fa-f]{4})/g,
+  // Matches \u{X} to \u{XXXXXX}
+  "unicode-es6": /\\u\{([0-9A-Fa-f]{1,6})\}/g,
+  // Matches \xNN
+  hex: /\\x([0-9A-Fa-f]{2})/g,
+  // Matches &#xNNNN;
+  "html-hex": /&#x([0-9A-Fa-f]+);/gi,
+  // Matches &#NNNN;
+  "html-decimal": /&#(\d+);/g,
+  // Matches U+XXXX
+  codepoint: /U\+([0-9A-Fa-f]{4,6})/gi
+};
+var combinedUnescapePattern = /\\u\{([0-9A-Fa-f]{1,6})\}|\\u([0-9A-Fa-f]{4})|\\x([0-9A-Fa-f]{2})|&#x([0-9A-Fa-f]+);|&#(\d+);|U\+([0-9A-Fa-f]{4,6})/gi;
+var surrogatePairPattern = /\\u([Dd][89AaBb][0-9A-Fa-f]{2})\\u([Dd][CcDdEeFf][0-9A-Fa-f]{2})/g;
+function isValidCodePoint(codePoint) {
+  return codePoint >= 0 && codePoint <= 1114111;
+}
+function isSurrogateCodePoint(codePoint) {
+  return codePoint >= 55296 && codePoint <= 57343;
+}
+function surrogateToCodePoint(high, low) {
+  return (high - 55296 << 10) + (low - 56320) + 65536;
+}
+
+// src/filters.ts
+var ASCII_MAX = 127;
+var LATIN1_MAX = 255;
+var BMP_MAX = 65535;
+var SURROGATE_HIGH_START = 55296;
+var SURROGATE_HIGH_END = 56319;
+var SURROGATE_LOW_START = 56320;
+var SURROGATE_LOW_END = 57343;
+var isAscii = (_char, codePoint) => {
+  return codePoint <= ASCII_MAX;
+};
+var isNotAscii = (_char, codePoint) => {
+  return codePoint > ASCII_MAX;
+};
+var isLatin1 = (_char, codePoint) => {
+  return codePoint <= LATIN1_MAX;
+};
+var isNotLatin1 = (_char, codePoint) => {
+  return codePoint > LATIN1_MAX;
+};
+var isBmp = (_char, codePoint) => {
+  return codePoint <= BMP_MAX;
+};
+var isNotBmp = (_char, codePoint) => {
+  return codePoint > BMP_MAX;
+};
+var isHighSurrogate = (_char, codePoint) => {
+  return codePoint >= SURROGATE_HIGH_START && codePoint <= SURROGATE_HIGH_END;
+};
+var isLowSurrogate = (_char, codePoint) => {
+  return codePoint >= SURROGATE_LOW_START && codePoint <= SURROGATE_LOW_END;
+};
+var isSurrogate = (_char, codePoint) => {
+  return codePoint >= SURROGATE_HIGH_START && codePoint <= SURROGATE_LOW_END;
+};
+var isPrintableAscii = (_char, codePoint) => {
+  return codePoint >= 32 && codePoint <= 126;
+};
+var isNotPrintableAscii = (_char, codePoint) => {
+  return codePoint < 32 || codePoint > 126;
+};
+var isControl = (_char, codePoint) => {
+  return codePoint <= 31 || codePoint === 127;
+};
+var isWhitespace = (char, _codePoint) => {
+  return /\s/.test(char);
+};
+function inRange(start, end) {
+  return (_char, codePoint) => {
+    return codePoint >= start && codePoint <= end;
+  };
+}
+function notInRange(start, end) {
+  return (_char, codePoint) => {
+    return codePoint < start || codePoint > end;
+  };
+}
+function oneOf(chars) {
+  const charSet = /* @__PURE__ */ new Set([...chars]);
+  return (char, _codePoint) => {
+    return charSet.has(char);
+  };
+}
+function noneOf(chars) {
+  const charSet = /* @__PURE__ */ new Set([...chars]);
+  return (char, _codePoint) => {
+    return !charSet.has(char);
+  };
+}
+function and(...filters) {
+  return (char, codePoint) => {
+    return filters.every((filter) => filter(char, codePoint));
+  };
+}
+function or(...filters) {
+  return (char, codePoint) => {
+    return filters.some((filter) => filter(char, codePoint));
+  };
+}
+function not(filter) {
+  return (char, codePoint) => {
+    return !filter(char, codePoint);
+  };
+}
+var all = () => true;
+var none = () => false;
+
+// src/escape.ts
+var DEFAULT_OPTIONS = {
+  format: "unicode",
+  uppercase: true
+};
+function createPreserveFilter(options) {
+  const { preserveAscii = true, preserveLatin1 = false } = options;
+  if (preserveLatin1) {
+    return isNotLatin1;
+  }
+  if (preserveAscii) {
+    return isNotAscii;
+  }
+  return () => true;
+}
+function escape(input, options = {}) {
+  if (typeof input !== "string") {
+    throw new TypeError(`Expected string, got ${typeof input}`);
+  }
+  if (input.length === 0) {
+    return "";
+  }
+  const format = options.format ?? DEFAULT_OPTIONS.format;
+  const uppercase = options.uppercase ?? DEFAULT_OPTIONS.uppercase;
+  const formatter = formatters[format];
+  if (!formatter) {
+    throw new Error(`Unknown escape format: ${format}`);
+  }
+  const filter = options.filter ?? createPreserveFilter(options);
+  const result = [];
+  for (const char of input) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === void 0) {
+      result.push(char);
+      continue;
+    }
+    if (filter(char, codePoint)) {
+      result.push(formatter(codePoint, uppercase));
+    } else {
+      result.push(char);
+    }
+  }
+  return result.join("");
+}
+function escapeWithInfo(input, options = {}) {
+  if (typeof input !== "string") {
+    throw new TypeError(`Expected string, got ${typeof input}`);
+  }
+  if (input.length === 0) {
+    return {
+      escaped: "",
+      escapedCount: 0,
+      preservedCount: 0,
+      totalCount: 0
+    };
+  }
+  const format = options.format ?? DEFAULT_OPTIONS.format;
+  const uppercase = options.uppercase ?? DEFAULT_OPTIONS.uppercase;
+  const formatter = formatters[format];
+  if (!formatter) {
+    throw new Error(`Unknown escape format: ${format}`);
+  }
+  const filter = options.filter ?? createPreserveFilter(options);
+  const result = [];
+  let escapedCount = 0;
+  let preservedCount = 0;
+  for (const char of input) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint === void 0) {
+      result.push(char);
+      preservedCount++;
+      continue;
+    }
+    if (filter(char, codePoint)) {
+      result.push(formatter(codePoint, uppercase));
+      escapedCount++;
+    } else {
+      result.push(char);
+      preservedCount++;
+    }
+  }
+  return {
+    escaped: result.join(""),
+    escapedCount,
+    preservedCount,
+    totalCount: escapedCount + preservedCount
+  };
+}
+function escapeToUnicode(input, options = {}) {
+  return escape(input, { ...options, format: "unicode" });
+}
+function escapeToUnicodeES6(input, options = {}) {
+  return escape(input, { ...options, format: "unicode-es6" });
+}
+function escapeToHex(input, options = {}) {
+  return escape(input, { ...options, format: "hex" });
+}
+function escapeToHtmlHex(input, options = {}) {
+  return escape(input, { ...options, format: "html-hex" });
+}
+function escapeToHtmlDecimal(input, options = {}) {
+  return escape(input, { ...options, format: "html-decimal" });
+}
+function escapeToCodePoint(input, options = {}) {
+  return escape(input, { ...options, format: "codepoint" });
+}
+function escapeAll(input, options = {}) {
+  return escape(input, { ...options, filter: () => true });
+}
+function escapeNonPrintable(input, options = {}) {
+  return escape(input, {
+    ...options,
+    filter: (_char, codePoint) => {
+      return codePoint < 32 || codePoint === 127 || codePoint > 126;
+    }
+  });
+}
+
+// src/unescape.ts
+var DEFAULT_OPTIONS2 = {
+  formats: ["unicode", "unicode-es6", "hex", "html-hex", "html-decimal", "codepoint"],
+  lenient: true
+};
+function hexToCodePoint(hex, lenient) {
+  const codePoint = parseInt(hex, 16);
+  if (isNaN(codePoint)) {
+    if (lenient) return null;
+    throw new Error(`Invalid hex value: ${hex}`);
+  }
+  if (!isValidCodePoint(codePoint)) {
+    if (lenient) return null;
+    throw new Error(`Invalid code point: U+${hex.toUpperCase()}`);
+  }
+  return codePoint;
+}
+function decimalToCodePoint(decimal, lenient) {
+  const codePoint = parseInt(decimal, 10);
+  if (isNaN(codePoint)) {
+    if (lenient) return null;
+    throw new Error(`Invalid decimal value: ${decimal}`);
+  }
+  if (!isValidCodePoint(codePoint)) {
+    if (lenient) return null;
+    throw new Error(`Invalid code point: ${codePoint}`);
+  }
+  return codePoint;
+}
+function codePointToChar(codePoint) {
+  return String.fromCodePoint(codePoint);
+}
+function unescape(input, options = {}) {
+  if (typeof input !== "string") {
+    throw new TypeError(`Expected string, got ${typeof input}`);
+  }
+  if (input.length === 0) {
+    return "";
+  }
+  const lenient = options.lenient ?? DEFAULT_OPTIONS2.lenient;
+  const formats = options.formats ?? DEFAULT_OPTIONS2.formats;
+  let result = input;
+  if (formats.includes("unicode")) {
+    const pairPattern = new RegExp(surrogatePairPattern.source, surrogatePairPattern.flags);
+    result = result.replace(pairPattern, (match, highHex, lowHex) => {
+      const high = hexToCodePoint(highHex, lenient);
+      const low = hexToCodePoint(lowHex, lenient);
+      if (high === null || low === null) {
+        return match;
+      }
+      const codePoint = surrogateToCodePoint(high, low);
+      return codePointToChar(codePoint);
+    });
+  }
+  for (const format of formats) {
+    const pattern = unescapePatterns[format];
+    if (!pattern) continue;
+    const regex = new RegExp(pattern.source, pattern.flags);
+    result = result.replace(regex, (match, captured) => {
+      let codePoint;
+      if (format === "html-decimal") {
+        codePoint = decimalToCodePoint(captured, lenient);
+      } else {
+        codePoint = hexToCodePoint(captured, lenient);
+      }
+      if (codePoint === null) {
+        return match;
+      }
+      if (isSurrogateCodePoint(codePoint)) {
+        if (lenient) {
+          return match;
+        }
+        throw new Error(`Standalone surrogate not allowed: U+${codePoint.toString(16).toUpperCase()}`);
+      }
+      return codePointToChar(codePoint);
+    });
+  }
+  return result;
+}
+function unescapeUnicode(input, options = {}) {
+  return unescape(input, { ...options, formats: ["unicode"] });
+}
+function unescapeUnicodeES6(input, options = {}) {
+  return unescape(input, { ...options, formats: ["unicode-es6"] });
+}
+function unescapeHex(input, options = {}) {
+  return unescape(input, { ...options, formats: ["hex"] });
+}
+function unescapeHtmlHex(input, options = {}) {
+  return unescape(input, { ...options, formats: ["html-hex"] });
+}
+function unescapeHtmlDecimal(input, options = {}) {
+  return unescape(input, { ...options, formats: ["html-decimal"] });
+}
+function unescapeCodePoint(input, options = {}) {
+  return unescape(input, { ...options, formats: ["codepoint"] });
+}
+function unescapeHtml(input, options = {}) {
+  return unescape(input, { ...options, formats: ["html-hex", "html-decimal"] });
+}
+function unescapeJs(input, options = {}) {
+  return unescape(input, { ...options, formats: ["unicode", "unicode-es6", "hex"] });
+}
+function hasEscapeSequences(input, formats) {
+  if (typeof input !== "string" || input.length === 0) {
+    return false;
+  }
+  if (formats) {
+    return formats.some((format) => {
+      const pattern = unescapePatterns[format];
+      if (!pattern) return false;
+      return new RegExp(pattern.source, pattern.flags.replace("g", "")).test(input);
+    });
+  }
+  return new RegExp(combinedUnescapePattern.source, "i").test(input);
+}
+function countEscapeSequences(input, formats) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  let count = 0;
+  if (formats) {
+    for (const format of formats) {
+      const pattern = unescapePatterns[format];
+      if (!pattern) continue;
+      const matches = input.match(new RegExp(pattern.source, pattern.flags));
+      count += matches?.length ?? 0;
+    }
+  } else {
+    const matches = input.match(new RegExp(combinedUnescapePattern.source, combinedUnescapePattern.flags));
+    count = matches?.length ?? 0;
+  }
+  return count;
+}
+
+// src/utils.ts
+function getCodePoint(char) {
+  if (typeof char !== "string" || char.length === 0) {
+    return void 0;
+  }
+  return char.codePointAt(0);
+}
+function fromCodePoint(codePoint) {
+  if (typeof codePoint !== "number" || !Number.isInteger(codePoint)) {
+    throw new TypeError("Code point must be an integer");
+  }
+  if (codePoint < 0 || codePoint > 1114111) {
+    throw new RangeError(`Invalid code point: ${codePoint}`);
+  }
+  return String.fromCodePoint(codePoint);
+}
+function isAscii2(char) {
+  const codePoint = getCodePoint(char);
+  return codePoint !== void 0 && codePoint <= 127;
+}
+function isLatin12(char) {
+  const codePoint = getCodePoint(char);
+  return codePoint !== void 0 && codePoint <= 255;
+}
+function isBmp2(char) {
+  const codePoint = getCodePoint(char);
+  return codePoint !== void 0 && codePoint <= 65535;
+}
+function isHighSurrogate2(codePoint) {
+  return codePoint >= 55296 && codePoint <= 56319;
+}
+function isLowSurrogate2(codePoint) {
+  return codePoint >= 56320 && codePoint <= 57343;
+}
+function isSurrogate2(codePoint) {
+  return codePoint >= 55296 && codePoint <= 57343;
+}
+function getCharInfo(char) {
+  const codePoint = getCodePoint(char);
+  if (codePoint === void 0) {
+    return void 0;
+  }
+  return {
+    char,
+    codePoint,
+    hex: codePoint.toString(16).toUpperCase().padStart(4, "0"),
+    isAscii: codePoint <= 127,
+    isBmp: codePoint <= 65535,
+    isLatin1: codePoint <= 255,
+    isHighSurrogate: codePoint >= 55296 && codePoint <= 56319,
+    isLowSurrogate: codePoint >= 56320 && codePoint <= 57343,
+    utf16Length: char.length
+  };
+}
+function* iterateCodePoints(input) {
+  let index = 0;
+  for (const char of input) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint !== void 0) {
+      yield { char, codePoint, index };
+    }
+    index++;
+  }
+}
+function toCodePoints(input) {
+  const codePoints = [];
+  for (const char of input) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint !== void 0) {
+      codePoints.push(codePoint);
+    }
+  }
+  return codePoints;
+}
+function fromCodePoints(codePoints) {
+  return String.fromCodePoint(...codePoints);
+}
+function codePointLength(input) {
+  return [...input].length;
+}
+function toHex2(codePoint, options = {}) {
+  const { prefix = "", minLength = 4, uppercase = true } = options;
+  let hex = codePoint.toString(16);
+  hex = hex.padStart(minLength, "0");
+  hex = uppercase ? hex.toUpperCase() : hex.toLowerCase();
+  return prefix + hex;
+}
+function parseHex(hex) {
+  const cleaned = hex.replace(/^(0x|U\+|\\u\{?|&#x)/i, "").replace(/[}\;]$/, "");
+  const codePoint = parseInt(cleaned, 16);
+  if (isNaN(codePoint) || codePoint < 0 || codePoint > 1114111) {
+    return void 0;
+  }
+  return codePoint;
+}
+function isValidUnicode(input) {
+  for (let i = 0; i < input.length; i++) {
+    const code = input.charCodeAt(i);
+    if (isHighSurrogate2(code)) {
+      if (i + 1 >= input.length || !isLowSurrogate2(input.charCodeAt(i + 1))) {
+        return false;
+      }
+      i++;
+    } else if (isLowSurrogate2(code)) {
+      return false;
+    }
+  }
+  return true;
+}
+function normalizeNFC(input) {
+  return input.normalize("NFC");
+}
+function normalizeNFD(input) {
+  return input.normalize("NFD");
+}
+function unicodeEquals(a, b) {
+  return normalizeNFC(a) === normalizeNFC(b);
+}
+
+// src/stream.browser.ts
+function createWebEscapeStream(options = {}) {
+  let buffer = "";
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffer += chunk;
+      const lastChar = buffer.charCodeAt(buffer.length - 1);
+      const isHighSurrogate3 = lastChar >= 55296 && lastChar <= 56319;
+      if (isHighSurrogate3) {
+        const toProcess = buffer.slice(0, -1);
+        buffer = buffer.slice(-1);
+        if (toProcess.length > 0) {
+          controller.enqueue(escape(toProcess, options));
+        }
+      } else {
+        controller.enqueue(escape(buffer, options));
+        buffer = "";
+      }
+    },
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.enqueue(escape(buffer, options));
+      }
+    }
+  });
+}
+function createWebUnescapeStream(options = {}) {
+  let buffer = "";
+  const maxLookback = 12;
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffer += chunk;
+      if (buffer.length > maxLookback) {
+        const toProcess = buffer.slice(0, -maxLookback);
+        buffer = buffer.slice(-maxLookback);
+        controller.enqueue(unescape(toProcess, options));
+      }
+    },
+    flush(controller) {
+      if (buffer.length > 0) {
+        controller.enqueue(unescape(buffer, options));
+      }
+    }
+  });
+}
+
+export { all, and, codePointLength, countEscapeSequences, createWebEscapeStream, createWebUnescapeStream, escape, escapeAll, escapeNonPrintable, escapeToCodePoint, escapeToHex, escapeToHtmlDecimal, escapeToHtmlHex, escapeToUnicode, escapeToUnicodeES6, escapeWithInfo, formatters, fromCodePoint, fromCodePoints, getCharInfo, getCodePoint, hasEscapeSequences, inRange, isAscii, isAscii2 as isAsciiChar, isBmp, isBmp2 as isBmpChar, isControl, isHighSurrogate, isHighSurrogate2 as isHighSurrogateCode, isLatin1, isLatin12 as isLatin1Char, isLowSurrogate, isLowSurrogate2 as isLowSurrogateCode, isNotAscii, isNotBmp, isNotLatin1, isNotPrintableAscii, isPrintableAscii, isSurrogate, isSurrogate2 as isSurrogateCode, isSurrogateCodePoint, isValidCodePoint, isValidUnicode, isWhitespace, iterateCodePoints, none, noneOf, normalizeNFC, normalizeNFD, not, notInRange, oneOf, or, parseHex, surrogateToCodePoint, toCodePoints, toHex2 as toHex, unescape, unescapeCodePoint, unescapeHex, unescapeHtml, unescapeHtmlDecimal, unescapeHtmlHex, unescapeJs, unescapePatterns, unescapeUnicode, unescapeUnicodeES6, unicodeEquals };
+//# sourceMappingURL=index.browser.js.map
+//# sourceMappingURL=index.browser.js.map