buninu-browser 0.3.0 → 0.5.0

package/test/fixtures/qml/flea-theme/ui/js/Palette.js

@@ -0,0 +1,33 @@
+// The Omarchy theme palette in colors.toml, parsed and queried. Pure, with no QML imports, so
+// tests/js/palette.js can run it under qml6 with no window.
+
+// Sample input: cyan = "#27a6a2"   # the ANSI ring
+function parse(body) {
+    var found = {};
+    var lines = String(body || "").split("\n");
+    for (var i = 0; i < lines.length; i++) {
+        var kv = lines[i].match(/^\s*([A-Za-z0-9_-]+)\s*=\s*["']?(#[0-9A-Fa-f]{6})/);
+        if (kv)
+            found[kv[1]] = kv[2];
+    }
+    return found;
+}
+
+// ThemeRoles.html's surface ladder: the chrome plane, then background as the neutral fallback when
+// it is absent, then selection for the alacritty-derived file that emits neither ladder key at all.
+var SURFACE_KEYS = ["dark_background", "background", "selection"];
+
+// The first key the theme actually set wins, and a role no theme models keeps Flea's own colour.
+function pick(found, keys, fallback) {
+    for (var i = 0; i < keys.length; i++) {
+        if (found[keys[i]])
+            return found[keys[i]];
+    }
+    return fallback;
+}
+
+// A theme need not set every role and pick() already falls back per role, so the only question a
+// readiness flag can answer honestly is whether the file yielded any colour at all.
+function isPalette(found) {
+    return Object.keys(found).length > 0;
+}

package/test/fixtures/qml/flea-theme/ui/js/Places.js

@@ -0,0 +1,236 @@
+.pragma library
+
+.import "Mounts.js" as Mounts
+.import "UserDirs.js" as UserDirs
+
+// Sample input: XDG_DOWNLOAD_DIR="$HOME/Downloads"
+function userDirs(body, home) {
+    return UserDirs.userDirs(body, home)
+}
+
+// Sample input: file:///home/gm/Downloads Downloads
+function bookmarks(body) {
+    var out = []
+    var lines = String(body || "").split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i].trim()
+        // corner: a bookmark may be smb:// or sftp://, which is a Location and not a Favorite.
+        if (line.indexOf("file://") !== 0)
+            continue
+        var space = line.indexOf(" ")
+        var uri = space < 0 ? line : line.substring(0, space)
+        var label = space < 0 ? "" : line.substring(space + 1).trim()
+        var path = Mounts.decodePath(uri.substring("file://".length))
+        out.push({ path: path, label: label.length > 0 ? label : leaf(path) })
+    }
+    return out
+}
+
+// The FAVORITES rail's rows, Home first and always, then XDG dirs and bookmarked places in file
+// order, a path seen twice keeping its first position. glyphFor resolves each row's mark so the
+// rail's Icons import stays the rail's own business; see ui/Sidebar.qml's rebuild.
+function favorites(home, dirsText, marksText, glyphFor) {
+    var favs = [{ path: home, label: "Home", group: "favorite", kind: "favorite", glyph: glyphFor("Home") }]
+    var seen = {}
+    seen[home] = true
+    var groups = [userDirs(dirsText, home), bookmarks(marksText)]
+    for (var g = 0; g < groups.length; g++) {
+        for (var i = 0; i < groups[g].length; i++) {
+            if (seen[groups[g][i].path])
+                continue
+            var e = groups[g][i]
+            seen[e.path] = true
+            favs.push({ path: e.path, label: e.label, group: "favorite", kind: "favorite", glyph: glyphFor(e.label) })
+        }
+    }
+    return favs
+}
+
+function leaf(path) {
+    var cut = path.lastIndexOf("/")
+    return cut < 0 ? path : path.substring(cut + 1)
+}
+
+// Sample input: "smb://192.168.1.10/data NAS"; see AGENTS.md "Places.relabel" for the matching, duplicate and control-character rules.
+function relabel(body, path, name) {
+    // A trust boundary: an embedded newline could otherwise split one bookmark into two lines.
+    var trimmed = String(name || "").replace(/[\r\n]/g, "").trim()
+    if (trimmed.length === 0)
+        return String(body || "")
+    var target = Mounts.normalize(path)
+    var lines = String(body || "").split("\n")
+    var found = false
+    for (var i = 0; i < lines.length; i++) {
+        // Read off the trimmed line the way Mounts.removeBookmark reads it, or an indented bookmark
+        // is one Remove can drop and this could only ever duplicate.
+        var line = lines[i].trim()
+        if (line.length === 0)
+            continue
+        var space = line.indexOf(" ")
+        var uri = space < 0 ? line : line.substring(0, space)
+        if (Mounts.normalize(uri) === target) {
+            lines[i] = uri + " " + trimmed
+            found = true
+        }
+    }
+    if (found)
+        return lines.join("\n")
+    var out = String(body || "")
+    if (out.length > 0 && out.charAt(out.length - 1) !== "\n")
+        out += "\n"
+    return out + target + " " + trimmed + "\n"
+}
+
+// Sample input: body as relabel's, oldUri the saved line being rewritten, newUri the address the
+// form's Mounts-as line showed. Matched the way relabel matches, so a live mount's trailing slash
+// still finds the saved line, and an empty oldUri matches nothing and appends instead. PR 21.
+function replace(body, oldUri, newUri, label) {
+    var next = Mounts.normalize(newUri)
+    if (next.length === 0)
+        return String(body || "")
+    // The same trust boundary relabel names: an embedded newline would split one bookmark into two.
+    var name = String(label || "").replace(/[\r\n]/g, "").trim()
+    if (name.length === 0)
+        name = leaf(next)
+    var target = Mounts.normalize(oldUri)
+    var lines = String(body || "").split("\n")
+    var found = false
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i].trim()
+        if (line.length === 0)
+            continue
+        var space = line.indexOf(" ")
+        var uri = space < 0 ? line : line.substring(0, space)
+        if (target.length > 0 && Mounts.normalize(uri) === target) {
+            lines[i] = next + " " + name
+            found = true
+        }
+    }
+    if (found)
+        return lines.join("\n")
+    var out = String(body || "")
+    if (out.length > 0 && out.charAt(out.length - 1) !== "\n")
+        out += "\n"
+    return out + next + " " + name + "\n"
+}
+
+var WIDTH_STOPS = [160, 192, 224, 256]
+function sidebarWidth(value) {
+    if (typeof value !== "number" || !isFinite(value)) return 192
+    var nearest = WIDTH_STOPS[0]
+    for (var i = 1; i < WIDTH_STOPS.length; i++) {
+        if (Math.abs(WIDTH_STOPS[i] - value) < Math.abs(nearest - value)) nearest = WIDTH_STOPS[i]
+    }
+    return nearest
+}
+
+function recordError(record) {
+    if (!record || typeof record !== "object" || Array.isArray(record)) return "invalid favorite record"
+    if (typeof record.label !== "string" || record.label.trim().length === 0) return "label needs visible text"
+    if (typeof record.path !== "string" || /[\u0000-\u001f\u007f]/.test(record.path)) return "invalid path"
+    if (record.path.charAt(0) === "/" || record.path === "~" || record.path.indexOf("~/") === 0) return ""
+    var schemes = ["smb://", "sftp://", "ftp://", "dav://", "davs://", "afp://", "nfs://", "file://"]
+    for (var i = 0; i < schemes.length; i++) {
+        if (record.path.indexOf(schemes[i]) === 0 && record.path.length > schemes[i].length) return ""
+    }
+    return "use a full path, a path that starts with ~/, or a network address"
+}
+
+function storedEntries(records, home) {
+    var out = []
+    for (var i = 0; Array.isArray(records) && i < records.length; i++) {
+        var record = records[i]
+        var error = recordError(record)
+        var label = record && typeof record.label === "string" ? record.label : JSON.stringify(record)
+        var path = record && typeof record.path === "string" ? record.path : ""
+        var resolved = path === "~" ? home : path.indexOf("~/") === 0 ? home + path.substring(1) : path
+        out.push({ label: label || "Invalid favorite", path: resolved, storedPath: path,
+            error: error, original: record, favouriteIndex: i, group: "favourite", kind: "favourite",
+            glyph: path.indexOf("://") >= 0 ? "network" : "folder" })
+    }
+    return out
+}
+
+function homeEntries(home, dirsText, glyphFor) {
+    var entries = [{ label: "Home", path: home }].concat(userDirs(dirsText, home))
+    return entries.map(function (entry) {
+        return { label: entry.label, path: entry.path, group: "home", kind: "home", glyph: glyphFor(entry.label) }
+    })
+}
+
+// The rail and query use the same validation, URI decoding and mount-first open.
+function openEntry(entry, ports) {
+    if (!entry) return
+    if (entry.kind === "trash") { ports.trash(); return }
+    var error = entry.kind === "favourite" ? recordError(entry.original) : ""
+    if (error) { ports.message("Could not open %1 · %2".replace(/%([12])/g, function (m, n) { return n === "1" ? entry.label : error }), true); return }
+    if (entry.path.indexOf("://") >= 0 && entry.path.indexOf("file://") !== 0) {
+        var host = ports.networkHost()
+        if (host) host.openChildShare(entry.path, entry.label, ports.pane)
+    } else {
+        ports.opened(entry.path.indexOf("file://") === 0 ? Mounts.decodePath(entry.path.substring(7)) : entry.path)
+    }
+}
+
+function railIdentity(entry) {
+    if (!entry) return ""
+    if (entry.kind === "favourite") return JSON.stringify([entry.kind, entry.original])
+    return JSON.stringify([entry.group, entry.kind, Mounts.railKey(entry) || entry.device || entry.uri || entry.path])
+}
+
+// Duplicate originals have no stored ID; a changed multiplicity cannot safely identify the selected occurrence.
+function railCursorAfter(before, after, index) {
+    if (before.length === 0 && index === 0) return 0
+    if (index < 0 || index >= before.length) return -1
+    var key = railIdentity(before[index]), oldCount = 0, occurrence = 0, matches = []
+    for (var i = 0; i < before.length; i++) {
+        if (railIdentity(before[i]) !== key) continue
+        oldCount++
+        if (i < index) occurrence++
+    }
+    for (var j = 0; j < after.length; j++) {
+        if (railIdentity(after[j]) === key) matches.push(j)
+    }
+    return matches.length === oldCount ? matches[occurrence] : -1
+}
+
+// Under gvfs only the mounted row opened under view.shareKey lights, never a folder prefix or the disk.
+function heldBy(entries, dir, view) {
+    var list = entries || []
+    var at = view || ({ kind: "dir" })
+    var path = String(dir || "")
+    var gvfs = Mounts.underGvfs(path)
+    var best = -1, depth = -1
+    for (var i = 0; i < list.length; i++) {
+        var e = list[i]
+        if (at.kind !== "dir") {
+            if (e.kind === at.kind && (at.kind !== "tag" || e.tag === at.tag))
+                return i
+            continue
+        }
+        if (e.kind === "recent" || e.kind === "trash" || e.kind === "tag" || e.error || e.mounted === false)
+            continue
+        if (gvfs) {
+            var key = String(at.shareKey || "")
+            if (key.length > 0 && !e.path && (Mounts.normalize(e.uri) === key || Mounts.normalize(e.mountUri) === key))
+                return i
+            continue
+        }
+        if (typeof e.path !== "string" || e.path.length === 0)
+            continue
+        if ((e.path === "/" ? path.charAt(0) === "/" : Mounts.inside(path, e.path)) && e.path.length > depth) {
+            best = i
+            depth = e.path.length
+        }
+    }
+    return best
+}
+
+// pathAlias is the pane's remembered gvfs share (or null); its key is the share's normalized address.
+function litView(trashOpened, recentMode, searchMode, answeredQuery, pathAlias) {
+    if (trashOpened) return { kind: "trash" }
+    if (String(recentMode || "").length > 0) return { kind: "recent" }
+    var query = String(answeredQuery || "")
+    if (String(searchMode || "").length > 0 && query.indexOf("tag:") === 0) return { kind: "tag", tag: query.substring(4) }
+    return { kind: "dir", shareKey: pathAlias ? String(pathAlias.key || "") : "" }
+}

package/test/fixtures/qml/flea-theme/ui/js/Protocols.js

@@ -0,0 +1,296 @@
+.pragma library
+
+// The Add-network-place form is a form over a gvfs URI, never a second mount system: a protocol
+// picks the scheme, prefills the port and swaps the field set, and the Mounts-as line always shows
+// the exact URI the dialog will hand to gio mount.
+
+// The five the canvas draws, in the order it draws them.
+var PROTOCOLS = ["SMB", "SFTP", "FTPS", "WebDAV", "NFS"]
+
+// Which fields each protocol asks for. "path" is the label the canvas gives that row, which differs
+// per protocol because the thing it names differs: a share, a remote path, an export.
+var FIELDS = {
+    "SMB": { pathLabel: "Share",  credentials: true,  domain: true,  tls: false },
+    "SFTP":   { pathLabel: "Path",   credentials: true,  domain: false, tls: false },
+    "FTPS":   { pathLabel: "Path",   credentials: true,  domain: false, tls: true },
+    "WebDAV": { pathLabel: "Path",   credentials: true,  domain: false, tls: true },
+    // NFS has no credentials at all: the export is authorised by the server, not by a password.
+    "NFS": { pathLabel: "Export", credentials: false, domain: false, tls: false }
+}
+
+// The TLS box flips two schemes and defaults on, which is what the canvas draws ticked.
+function scheme(protocol, tls) {
+    switch (protocol) {
+    case "SMB": return "smb"
+    case "SFTP": return "sftp"
+    case "FTPS": return tls ? "ftps" : "ftp"
+    case "WebDAV": return tls ? "davs" : "dav"
+    case "NFS": return "nfs"
+    }
+    return ""
+}
+
+function fieldsFor(protocol) {
+    return FIELDS[protocol] || FIELDS["SMB"]
+}
+
+// The port the form prefills. It belongs to the scheme, never to the protocol: WebDAV builds two
+// schemes and SCHEME_PORTS below is the one table both this and the rail's dedup read it out of.
+function defaultPort(protocol, tls) {
+    return defaultPortFor(scheme(protocol, tls))
+}
+
+// The exact URI gio mount will be handed. Empty when there is not enough to build one, so the
+// Mounts-as line shows nothing rather than a half-formed address.
+function uri(form) {
+    var host = String(form.host || "").trim()
+    var port = String(form.port || "").trim()
+    if (!validHost(host) || !validPort(port)) {
+        return ""
+    }
+    var spec = fieldsFor(form.protocol)
+    var head = scheme(form.protocol, form.tls) + "://"
+    if (spec.credentials) {
+        head += userPart(form, spec)
+    }
+    head += host
+    // Keep canvas defaults in the form, but omit them because GVFS NFS rejects an explicit :2049.
+    if (port.length > 0 && Number(port) !== defaultPort(form.protocol, form.tls)) {
+        head += ":" + port
+    }
+    return head + pathPart(form.path)
+}
+
+function validHost(host) {
+    return /^\[[0-9A-Fa-f:.]+\]$/.test(host) || /^[A-Za-z0-9._-]+$/.test(host)
+}
+
+function validPort(port) {
+    if (port.length === 0) {
+        return true
+    }
+    if (!/^[0-9]+$/.test(port)) {
+        return false
+    }
+    var number = Number(port)
+    return number >= 1 && number <= 65535
+}
+
+// smb://DOMAIN;user@host/share is the form a domain takes; without one it is just user@host.
+function userPart(form, spec) {
+    var user = String(form.user || "").trim()
+    if (user.length === 0) {
+        return ""
+    }
+    var domain = spec.domain ? String(form.domain || "").trim() : ""
+    return (domain.length > 0 ? encodeURIComponent(domain) + ";" : "")
+        + encodeURIComponent(user) + "@"
+}
+
+function pathPart(path) {
+    var text = String(path || "").trim()
+    if (text.length === 0) {
+        return "/"
+    }
+    var parts = text.split("/")
+    for (var i = 0; i < parts.length; i++) {
+        parts[i] = encodeURIComponent(parts[i])
+    }
+    var encoded = parts.join("/")
+    return encoded.charAt(0) === "/" ? encoded : "/" + encoded
+}
+
+// The label the sidebar row will carry: what the operator typed, or the last part of the path.
+function label(form) {
+    var given = String(form.label || "").trim()
+    if (given.length > 0) {
+        return given
+    }
+    var path = String(form.path || "").replace(/\/+$/, "")
+    var cut = path.lastIndexOf("/")
+    var leaf = cut >= 0 ? path.substring(cut + 1) : path
+    return leaf.length > 0 ? leaf : String(form.host || "").trim()
+}
+
+// A form with nothing to mount cannot be saved, which is what greys the Save row out.
+function complete(form) {
+    var host = String(form.host || "").trim()
+    var port = String(form.port || "").trim()
+    return validHost(host) && validPort(port)
+}
+
+// The port each scheme drops, which is a property of the scheme and not of the protocol the form
+// picked: WebDAV builds two schemes whose ports differ, and one number for both stripped a real
+// ":443" off "dav://" and left its real ":80" on, the duplicate rail row this exists to remove.
+// Measured on this box against gvfs 1.60.2 and glib2 2.88.3 by round-tripping each spelling through
+// Gio.File, the uri mapper "gio mount -l" prints through: gio drops smb 445, sftp 22, ftp 21,
+// ftps 21 (not IANA's 990), dav 80 and davs 443, and keeps every other port it is given, ftps 990
+// and dav 443 included. It drops no nfs port at all, so 2049 is here for the other half of the job:
+// the port an nfs client uses when the line omits one, so two spellings of one export make one row.
+var SCHEME_PORTS = {
+    "smb": 445, "sftp": 22, "ftp": 21, "ftps": 21, "dav": 80, "davs": 443, "nfs": 2049
+}
+
+// A bookmarks line is arbitrary text, so an inherited Object member must never answer as a port.
+function defaultPortFor(uriScheme) {
+    var want = String(uriScheme || "").toLowerCase()
+    return SCHEME_PORTS.hasOwnProperty(want) ? SCHEME_PORTS[want] : 0
+}
+
+// "gio mount -l" never reports a scheme's default port and the add form spells out the one it
+// prefilled, so the same share arrives spelled two ways and must resolve to one rail row. The port
+// is found in the authority alone: a ":" or an "@" further along belongs to the path.
+function stripDefaultPort(uri) {
+    var text = String(uri || "")
+    var auth = authority(text)
+    var tail = ":" + defaultPortFor(schemeOf(text))
+    // A bracketed IPv6 literal ends in "]", so its own trailing digits can never match this tail.
+    if (auth.length === 0 || tail === ":0" || auth.substring(auth.length - tail.length) !== tail)
+        return text
+    var mark = text.indexOf("://") + 3
+    return text.substring(0, mark) + auth.substring(0, auth.length - tail.length)
+        + text.substring(mark + auth.length)
+}
+
+// The scheme a built or bookmarked URI carries, lowercased; "" when the text is not a URI at all.
+function schemeOf(uri) {
+    var text = String(uri || "")
+    var mark = text.indexOf("://")
+    return mark < 0 ? "" : text.substring(0, mark).toLowerCase()
+}
+
+// Everything between "://" and the next "/", which is the only place a userinfo, a host or a port
+// can live: a scan over the whole URI would read a "@" or a ":" inside the path as one of those.
+function authority(uri) {
+    var text = String(uri || "")
+    var mark = text.indexOf("://")
+    if (mark < 0)
+        return ""
+    var rest = text.substring(mark + 3)
+    var slash = rest.indexOf("/")
+    return slash < 0 ? rest : rest.substring(0, slash)
+}
+
+// The host alone: userinfo dropped at the authority's own last "@", a bracketed IPv6 literal kept
+// whole because its colons are not a port separator, and any real port dropped.
+function hostOf(uri) {
+    var auth = authority(uri)
+    var at = auth.lastIndexOf("@")
+    var hostPort = at < 0 ? auth : auth.substring(at + 1)
+    if (hostPort.charAt(0) === "[") {
+        var close = hostPort.indexOf("]")
+        return close < 0 ? hostPort : hostPort.substring(0, close + 1)
+    }
+    var colon = hostPort.indexOf(":")
+    return colon < 0 ? hostPort : hostPort.substring(0, colon)
+}
+
+// gvfsd renders a network mount as "<share> <word> <host>" and translates that word, so issue #36's
+// rule reads the URI instead: the tail that gets cut is this URI's own host, in any language, and a
+// label that does not end in it is left exactly as gio gave it.
+function shareName(rawLabel, uri) {
+    var text = String(rawLabel || "")
+    var host = hostOf(uri)
+    var head = text.substring(0, text.length - host.length)
+    if (host.length === 0 || head.length === 0 || text.substring(head.length) !== host)
+        return text
+    // The one assumption left after the host check: gvfsd's connector is a single whitespace-delimited
+    // word in whatever language it renders. A translation using two would leave one of them on the
+    // name, a wrong label and never a wrong destination; a head this does not shorten is left whole.
+    var name = head.replace(/\s+\S+\s+$/, "")
+    return name.length > 0 && name !== head ? name : text
+}
+
+// Sample input: smb://dan@192.168.1.75/test, the reporter's share, and its FUSE folder
+// /run/user/1000/gvfs/smb-share:server=192.168.1.75,share=test,user=dan. A FUSE path for
+// another user, another share or another server must never open as this share's listing:
+// a mount problem answers as one instead of reading like an unreadable directory.
+function decodeSegment(raw) {
+    try { return decodeURIComponent(String(raw)) } catch (e) { return String(raw) }
+}
+
+// The smb:// request as gio sees it: the user past any DOMAIN; prefix, the host without
+// a port, and the share as the first path segment. Null when not an smb:// URI at all.
+function smbParts(uri) {
+    if (schemeOf(uri) !== "smb") return null
+    var auth = authority(uri)
+    if (auth.length === 0) return null
+    var at = auth.lastIndexOf("@")
+    var info = at < 0 ? "" : auth.substring(0, at)
+    var semi = info.indexOf(";")
+    var user = semi < 0 ? info : info.substring(semi + 1)
+    var mark = String(uri).indexOf("://") + 3
+    var rest = String(uri).substring(mark + auth.length)
+    if (rest.charAt(0) === "/") rest = rest.substring(1)
+    var cut = rest.indexOf("/")
+    var share = cut < 0 ? rest : rest.substring(0, cut)
+    return { user: decodeSegment(user), host: hostOf(uri).toLowerCase(), share: decodeSegment(share) }
+}
+
+// The smb-share: FUSE directory gio info prints a local path for, or null when the path
+// is no smb FUSE directory at all. Null is undecided, never a mismatch: an unknown shape
+// opens exactly as before rather than refusing a mount over a format this never learned.
+function fuseSmbParts(path) {
+    var m = String(path || "").match(/smb-share:server=([^,\/]+),share=([^,\/]+)(?:,user=([^,\/]+))?/)
+    if (!m) return null
+    return { host: String(m[1]).toLowerCase(), share: m[2], user: m[3] || "" }
+}
+
+// Whether gio info's answer belongs to the smb:// request that asked for it. True for any
+// non-smb URI and whenever either side will not parse; false only on a parsed mismatch, a
+// user the answer drops or changes above all, so that answer is refused as a mount failure.
+function smbFuseMatches(uri, fusePath) {
+    if (schemeOf(uri) !== "smb") return true
+    var want = smbParts(uri)
+    var got = fuseSmbParts(fusePath)
+    if (!want || !got) return true
+    var wantUser = String(want.user || "")
+    var gotUser = String(got.user || "")
+    var semi = gotUser.indexOf(";")
+    if (semi >= 0) gotUser = gotUser.substring(semi + 1)
+    return want.host === got.host
+        && String(want.share).toLowerCase() === String(got.share).toLowerCase()
+        && wantUser.toLowerCase() === gotUser.toLowerCase()
+}
+
+// Sample input: uri smb://dan@192.168.1.75/test with gio info printing the path without
+// ,user=dan while only the user=dan folder exists. Answers the entry whose user the URI
+// names; with no user the single share match wins, several prefer the desktop login.
+function smbResolve(uri, fusePaths, login) {
+    var found = { path: "", users: [] }
+    var want = smbParts(uri)
+    if (!want) return found
+    var hits = []
+    var list = fusePaths || []
+    for (var i = 0; i < list.length; i++) {
+        var got = fuseSmbParts(list[i])
+        if (!got || got.host !== want.host) continue
+        if (String(got.share).toLowerCase() !== String(want.share).toLowerCase()) continue
+        hits.push({ path: list[i], user: String(got.user || "") })
+    }
+    if (String(want.user || "").length > 0) {
+        for (var j = 0; j < hits.length; j++) {
+            if (hits[j].user.toLowerCase() === String(want.user).toLowerCase()) {
+                found.path = hits[j].path
+                return found
+            }
+        }
+        return found
+    }
+    if (hits.length === 1) {
+        found.path = hits[0].path
+        return found
+    }
+    if (hits.length > 1) {
+        for (var k = 0; k < hits.length; k++) {
+            if (hits[k].user.toLowerCase() === String(login || "").toLowerCase()) {
+                found.path = hits[k].path
+                return found
+            }
+        }
+        for (var m = 0; m < hits.length; m++) {
+            if (found.users.indexOf(hits[m].user) < 0) found.users.push(hits[m].user)
+        }
+    }
+    return found
+}