@sdxc/flags-engine 0.0.0-pre.1

package/dist/definition.d.ts

@@ -0,0 +1,114 @@
+/**
+ * What a flag is written down as: the values it can take, the ordered rules
+ * that choose between them, and the conditions those rules match on. Types
+ * only, so an admin UI and the engine describe a definition the same way.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { FlagMetadata, FlagValue } from "@sdxc/flags";
+import type { JSONPrimitive } from "@sdxc/types";
+/**
+ * How `semver` compares a version field against its value. `~` holds for a
+ * matching major and minor, `^` for a matching major; the other six read as
+ * they do in arithmetic.
+ */
+export type SemVerComparison = "=" | "!=" | "<" | "<=" | ">" | ">=" | "~" | "^";
+/**
+ * Whether a flag evaluates at all. A disabled flag serves the caller's own
+ * default value, which is how a flag is switched off without the rules that
+ * describe its rollout being deleted.
+ */
+export type FlagState = "enabled" | "disabled";
+/**
+ * One test against the evaluation context. `field` is a dotted path, so
+ * `plan.tier` reads a nested structure; a path that resolves to nothing makes
+ * every operator except `exists` false, and each operator compares within one
+ * type rather than coercing across them.
+ */
+export type Condition = {
+    op: "all";
+    of: Condition[];
+} | {
+    op: "any";
+    of: Condition[];
+} | {
+    op: "not";
+    of: Condition;
+} | {
+    op: "eq" | "ne";
+    field: string;
+    value: JSONPrimitive;
+} | {
+    op: "in" | "notIn";
+    field: string;
+    values: JSONPrimitive[];
+} | {
+    op: "lt" | "lte" | "gt" | "gte";
+    field: string;
+    value: number;
+} | {
+    op: "startsWith" | "endsWith" | "contains";
+    field: string;
+    value: string;
+} | {
+    op: "matches";
+    field: string;
+    pattern: string;
+} | {
+    op: "semver";
+    field: string;
+    compare: SemVerComparison;
+    value: string;
+} | {
+    op: "exists";
+    field: string;
+} | {
+    op: "segment";
+    name: string;
+} | {
+    op: "always";
+};
+/** How a rule spreads one condition's subjects across several variants. */
+export interface Split {
+    /**
+     * Whole, non-negative weights by variant name, taken against their own sum,
+     * so `{ on: 1, off: 1 }` is a half-and-half split and one arm widens without
+     * the others being rebalanced.
+     */
+    weights: Record<string, number>;
+    /** The context field the subject is read from. @default "targetingKey" */
+    by?: string;
+    /** Mixed into the hash instead of the flag key, so two flags share a bucketing. */
+    seed?: string;
+}
+/** One row of a flag's targeting: who it is about, and what they are served. */
+export interface TargetingRule {
+    when: Condition;
+    /** The variant this rule names, or the weights it buckets its subjects among. */
+    serve: string | Split;
+}
+/** A flag as an author writes it, and as a store hands it back. */
+export interface FlagDefinition {
+    /** Every value this flag can take, by variant name. */
+    variants: Record<string, FlagValue>;
+    /** The variant served when no rule matches; absent means the caller's own default. */
+    defaultVariant?: string;
+    /** @default "enabled" */
+    state?: FlagState;
+    /** Tried in order; the first rule whose condition holds decides the variant. */
+    targeting?: TargetingRule[];
+    /** Travels onto every resolution of this flag, for whatever reads the wide event. */
+    metadata?: FlagMetadata;
+}
+/**
+ * Conditions declared once and referenced by name, so "is an internal user" is
+ * written in one place and read by twenty flags. A segment may reference
+ * another segment.
+ */
+export type SegmentSet = Record<string, Condition>;
+/** A whole definition set: the flags to evaluate, and the segments they share. */
+export interface FlagSet {
+    flags: Record<string, FlagDefinition>;
+    segments?: SegmentSet;
+}

package/dist/definition.js

@@ -0,0 +1,8 @@
+/**
+ * What a flag is written down as: the values it can take, the ordered rules
+ * that choose between them, and the conditions those rules match on. Types
+ * only, so an admin UI and the engine describe a definition the same way.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */

package/dist/engine.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The half of evaluation that holds state: an object that reads a store, parses
+ * the set once, and resolves every later flag against the snapshot it kept. It
+ * is what a worker holds for the life of an isolate.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { DurationInput } from "@sdxc/duration";
+import type { EvaluationContext, FlagValue, MaybePromise, ResolutionDetails } from "@sdxc/flags";
+import type { Result } from "@sdxc/result";
+import type { FlagParseFailure, FlagSnapshot } from "./snapshot.js";
+import type { FlagStore, FlagStoreError } from "./store/index.js";
+/** What an engine is built from. */
+export interface EngineOptions {
+    /** Where definitions are read from, and the whole of what the engine knows about storage. */
+    store: FlagStore;
+    /**
+     * How long a loaded snapshot counts as current, which is what `stale` is
+     * measured against. Omitted, a snapshot stays current until a caller loads
+     * another one.
+     */
+    maxAge?: DurationInput;
+}
+/**
+ * Holds one definition set and resolves flags against it. A caller decides when
+ * the definitions are read again — on a request, inside `waitUntil`, or from a
+ * cron trigger — and `stale` is what that decision is made on.
+ */
+export interface Engine {
+    /** The set being evaluated against, present once a load has succeeded. */
+    readonly snapshot: FlagSnapshot | undefined;
+    /**
+     * The definitions the held set carried and the engine refused, so a caller
+     * logs them once after a load instead of once per evaluation of the key.
+     */
+    readonly failures: readonly FlagParseFailure[];
+    /**
+     * Whether what the engine holds has aged past `maxAge`. It reads `true` until
+     * a load has succeeded, so a fresh engine reads as one that wants a load.
+     */
+    readonly stale: boolean;
+    /**
+     * Reads the store and parses the set once, keeping the snapshot for every
+     * evaluation that follows. A store that reads synchronously loads
+     * synchronously, and the answer is `await`-able either way.
+     *
+     * @returns The snapshot now held, or the reason the store could not hand its
+     * set over — a configuration failure a caller reports.
+     */
+    load(): MaybePromise<Result<FlagSnapshot, FlagStoreError>>;
+    /**
+     * Resolves one flag against the held snapshot, answering with the caller's own
+     * default and `PROVIDER_NOT_READY` until a load has succeeded.
+     *
+     * @param key The flag to resolve.
+     * @param defaultValue What the caller uses when nothing resolves, and the type
+     * every variant is checked against.
+     * @param context The merged context targeting reads.
+     */
+    evaluate<T extends FlagValue>(key: string, defaultValue: T, context?: EvaluationContext): ResolutionDetails<T>;
+    /**
+     * Resolves every flag the held snapshot carries, for a caller with no per-flag
+     * default to fall back on. An engine before its first load answers with an
+     * empty record, which is every flag it knows of.
+     *
+     * @param context The merged context targeting reads.
+     */
+    evaluateAll(context?: EvaluationContext): Record<string, ResolutionDetails<FlagValue>>;
+}
+/**
+ * Builds an engine over a store, holding no definitions until `load` succeeds.
+ *
+ * @param options The store to read from, and how long a snapshot counts as current.
+ * @returns An engine a caller loads, evaluates through, and reloads on its own schedule.
+ *
+ * @example
+ * let engine = createEngine({ store: new InMemoryFlagStore(set), maxAge: "5 minutes" });
+ */
+export declare function createEngine({ store, maxAge }: EngineOptions): Engine;

package/dist/engine.js

@@ -0,0 +1,76 @@
+/**
+ * The half of evaluation that holds state: an object that reads a store, parses
+ * the set once, and resolves every later flag against the snapshot it kept. It
+ * is what a worker holds for the life of an isolate.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { toMs } from "@sdxc/duration";
+import { isFailure, success } from "@sdxc/result";
+import { evaluate as resolve, evaluateAll as resolveAll } from "./evaluate.js";
+import { parseFlagSet } from "./parse.js";
+/**
+ * Builds an engine over a store, holding no definitions until `load` succeeds.
+ *
+ * @param options The store to read from, and how long a snapshot counts as current.
+ * @returns An engine a caller loads, evaluates through, and reloads on its own schedule.
+ *
+ * @example
+ * let engine = createEngine({ store: new InMemoryFlagStore(set), maxAge: "5 minutes" });
+ */
+export function createEngine({ store, maxAge }) {
+    let held;
+    let lifetime = maxAge === undefined ? Number.POSITIVE_INFINITY : toMs(maxAge);
+    /**
+     * Parses what a successful read handed over and keeps it, which is what makes
+     * parsing a cost per load while evaluation walks a structure already known to
+     * be well formed.
+     */
+    function keep(read) {
+        if (isFailure(read))
+            return read;
+        held = parseFlagSet(read.data);
+        return success(held);
+    }
+    return {
+        get snapshot() {
+            return held;
+        },
+        get failures() {
+            return held === undefined ? [] : [...held.failures.values()];
+        },
+        get stale() {
+            return held === undefined || Date.now() - held.createdAt >= lifetime;
+        },
+        load() {
+            let read = store.read();
+            if (read instanceof Promise)
+                return read.then(keep);
+            return keep(read);
+        },
+        evaluate(key, defaultValue, context) {
+            if (held === undefined)
+                return notReady(defaultValue);
+            return resolve(held, key, defaultValue, context);
+        },
+        evaluateAll(context) {
+            if (held === undefined)
+                return {};
+            return resolveAll(held, context);
+        },
+    };
+}
+/**
+ * What an evaluation gets while the engine holds no snapshot: the caller's own
+ * default, under the code the specification reserves for a resolution asked for
+ * before the flags arrived.
+ */
+function notReady(defaultValue) {
+    return {
+        value: defaultValue,
+        reason: "ERROR",
+        errorCode: "PROVIDER_NOT_READY",
+        errorMessage: "The engine holds no definitions until a load succeeds",
+    };
+}

package/dist/evaluate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The whole of what evaluation is: a snapshot and a context in, a resolution
+ * out. Pure and synchronous, so the same function answers a provider, an HTTP
+ * endpoint and an admin preview, and it reports every outcome rather than
+ * throwing one.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { EvaluationContext, FlagValue, ResolutionDetails } from "@sdxc/flags";
+import type { FlagSnapshot } from "./snapshot.js";
+/**
+ * Resolves one flag for one context, answering with the caller's own default
+ * whenever the definition serves no value of the requested type — a flag that
+ * is off, absent, broken or holding another type included.
+ *
+ * @param snapshot The parsed definition set to resolve against.
+ * @param key The flag to resolve.
+ * @param defaultValue What the caller uses when nothing resolves, and the type
+ * every variant is checked against.
+ * @param context The merged context targeting reads; an absent one targets on nothing.
+ * @example evaluate(snapshot, "new-checkout", false, { targetingKey: "user-1" })
+ */
+export declare function evaluate<T extends FlagValue>(snapshot: FlagSnapshot, key: string, defaultValue: T, context?: EvaluationContext): ResolutionDetails<T>;
+/**
+ * Resolves every flag the snapshot carries, the ones that failed to parse
+ * included, for a caller with no per-flag default to fall back on. A flag that
+ * produces no value of its own reports `null` beside the reason, which is the
+ * one value in `FlagValue` that stands for "use the default you already have".
+ *
+ * @param snapshot The parsed definition set to resolve against.
+ * @param context The merged context targeting reads; an absent one targets on nothing.
+ * @example evaluateAll(snapshot, { targetingKey: "user-1" })["new-checkout"]
+ */
+export declare function evaluateAll(snapshot: FlagSnapshot, context?: EvaluationContext): Record<string, ResolutionDetails<FlagValue>>;

package/dist/evaluate.js

@@ -0,0 +1,153 @@
+/**
+ * The whole of what evaluation is: a snapshot and a context in, a resolution
+ * out. Pure and synchronous, so the same function answers a provider, an HTTP
+ * endpoint and an admin preview, and it reports every outcome rather than
+ * throwing one.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { isFailure } from "@sdxc/result";
+import { matchesCondition } from "./lib/condition.js";
+import { selectVariant } from "./lib/split.js";
+/**
+ * Resolves one flag for one context, answering with the caller's own default
+ * whenever the definition serves no value of the requested type — a flag that
+ * is off, absent, broken or holding another type included.
+ *
+ * @param snapshot The parsed definition set to resolve against.
+ * @param key The flag to resolve.
+ * @param defaultValue What the caller uses when nothing resolves, and the type
+ * every variant is checked against.
+ * @param context The merged context targeting reads; an absent one targets on nothing.
+ * @example evaluate(snapshot, "new-checkout", false, { targetingKey: "user-1" })
+ */
+export function evaluate(snapshot, key, defaultValue, context = {}) {
+    let selection = select(snapshot, key, context);
+    if (selection.variant === undefined)
+        return detailsOf(defaultValue, selection);
+    if (!sameType(selection.value, defaultValue)) {
+        let held = typeName(selection.value);
+        return detailsOf(defaultValue, {
+            reason: "ERROR",
+            errorCode: "TYPE_MISMATCH",
+            errorMessage: `The variant "${selection.variant}" of "${key}" holds a ${held}`,
+            metadata: selection.metadata,
+        });
+    }
+    return detailsOf(selection.value, selection);
+}
+/**
+ * Resolves every flag the snapshot carries, the ones that failed to parse
+ * included, for a caller with no per-flag default to fall back on. A flag that
+ * produces no value of its own reports `null` beside the reason, which is the
+ * one value in `FlagValue` that stands for "use the default you already have".
+ *
+ * @param snapshot The parsed definition set to resolve against.
+ * @param context The merged context targeting reads; an absent one targets on nothing.
+ * @example evaluateAll(snapshot, { targetingKey: "user-1" })["new-checkout"]
+ */
+export function evaluateAll(snapshot, context = {}) {
+    let all = {};
+    for (let key of [...snapshot.flags.keys(), ...snapshot.failures.keys()]) {
+        let selection = select(snapshot, key, context);
+        all[key] = detailsOf(selection.value ?? null, selection);
+    }
+    return all;
+}
+/**
+ * Finds the flag and runs its rules, reporting the two things that can be wrong
+ * with a key before any rule runs: nothing is stored under it, or what is
+ * stored under it was refused when the set was parsed.
+ */
+function select(snapshot, key, context) {
+    let failure = snapshot.failures.get(key);
+    if (failure !== undefined) {
+        return { reason: "ERROR", errorCode: "PARSE_ERROR", errorMessage: failure.message };
+    }
+    let flag = snapshot.flags.get(key);
+    if (flag === undefined) {
+        return { reason: "ERROR", errorCode: "FLAG_NOT_FOUND", errorMessage: `No flag named "${key}"` };
+    }
+    return { ...served(flag, context), metadata: flag.metadata };
+}
+/**
+ * Runs the flag's rules in the order they were written, so the first rule whose
+ * condition holds decides. A flag with no rules at all serves its default
+ * variant statically, which is the distinction `STATIC` carries over `DEFAULT`.
+ */
+function served(flag, context) {
+    if (flag.state === "disabled")
+        return { reason: "DISABLED" };
+    if (flag.targeting.length === 0)
+        return fallback(flag, "STATIC");
+    for (let rule of flag.targeting) {
+        if (matchesCondition(rule.when, context))
+            return matched(flag, rule.serve, context);
+    }
+    return fallback(flag, "DEFAULT");
+}
+/**
+ * Serves what the matching rule names: one variant, or the arm the subject
+ * buckets into. A split whose subject is nowhere in the context reports that
+ * rather than serving an arm, so a rollout that never happened reads as one.
+ */
+function matched(flag, serve, context) {
+    if (typeof serve === "string") {
+        return { reason: "TARGETING_MATCH", variant: serve, value: flag.variants.get(serve) };
+    }
+    let bucketed = selectVariant(serve, flag.key, context);
+    if (isFailure(bucketed)) {
+        return {
+            reason: "ERROR",
+            errorCode: "TARGETING_KEY_MISSING",
+            errorMessage: bucketed.error.message,
+        };
+    }
+    return { reason: "SPLIT", variant: bucketed.data, value: flag.variants.get(bucketed.data) };
+}
+/**
+ * Serves the variant a flag falls back to under the reason that describes how
+ * it got there. A flag declaring no `defaultVariant` exists to target a few
+ * subjects, so everyone else is served the default their call site passed.
+ */
+function fallback(flag, reason) {
+    if (flag.defaultVariant === undefined)
+        return { reason: "DEFAULT" };
+    return {
+        reason,
+        variant: flag.defaultVariant,
+        value: flag.variants.get(flag.defaultVariant),
+    };
+}
+/**
+ * Holds when the variant's value is one the caller could have passed as its own
+ * default. A structure is checked no further than being one, because what its
+ * fields hold is the caller's schema to decide.
+ */
+function sameType(value, expected) {
+    if (expected === null || typeof expected === "object")
+        return typeof value === "object";
+    return typeof value === typeof expected;
+}
+/** Names the type a variant turned out to hold, for the message a mismatch carries. */
+function typeName(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+/** Assembles the structure a caller reads, carrying only the fields this selection filled. */
+function detailsOf(value, selection) {
+    let details = { value, reason: selection.reason };
+    if (selection.variant !== undefined)
+        details.variant = selection.variant;
+    if (selection.errorCode !== undefined)
+        details.errorCode = selection.errorCode;
+    if (selection.errorMessage !== undefined)
+        details.errorMessage = selection.errorMessage;
+    if (selection.metadata !== undefined)
+        details.flagMetadata = selection.metadata;
+    return details;
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What a flag is written down as, the schema a definition is validated against,
+ * and the two ways to resolve one: the pure functions over a snapshot, and the
+ * engine that goes and gets the snapshot for them.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+export type { Condition, FlagDefinition, FlagSet, FlagState, SegmentSet, SemVerComparison, Split, TargetingRule, } from "./definition.js";
+export type { Engine, EngineOptions } from "./engine.js";
+export type { CompiledCondition, CompiledFlag, CompiledRule, CompiledSegments, FlagParseFailure, FlagSnapshot, } from "./snapshot.js";
+export { createEngine } from "./engine.js";
+export { evaluate, evaluateAll } from "./evaluate.js";
+export { parseFlagSet } from "./parse.js";
+export { CONDITION_SCHEMA, FLAG_DEFINITION_SCHEMA, SEGMENT_SET_SCHEMA, SPLIT_SCHEMA, TARGETING_RULE_SCHEMA, } from "./schema.js";

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * What a flag is written down as, the schema a definition is validated against,
+ * and the two ways to resolve one: the pure functions over a snapshot, and the
+ * engine that goes and gets the snapshot for them.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+export { createEngine } from "./engine.js";
+export { evaluate, evaluateAll } from "./evaluate.js";
+export { parseFlagSet } from "./parse.js";
+export { CONDITION_SCHEMA, FLAG_DEFINITION_SCHEMA, SEGMENT_SET_SCHEMA, SPLIT_SCHEMA, TARGETING_RULE_SCHEMA, } from "./schema.js";

package/dist/lib/condition.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether one compiled condition holds for an evaluation context: the operator
+ * table a targeting rule is written in, applied one operator at a time over the
+ * dotted path each of them names.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import type { EvaluationContext } from "@sdxc/flags";
+import type { CompiledCondition } from "../snapshot.js";
+/**
+ * Answers whether the subject this context describes is one the condition is
+ * about. Composition is the whole of what `all`, `any`, `not` and `segment`
+ * add, so every other operator sees one field and one value.
+ *
+ * @param condition The condition as the snapshot compiled it.
+ * @param context The merged context an evaluation was given.
+ * @example matchesCondition({ op: "eq", field: "country", value: "AR" }, { country: "AR" })
+ */
+export declare function matchesCondition(condition: CompiledCondition, context: EvaluationContext): boolean;

package/dist/lib/condition.js

@@ -0,0 +1,76 @@
+/**
+ * Whether one compiled condition holds for an evaluation context: the operator
+ * table a targeting rule is written in, applied one operator at a time over the
+ * dotted path each of them names.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+import { satisfies } from "@sdxc/semver";
+import { read } from "./path.js";
+/**
+ * Answers whether the subject this context describes is one the condition is
+ * about. Composition is the whole of what `all`, `any`, `not` and `segment`
+ * add, so every other operator sees one field and one value.
+ *
+ * @param condition The condition as the snapshot compiled it.
+ * @param context The merged context an evaluation was given.
+ * @example matchesCondition({ op: "eq", field: "country", value: "AR" }, { country: "AR" })
+ */
+export function matchesCondition(condition, context) {
+    switch (condition.op) {
+        case "all":
+            return condition.of.every((member) => matchesCondition(member, context));
+        case "any":
+            return condition.of.some((member) => matchesCondition(member, context));
+        case "not":
+            return !matchesCondition(condition.of, context);
+        case "segment":
+            return matchesCondition(condition.of, context);
+        case "always":
+            return true;
+        default:
+            return matchesField(condition, context);
+    }
+}
+/**
+ * Compares one field against the value a rule was written with. A path that
+ * resolves to nothing holds for no comparison, which is what keeps a rule about
+ * a field the caller did not send from matching everyone; `exists` asks about
+ * the path itself, so it answers first.
+ */
+function matchesField(condition, context) {
+    let value = read(context, condition.field);
+    if (condition.op === "exists")
+        return value !== undefined;
+    if (value === undefined)
+        return false;
+    switch (condition.op) {
+        case "eq":
+            return value === condition.value;
+        case "ne":
+            return value !== condition.value;
+        case "in":
+            return condition.values.some((member) => member === value);
+        case "notIn":
+            return condition.values.every((member) => member !== value);
+        case "lt":
+            return typeof value === "number" && value < condition.value;
+        case "lte":
+            return typeof value === "number" && value <= condition.value;
+        case "gt":
+            return typeof value === "number" && value > condition.value;
+        case "gte":
+            return typeof value === "number" && value >= condition.value;
+        case "startsWith":
+            return typeof value === "string" && value.startsWith(condition.value);
+        case "endsWith":
+            return typeof value === "string" && value.endsWith(condition.value);
+        case "contains":
+            return typeof value === "string" && value.includes(condition.value);
+        case "matches":
+            return typeof value === "string" && condition.pattern.test(value);
+        case "semver":
+            return typeof value === "string" && satisfies(value, condition.compare, condition.value);
+    }
+}

package/dist/lib/hash.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MurmurHash3 x86 32-bit at seed 0, the hash a percentage split buckets a
+ * subject with. The reference engine hashes the same way, so a rollout
+ * percentage written here selects the same subjects it selects there.
+ *
+ * @author [Sergio Xalambrí](https://sergiodxa.com)
+ * @copyright Sergio Xalambrí 2026
+ */
+/**
+ * Hashes a subject string to an unsigned 32-bit integer, spread evenly enough
+ * that a ten percent bucket holds ten percent of subjects. The string is hashed
+ * as its UTF-8 bytes, so a subject outside ASCII lands where the reference puts it.
+ *
+ * @param input The subject string, already assembled from seed and context field.
+ * @returns A value in `[0, 2^32)`.
+ * @example murmurHash3("welcome-banneruser-42") // 2364819184
+ */
+export declare function murmurHash3(input: string): number;