{unescaped: "true", escaped: "__true__"},
		{unescaped: "false", escaped: "__false__"},
		{unescaped: "null", escaped: "__null__"},
		{unescaped: "in", escaped: "__in__"},
		{unescaped: "as", escaped: "__as__"},
		{unescaped: "break", escaped: "__break__"},
		{unescaped: "const", escaped: "__const__"},
		{unescaped: "continue", escaped: "__continue__"},
		{unescaped: "else", escaped: "__else__"},
		{unescaped: "for", escaped: "__for__"},

        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]

      <w>ctor</w>
      <w>inlining</w>
      <w>interner</w>
      <w>intrinsicify</w>
      <w>kclass</w>
      <w>lookups</w>
      <w>minification</w>
      <w>minifier</w>
      <w>minify</w>
      <w>unescape</w>
    </words>
  </dictionary>

	return ident, true
}

var unexpandMatcher = regexp.MustCompile(`(_{2}[^_]+_{2})`)

// Unescape unescapes an CEL identifier containing the escape sequences described in Escape, or return false if the
// string contains invalid escape sequences. The escaped input is expected to be a valid CEL identifier, but is
// not checked.
func Unescape(escaped string) (string, bool) {
	ok := true

	}{
		{
			"/a", // this pattern matches a path that unescapes to "/a"
			[]string{"/a", "/%61"},
			[]string{"/a", "/%61"},
		},
		{
			"/%62", // patterns are unescaped by segment; matches paths that unescape to "/b"
			[]string{"/b", "/%62"},
			[]string{"/%2562"}, // In 1.21, patterns were not unescaped but paths were.
		},
		{

                    }
                    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) {

                result = m.group(1);
            }

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

        return result;

    }

    /**
     * Quote and escape input value for CSV
     *
     * @param original Original text.
     * @return Escaped text.

			switch i {
			case 0x5c:
				output = strings.ReplaceAll(output, `\`, `/`)
			case 0x7e:
				output = strings.ReplaceAll(output, `%7e`, `~`)
			}
			if err != nil {
				t.Errorf("failed to unescape percent encoded path %s: %v", input, err)
			}
		}
		percentEncodedCases = append(percentEncodedCases, expect{in: input, out: output})
	}
	framework.NewTest(t).
		Run(func(t framework.TestContext) {

	m.values[name] = v
	return v
}

func (m *MapValue) Find(key ref.Val) (ref.Val, bool) {
	n, ok := key.(types.String)
	if !ok {
		return types.MaybeNoSuchOverloadErr(n), true
	}
	name, ok := cel.Unescape(n.Value().(string))
	if !ok {
		return nil, false
	}
	if _, exists := m.callbacks[name]; !exists {
		return nil, false
	}
	return m.resolveField(name), true
}