}
                }
            }
        }
    }

    private
    fun String.urlEncodeSpace() = replace(" ", "%20")

    private
    fun String.escape() = replace("<", "&lt;").replace(">", "&gt;")
}

data class Problem(
    val name: String,
    val relativePath: String,
    val lineNumber: Int
)

    classFilePath
        .removeSuffix(CLASS_FILE_EXTENSION)
        .removeSuffix("Kt")
        .replace(slashOrDollar, ".")


// visible for testing
fun classFilePathCandidatesFor(sourceName: String): Sequence<String> =
    sourceName.replace(".", "/").let { path ->
        candidateClassFiles(path) + nestedClassFilePathCandidatesFor(path)
    }


private

	}
	return u.detail
}

// Msg - Replace the current error's message
func (u Err) Msg(m string) Err {
	e := u.Clone()
	e.msg = m
	return e
}

// Msgf - Replace the current error's message
func (u Err) Msgf(m string, args ...any) Err {
	e := u.Clone()
	if len(args) == 0 {
		e.msg = m
	} else {
		e.msg = fmt.Sprintf(m, args...)
	}
	return e
}

// Hint - Replace the current error's message

}

// Raw - returns the underlying data with format info.
func (r *Record) Raw() (sql.SelectObjectFormat, any) {
	return sql.SelectFmtCSV, r
}

// Replace - is not supported for CSV
func (r *Record) Replace(_ any) error {
	return errors.New("Replace is not supported for CSV")
}

// NewRecord - creates new CSV record.
func NewRecord() *Record {
	return &Record{}

     */
    @Deprecated
    public File getPomFile() {
        return getFile();
    }

    @Override
    public ModelSource2 getRelatedSource(String relPath) {
        relPath = relPath.replace('\\', File.separatorChar).replace('/', File.separatorChar);

        Path relatedPom = getPath().getParent().resolve(relPath);

        if (Files.isDirectory(relatedPom)) {

    @Override
    public String alignToBaseDirectory(String path, File basedir) {
        String result = path;

        if (path != null && basedir != null) {
            path = path.replace('\\', File.separatorChar).replace('/', File.separatorChar);

            File file = new File(path);
            if (file.isAbsolute()) {
                // path was already absolute, just normalize file separator and we're done

    cache.put(10, 100);
    cache.put(2, 52);

    asMap.replace(2, 79);
    asMap.replace(3, 60);

    assertThat(cache.getIfPresent(3)).isNull();
    assertThat(asMap.get(3)).isNull();

    assertThat(cache.getIfPresent(2)).isEqualTo(79);
    assertThat(asMap.get(2)).isEqualTo(79);

    asMap.replace(10, 100, 50);
    asMap.replace(2, 52, 99);

    assertThat(cache.getIfPresent(10)).isEqualTo(50);

			for i, val := range v {
				tmpRec := input.Clone(nil)
				if err = tmpRec.Replace(val); err != nil {
					return nil, err
				}
				recs[i] = &tmpRec
			}
			return recs, nil

		default:
			kvs = jstream.KVS{jstream.KV{Key: "_1", Value: v}}
		}

		if err = input.Replace(kvs); err != nil {
			return nil, err
		}

		return []*Record{&input}, nil
	case simdjson.Object:

        includes.map {
            if (it.endsWith("/**")) {
                Pattern.compile(it.substring(0, it.length - 3).replace("/", "\\.") + "(\\..+)?")
            } else {
                Pattern.compile(it.substring(0, it.length - 2).replace("/", "\\.") + "\\.[^.]+")
            }
        }
    }

    private val excludePackagePatterns = listOf(Pattern.compile(".+\\.internal(\\..+)?"))

                    // we're going to parse this back in as XML so we need to escape XML markup
                    value = value.toString()
                            .replace("&", "&")
                            .replace("<", "&lt;")
                            .replace(">", "&gt;");
                    return value;
                }
                return null;
            }
        });

        try {