{"version":3,"file":"main.963d2c752f792ddbf21e.bundle.mjs","mappings":"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","sources":["webpack://@anarchytube/frontend/./node_modules/.pnpm/path-to-regexp@6.2.1/node_modules/path-to-regexp/dist.es2015/index.js","webpack://@anarchytube/frontend/./src/xeact/jsx-runtime.ts","webpack://@anarchytube/frontend/./src/xeact/xeact.ts","webpack://@anarchytube/frontend/./src/fuzzySearch.ts","webpack://@anarchytube/frontend/./src/searchEngine.ts","webpack://@anarchytube/frontend/./src/pages/search.tsx","webpack://@anarchytube/frontend/./src/utils.ts","webpack://@anarchytube/frontend/./src/index.tsx"],"sourcesContent":["/**\n * Tokenize input string.\n */\nfunction lexer(str) {\n    var tokens = [];\n    var i = 0;\n    while (i < str.length) {\n        var char = str[i];\n        if (char === \"*\" || char === \"+\" || char === \"?\") {\n            tokens.push({ type: \"MODIFIER\", index: i, value: str[i++] });\n            continue;\n        }\n        if (char === \"\\\\\") {\n            tokens.push({ type: \"ESCAPED_CHAR\", index: i++, value: str[i++] });\n            continue;\n        }\n        if (char === \"{\") {\n            tokens.push({ type: \"OPEN\", index: i, value: str[i++] });\n            continue;\n        }\n        if (char === \"}\") {\n            tokens.push({ type: \"CLOSE\", index: i, value: str[i++] });\n            continue;\n        }\n        if (char === \":\") {\n            var name = \"\";\n            var j = i + 1;\n            while (j < str.length) {\n                var code = str.charCodeAt(j);\n                if (\n                // `0-9`\n                (code >= 48 && code <= 57) ||\n                    // `A-Z`\n                    (code >= 65 && code <= 90) ||\n                    // `a-z`\n                    (code >= 97 && code <= 122) ||\n                    // `_`\n                    code === 95) {\n                    name += str[j++];\n                    continue;\n                }\n                break;\n            }\n            if (!name)\n                throw new TypeError(\"Missing parameter name at \".concat(i));\n            tokens.push({ type: \"NAME\", index: i, value: name });\n            i = j;\n            continue;\n        }\n        if (char === \"(\") {\n            var count = 1;\n            var pattern = \"\";\n            var j = i + 1;\n            if (str[j] === \"?\") {\n                throw new TypeError(\"Pattern cannot start with \\\"?\\\" at \".concat(j));\n            }\n            while (j < str.length) {\n                if (str[j] === \"\\\\\") {\n                    pattern += str[j++] + str[j++];\n                    continue;\n                }\n                if (str[j] === \")\") {\n                    count--;\n                    if (count === 0) {\n                        j++;\n                        break;\n                    }\n                }\n                else if (str[j] === \"(\") {\n                    count++;\n                    if (str[j + 1] !== \"?\") {\n                        throw new TypeError(\"Capturing groups are not allowed at \".concat(j));\n                    }\n                }\n                pattern += str[j++];\n            }\n            if (count)\n                throw new TypeError(\"Unbalanced pattern at \".concat(i));\n            if (!pattern)\n                throw new TypeError(\"Missing pattern at \".concat(i));\n            tokens.push({ type: \"PATTERN\", index: i, value: pattern });\n            i = j;\n            continue;\n        }\n        tokens.push({ type: \"CHAR\", index: i, value: str[i++] });\n    }\n    tokens.push({ type: \"END\", index: i, value: \"\" });\n    return tokens;\n}\n/**\n * Parse a string for the raw tokens.\n */\nexport function parse(str, options) {\n    if (options === void 0) { options = {}; }\n    var tokens = lexer(str);\n    var _a = options.prefixes, prefixes = _a === void 0 ? \"./\" : _a;\n    var defaultPattern = \"[^\".concat(escapeString(options.delimiter || \"/#?\"), \"]+?\");\n    var result = [];\n    var key = 0;\n    var i = 0;\n    var path = \"\";\n    var tryConsume = function (type) {\n        if (i < tokens.length && tokens[i].type === type)\n            return tokens[i++].value;\n    };\n    var mustConsume = function (type) {\n        var value = tryConsume(type);\n        if (value !== undefined)\n            return value;\n        var _a = tokens[i], nextType = _a.type, index = _a.index;\n        throw new TypeError(\"Unexpected \".concat(nextType, \" at \").concat(index, \", expected \").concat(type));\n    };\n    var consumeText = function () {\n        var result = \"\";\n        var value;\n        while ((value = tryConsume(\"CHAR\") || tryConsume(\"ESCAPED_CHAR\"))) {\n            result += value;\n        }\n        return result;\n    };\n    while (i < tokens.length) {\n        var char = tryConsume(\"CHAR\");\n        var name = tryConsume(\"NAME\");\n        var pattern = tryConsume(\"PATTERN\");\n        if (name || pattern) {\n            var prefix = char || \"\";\n            if (prefixes.indexOf(prefix) === -1) {\n                path += prefix;\n                prefix = \"\";\n            }\n            if (path) {\n                result.push(path);\n                path = \"\";\n            }\n            result.push({\n                name: name || key++,\n                prefix: prefix,\n                suffix: \"\",\n                pattern: pattern || defaultPattern,\n                modifier: tryConsume(\"MODIFIER\") || \"\",\n            });\n            continue;\n        }\n        var value = char || tryConsume(\"ESCAPED_CHAR\");\n        if (value) {\n            path += value;\n            continue;\n        }\n        if (path) {\n            result.push(path);\n            path = \"\";\n        }\n        var open = tryConsume(\"OPEN\");\n        if (open) {\n            var prefix = consumeText();\n            var name_1 = tryConsume(\"NAME\") || \"\";\n            var pattern_1 = tryConsume(\"PATTERN\") || \"\";\n            var suffix = consumeText();\n            mustConsume(\"CLOSE\");\n            result.push({\n                name: name_1 || (pattern_1 ? key++ : \"\"),\n                pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,\n                prefix: prefix,\n                suffix: suffix,\n                modifier: tryConsume(\"MODIFIER\") || \"\",\n            });\n            continue;\n        }\n        mustConsume(\"END\");\n    }\n    return result;\n}\n/**\n * Compile a string to a template function for the path.\n */\nexport function compile(str, options) {\n    return tokensToFunction(parse(str, options), options);\n}\n/**\n * Expose a method for transforming tokens into the path function.\n */\nexport function tokensToFunction(tokens, options) {\n    if (options === void 0) { options = {}; }\n    var reFlags = flags(options);\n    var _a = options.encode, encode = _a === void 0 ? function (x) { return x; } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;\n    // Compile all the tokens into regexps.\n    var matches = tokens.map(function (token) {\n        if (typeof token === \"object\") {\n            return new RegExp(\"^(?:\".concat(token.pattern, \")$\"), reFlags);\n        }\n    });\n    return function (data) {\n        var path = \"\";\n        for (var i = 0; i < tokens.length; i++) {\n            var token = tokens[i];\n            if (typeof token === \"string\") {\n                path += token;\n                continue;\n            }\n            var value = data ? data[token.name] : undefined;\n            var optional = token.modifier === \"?\" || token.modifier === \"*\";\n            var repeat = token.modifier === \"*\" || token.modifier === \"+\";\n            if (Array.isArray(value)) {\n                if (!repeat) {\n                    throw new TypeError(\"Expected \\\"\".concat(token.name, \"\\\" to not repeat, but got an array\"));\n                }\n                if (value.length === 0) {\n                    if (optional)\n                        continue;\n                    throw new TypeError(\"Expected \\\"\".concat(token.name, \"\\\" to not be empty\"));\n                }\n                for (var j = 0; j < value.length; j++) {\n                    var segment = encode(value[j], token);\n                    if (validate && !matches[i].test(segment)) {\n                        throw new TypeError(\"Expected all \\\"\".concat(token.name, \"\\\" to match \\\"\").concat(token.pattern, \"\\\", but got \\\"\").concat(segment, \"\\\"\"));\n                    }\n                    path += token.prefix + segment + token.suffix;\n                }\n                continue;\n            }\n            if (typeof value === \"string\" || typeof value === \"number\") {\n                var segment = encode(String(value), token);\n                if (validate && !matches[i].test(segment)) {\n                    throw new TypeError(\"Expected \\\"\".concat(token.name, \"\\\" to match \\\"\").concat(token.pattern, \"\\\", but got \\\"\").concat(segment, \"\\\"\"));\n                }\n                path += token.prefix + segment + token.suffix;\n                continue;\n            }\n            if (optional)\n                continue;\n            var typeOfMessage = repeat ? \"an array\" : \"a string\";\n            throw new TypeError(\"Expected \\\"\".concat(token.name, \"\\\" to be \").concat(typeOfMessage));\n        }\n        return path;\n    };\n}\n/**\n * Create path match function from `path-to-regexp` spec.\n */\nexport function match(str, options) {\n    var keys = [];\n    var re = pathToRegexp(str, keys, options);\n    return regexpToFunction(re, keys, options);\n}\n/**\n * Create a path match function from `path-to-regexp` output.\n */\nexport function regexpToFunction(re, keys, options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.decode, decode = _a === void 0 ? function (x) { return x; } : _a;\n    return function (pathname) {\n        var m = re.exec(pathname);\n        if (!m)\n            return false;\n        var path = m[0], index = m.index;\n        var params = Object.create(null);\n        var _loop_1 = function (i) {\n            if (m[i] === undefined)\n                return \"continue\";\n            var key = keys[i - 1];\n            if (key.modifier === \"*\" || key.modifier === \"+\") {\n                params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {\n                    return decode(value, key);\n                });\n            }\n            else {\n                params[key.name] = decode(m[i], key);\n            }\n        };\n        for (var i = 1; i < m.length; i++) {\n            _loop_1(i);\n        }\n        return { path: path, index: index, params: params };\n    };\n}\n/**\n * Escape a regular expression string.\n */\nfunction escapeString(str) {\n    return str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, \"\\\\$1\");\n}\n/**\n * Get the flags for a regexp from the options.\n */\nfunction flags(options) {\n    return options && options.sensitive ? \"\" : \"i\";\n}\n/**\n * Pull out keys from a regexp.\n */\nfunction regexpToRegexp(path, keys) {\n    if (!keys)\n        return path;\n    var groupsRegex = /\\((?:\\?<(.*?)>)?(?!\\?)/g;\n    var index = 0;\n    var execResult = groupsRegex.exec(path.source);\n    while (execResult) {\n        keys.push({\n            // Use parenthesized substring match if available, index otherwise\n            name: execResult[1] || index++,\n            prefix: \"\",\n            suffix: \"\",\n            modifier: \"\",\n            pattern: \"\",\n        });\n        execResult = groupsRegex.exec(path.source);\n    }\n    return path;\n}\n/**\n * Transform an array into a regexp.\n */\nfunction arrayToRegexp(paths, keys, options) {\n    var parts = paths.map(function (path) { return pathToRegexp(path, keys, options).source; });\n    return new RegExp(\"(?:\".concat(parts.join(\"|\"), \")\"), flags(options));\n}\n/**\n * Create a path regexp from string input.\n */\nfunction stringToRegexp(path, keys, options) {\n    return tokensToRegexp(parse(path, options), keys, options);\n}\n/**\n * Expose a function for taking tokens and returning a RegExp.\n */\nexport function tokensToRegexp(tokens, keys, options) {\n    if (options === void 0) { options = {}; }\n    var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function (x) { return x; } : _d, _e = options.delimiter, delimiter = _e === void 0 ? \"/#?\" : _e, _f = options.endsWith, endsWith = _f === void 0 ? \"\" : _f;\n    var endsWithRe = \"[\".concat(escapeString(endsWith), \"]|$\");\n    var delimiterRe = \"[\".concat(escapeString(delimiter), \"]\");\n    var route = start ? \"^\" : \"\";\n    // Iterate over the tokens and create our regexp string.\n    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {\n        var token = tokens_1[_i];\n        if (typeof token === \"string\") {\n            route += escapeString(encode(token));\n        }\n        else {\n            var prefix = escapeString(encode(token.prefix));\n            var suffix = escapeString(encode(token.suffix));\n            if (token.pattern) {\n                if (keys)\n                    keys.push(token);\n                if (prefix || suffix) {\n                    if (token.modifier === \"+\" || token.modifier === \"*\") {\n                        var mod = token.modifier === \"*\" ? \"?\" : \"\";\n                        route += \"(?:\".concat(prefix, \"((?:\").concat(token.pattern, \")(?:\").concat(suffix).concat(prefix, \"(?:\").concat(token.pattern, \"))*)\").concat(suffix, \")\").concat(mod);\n                    }\n                    else {\n                        route += \"(?:\".concat(prefix, \"(\").concat(token.pattern, \")\").concat(suffix, \")\").concat(token.modifier);\n                    }\n                }\n                else {\n                    if (token.modifier === \"+\" || token.modifier === \"*\") {\n                        route += \"((?:\".concat(token.pattern, \")\").concat(token.modifier, \")\");\n                    }\n                    else {\n                        route += \"(\".concat(token.pattern, \")\").concat(token.modifier);\n                    }\n                }\n            }\n            else {\n                route += \"(?:\".concat(prefix).concat(suffix, \")\").concat(token.modifier);\n            }\n        }\n    }\n    if (end) {\n        if (!strict)\n            route += \"\".concat(delimiterRe, \"?\");\n        route += !options.endsWith ? \"$\" : \"(?=\".concat(endsWithRe, \")\");\n    }\n    else {\n        var endToken = tokens[tokens.length - 1];\n        var isEndDelimited = typeof endToken === \"string\"\n            ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1\n            : endToken === undefined;\n        if (!strict) {\n            route += \"(?:\".concat(delimiterRe, \"(?=\").concat(endsWithRe, \"))?\");\n        }\n        if (!isEndDelimited) {\n            route += \"(?=\".concat(delimiterRe, \"|\").concat(endsWithRe, \")\");\n        }\n    }\n    return new RegExp(route, flags(options));\n}\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n */\nexport function pathToRegexp(path, keys, options) {\n    if (path instanceof RegExp)\n        return regexpToRegexp(path, keys);\n    if (Array.isArray(path))\n        return arrayToRegexp(path, keys, options);\n    return stringToRegexp(path, keys, options);\n}\n//# sourceMappingURL=index.js.map","import { h } from \"./xeact.js\";\nexport function jsx(tag, data) {\n    let children = data.children;\n    delete data.children;\n    const result = h(tag, data, children);\n    if (result === null) {\n        return;\n    }\n    if (result.class !== undefined) {\n        result.classList.value = result.class;\n    }\n    return result;\n}\nexport const jsxs = jsx;\nexport function Fragment() {\n    return document.createDocumentFragment();\n}\n","/**\n * Creates a DOM element, assigns the properties of `data` to it, and appends all `children`.\n *\n * @type{function(string|Function, Object=, Node|Array.<Node|string>=)}\n */\nconst h = (name, data = {}, children = []) => {\n    const list = data.list;\n    if (list) {\n        delete data.list;\n    }\n    const result = typeof name == \"function\"\n        ? name(data)\n        : Object.assign(document.createElement(name), data);\n    if (result === null) {\n        return null;\n    }\n    for (const [k, v] of Object.entries(data)) {\n        if (k === \"style\" && typeof v === \"object\") {\n            Object.assign(result.style, v);\n        }\n        else if (k.startsWith(\"data-\")) {\n            result.dataset[k.substring(\"data-\".length)] = v;\n        }\n    }\n    if (list) {\n        result.setAttribute(\"list\", list);\n    }\n    if (!Array.isArray(children)) {\n        children = [children];\n    }\n    result.append(...children.flat().filter((c) => c != null));\n    return result;\n};\n/**\n * Create a text node.\n *\n * Equivalent to `document.createTextNode(text)`\n *\n * @type{function(string): Text}\n */\nconst t = (text) => document.createTextNode(text);\n/**\n * Remove all child nodes from a DOM element.\n *\n * @type{function(Node)}\n */\nconst x = (elem) => {\n    while (elem.lastChild) {\n        elem.removeChild(elem.lastChild);\n    }\n};\n/**\n * Get all elements with the given ID.\n *\n * Equivalent to `document.getElementById(name)`\n *\n * @type{function(string): HTMLElement}\n */\nconst g = (name) => document.getElementById(name);\n/**\n * Get all elements with the given class name.\n *\n * Equivalent to `document.getElementsByClassName(name)`\n *\n * @type{function(string): HTMLCollectionOf.<Element>}\n */\nconst c = (name) => document.getElementsByClassName(name);\n/** @type{function(string): HTMLCollectionOf.<Element>} */\nconst n = (name) => document.getElementsByName(name);\n/**\n * Get all elements matching the given HTML selector.\n *\n * Matches selectors with `document.querySelectorAll(selector)`\n *\n * @type{function(string): Array.<HTMLElement>}\n */\nconst s = (selector) => Array.from(document.querySelectorAll(selector));\n/**\n * Generate a relative URL from `url`, appending all key-value pairs from `params` as URL-encoded parameters.\n *\n * @type{function(string=, Object=): string}\n */\nconst u = (url = \"\", params = {}) => {\n    let result = new URL(url, window.location.href);\n    Object.entries(params).forEach((kv) => {\n        let [k, v] = kv;\n        result.searchParams.set(k, v);\n    });\n    return result.toString();\n};\n/**\n * Takes a callback to run when all DOM content is loaded.\n *\n * Equivalent to `window.addEventListener('DOMContentLoaded', callback)`\n *\n * @type{function(function())}\n */\nconst r = (callback) => window.addEventListener(\"DOMContentLoaded\", callback);\n/**\n * Allows a stateful value to be tracked by consumers.\n *\n * This is the Xeact version of the React useState hook.\n *\n * @type{function(any): [function(): any, function(any): void]}\n */\nconst useState = (value = undefined) => {\n    return [\n        () => value,\n        (x) => {\n            value = x;\n        },\n    ];\n};\n/**\n * Debounce an action for up to ms milliseconds.\n *\n * @type{function(number): function(function(any): void)}\n */\nconst d = (ms) => {\n    let debounceTimer = null;\n    return (f) => {\n        clearTimeout(debounceTimer ?? undefined);\n        debounceTimer = setTimeout(f, ms);\n    };\n};\nexport { h, t, x, g, c, n, u, s, r, useState, d };\n","export const fuzzySearch = (searchString, data, valueExtractor) => {\n    searchString = searchString.toLocaleLowerCase();\n    const lazyMatchRegex = new RegExp(searchString.split(\"\").join(\".*\"));\n    const matchRegex = new RegExp(searchString);\n    return data\n        .map((v) => {\n        const str = valueExtractor(v).toLowerCase();\n        if (str === searchString) {\n            return { v, m: 3 };\n        }\n        else if (matchRegex.test(str)) {\n            return { v, m: 2 };\n        }\n        else if (lazyMatchRegex.test(str)) {\n            return { v, m: 1 };\n        }\n        return { v, m: 0 };\n    })\n        .filter((v) => v.m !== 0)\n        .sort((a, b) => (a.m === b.m ? 0 : a.m > b.m ? -1 : 1))\n        .map((v) => v.v);\n};\n","export const BASE_URL = new URL(import.meta.env.BACKEND_BASE);\nexport const getUrl = (tags, searchTerm, page) => {\n    const newUrl = new URL(document.location.toString());\n    if (searchTerm) {\n        newUrl.searchParams.set(\"search\", searchTerm);\n    }\n    else {\n        newUrl.searchParams.delete(\"search\");\n    }\n    if (tags.length) {\n        newUrl.searchParams.set(\"tags\", tags.join(\",\"));\n    }\n    else {\n        newUrl.searchParams.delete(\"tags\");\n    }\n    if (page) {\n        newUrl.searchParams.set(\"page\", page.toString());\n    }\n    else {\n        newUrl.searchParams.delete(\"page\");\n    }\n    return newUrl;\n};\nexport const setUrl = (tags, searchTerm, page) => {\n    history.pushState(undefined, \"\", getUrl(tags, searchTerm, page));\n};\nexport const createSearchEngine = () => {\n    const handlers = [];\n    let currentSearch = \"\";\n    const search = async (tags, searchTerm, page) => {\n        const searchUrl = new URL(\"search\", BASE_URL);\n        const searchId = crypto.randomUUID();\n        currentSearch = searchId;\n        if (tags.length) {\n            searchUrl.searchParams.set(\"tags\", tags.join(\",\"));\n        }\n        if (searchTerm) {\n            searchUrl.searchParams.set(\"search\", searchTerm);\n        }\n        if (page) {\n            searchUrl.searchParams.set(\"offset\", ((page - 1) * 50).toString());\n        }\n        const resp = await fetch(searchUrl);\n        const results = await resp.json();\n        if (currentSearch !== searchId) {\n            return;\n        }\n        console.log(results);\n        setUrl(tags, searchTerm, page);\n        handlers.forEach((h) => h(results, { tags, searchTerm, page }));\n    };\n    const registerCallback = (handler) => {\n        handlers.push(handler);\n    };\n    return [search, registerCallback];\n};\nexport const getTags = async (type) => {\n    const tagsUrl = new URL(`tags/${type}`, BASE_URL);\n    const resp = await fetch(tagsUrl);\n    return resp.json();\n};\n","import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from \"@xeserv/xeact/jsx-runtime\";\nimport { fuzzySearch } from \"../fuzzySearch\";\nimport { BASE_URL, createSearchEngine, getTags, getUrl, } from \"../searchEngine\";\nimport { debounce } from \"../utils\";\nconst ClickableTag = ({ tag, status, allTags, onToggle, }) => {\n    let statusClass = \"\";\n    if (status === \"enabled\") {\n        statusClass = \"positive\";\n    }\n    else if (status === \"disabled\") {\n        statusClass = \"negative\";\n    }\n    return (_jsx(\"div\", { class: `tag ${statusClass}`, children: _jsx(\"button\", { onclick: (ev) => onToggle(ev), children: allTags.find((t) => t.permalink === tag)?.name ?? tag }) }));\n};\nconst Tags = ({ tags, doSearch, registerCallback, }) => {\n    let allTags = [];\n    let tagSearch = \"\";\n    let tagsOpen = tags.length === 0;\n    const tagSearchArea = (_jsx(\"div\", { class: \"tags-filter\", children: \"Loading tags...\" }));\n    const tagArea = _jsx(\"div\", { class: \"tags-list\" });\n    const renderTags = () => {\n        const renderTagList = (tagList) => (_jsx(_Fragment, { children: tagList.map((tag) => {\n                let status = (tags.includes(tag.permalink)\n                    ? \"enabled\"\n                    : tags.includes(`-${tag.permalink}`)\n                        ? \"disabled\"\n                        : \"none\");\n                return (_jsx(ClickableTag, { tag: tag.permalink, status: status, allTags: allTags, onToggle: (ev) => {\n                        console.log(\"onToggle\", ev);\n                        const evParent = ev.target\n                            .parentElement;\n                        if (status === \"none\") {\n                            tags.push(tag.permalink);\n                            evParent.classList.add(\"positive\");\n                            status = \"enabled\";\n                        }\n                        else if (status === \"enabled\") {\n                            const index = tags.findIndex((v) => v === tag.permalink);\n                            tags[index] = `-${tag.permalink}`;\n                            evParent.classList.remove(\"positive\");\n                            evParent.classList.add(\"negative\");\n                            status = \"disabled\";\n                        }\n                        else {\n                            const index = tags.findIndex((v) => v === `-${tag.permalink}`);\n                            tags.splice(index, 1);\n                            if (tagsOpen) {\n                                evParent.classList.remove(\"negative\");\n                                status = \"none\";\n                            }\n                            else {\n                                evParent.remove();\n                            }\n                        }\n                        doSearch();\n                    } }));\n            }) }));\n        tagArea.innerHTML = \"\";\n        tagArea.append(tagsOpen\n            ? renderTagList(tagSearch\n                ? fuzzySearch(tagSearch, allTags, (v) => v.name)\n                : allTags)\n            : renderTagList((tagSearch\n                ? fuzzySearch(tagSearch, allTags, (v) => v.name)\n                : allTags).filter((v) => tags.includes(v.permalink) || tags.includes(`-${v.permalink}`))));\n    };\n    const renderTagSearch = () => {\n        tagSearchArea.innerHTML = \"\";\n        tagSearchArea.append(_jsxs(\"form\", { class: \"tag-filter\", onsubmit: (ev) => {\n                ev.preventDefault();\n                const searchEl = document.querySelector(\"#tag-search\");\n                const tagSearch = searchEl.value ?? \"\";\n                if (!tagSearch) {\n                    return;\n                }\n                const filtered = fuzzySearch(tagSearch, allTags, (v) => v.name);\n                if (!filtered.length) {\n                    return;\n                }\n                const tag = filtered[0];\n                if (tags.includes(tag.permalink)) {\n                    const index = tags.findIndex((v) => v === tag.permalink);\n                    tags[index] = `-${tag.permalink}`;\n                }\n                else if (tags.includes(`-${tag.permalink}`)) {\n                    const index = tags.findIndex((v) => v === tag.permalink);\n                    tags.splice(index, 1);\n                }\n                else {\n                    tags.push(tag.permalink);\n                }\n                renderTags();\n                doSearch();\n            }, children: [_jsx(\"input\", { class: \"tag-search\", id: \"tag-search\", type: \"text\", placeholder: \"Filter tags\", value: tagSearch, oninput: (ev) => {\n                        tagSearch = ev.target?.value ?? \"\";\n                        renderTags();\n                    } }), _jsxs(\"button\", { class: \"tags-list-toggle\", onclick: (ev) => {\n                        tagsOpen = !tagsOpen;\n                        renderTags();\n                        ev.target.innerText = `Show ${tagsOpen ? \"less\" : \"all\"} tags`;\n                    }, type: \"button\", children: [\"Show \", tagsOpen ? \"less\" : \"all\", \" tags\"] })] }));\n    };\n    registerCallback((_, lastSearch) => {\n        if (lastSearch.tags !== tags) {\n            tags.splice(0, tags.length, ...lastSearch.tags);\n            renderTags();\n        }\n    });\n    const fetchGeneralTags = async () => {\n        allTags = await getTags(\"General\");\n        renderTags();\n        renderTagSearch();\n    };\n    fetchGeneralTags();\n    return (_jsxs(_Fragment, { children: [tagSearchArea, tagArea] }));\n};\nconst SearchBox = ({ search, registerCallback, }) => {\n    const url = new URL(document.location.toString());\n    let searchTerm = url.searchParams.get(\"search\") ?? \"\";\n    let tags = (url.searchParams.get(\"tags\") ?? \"\")\n        .split(\",\")\n        .filter((v) => v !== \"\");\n    const initialPage = url.searchParams.get(\"page\");\n    const doSearch = debounce(() => {\n        search(tags, searchTerm || undefined);\n    }, 100);\n    if (tags.length || searchTerm) {\n        search(tags, searchTerm, initialPage ? parseInt(initialPage) : undefined);\n    }\n    return (_jsxs(\"div\", { children: [_jsx(\"div\", { class: \"search-area\", children: _jsx(\"input\", { type: \"search\", placeholder: \"Search\", class: \"search\", value: searchTerm, oninput: (ev) => {\n                        searchTerm = ev.currentTarget.value.trim();\n                        doSearch();\n                    }, autofocus: true }) }), _jsx(Tags, { registerCallback: registerCallback, tags: tags, doSearch: doSearch })] }));\n};\nconst DYNASTY_BASE = new URL(\"https://dynasty-scans.com/\");\nconst Results = ({ registerCallback, search, }) => {\n    const resultsArea = _jsx(\"div\", { class: \"search-results\" });\n    registerCallback((results, lastSearch) => {\n        resultsArea.innerHTML = \"\";\n        const pages = [];\n        const totalPages = Math.ceil(results.total / 50);\n        for (let i = 0; i < totalPages; i++) {\n            pages.push({\n                num: i + 1,\n                active: lastSearch.page === i + 1 ||\n                    (lastSearch.page === undefined && i === 0),\n            });\n        }\n        resultsArea.append(_jsx(_Fragment, { children: results.results.map((result) => {\n                const link = result.type === \"chapter\"\n                    ? new URL(`chapters/${result.permalink}`, DYNASTY_BASE)\n                    : new URL(`series/${result.permalink}`, DYNASTY_BASE);\n                let author = \"\";\n                const authors = result.tags.filter((v) => v.type === \"Author\");\n                if (authors.length === 1) {\n                    author = authors[0].name;\n                }\n                else if (authors.length > 1) {\n                    author = `${authors\n                        .slice(0, -1)\n                        .map((a) => a.name)\n                        .join(\", \")} and ${authors.at(-1).name}`;\n                }\n                let scanlator = \"\";\n                const scanlators = result.tags.filter((v) => v.type === \"Scanlator\");\n                if (scanlators.length === 1) {\n                    scanlator = scanlators[0].name;\n                }\n                else if (scanlators.length > 1) {\n                    scanlator = `${scanlators\n                        .slice(0, -1)\n                        .map((s) => s.name)\n                        .join(\", \")} and ${scanlators.at(-1).name}`;\n                }\n                return (_jsxs(\"a\", { class: \"search-item\", href: link.toString(), children: [_jsx(\"div\", { children: result.cover && (_jsx(\"img\", { src: new URL(\"thumb\" + result.cover, BASE_URL).toString(), loading: \"lazy\" })) }), _jsxs(\"div\", { class: \"item-details\", children: [_jsxs(\"div\", { class: \"item-name\", children: [result.name, \" (\", result.type, \")\"] }), _jsx(\"div\", { class: \"item-author\", children: author }), scanlator && _jsx(\"div\", { class: \"item-scanlator\", children: scanlator }), _jsx(\"div\", { class: \"item-tags\", children: result.tags\n                                        .filter((t) => t.type === \"General\")\n                                        .map((t) => (_jsx(\"button\", { class: \"tag\", onclick: (ev) => {\n                                            ev.preventDefault();\n                                            const tags = [...lastSearch.tags];\n                                            if (tags.includes(t.permalink)) {\n                                                return;\n                                            }\n                                            tags.push(t.permalink);\n                                            search(tags, lastSearch.searchTerm);\n                                        }, children: t.name }))) })] })] }));\n            }) }));\n        if (results.returned === 0) {\n            resultsArea.append(_jsx(\"div\", { children: \"No results!\" }));\n        }\n        resultsArea.append(_jsx(\"div\", { class: \"pages\", children: pages.map((p) => (_jsx(\"a\", { href: getUrl(lastSearch.tags, lastSearch.searchTerm, p.num).toString(), onclick: (ev) => {\n                    ev.preventDefault();\n                    search(lastSearch.tags, lastSearch.searchTerm, p.num);\n                }, children: p.active ? _jsx(\"b\", { children: p.num }) : p.num }))) }));\n    });\n    return resultsArea;\n};\nexport const buildSearchPage = (root) => {\n    const [search, registerCallback] = createSearchEngine();\n    registerCallback(() => {\n        window.scroll({ top: 0 });\n    });\n    root.append(_jsxs(\"div\", { class: \"search-container\", children: [_jsx(SearchBox, { registerCallback: registerCallback, search: search }), _jsx(Results, { registerCallback: registerCallback, search: search })] }));\n};\n","export const debounce = (callback, delay) => {\n    let timer = 0;\n    return ((...params) => {\n        clearTimeout(timer);\n        timer = setTimeout(() => {\n            callback(...params);\n        }, delay);\n    });\n};\n","import \"./styles.scss\";\nimport { pathToRegexp } from \"path-to-regexp\";\nimport { buildSearchPage } from \"./pages/search\";\nconst builders = [\n    [pathToRegexp(\"/\"), buildSearchPage],\n];\nconst path = document.location.pathname;\nconst rootNode = document.querySelector(\"#root\");\nfor (const [match, builder] of builders) {\n    if (match.test(path)) {\n        const value = match.exec(path);\n        builder(rootNode, ...value.slice(1));\n    }\n}\n"],"names":["escapeString","str","replace","flags","options","sensitive","stringToRegexp","path","keys","tokens","_a","strict","_b","start","_c","end","_d","encode","x","_e","delimiter","_f","endsWith","endsWithRe","concat","delimiterRe","route","_i","tokens_1","length","token","prefix","suffix","pattern","push","modifier","mod","endToken","isEndDelimited","indexOf","undefined","RegExp","tokensToRegexp","i","char","type","index","value","count","j","TypeError","name","code","charCodeAt","lexer","prefixes","defaultPattern","result","key","tryConsume","mustConsume","nextType","consumeText","name_1","pattern_1","parse","jsx","tag","data","children","list","Object","assign","document","createElement","k","v","entries","style","startsWith","dataset","substring","setAttribute","Array","isArray","append","flat","filter","c","h","class","classList","jsxs","Fragment","createDocumentFragment","fuzzySearch","searchString","valueExtractor","toLocaleLowerCase","lazyMatchRegex","split","join","matchRegex","map","toLowerCase","m","test","sort","a","b","BASE_URL","URL","getUrl","tags","searchTerm","page","newUrl","location","toString","searchParams","set","delete","ClickableTag","status","allTags","onToggle","statusClass","onclick","ev","find","t","permalink","Tags","doSearch","registerCallback","tagSearch","tagsOpen","tagSearchArea","tagArea","renderTags","innerHTML","includes","console","log","evParent","target","parentElement","add","findIndex","remove","splice","_","lastSearch","async","tagsUrl","fetch","json","getTags","onsubmit","preventDefault","querySelector","filtered","id","placeholder","oninput","innerText","fetchGeneralTags","SearchBox","search","url","get","initialPage","callback","delay","timer","params","clearTimeout","setTimeout","debounce","parseInt","currentTarget","trim","autofocus","DYNASTY_BASE","Results","resultsArea","results","pages","totalPages","Math","ceil","total","num","active","link","author","authors","slice","at","scanlator","scanlators","s","href","cover","src","loading","returned","p","builders","pathToRegexp","groupsRegex","execResult","exec","source","regexpToRegexp","paths","parts","arrayToRegexp","root","handlers","currentSearch","searchUrl","searchId","crypto","randomUUID","resp","history","pushState","setUrl","forEach","handler","createSearchEngine","window","scroll","top","pathname","rootNode","match","builder"],"sourceRoot":""}