shield360 1.1.0 → 1.2.0

package/dist/rasp/rule-expr.js

@@ -0,0 +1,1253 @@
+"use strict";
+/**
+ * Custom RASP rule expressions (sdk/rasp/README.md "Custom rules").
+ *
+ * A small, sandboxed, CEL-style expression language: a fixed set of fields,
+ * string literals, comparison, `in`, a handful of string methods, a safe
+ * regular-expression subset matched in linear time, and CIDR matching,
+ * joined by `&&`, `||` and `!`. No loops, no function definitions, no I/O,
+ * nothing outside the fields. Expressions are parsed and type-checked once
+ * and evaluated as data; nothing downloaded is ever run as code.
+ *
+ * This file is shared: `sdk/typescript/src/rasp/rule-expr.ts` and
+ * `src/client/src/lib/security/rasp/rule-expr.ts` are byte-identical (a test
+ * in each tree says so), so the platform accepts exactly what the SDK runs.
+ * It imports nothing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RULE_BUDGET = exports.COLLECTOR_RULE_FIELDS = exports.RULE_FIELDS = exports.RULE_EXPR_LIMITS = void 0;
+exports.ruleContextFields = ruleContextFields;
+exports.utf8Length = utf8Length;
+exports.compileRuleExpr = compileRuleExpr;
+exports.evaluateRuleExpr = evaluateRuleExpr;
+exports.compileRegex = compileRegex;
+exports.isSafeRegex = isSafeRegex;
+exports.parseIpBytes = parseIpBytes;
+exports.parseCidr = parseCidr;
+/** Hard limits, identical on the platform and in every SDK. */
+exports.RULE_EXPR_LIMITS = Object.freeze({
+    /** UTF-8 bytes of the whole expression. */
+    expressionBytes: 2048,
+    /** AST depth (a leaf is 1), and parenthesis nesting. */
+    depth: 12,
+    /** AST nodes. */
+    nodes: 128,
+    /** UTF-8 bytes of one string literal, after escapes. */
+    stringBytes: 1024,
+    /** Items in one `in [...]` list. */
+    listItems: 64,
+    /** `matches` calls in one expression. */
+    regexes: 8,
+    /** UTF-8 bytes of one pattern. */
+    regexBytes: 256,
+    /** Atoms of one pattern once counted repetitions are expanded. */
+    regexAtoms: 256,
+    /** The largest bound in `{n}`, `{n,}`, `{n,m}`. */
+    regexRepeat: 100,
+    /** `matches` reads at most this many code points of its subject. */
+    matchCodePoints: 4096,
+});
+/** The fields an expression may read (README "Custom rules: fields"). */
+exports.RULE_FIELDS = Object.freeze({
+    "request.method": "string",
+    "request.path": "string",
+    "request.route": "string",
+    "request.ip": "string",
+    "request.headers": "map",
+    "request.query": "map",
+    "request.body": "map",
+    "input.value": "string",
+    "input.key": "string",
+    "input.source": "string",
+    "sink.name": "string",
+    "attack.type": "string",
+    "attack.rule": "string",
+    "app.name": "string",
+});
+/** The fields of each collector context. None is a map. */
+exports.COLLECTOR_RULE_FIELDS = Object.freeze({
+    agent_tool: Object.freeze({
+        "tool.name": "string",
+        "tool.command": "string",
+        "tool.path": "string",
+        "agent.name": "string",
+        "user.id": "string",
+        "device.os": "string",
+    }),
+    ai_proxy: Object.freeze({
+        "ai.provider": "string",
+        "ai.model": "string",
+        "ai.tokens": "string",
+        "user.id": "string",
+        "device.os": "string",
+    }),
+});
+/** The fields an expression may read in a context, or null for one this parser does not know. */
+function ruleContextFields(context) {
+    if (context === "app")
+        return exports.RULE_FIELDS;
+    return Object.prototype.hasOwnProperty.call(exports.COLLECTOR_RULE_FIELDS, context) ? exports.COLLECTOR_RULE_FIELDS[context] : null;
+}
+class ExprError extends Error {
+    constructor(code, pos) {
+        super(code);
+        this.code = code;
+        this.pos = pos;
+    }
+}
+/** UTF-8 length of a JS string (a lone surrogate counts 3, as its U+FFFD replacement). */
+function utf8Length(s) {
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c < 0x80)
+            n += 1;
+        else if (c < 0x800)
+            n += 2;
+        else if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length && s.charCodeAt(i + 1) >= 0xdc00 && s.charCodeAt(i + 1) <= 0xdfff) {
+            n += 4;
+            i++;
+        }
+        else
+            n += 3;
+    }
+    return n;
+}
+/** The code points of a string, at most `max`. */
+function codePoints(s, max) {
+    const out = [];
+    for (let i = 0; i < s.length && out.length < max;) {
+        const c = s.codePointAt(i);
+        out.push(c);
+        i += c > 0xffff ? 2 : 1;
+    }
+    return out;
+}
+const OPS2 = ["==", "!=", "<=", ">=", "&&", "||"];
+const OPS1 = "()[],.<>!";
+const isIdentStart = (c) => (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || c === "_";
+const isIdentPart = (c) => isIdentStart(c) || (c >= "0" && c <= "9");
+const HEX = /^[0-9A-Fa-f]{4}$/;
+function lex(src) {
+    const toks = [];
+    let i = 0;
+    while (i < src.length) {
+        const c = src[i];
+        if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+            i++;
+            continue;
+        }
+        const start = i;
+        const raw = (c === "r" || c === "R") && (src[i + 1] === '"' || src[i + 1] === "'");
+        if (c === '"' || c === "'" || raw) {
+            if (raw)
+                i++;
+            const quote = src[i];
+            i++;
+            let v = "";
+            for (;;) {
+                if (i >= src.length)
+                    throw new ExprError("syntax", start);
+                const d = src[i];
+                if (d === quote) {
+                    i++;
+                    break;
+                }
+                if (d.charCodeAt(0) < 0x20)
+                    throw new ExprError("syntax", i);
+                if (d === "\\" && !raw) {
+                    const e = src[i + 1];
+                    if (e === "\\" || e === '"' || e === "'")
+                        v += e;
+                    else if (e === "n")
+                        v += "\n";
+                    else if (e === "r")
+                        v += "\r";
+                    else if (e === "t")
+                        v += "\t";
+                    else if (e === "u") {
+                        const h = src.slice(i + 2, i + 6);
+                        if (!HEX.test(h))
+                            throw new ExprError("syntax", i);
+                        const code = parseInt(h, 16);
+                        if (code >= 0xd800 && code <= 0xdfff)
+                            throw new ExprError("syntax", i);
+                        v += String.fromCharCode(code);
+                        i += 4;
+                    }
+                    else
+                        throw new ExprError("syntax", i);
+                    i += 2;
+                    continue;
+                }
+                v += d;
+                i++;
+            }
+            if (utf8Length(v) > exports.RULE_EXPR_LIMITS.stringBytes)
+                throw new ExprError("string_too_long", start);
+            toks.push({ t: "str", v, pos: start });
+            continue;
+        }
+        if (isIdentStart(c)) {
+            while (i < src.length && isIdentPart(src[i]))
+                i++;
+            toks.push({ t: "ident", v: src.slice(start, i), pos: start });
+            continue;
+        }
+        const two = src.slice(i, i + 2);
+        if (OPS2.includes(two)) {
+            toks.push({ t: "op", v: two, pos: start });
+            i += 2;
+            continue;
+        }
+        if (OPS1.includes(c)) {
+            toks.push({ t: "op", v: c, pos: start });
+            i++;
+            continue;
+        }
+        throw new ExprError("syntax", i);
+    }
+    toks.push({ t: "eof", v: "", pos: src.length });
+    return toks;
+}
+// ---- parser -----------------------------------------------------------------
+const KEYWORDS = new Set(["true", "false", "null", "in"]);
+const STR_METHODS = new Set(["startsWith", "endsWith", "contains"]);
+const METHODS = new Set(["startsWith", "endsWith", "contains", "lowerAscii", "matches", "inCidr"]);
+class Parser {
+    constructor(toks, fields = exports.RULE_FIELDS) {
+        this.toks = toks;
+        this.fields = fields;
+        this.i = 0;
+        this.nodes = 0;
+        /** Parenthesis nesting, and nested `!` (each adds AST depth): both bounded while parsing. */
+        this.parens = 0;
+        this.nots = 0;
+        this.regexes = 0;
+    }
+    peek(o = 0) {
+        return this.toks[Math.min(this.i + o, this.toks.length - 1)];
+    }
+    next() {
+        const t = this.peek();
+        if (this.i < this.toks.length - 1)
+            this.i++;
+        return t;
+    }
+    isOp(v, o = 0) {
+        const t = this.peek(o);
+        return t.t === "op" && t.v === v;
+    }
+    expectOp(v) {
+        const t = this.next();
+        if (t.t !== "op" || t.v !== v)
+            throw new ExprError("syntax", t.pos);
+        return t;
+    }
+    count(n, pos) {
+        this.nodes += n;
+        if (this.nodes > exports.RULE_EXPR_LIMITS.nodes)
+            throw new ExprError("nodes", pos);
+    }
+    parse() {
+        const n = this.or();
+        const t = this.peek();
+        if (t.t !== "eof")
+            throw new ExprError("syntax", t.pos);
+        return n;
+    }
+    or() {
+        const pos = this.peek().pos;
+        const xs = [this.and()];
+        while (this.isOp("||")) {
+            this.next();
+            xs.push(this.and());
+        }
+        if (xs.length === 1)
+            return xs[0];
+        this.count(1, pos);
+        return { k: "or", xs };
+    }
+    and() {
+        const pos = this.peek().pos;
+        const xs = [this.relation()];
+        while (this.isOp("&&")) {
+            this.next();
+            xs.push(this.relation());
+        }
+        if (xs.length === 1)
+            return xs[0];
+        this.count(1, pos);
+        return { k: "and", xs };
+    }
+    relation() {
+        const l = this.unary();
+        const t = this.peek();
+        if (t.t === "op" && (t.v === "==" || t.v === "!=" || t.v === "<" || t.v === "<=" || t.v === ">" || t.v === ">=")) {
+            this.next();
+            const r = this.unary();
+            this.count(1, t.pos);
+            return { k: "cmp", op: t.v, l, r };
+        }
+        if (t.t === "ident" && t.v === "in") {
+            this.next();
+            this.expectOp("[");
+            const items = [];
+            while (!this.isOp("]")) {
+                const s = this.next();
+                if (s.t !== "str")
+                    throw new ExprError("syntax", s.pos);
+                items.push(s.v);
+                if (items.length > exports.RULE_EXPR_LIMITS.listItems)
+                    throw new ExprError("list_too_long", s.pos);
+                if (this.isOp(","))
+                    this.next();
+                else if (!this.isOp("]"))
+                    throw new ExprError("syntax", this.peek().pos);
+            }
+            this.next();
+            this.count(2 + items.length, t.pos);
+            return { k: "in", l, items };
+        }
+        return l;
+    }
+    unary() {
+        const t = this.peek();
+        if (this.isOp("!")) {
+            this.next();
+            if (++this.nots > exports.RULE_EXPR_LIMITS.depth)
+                throw new ExprError("depth", t.pos);
+            const x = this.unary();
+            this.nots--;
+            this.count(1, t.pos);
+            return { k: "not", x };
+        }
+        return this.member();
+    }
+    member() {
+        let n = this.primary();
+        while (this.isOp(".")) {
+            this.next();
+            const name = this.next();
+            if (name.t !== "ident")
+                throw new ExprError("syntax", name.pos);
+            if (!this.isOp("("))
+                throw new ExprError("syntax", this.peek().pos);
+            this.next();
+            let arg;
+            if (this.peek().t === "str")
+                arg = this.next().v;
+            this.expectOp(")");
+            if (!METHODS.has(name.v))
+                throw new ExprError("unknown_method", name.pos);
+            if (name.v === "lowerAscii") {
+                if (arg !== undefined)
+                    throw new ExprError("type", name.pos);
+                this.count(1, name.pos);
+                n = { k: "lower", t: n };
+                continue;
+            }
+            if (arg === undefined)
+                throw new ExprError("type", name.pos);
+            this.count(2, name.pos);
+            if (STR_METHODS.has(name.v))
+                n = { k: "str_method", m: name.v, t: n, arg };
+            else if (name.v === "matches") {
+                this.regexes++;
+                if (this.regexes > exports.RULE_EXPR_LIMITS.regexes)
+                    throw new ExprError("too_many_regexes", name.pos);
+                const prog = compileRegex(arg);
+                if (!prog)
+                    throw new ExprError("regex", name.pos);
+                n = { k: "matches", t: n, prog };
+            }
+            else {
+                const net = parseCidr(arg);
+                if (!net)
+                    throw new ExprError("cidr", name.pos);
+                n = { k: "cidr", t: n, net };
+            }
+        }
+        return n;
+    }
+    primary() {
+        const t = this.next();
+        if (t.t === "str") {
+            this.count(1, t.pos);
+            return { k: "str", v: t.v };
+        }
+        if (t.t === "op" && t.v === "(") {
+            if (++this.parens > exports.RULE_EXPR_LIMITS.depth)
+                throw new ExprError("depth", t.pos);
+            const n = this.or();
+            this.parens--;
+            this.expectOp(")");
+            return n;
+        }
+        if (t.t === "ident") {
+            if (t.v === "true" || t.v === "false") {
+                this.count(1, t.pos);
+                return { k: "bool", v: t.v === "true" };
+            }
+            if (t.v === "null") {
+                this.count(1, t.pos);
+                return { k: "null" };
+            }
+            if (KEYWORDS.has(t.v))
+                throw new ExprError("syntax", t.pos);
+            // A dotted field name; a segment followed by `(` is a method call.
+            let name = t.v;
+            while (this.isOp(".") && this.peek(1).t === "ident" && !(this.peek(2).t === "op" && this.peek(2).v === "(")) {
+                this.next();
+                name += `.${this.next().v}`;
+            }
+            const type = Object.prototype.hasOwnProperty.call(this.fields, name) ? this.fields[name] : undefined;
+            if (!type)
+                throw new ExprError("unknown_field", t.pos);
+            let key;
+            if (this.isOp("[")) {
+                const open = this.next();
+                const s = this.next();
+                if (s.t !== "str")
+                    throw new ExprError("syntax", s.pos);
+                this.expectOp("]");
+                if (type !== "map")
+                    throw new ExprError("type", open.pos);
+                // Header names are case-insensitive: ASCII lower-cased here, as the SDKs record them.
+                key = name === "request.headers" ? asciiLower(s.v) : s.v;
+            }
+            else if (type === "map")
+                throw new ExprError("type", t.pos);
+            this.count(1, t.pos);
+            return key === undefined ? { k: "field", name } : { k: "field", name, key };
+        }
+        throw new ExprError("syntax", t.pos);
+    }
+}
+function typeOf(n) {
+    switch (n.k) {
+        case "str":
+            return "string";
+        case "bool":
+            return "bool";
+        case "null":
+            return "null";
+        case "field":
+            return "string";
+        case "not":
+            if (typeOf(n.x) !== "bool")
+                throw new ExprError("type", 0);
+            return "bool";
+        case "and":
+        case "or":
+            for (const x of n.xs)
+                if (typeOf(x) !== "bool")
+                    throw new ExprError("type", 0);
+            return "bool";
+        case "cmp": {
+            const l = typeOf(n.l);
+            const r = typeOf(n.r);
+            if (n.op === "==" || n.op === "!=") {
+                const strish = (t) => t === "string" || t === "null";
+                if (!((strish(l) && strish(r)) || (l === "bool" && r === "bool")))
+                    throw new ExprError("type", 0);
+            }
+            else if (l !== "string" || r !== "string")
+                throw new ExprError("type", 0);
+            return "bool";
+        }
+        case "in":
+        case "str_method":
+        case "matches":
+        case "cidr":
+            if (typeOf(n.k === "in" ? n.l : n.t) !== "string")
+                throw new ExprError("type", 0);
+            return "bool";
+        case "lower":
+            if (typeOf(n.t) !== "string")
+                throw new ExprError("type", 0);
+            return "string";
+    }
+}
+function depthOf(n) {
+    switch (n.k) {
+        case "not":
+            return 1 + depthOf(n.x);
+        case "and":
+        case "or":
+            return 1 + Math.max(...n.xs.map(depthOf));
+        case "cmp":
+            return 1 + Math.max(depthOf(n.l), depthOf(n.r));
+        case "in":
+            return 1 + Math.max(depthOf(n.l), 2);
+        case "str_method":
+        case "matches":
+        case "cidr":
+            return 1 + Math.max(depthOf(n.t), 1);
+        case "lower":
+            return 1 + depthOf(n.t);
+        default:
+            return 1;
+    }
+}
+function collectFields(n, out) {
+    switch (n.k) {
+        case "field":
+            out.add(n.name);
+            return;
+        case "not":
+            collectFields(n.x, out);
+            return;
+        case "and":
+        case "or":
+            n.xs.forEach((x) => collectFields(x, out));
+            return;
+        case "cmp":
+            collectFields(n.l, out);
+            collectFields(n.r, out);
+            return;
+        case "in":
+            collectFields(n.l, out);
+            return;
+        case "str_method":
+        case "matches":
+        case "cidr":
+        case "lower":
+            collectFields(n.t, out);
+            return;
+        default:
+            return;
+    }
+}
+/**
+ * Parses and type-checks an expression. Every limit is checked here; an
+ * expression that compiles is safe to evaluate on any input.
+ */
+function compileRuleExpr(src, context = "app") {
+    try {
+        const fieldsOf = ruleContextFields(context);
+        if (!fieldsOf)
+            return { ok: false, error: { code: "context", pos: 0 } };
+        if (typeof src !== "string" || src.trim() === "")
+            return { ok: false, error: { code: "empty", pos: 0 } };
+        if (utf8Length(src) > exports.RULE_EXPR_LIMITS.expressionBytes)
+            return { ok: false, error: { code: "too_long", pos: 0 } };
+        const p = new Parser(lex(src), fieldsOf);
+        const ast = p.parse();
+        if (typeOf(ast) !== "bool")
+            throw new ExprError("type", 0);
+        if (depthOf(ast) > exports.RULE_EXPR_LIMITS.depth)
+            throw new ExprError("depth", 0);
+        const set = new Set();
+        collectFields(ast, set);
+        const fields = Array.from(set).sort();
+        const phase = fields.some((f) => f.startsWith("sink.") || f.startsWith("attack.")) ? "finding" : "request";
+        return { ok: true, expr: { ast, fields, phase, usesInput: fields.some((f) => f.startsWith("input.")), usesBody: set.has("request.body"), context } };
+    }
+    catch (e) {
+        if (e instanceof ExprError)
+            return { ok: false, error: { code: e.code, pos: e.pos } };
+        return { ok: false, error: { code: "syntax", pos: 0 } };
+    }
+}
+exports.DEFAULT_RULE_BUDGET = 4000000;
+class BudgetExhausted extends Error {
+}
+const asciiLower = (s) => s.replace(/[A-Z]/g, (c) => String.fromCharCode(c.charCodeAt(0) + 32));
+function own(map, key) {
+    if (!map || typeof map !== "object" || !Object.prototype.hasOwnProperty.call(map, key))
+        return null;
+    const v = map[key];
+    return typeof v === "string" ? v : null;
+}
+const str = (v) => (typeof v === "string" ? v : null);
+/** Compares two strings by Unicode code point. */
+function cmpCodePoints(a, b) {
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        const x = a.codePointAt(i);
+        const y = b.codePointAt(j);
+        if (x !== y)
+            return x < y ? -1 : 1;
+        i += x > 0xffff ? 2 : 1;
+        j += y > 0xffff ? 2 : 1;
+    }
+    return i < a.length ? 1 : j < b.length ? -1 : 0;
+}
+function field(n, s, input) {
+    const r = s.request && typeof s.request === "object" ? s.request : null;
+    switch (n.name) {
+        case "request.method":
+            return str(r?.method);
+        case "request.path":
+            return str(r?.path);
+        case "request.route":
+            return str(r?.route);
+        case "request.ip":
+            return str(r?.ip);
+        case "request.headers":
+            return own(r?.headers, n.key);
+        case "request.query":
+            return own(r?.query, n.key);
+        case "request.body":
+            return own(r?.body, n.key);
+        case "input.value":
+            return str(input?.value);
+        case "input.key":
+            return str(input?.key);
+        case "input.source":
+            return str(input?.source);
+        case "sink.name":
+            return str(s.sink);
+        case "attack.type":
+            return str(s.attack?.type);
+        case "attack.rule":
+            return str(s.attack?.rule);
+        case "app.name":
+            return str(s.app);
+        default:
+            return collectorField(n.name, s);
+    }
+}
+function collectorField(name, s) {
+    const c = s.collector && typeof s.collector === "object" ? s.collector : null;
+    if (!c)
+        return null;
+    switch (name) {
+        case "tool.name":
+            return str(c.tool?.name);
+        case "tool.command":
+            return str(c.tool?.command);
+        case "tool.path":
+            return str(c.tool?.path);
+        case "agent.name":
+            return str(c.agent?.name);
+        case "ai.provider":
+            return str(c.ai?.provider);
+        case "ai.model":
+            return str(c.ai?.model);
+        case "ai.tokens":
+            return str(c.ai?.tokens);
+        case "user.id":
+            return str(c.user?.id);
+        case "device.os":
+            return str(c.device?.os);
+        default:
+            return null;
+    }
+}
+function ev(n, s, input, budget) {
+    switch (n.k) {
+        case "str":
+        case "bool":
+            return n.v;
+        case "null":
+            return null;
+        case "field":
+            return field(n, s, input);
+        case "not":
+            return !ev(n.x, s, input, budget);
+        case "and":
+            for (const x of n.xs)
+                if (!ev(x, s, input, budget))
+                    return false;
+            return true;
+        case "or":
+            for (const x of n.xs)
+                if (ev(x, s, input, budget))
+                    return true;
+            return false;
+        case "cmp": {
+            const l = ev(n.l, s, input, budget);
+            const r = ev(n.r, s, input, budget);
+            if (n.op === "==")
+                return l === r;
+            if (n.op === "!=")
+                return l !== r;
+            if (typeof l !== "string" || typeof r !== "string")
+                return false;
+            const c = cmpCodePoints(l, r);
+            return n.op === "<" ? c < 0 : n.op === "<=" ? c <= 0 : n.op === ">" ? c > 0 : c >= 0;
+        }
+        case "in": {
+            const l = ev(n.l, s, input, budget);
+            return typeof l === "string" && n.items.includes(l);
+        }
+        case "str_method": {
+            const t = ev(n.t, s, input, budget);
+            if (typeof t !== "string")
+                return false;
+            return n.m === "startsWith" ? t.startsWith(n.arg) : n.m === "endsWith" ? t.endsWith(n.arg) : t.includes(n.arg);
+        }
+        case "lower": {
+            const t = ev(n.t, s, input, budget);
+            return typeof t === "string" ? asciiLower(t) : null;
+        }
+        case "matches": {
+            const t = ev(n.t, s, input, budget);
+            return typeof t === "string" && runRegex(n.prog, codePoints(t, exports.RULE_EXPR_LIMITS.matchCodePoints), budget);
+        }
+        case "cidr": {
+            const t = ev(n.t, s, input, budget);
+            return typeof t === "string" && inCidr(t, n.net);
+        }
+    }
+}
+/**
+ * Evaluates a compiled expression. An expression that reads `input.*` is
+ * evaluated once per input, in order, and matches when any input makes it
+ * true (with no inputs, once with the input fields null). Never throws: an
+ * evaluation that runs out of budget, or fails in any way, is no match.
+ */
+function evaluateRuleExpr(expr, subject, budget = { steps: exports.DEFAULT_RULE_BUDGET }) {
+    try {
+        if (!expr.usesInput)
+            return { matched: ev(expr.ast, subject, null, budget) === true };
+        const inputs = Array.isArray(subject.inputs) ? subject.inputs : [];
+        if (!inputs.length)
+            return { matched: ev(expr.ast, subject, null, budget) === true };
+        for (const input of inputs) {
+            if (input && typeof input === "object" && ev(expr.ast, subject, input, budget) === true)
+                return { matched: true, input };
+        }
+        return { matched: false };
+    }
+    catch (e) {
+        return { matched: false, exhausted: e instanceof BudgetExhausted };
+    }
+}
+const MAX_CP = 0x10ffff;
+const DIGIT = [0x30, 0x39];
+const WORD = [0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a];
+const SPACE = [0x09, 0x0d, 0x20, 0x20];
+const META = "\\.^$|?*+()[]{}";
+const ESCAPABLE = "\\.^$|?*+()[]{}/-";
+class RegexError extends Error {
+}
+function complement(r) {
+    const sorted = [];
+    for (let i = 0; i < r.length; i += 2)
+        sorted.push([r[i], r[i + 1]]);
+    sorted.sort((a, b) => a[0] - b[0]);
+    const out = [];
+    let next = 0;
+    for (const [lo, hi] of sorted) {
+        if (lo > next)
+            out.push(next, lo - 1);
+        next = Math.max(next, hi + 1);
+    }
+    if (next <= MAX_CP)
+        out.push(next, MAX_CP);
+    return out;
+}
+class RegexParser {
+    constructor(cp) {
+        this.cp = cp;
+        this.i = 0;
+    }
+    peek() {
+        return this.cp[this.i];
+    }
+    ch(c) {
+        return this.cp[this.i] === c.charCodeAt(0);
+    }
+    parse() {
+        const n = this.alt();
+        if (this.i < this.cp.length)
+            throw new RegexError();
+        return n;
+    }
+    alt() {
+        const xs = [this.cat()];
+        while (this.ch("|")) {
+            this.i++;
+            xs.push(this.cat());
+        }
+        return xs.length === 1 ? xs[0] : { t: "alt", xs };
+    }
+    cat() {
+        const xs = [];
+        while (this.i < this.cp.length && !this.ch("|") && !this.ch(")"))
+            xs.push(this.piece());
+        return xs.length === 1 ? xs[0] : { t: "cat", xs };
+    }
+    piece() {
+        const atom = this.atom();
+        const q = this.quant();
+        if (!q)
+            return atom;
+        if (atom.t === "bol" || atom.t === "eol")
+            throw new RegexError();
+        if (hasRep(atom))
+            throw new RegexError(); // nested quantifier
+        if (atomsOf(atom) === 0)
+            throw new RegexError(); // nothing to repeat
+        return { t: "rep", x: atom, min: q.min, max: q.max };
+    }
+    num() {
+        let s = "";
+        while (this.peek() !== undefined && this.peek() >= 0x30 && this.peek() <= 0x39) {
+            s += String.fromCharCode(this.peek());
+            this.i++;
+            if (s.length > 3)
+                throw new RegexError();
+        }
+        return s ? parseInt(s, 10) : null;
+    }
+    quant() {
+        let q = null;
+        if (this.ch("*"))
+            q = { min: 0, max: -1 };
+        else if (this.ch("+"))
+            q = { min: 1, max: -1 };
+        else if (this.ch("?"))
+            q = { min: 0, max: 1 };
+        if (q)
+            this.i++;
+        else if (this.ch("{")) {
+            this.i++;
+            const min = this.num();
+            if (min === null)
+                throw new RegexError();
+            let max = min;
+            if (this.ch(",")) {
+                this.i++;
+                const m = this.num();
+                max = m === null ? -1 : m;
+            }
+            if (!this.ch("}"))
+                throw new RegexError();
+            this.i++;
+            const L = exports.RULE_EXPR_LIMITS.regexRepeat;
+            if (min > L || max > L || (max !== -1 && max < min))
+                throw new RegexError();
+            q = { min, max };
+        }
+        else
+            return null;
+        if (this.ch("?"))
+            this.i++; // lazy: the same language, so the same answer
+        if (this.ch("*") || this.ch("+") || this.ch("?") || this.ch("{"))
+            throw new RegexError();
+        return q;
+    }
+    escape() {
+        this.i++; // the backslash
+        const c = this.peek();
+        if (c === undefined)
+            throw new RegexError();
+        this.i++;
+        // Only ASCII has meaning after a backslash; a code point above U+FFFF must never alias one.
+        const e = c < 0x80 ? String.fromCharCode(c) : "";
+        if (e === "d" || e === "D")
+            return { t: "class", r: DIGIT.slice(), neg: e === "D" };
+        if (e === "w" || e === "W")
+            return { t: "class", r: WORD.slice(), neg: e === "W" };
+        if (e === "s" || e === "S")
+            return { t: "class", r: SPACE.slice(), neg: e === "S" };
+        if (e === "n")
+            return { t: "char", c: 0x0a };
+        if (e === "r")
+            return { t: "char", c: 0x0d };
+        if (e === "t")
+            return { t: "char", c: 0x09 };
+        if (e === "f")
+            return { t: "char", c: 0x0c };
+        if (e === "v")
+            return { t: "char", c: 0x0b };
+        if (e === "x" || e === "u") {
+            const n = e === "x" ? 2 : 4;
+            const digits = this.cp.slice(this.i, this.i + n);
+            if (digits.length !== n || digits.some((d) => d >= 0x80))
+                throw new RegexError();
+            const h = String.fromCharCode(...digits);
+            if (!/^[0-9A-Fa-f]+$/.test(h))
+                throw new RegexError();
+            const code = parseInt(h, 16);
+            if (code >= 0xd800 && code <= 0xdfff)
+                throw new RegexError();
+            this.i += n;
+            return { t: "char", c: code };
+        }
+        if (e && ESCAPABLE.includes(e))
+            return { t: "char", c };
+        throw new RegexError();
+    }
+    atom() {
+        const c = this.peek();
+        // Operators are ASCII; any other code point (U+1002E included) is a literal.
+        const s = c < 0x80 ? String.fromCharCode(c) : "";
+        if (s === "(") {
+            this.i++;
+            if (this.ch("?")) {
+                this.i++;
+                if (!this.ch(":"))
+                    throw new RegexError(); // lookaround, named groups, flags
+                this.i++;
+            }
+            const inner = this.alt();
+            if (!this.ch(")"))
+                throw new RegexError();
+            this.i++;
+            return inner;
+        }
+        if (s === "[")
+            return this.cls();
+        if (s === ".") {
+            this.i++;
+            return { t: "any" };
+        }
+        if (s === "^") {
+            this.i++;
+            return { t: "bol" };
+        }
+        if (s === "$") {
+            this.i++;
+            return { t: "eol" };
+        }
+        if (s === "\\")
+            return this.escape();
+        if (s && META.includes(s))
+            throw new RegexError();
+        this.i++;
+        return { t: "char", c };
+    }
+    clsItem() {
+        const c = this.peek();
+        if (c === undefined)
+            throw new RegexError();
+        if (c === 0x5c)
+            return this.escape();
+        if (c === 0x5b)
+            throw new RegexError(); // unescaped [ inside a class
+        this.i++;
+        return { t: "char", c };
+    }
+    cls() {
+        this.i++; // [
+        let neg = false;
+        if (this.ch("^")) {
+            neg = true;
+            this.i++;
+        }
+        const r = [];
+        while (!this.ch("]")) {
+            if (this.i >= this.cp.length)
+                throw new RegexError();
+            const a = this.clsItem();
+            // `-` between two items is a range; at the start or right before `]` it is literal.
+            if (this.ch("-") && this.cp[this.i + 1] !== undefined && this.cp[this.i + 1] !== 0x5d) {
+                this.i++; // -
+                const b = this.clsItem();
+                if (a.t !== "char" || b.t !== "char" || a.c > b.c)
+                    throw new RegexError();
+                r.push(a.c, b.c);
+            }
+            else if (a.t === "char")
+                r.push(a.c, a.c);
+            else if (a.t === "class") {
+                const parts = a.neg ? complement(a.r) : a.r;
+                r.push(...parts);
+            }
+            else
+                throw new RegexError();
+        }
+        this.i++; // ]
+        if (!r.length)
+            throw new RegexError();
+        return { t: "class", r, neg };
+    }
+}
+function hasRep(n) {
+    if (n.t === "rep")
+        return true;
+    if (n.t === "cat" || n.t === "alt")
+        return n.xs.some(hasRep);
+    return false;
+}
+/** Atoms once counted repetitions are expanded (README "Regular expressions"). */
+function atomsOf(n) {
+    switch (n.t) {
+        case "char":
+        case "any":
+        case "class":
+            return 1;
+        case "bol":
+        case "eol":
+            return 0;
+        case "cat":
+        case "alt":
+            return n.xs.reduce((a, x) => a + atomsOf(x), 0);
+        case "rep": {
+            // The copies the program holds: min, then one loop (unbounded) or max - min optional ones.
+            return atomsOf(n.x) * (n.max === -1 ? n.min + 1 : n.max);
+        }
+    }
+}
+function emit(n, prog) {
+    switch (n.t) {
+        case "char":
+            prog.push({ op: "char", c: n.c });
+            return;
+        case "any":
+            prog.push({ op: "any" });
+            return;
+        case "class":
+            prog.push({ op: "class", r: n.r, neg: n.neg });
+            return;
+        case "bol":
+            prog.push({ op: "bol" });
+            return;
+        case "eol":
+            prog.push({ op: "eol" });
+            return;
+        case "cat":
+            n.xs.forEach((x) => emit(x, prog));
+            return;
+        case "alt": {
+            // split L1, next; L1: x0; jmp end; next: split ... ; last
+            const jumps = [];
+            for (let k = 0; k < n.xs.length; k++) {
+                if (k < n.xs.length - 1) {
+                    const split = { op: "split", x: prog.length + 1, y: -1 };
+                    prog.push(split);
+                    emit(n.xs[k], prog);
+                    const j = { op: "jmp", x: -1 };
+                    prog.push(j);
+                    jumps.push(j);
+                    split.y = prog.length;
+                }
+                else
+                    emit(n.xs[k], prog);
+            }
+            for (const j of jumps)
+                j.x = prog.length;
+            return;
+        }
+        case "rep": {
+            for (let k = 0; k < n.min; k++)
+                emit(n.x, prog);
+            if (n.max === -1) {
+                // L: split body, end; body; jmp L
+                const L = prog.length;
+                const split = { op: "split", x: L + 1, y: -1 };
+                prog.push(split);
+                emit(n.x, prog);
+                prog.push({ op: "jmp", x: L });
+                split.y = prog.length;
+            }
+            else {
+                for (let k = n.min; k < n.max; k++) {
+                    const split = { op: "split", x: prog.length + 1, y: -1 };
+                    prog.push(split);
+                    emit(n.x, prog);
+                    split.y = prog.length;
+                }
+            }
+            return;
+        }
+    }
+}
+/** Checks a pattern against the safe subset and compiles it; null when refused. */
+function compileRegex(pattern) {
+    try {
+        if (typeof pattern !== "string" || utf8Length(pattern) > exports.RULE_EXPR_LIMITS.regexBytes)
+            return null;
+        const ast = new RegexParser(codePoints(pattern, Infinity)).parse();
+        if (atomsOf(ast) > exports.RULE_EXPR_LIMITS.regexAtoms)
+            return null;
+        const prog = [];
+        emit(ast, prog);
+        prog.push({ op: "match" });
+        return prog;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether a pattern is in the safe subset. */
+function isSafeRegex(pattern) {
+    return compileRegex(pattern) !== null;
+}
+function classHas(r, c) {
+    for (let k = 0; k < r.length; k += 2)
+        if (c >= r[k] && c <= r[k + 1])
+            return true;
+    return false;
+}
+/**
+ * Pike VM: every thread advances in lock step, one code point at a time, so
+ * the work is at most (subject length + 1) x (program size). True when some
+ * substring of the subject (respecting `^` and `$`) is in the pattern's language.
+ */
+function runRegex(prog, subject, budget) {
+    const size = prog.length;
+    const mark = new Int32Array(size).fill(-1);
+    let gen = 0;
+    let clist = [];
+    let nlist = [];
+    const stack = [];
+    const len = subject.length;
+    const add = (list, pc0, pos) => {
+        stack.length = 0;
+        stack.push(pc0);
+        while (stack.length) {
+            const pc = stack.pop();
+            if (mark[pc] === gen)
+                continue;
+            mark[pc] = gen;
+            if (--budget.steps < 0)
+                throw new BudgetExhausted();
+            const inst = prog[pc];
+            switch (inst.op) {
+                case "jmp":
+                    stack.push(inst.x);
+                    break;
+                case "split":
+                    stack.push(inst.y, inst.x);
+                    break;
+                case "bol":
+                    if (pos === 0)
+                        stack.push(pc + 1);
+                    break;
+                case "eol":
+                    if (pos === len)
+                        stack.push(pc + 1);
+                    break;
+                case "match":
+                    return true;
+                default:
+                    list.push(pc);
+            }
+        }
+        return false;
+    };
+    for (let pos = 0;; pos++) {
+        // Threads already in clist were marked with this generation when added.
+        if (add(clist, 0, pos))
+            return true;
+        if (pos === len)
+            return false;
+        const c = subject[pos];
+        gen++;
+        nlist = [];
+        for (const pc of clist) {
+            const inst = prog[pc];
+            const ok = inst.op === "any" || (inst.op === "char" && inst.c === c) || (inst.op === "class" && classHas(inst.r, c) !== inst.neg);
+            if (ok && add(nlist, pc + 1, pos + 1))
+                return true;
+        }
+        clist = nlist;
+    }
+}
+// ---- CIDR -------------------------------------------------------------------
+const V4_PART = /^(0|[1-9][0-9]{0,2})$/;
+function parseV4(s) {
+    const parts = s.split(".");
+    if (parts.length !== 4)
+        return null;
+    const out = [];
+    for (const p of parts) {
+        if (!V4_PART.test(p))
+            return null;
+        const n = parseInt(p, 10);
+        if (n > 255)
+            return null;
+        out.push(n);
+    }
+    return out;
+}
+/** An IPv4 or IPv6 address as 16 bytes (IPv4 as `::ffff:a.b.c.d`); null when not an address. */
+function parseIpBytes(s) {
+    if (typeof s !== "string" || s.length > 64)
+        return null;
+    const v4 = parseV4(s);
+    if (v4)
+        return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, ...v4];
+    if (!s.includes(":"))
+        return null;
+    const halves = s.split("::");
+    if (halves.length > 2)
+        return null;
+    const groups = (h) => {
+        if (h === "")
+            return [];
+        const out = [];
+        const parts = h.split(":");
+        for (let k = 0; k < parts.length; k++) {
+            const p = parts[k];
+            if (k === parts.length - 1 && p.includes(".")) {
+                const t = parseV4(p);
+                if (!t)
+                    return null;
+                out.push((t[0] << 8) | t[1], (t[2] << 8) | t[3]);
+            }
+            else {
+                if (!/^[0-9A-Fa-f]{1,4}$/.test(p))
+                    return null;
+                out.push(parseInt(p, 16));
+            }
+        }
+        return out;
+    };
+    const head = groups(halves[0]);
+    const tail = halves.length === 2 ? groups(halves[1]) : [];
+    if (!head || !tail)
+        return null;
+    if (halves.length === 2 && halves[0] !== "" && halves[0].includes("."))
+        return null;
+    let words;
+    if (halves.length === 2) {
+        if (head.length + tail.length > 7)
+            return null;
+        words = [...head, ...new Array(8 - head.length - tail.length).fill(0), ...tail];
+    }
+    else {
+        if (head.length !== 8)
+            return null;
+        words = head;
+    }
+    const bytes = [];
+    for (const w of words)
+        bytes.push(w >> 8, w & 0xff);
+    return bytes;
+}
+/** `a.b.c.d/n`, `x:y::z/n`, or a bare address (all bits). Null when malformed. */
+function parseCidr(s) {
+    if (typeof s !== "string")
+        return null;
+    const slash = s.indexOf("/");
+    const addr = slash === -1 ? s : s.slice(0, slash);
+    if (addr.includes("%"))
+        return null;
+    const bytes = parseIpBytes(addr);
+    if (!bytes)
+        return null;
+    const v4 = parseV4(addr) !== null;
+    let prefix = 128;
+    if (slash !== -1) {
+        const p = s.slice(slash + 1);
+        if (!/^(0|[1-9][0-9]{0,2})$/.test(p))
+            return null;
+        const n = parseInt(p, 10);
+        if (n > (v4 ? 32 : 128))
+            return null;
+        prefix = v4 ? n + 96 : n;
+    }
+    return { bytes, prefix };
+}
+function inCidr(ip, net) {
+    const pct = ip.indexOf("%");
+    const bytes = parseIpBytes(pct === -1 ? ip : ip.slice(0, pct));
+    if (!bytes)
+        return false;
+    let bits = net.prefix;
+    for (let k = 0; k < 16 && bits > 0; k++, bits -= 8) {
+        const mask = bits >= 8 ? 0xff : (0xff << (8 - bits)) & 0xff;
+        if ((bytes[k] & mask) !== (net.bytes[k] & mask))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=rule-expr.js.map