@mpen/rerouter 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Mark Penner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# YourLib
+    
+Created with [`ctslib`](https://yarnpkg.com/en/package/create-tslib).
+
+## Getting Started
+
+### Run source code directly
+
+```sh
+make dev
+```
+
+### Build code for production
+
+```sh
+make
+```
+
+It will be written to `dist/`. After that, you don't need TypeScript nor babel installed. It can be distributed for node LTS.

package/dist/bundle.cjs

@@ -0,0 +1,406 @@
+"use strict";
+
+const PREFIX_RE = /^[+#./;?&]/;
+
+const MODIFIER_RE = /(?<repeat>\*)?(?::(?<func>[a-zA-Z][a-zA-Z0-9_]*))?(?::(?:(?<length>\d+)))?$/;
+
+const UNRESERVED = /[^a-zA-Z0-9\-._~]+/gsu;
+
+const UR_SET = /[^a-zA-Z0-9\-._~:\/?#[\]@!$&'()*+,;=]+/gsu;
+
+const PERCENT_RE = /^%[0-9a-fA-F]{2}$/;
+
+const STR = Symbol("string");
+
+const VAR = Symbol("var");
+
+const SeparatorMap = {
+    "": ",",
+    "+": ",",
+    ".": ".",
+    "/": "/",
+    ";": ";",
+    "?": "&",
+    "&": "&",
+    "#": ","
+};
+
+const FirstMap = {
+    "": "",
+    "+": "",
+    ".": ".",
+    "/": "/",
+    ";": ";",
+    "?": "?",
+    "&": "&",
+    "#": "#"
+};
+
+const Named = {
+    "": false,
+    "+": false,
+    ".": false,
+    "/": false,
+    ";": true,
+    "?": true,
+    "&": true,
+    "#": false
+};
+
+const IfEmp = {
+    "": "",
+    "+": "",
+    ".": "",
+    "/": "",
+    ";": "",
+    "?": "=",
+    "&": "=",
+    "#": ""
+};
+
+const ReservedExpansion = {
+    "": false,
+    "+": true,
+    ".": false,
+    "/": false,
+    ";": false,
+    "?": false,
+    "&": false,
+    "#": true
+};
+
+var VarType;
+
+(function(VarType) {
+    VarType[VarType["NAMED"] = 0] = "NAMED";
+    VarType[VarType["STATIC"] = 1] = "STATIC";
+    VarType[VarType["DYNAMIC"] = 2] = "DYNAMIC";
+})(VarType || (VarType = {}));
+
+class UriTemplate {
+    expandParts;
+    matchRegex;
+    matchMap;
+    constructor(template) {
+        this.expandParts = [];
+        const re = [ "^" ];
+        this.matchMap = new Map;
+        let pos = 0;
+        const matches = Array.from(template.matchAll(/\{(.+?)\}/g));
+        let matchCounter = 0;
+        for (const m of matches) {
+            if (m.index > pos) {
+                const lit = template.slice(pos, m.index);
+                this.expandParts.push({
+                    type: STR,
+                    value: lit
+                });
+                const groupName = `static${matchCounter++}`;
+                re.push(`(?<${groupName}>${escapeRegExp(lit)})`);
+                this.matchMap.set(groupName, {
+                    type: VarType.STATIC
+                });
+            }
+            pos = m.index + m[0].length;
+            const ph = {
+                type: VAR,
+                prefix: "",
+                vars: []
+            };
+            this.expandParts.push(ph);
+            let varStr = m[1];
+            const prefix = varStr.match(PREFIX_RE);
+            if (prefix) {
+                varStr = varStr.slice(1);
+                ph.prefix = prefix[0];
+            }
+            const vars = varStr.split(",");
+            const isNamed = Named[ph.prefix];
+            let isFirst = true;
+            if (!isNamed) {
+                re.push(escapeRegExp(FirstMap[ph.prefix]));
+            }
+            for (const v of vars) {
+                const item = {
+                    name: v,
+                    length: null,
+                    func: null,
+                    repeat: false
+                };
+                const mod = v.match(MODIFIER_RE);
+                if (mod) {
+                    if (mod.groups.repeat !== undefined) {
+                        item.repeat = true;
+                    }
+                    if (mod.groups.length !== undefined) {
+                        item.length = Number(mod.groups.length);
+                    }
+                    if (mod.groups.func !== undefined) {
+                        item.func = mod.groups.func;
+                    }
+                    item.name = item.name.slice(0, mod.index);
+                }
+                ph.vars.push(item);
+                if (!isNamed) {
+                    if (!isFirst) {
+                        re.push(escapeRegExp(SeparatorMap[ph.prefix]));
+                    }
+                    let groupName = item.name;
+                    if (!/^[a-z][a-z0-9_]*$/i.test(groupName)) {
+                        groupName = "param";
+                    }
+                    groupName += String(matchCounter++);
+                    re.push(`(?<${groupName}>`);
+                    if (item.func != null) {
+                        switch (item.func) {
+                          case "int":
+                            if (item.length != null) {
+                                re.push(`\\d{${item.length}}`);
+                            } else {
+                                re.push("-?\\d+");
+                            }
+                            break;
+
+                          default:
+                            throw new Error(`Unrecognized UriTemplate func: ${item.func}`);
+                        }
+                    } else {
+                        let ch;
+                        if (ph.prefix === "+") {
+                            ch = "[^?#]";
+                        } else if (ph.prefix === "#") {
+                            ch = ".";
+                        } else if (ph.prefix === "/" && item.repeat) {
+                            ch = "[^?#]";
+                        } else {
+                            ch = "[^/?#]";
+                        }
+                        if (item.length != null) {
+                            ch = `(?:%[0-9a-fA-F]{2}|${ch})`;
+                            re.push(ch, `{${item.length}}`);
+                        } else {
+                            re.push(ch, "+?");
+                        }
+                    }
+                    re.push(")");
+                    this.matchMap.set(groupName, {
+                        var: item,
+                        type: VarType.DYNAMIC,
+                        prefix: ph.prefix
+                    });
+                }
+                isFirst = false;
+            }
+            if (isNamed) {
+                re.push("(?:", escapeRegExp(FirstMap[ph.prefix]));
+                const groupName = `kwargs${matchCounter++}`;
+                re.push(`(?<${groupName}>[^/?#]*)`);
+                re.push(")?");
+                this.matchMap.set(groupName, {
+                    vars: ph.vars,
+                    type: VarType.NAMED,
+                    prefix: ph.prefix
+                });
+            }
+        }
+        if (pos < template.length) {
+            const lit = template.slice(pos);
+            this.expandParts.push({
+                type: STR,
+                value: lit
+            });
+            const groupName = `static${matchCounter++}`;
+            re.push(`(?<${groupName}>${escapeRegExp(lit)})`);
+            this.matchMap.set(groupName, {
+                type: VarType.STATIC
+            });
+        }
+        re.push("$");
+        this.matchRegex = new RegExp(re.join(""));
+    }
+    expand(variables) {
+        const out = [];
+        for (const p of this.expandParts) {
+            switch (p.type) {
+              case VAR:
+                const vs = [];
+                for (const v of p.vars) {
+                    if (Object.hasOwn(variables, v.name)) {
+                        const x = variables[v.name];
+                        const esc = x => percentEncodeRegExp(x, ReservedExpansion[p.prefix], v.length);
+                        let pre = "";
+                        if (Named[p.prefix]) {
+                            pre = v.name + (isEmpty(x) ? IfEmp[p.prefix] : "=");
+                        }
+                        if (Array.isArray(x)) {
+                            if (x.length) {
+                                vs.push((v.repeat ? "" : pre) + x.map((z => (v.repeat ? pre : "") + esc(z))).join(v.repeat ? SeparatorMap[p.prefix] : ","));
+                            }
+                        } else if (typeof x === "object") {
+                            if (Object.keys(x).length) {
+                                vs.push((v.repeat ? "" : pre) + Object.entries(x).map((([ok, ov]) => `${esc(ok)}${v.repeat ? "=" : ","}${esc(ov)}`)).join(v.repeat ? SeparatorMap[p.prefix] : ","));
+                            }
+                        } else {
+                            vs.push(pre + esc(x));
+                        }
+                    }
+                }
+                if (vs.length) {
+                    out.push(FirstMap[p.prefix], vs.join(SeparatorMap[p.prefix]));
+                }
+                break;
+
+              case STR:
+                out.push(p.value);
+                break;
+            }
+        }
+        return out.join("");
+    }
+    match(url) {
+        let score = 0;
+        const m = url.match(this.matchRegex);
+        if (m !== null) {
+            let params = [];
+            if (m.groups != null) {
+                for (const [k, v] of Object.entries(m.groups)) {
+                    const itemSpec = this.matchMap.get(k);
+                    let value;
+                    switch (itemSpec.type) {
+                      case VarType.NAMED:
+                        {
+                            const parsed = v == null ? Object.create(null) : parseParams(v, SeparatorMap[itemSpec.prefix]);
+                            for (const vs of itemSpec.vars) {
+                                if (vs.repeat) {
+                                    score -= 1;
+                                    if (isEmpty(parsed)) {
+                                        params.push([ vs.name, EMPTY_OBJ ]);
+                                    } else {
+                                        params.push([ vs.name, mapValues(parsed, (x => formatElement(x, vs))) ]);
+                                    }
+                                    break;
+                                } else {
+                                    if (parsed[vs.name] !== undefined) {
+                                        score += 2;
+                                        params.push([ vs.name, formatElement(parsed[vs.name], vs) ]);
+                                        delete parsed[vs.name];
+                                    } else {
+                                        params.push([ vs.name, null ]);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+
+                      case VarType.DYNAMIC:
+                        {
+                            score += 2;
+                            if (v == null) {
+                                if (itemSpec.var.repeat) {
+                                    if (Named[itemSpec.prefix]) {
+                                        value = EMPTY_OBJ;
+                                    } else {
+                                        value = EMPTY_ARR;
+                                    }
+                                } else {
+                                    value = null;
+                                }
+                            } else {
+                                value = v;
+                                if (itemSpec.var.repeat) {
+                                    value = value.split(SeparatorMap[itemSpec.prefix]).map((x => formatElement(x, itemSpec.var)));
+                                } else {
+                                    value = formatElement(value, itemSpec.var);
+                                }
+                            }
+                            params.push([ itemSpec.var.name, value ]);
+                        }
+                        break;
+
+                      case VarType.STATIC:
+                        {
+                            score += 3;
+                        }
+                        break;
+                    }
+                }
+            }
+            return {
+                score,
+                params: Object.fromEntries(params)
+            };
+        }
+        return null;
+    }
+}
+
+function formatElement(str, varSpec) {
+    if (str == null) return null;
+    let out = decodeURIComponent(str);
+    if (varSpec.length != null) {
+        out = out.slice(0, varSpec.length);
+    }
+    if (varSpec.func === "int") {
+        out = Number(out);
+    }
+    return out;
+}
+
+function mapValues(obj, callback) {
+    return Object.fromEntries(Object.entries(obj).map((([key, value]) => [ key, callback(value) ])));
+}
+
+function parseParams(queryString, separator) {
+    const pairs = queryString.split(separator);
+    return Object.fromEntries(pairs.map((pair => {
+        const idx = pair.indexOf("=");
+        if (idx === -1) {
+            return [ pair, null ];
+        }
+        const key = pair.slice(0, idx);
+        const value = pair.slice(idx + 1);
+        return [ key, value ];
+    })));
+}
+
+const EMPTY_OBJ = Object.freeze(Object.create(null));
+
+const EMPTY_ARR = Object.freeze([]);
+
+function isEmpty(x) {
+    return x == null || x === "" || (Array.isArray(x) ? !x.length : typeof x === "object" && !Object.keys(x).length);
+}
+
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function percentEncodeRegExp(x, reserved, length) {
+    if (typeof x === "number") {
+        return String(x);
+    }
+    if (x === true) return "1";
+    if (x === false) return "0";
+    if (x === null) return "";
+    if (length != null) {
+        x = x.slice(0, length);
+    }
+    if (reserved) {
+        return x.replace(/%[0-9a-fA-F]{2}|./gsu, (m => {
+            let v = PERCENT_RE.test(m) ? decodeURIComponent(m) : m;
+            if (UR_SET.test(v)) {
+                return percentEncode(v);
+            }
+            return m;
+        }));
+    }
+    return x.replace(UNRESERVED, percentEncode);
+}
+
+const UTF8_ENCODER = new TextEncoder;
+
+function percentEncode(str) {
+    return Array.from(UTF8_ENCODER.encode(str)).map((i => "%" + i.toString(16).toUpperCase().padStart(2, "0"))).join("");
+}
+
+exports.UriTemplate = UriTemplate;

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+export { UriTemplate } from './uri-template';
+export type { UrlParamValue } from './uri-template';

package/dist/bundle.mjs

@@ -0,0 +1,404 @@
+const PREFIX_RE = /^[+#./;?&]/;
+
+const MODIFIER_RE = /(?<repeat>\*)?(?::(?<func>[a-zA-Z][a-zA-Z0-9_]*))?(?::(?:(?<length>\d+)))?$/;
+
+const UNRESERVED = /[^a-zA-Z0-9\-._~]+/gsu;
+
+const UR_SET = /[^a-zA-Z0-9\-._~:\/?#[\]@!$&'()*+,;=]+/gsu;
+
+const PERCENT_RE = /^%[0-9a-fA-F]{2}$/;
+
+const STR = Symbol("string");
+
+const VAR = Symbol("var");
+
+const SeparatorMap = {
+    "": ",",
+    "+": ",",
+    ".": ".",
+    "/": "/",
+    ";": ";",
+    "?": "&",
+    "&": "&",
+    "#": ","
+};
+
+const FirstMap = {
+    "": "",
+    "+": "",
+    ".": ".",
+    "/": "/",
+    ";": ";",
+    "?": "?",
+    "&": "&",
+    "#": "#"
+};
+
+const Named = {
+    "": false,
+    "+": false,
+    ".": false,
+    "/": false,
+    ";": true,
+    "?": true,
+    "&": true,
+    "#": false
+};
+
+const IfEmp = {
+    "": "",
+    "+": "",
+    ".": "",
+    "/": "",
+    ";": "",
+    "?": "=",
+    "&": "=",
+    "#": ""
+};
+
+const ReservedExpansion = {
+    "": false,
+    "+": true,
+    ".": false,
+    "/": false,
+    ";": false,
+    "?": false,
+    "&": false,
+    "#": true
+};
+
+var VarType;
+
+(function(VarType) {
+    VarType[VarType["NAMED"] = 0] = "NAMED";
+    VarType[VarType["STATIC"] = 1] = "STATIC";
+    VarType[VarType["DYNAMIC"] = 2] = "DYNAMIC";
+})(VarType || (VarType = {}));
+
+class UriTemplate {
+    expandParts;
+    matchRegex;
+    matchMap;
+    constructor(template) {
+        this.expandParts = [];
+        const re = [ "^" ];
+        this.matchMap = new Map;
+        let pos = 0;
+        const matches = Array.from(template.matchAll(/\{(.+?)\}/g));
+        let matchCounter = 0;
+        for (const m of matches) {
+            if (m.index > pos) {
+                const lit = template.slice(pos, m.index);
+                this.expandParts.push({
+                    type: STR,
+                    value: lit
+                });
+                const groupName = `static${matchCounter++}`;
+                re.push(`(?<${groupName}>${escapeRegExp(lit)})`);
+                this.matchMap.set(groupName, {
+                    type: VarType.STATIC
+                });
+            }
+            pos = m.index + m[0].length;
+            const ph = {
+                type: VAR,
+                prefix: "",
+                vars: []
+            };
+            this.expandParts.push(ph);
+            let varStr = m[1];
+            const prefix = varStr.match(PREFIX_RE);
+            if (prefix) {
+                varStr = varStr.slice(1);
+                ph.prefix = prefix[0];
+            }
+            const vars = varStr.split(",");
+            const isNamed = Named[ph.prefix];
+            let isFirst = true;
+            if (!isNamed) {
+                re.push(escapeRegExp(FirstMap[ph.prefix]));
+            }
+            for (const v of vars) {
+                const item = {
+                    name: v,
+                    length: null,
+                    func: null,
+                    repeat: false
+                };
+                const mod = v.match(MODIFIER_RE);
+                if (mod) {
+                    if (mod.groups.repeat !== undefined) {
+                        item.repeat = true;
+                    }
+                    if (mod.groups.length !== undefined) {
+                        item.length = Number(mod.groups.length);
+                    }
+                    if (mod.groups.func !== undefined) {
+                        item.func = mod.groups.func;
+                    }
+                    item.name = item.name.slice(0, mod.index);
+                }
+                ph.vars.push(item);
+                if (!isNamed) {
+                    if (!isFirst) {
+                        re.push(escapeRegExp(SeparatorMap[ph.prefix]));
+                    }
+                    let groupName = item.name;
+                    if (!/^[a-z][a-z0-9_]*$/i.test(groupName)) {
+                        groupName = "param";
+                    }
+                    groupName += String(matchCounter++);
+                    re.push(`(?<${groupName}>`);
+                    if (item.func != null) {
+                        switch (item.func) {
+                          case "int":
+                            if (item.length != null) {
+                                re.push(`\\d{${item.length}}`);
+                            } else {
+                                re.push("-?\\d+");
+                            }
+                            break;
+
+                          default:
+                            throw new Error(`Unrecognized UriTemplate func: ${item.func}`);
+                        }
+                    } else {
+                        let ch;
+                        if (ph.prefix === "+") {
+                            ch = "[^?#]";
+                        } else if (ph.prefix === "#") {
+                            ch = ".";
+                        } else if (ph.prefix === "/" && item.repeat) {
+                            ch = "[^?#]";
+                        } else {
+                            ch = "[^/?#]";
+                        }
+                        if (item.length != null) {
+                            ch = `(?:%[0-9a-fA-F]{2}|${ch})`;
+                            re.push(ch, `{${item.length}}`);
+                        } else {
+                            re.push(ch, "+?");
+                        }
+                    }
+                    re.push(")");
+                    this.matchMap.set(groupName, {
+                        var: item,
+                        type: VarType.DYNAMIC,
+                        prefix: ph.prefix
+                    });
+                }
+                isFirst = false;
+            }
+            if (isNamed) {
+                re.push("(?:", escapeRegExp(FirstMap[ph.prefix]));
+                const groupName = `kwargs${matchCounter++}`;
+                re.push(`(?<${groupName}>[^/?#]*)`);
+                re.push(")?");
+                this.matchMap.set(groupName, {
+                    vars: ph.vars,
+                    type: VarType.NAMED,
+                    prefix: ph.prefix
+                });
+            }
+        }
+        if (pos < template.length) {
+            const lit = template.slice(pos);
+            this.expandParts.push({
+                type: STR,
+                value: lit
+            });
+            const groupName = `static${matchCounter++}`;
+            re.push(`(?<${groupName}>${escapeRegExp(lit)})`);
+            this.matchMap.set(groupName, {
+                type: VarType.STATIC
+            });
+        }
+        re.push("$");
+        this.matchRegex = new RegExp(re.join(""));
+    }
+    expand(variables) {
+        const out = [];
+        for (const p of this.expandParts) {
+            switch (p.type) {
+              case VAR:
+                const vs = [];
+                for (const v of p.vars) {
+                    if (Object.hasOwn(variables, v.name)) {
+                        const x = variables[v.name];
+                        const esc = x => percentEncodeRegExp(x, ReservedExpansion[p.prefix], v.length);
+                        let pre = "";
+                        if (Named[p.prefix]) {
+                            pre = v.name + (isEmpty(x) ? IfEmp[p.prefix] : "=");
+                        }
+                        if (Array.isArray(x)) {
+                            if (x.length) {
+                                vs.push((v.repeat ? "" : pre) + x.map((z => (v.repeat ? pre : "") + esc(z))).join(v.repeat ? SeparatorMap[p.prefix] : ","));
+                            }
+                        } else if (typeof x === "object") {
+                            if (Object.keys(x).length) {
+                                vs.push((v.repeat ? "" : pre) + Object.entries(x).map((([ok, ov]) => `${esc(ok)}${v.repeat ? "=" : ","}${esc(ov)}`)).join(v.repeat ? SeparatorMap[p.prefix] : ","));
+                            }
+                        } else {
+                            vs.push(pre + esc(x));
+                        }
+                    }
+                }
+                if (vs.length) {
+                    out.push(FirstMap[p.prefix], vs.join(SeparatorMap[p.prefix]));
+                }
+                break;
+
+              case STR:
+                out.push(p.value);
+                break;
+            }
+        }
+        return out.join("");
+    }
+    match(url) {
+        let score = 0;
+        const m = url.match(this.matchRegex);
+        if (m !== null) {
+            let params = [];
+            if (m.groups != null) {
+                for (const [k, v] of Object.entries(m.groups)) {
+                    const itemSpec = this.matchMap.get(k);
+                    let value;
+                    switch (itemSpec.type) {
+                      case VarType.NAMED:
+                        {
+                            const parsed = v == null ? Object.create(null) : parseParams(v, SeparatorMap[itemSpec.prefix]);
+                            for (const vs of itemSpec.vars) {
+                                if (vs.repeat) {
+                                    score -= 1;
+                                    if (isEmpty(parsed)) {
+                                        params.push([ vs.name, EMPTY_OBJ ]);
+                                    } else {
+                                        params.push([ vs.name, mapValues(parsed, (x => formatElement(x, vs))) ]);
+                                    }
+                                    break;
+                                } else {
+                                    if (parsed[vs.name] !== undefined) {
+                                        score += 2;
+                                        params.push([ vs.name, formatElement(parsed[vs.name], vs) ]);
+                                        delete parsed[vs.name];
+                                    } else {
+                                        params.push([ vs.name, null ]);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+
+                      case VarType.DYNAMIC:
+                        {
+                            score += 2;
+                            if (v == null) {
+                                if (itemSpec.var.repeat) {
+                                    if (Named[itemSpec.prefix]) {
+                                        value = EMPTY_OBJ;
+                                    } else {
+                                        value = EMPTY_ARR;
+                                    }
+                                } else {
+                                    value = null;
+                                }
+                            } else {
+                                value = v;
+                                if (itemSpec.var.repeat) {
+                                    value = value.split(SeparatorMap[itemSpec.prefix]).map((x => formatElement(x, itemSpec.var)));
+                                } else {
+                                    value = formatElement(value, itemSpec.var);
+                                }
+                            }
+                            params.push([ itemSpec.var.name, value ]);
+                        }
+                        break;
+
+                      case VarType.STATIC:
+                        {
+                            score += 3;
+                        }
+                        break;
+                    }
+                }
+            }
+            return {
+                score,
+                params: Object.fromEntries(params)
+            };
+        }
+        return null;
+    }
+}
+
+function formatElement(str, varSpec) {
+    if (str == null) return null;
+    let out = decodeURIComponent(str);
+    if (varSpec.length != null) {
+        out = out.slice(0, varSpec.length);
+    }
+    if (varSpec.func === "int") {
+        out = Number(out);
+    }
+    return out;
+}
+
+function mapValues(obj, callback) {
+    return Object.fromEntries(Object.entries(obj).map((([key, value]) => [ key, callback(value) ])));
+}
+
+function parseParams(queryString, separator) {
+    const pairs = queryString.split(separator);
+    return Object.fromEntries(pairs.map((pair => {
+        const idx = pair.indexOf("=");
+        if (idx === -1) {
+            return [ pair, null ];
+        }
+        const key = pair.slice(0, idx);
+        const value = pair.slice(idx + 1);
+        return [ key, value ];
+    })));
+}
+
+const EMPTY_OBJ = Object.freeze(Object.create(null));
+
+const EMPTY_ARR = Object.freeze([]);
+
+function isEmpty(x) {
+    return x == null || x === "" || (Array.isArray(x) ? !x.length : typeof x === "object" && !Object.keys(x).length);
+}
+
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function percentEncodeRegExp(x, reserved, length) {
+    if (typeof x === "number") {
+        return String(x);
+    }
+    if (x === true) return "1";
+    if (x === false) return "0";
+    if (x === null) return "";
+    if (length != null) {
+        x = x.slice(0, length);
+    }
+    if (reserved) {
+        return x.replace(/%[0-9a-fA-F]{2}|./gsu, (m => {
+            let v = PERCENT_RE.test(m) ? decodeURIComponent(m) : m;
+            if (UR_SET.test(v)) {
+                return percentEncode(v);
+            }
+            return m;
+        }));
+    }
+    return x.replace(UNRESERVED, percentEncode);
+}
+
+const UTF8_ENCODER = new TextEncoder;
+
+function percentEncode(str) {
+    return Array.from(UTF8_ENCODER.encode(str)).map((i => "%" + i.toString(16).toUpperCase().padStart(2, "0"))).join("");
+}
+
+export { UriTemplate };

package/dist/dev.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/log.d.ts

@@ -0,0 +1 @@
+export default function log(...vars: any): void;

package/dist/uri-template.d.ts

@@ -0,0 +1,48 @@
+declare const STR: unique symbol;
+declare const VAR: unique symbol;
+interface Placeholder {
+    type: typeof VAR;
+    prefix: string;
+    vars: VarSpec[];
+}
+interface StringLiteral {
+    type: typeof STR;
+    value: string;
+}
+type TemplateParts = Array<Placeholder | StringLiteral>;
+interface VarSpec {
+    name: string;
+    length: number | null;
+    func: string | null;
+    repeat: boolean;
+}
+declare enum VarType {
+    NAMED = 0,
+    STATIC = 1,
+    DYNAMIC = 2
+}
+type MapItem = {
+    type: VarType.DYNAMIC;
+    var: VarSpec;
+    prefix: string;
+} | {
+    type: VarType.NAMED;
+    vars: VarSpec[];
+    prefix: string;
+} | {
+    type: VarType.STATIC;
+};
+export declare class UriTemplate {
+    expandParts: TemplateParts;
+    matchRegex: RegExp;
+    matchMap: Map<string, MapItem>;
+    constructor(template: string);
+    expand(variables: Record<string, UrlParamValue>): string;
+    match(url: string): Match | null;
+}
+export type UrlParamValue = string | number | string[] | number[] | Record<string, string | number | null>;
+interface Match {
+    score: number;
+    params: Record<string, UrlParamValue | null>;
+}
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mpen/rerouter",
+  "version": "0.1.2",
+  "packageManager": "bun",
+  "exports": "./dist/bundle.cjs",
+  "module": "./dist/bundle.mjs",
+  "types": "./dist/bundle.d.ts",
+  "files": [
+    "./dist"
+  ],
+  "type": "module",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.4",
+    "@rollup/plugin-node-resolve": "^15.2.1",
+    "@rollup/plugin-replace": "^5.0.2",
+    "@rollup/plugin-terser": "^0.4.3",
+    "@rollup/plugin-typescript": "^11.1.3",
+    "bun-types": "^1.0.2",
+    "chalk": "^5.3.0",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^5.0.1",
+    "rollup": "^3.29.2",
+    "tslib": "^2.6.2",
+    "typescript": "^5.2.2"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "bun test --watch src",
+    "dev": "bun run --hot src/dev.ts",
+    "bundle:clean": "rimraf -g \"dist/*\"",
+    "bundle:build": "rollup -c",
+    "bundle": "run-s bundle:clean bundle:build",
+    "patch": "npm version patch && VER=$(jq -r '.version' package.json) && hg ci -m \"Publish v$VER\" && hg tag \"v$VER\"",
+    "release": "run-s bundle patch && npm publish && hg push"
+  }
+}