}
        return Pattern.quote(s);
    }

    /**
     * Unescapes double backslashes in regex patterns.
     * Converts escaped backslashes (\\) back to single backslashes (\).
     *
     * @param s the string to unescape
     * @return the unescaped string
     */
    protected String unescape(final String s) {
        return s.replace("\\\\", "\\");
    }

    /**

        val element = WebPlatformUrlTestData()
        element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =
          when {
            base == null || base.isEmpty() -> list[list.size - 1].base
            else -> unescape(base)
          }

        while (i < parts.size) {
          val piece = parts[i]

```

### Text Processing and JSON
```java
import org.codelibs.core.text.*;

// JSON utilities with proper escaping
String escaped = JsonUtil.escape("Hello \"World\" with special chars");
String unescaped = JsonUtil.unescape(escaped);

// Text tokenization
Tokenizer tokenizer = new Tokenizer("field1,field2,field3", ",");
while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();
    // Process each token

                        inputs[i] = unescape(inputStrings.get(i)).trim();
                    }

                    final List<String> outputStrings = split(sides.get(1), ",");
                    outputs = new String[outputStrings.size()];
                    for (int i = 0; i < outputs.length; i++) {
                        outputs[i] = unescape(outputStrings.get(i)).trim();
                    }

    }

    public void test_unescape() {
        GsaConfigParser parser = new GsaConfigParser();

        assertEquals("test\\", parser.unescape("test\\\\"));
        assertEquals("test", parser.unescape("test"));
        assertEquals("\\", parser.unescape("\\\\"));
    }

    public void test_appendFilterPath() {
        GsaConfigParser parser = new GsaConfigParser();

                    }
                    continue; // ignore empty lines and comments
                }

                final String inputStrings = line;
                final String input = unescape(inputStrings);

                if (input.length() > 0) {
                    id++;
                    final ProtwordsItem item = new ProtwordsItem(id, input);
                    if (updater != null) {

                    }
                    continue; // ignore empty lines and comments
                }

                final String inputStrings = line;
                final String input = unescape(inputStrings);

                if (input.length() > 0) {
                    id++;
                    final StopwordsItem item = new StopwordsItem(id, input);
                    if (updater != null) {

private fun Buffer.startsWith(prefix: Byte): Boolean = !exhausted() && this[0] == prefix

/**
 * Reads a double-quoted string, unescaping quoted pairs like `\"` to the 2nd character in each
 * sequence. Returns the unescaped string, or null if the buffer isn't prefixed with a
 * double-quoted string.
 */
@Throws(EOFException::class)
private fun Buffer.readQuotedString(): String? {
  require(readByte() == '\"'.code.toByte())

        if (result.indexOf('\"') >= 0) {
            final Matcher m = QUOTE_REPLACE_PATTERN.matcher(original);
            if (m.matches()) {
                result = m.group(1);
            }

            // Unescape
            if (result.indexOf(ESCAPED_QUOTE) >= 0) {
                result = result.replace(ESCAPED_QUOTE, "\"");
            }
        }

        return result;

    }

    /**

    assertEquals("string with spaces", spaceEscaper.escape("string with spaces"));
  }

  /** Tests that if we add extra 'safe' characters they remain unescaped */
  public void testCustomEscaper() {
    UnicodeEscaper e = new PercentEscaper("+*/-", false);
    for (char c = 0; c < 128; c++) {
      if ((c >= '0' && c <= '9')
          || (c >= 'a' && c <= 'z')