har-o-scope 0.1.0

package/dist/lib/analyze.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Top-level analyze pipeline: parse -> normalize -> rules -> classify -> score.
+ * This is the main entry point for library consumers.
+ */
+import type { Har } from 'har-format';
+import type { AnalysisResult, AnalysisOptions } from './types.js';
+import type { IssueRulesFile, SharedConditionsFile, FiltersFile } from './schema.js';
+export declare function setBuiltinRules(rules: IssueRulesFile, conditions?: SharedConditionsFile, filters?: FiltersFile): void;
+export declare function analyze(input: string | Har, options?: AnalysisOptions): AnalysisResult;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/lib/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/lib/analyze.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AACrC,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EAIhB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAapF,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,UAAU,CAAC,EAAE,oBAAoB,EACjC,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI,CAIN;AAmBD,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,CA+EtF"}

package/dist/lib/analyze.js

@@ -0,0 +1,83 @@
+import { parseHar, normalizeHar } from './normalizer.js';
+import { evaluateRules } from './rule-engine.js';
+import { classifyRootCause } from './classifier.js';
+import { detectUnbatchedApis } from './unbatched-detect.js';
+import { createWarning } from './errors.js';
+// ── Built-in rules (loaded lazily) ──────────────────────────────
+let builtinRules = null;
+let builtinConditions = null;
+let builtinFilters = null;
+export function setBuiltinRules(rules, conditions, filters) {
+    builtinRules = rules;
+    builtinConditions = conditions ?? null;
+    builtinFilters = filters ?? null;
+}
+// ── Severity filter ─────────────────────────────────────────────
+const SEVERITY_ORDER = { info: 0, warning: 1, critical: 2 };
+function filterBySeverity(findings, minSeverity) {
+    if (!minSeverity || minSeverity === 'info')
+        return findings;
+    const minOrder = SEVERITY_ORDER[minSeverity] ?? 0;
+    return findings.filter((f) => (SEVERITY_ORDER[f.severity] ?? 0) >= minOrder);
+}
+// ── Main analyze function ───────────────────────────────────────
+export function analyze(input, options) {
+    const startTime = performance.now();
+    const warnings = [];
+    // Parse if string input
+    const har = typeof input === 'string' ? parseHar(input) : input;
+    // Normalize
+    const { entries, warnings: normalizeWarnings } = normalizeHar(har);
+    warnings.push(...normalizeWarnings);
+    // Evaluate rules
+    let findings = [];
+    if (!options?.noBuiltin && builtinRules) {
+        const builtinFindings = evaluateRules(builtinRules, entries, builtinConditions ?? undefined, builtinFilters ?? undefined);
+        findings.push(...builtinFindings);
+    }
+    // Custom rules
+    if (options?.customRulesData) {
+        for (const data of options.customRulesData) {
+            try {
+                const customFile = data;
+                if (customFile?.rules) {
+                    const customFindings = evaluateRules(customFile, entries);
+                    findings.push(...customFindings);
+                }
+            }
+            catch (e) {
+                warnings.push(createWarning('RULE001', `Failed to evaluate custom rules: ${e instanceof Error ? e.message : 'unknown error'}`, 'Check that custom rules follow the YAML rule schema.'));
+            }
+        }
+    }
+    // TypeScript-only rules
+    const unbatchedFinding = detectUnbatchedApis(entries);
+    if (unbatchedFinding)
+        findings.push(unbatchedFinding);
+    // Severity filter
+    findings = filterBySeverity(findings, options?.minSeverity);
+    // Classify root cause
+    const rootCause = classifyRootCause(findings, entries, builtinRules ?? undefined);
+    const analysisTimeMs = Math.round(performance.now() - startTime);
+    // Compute total wall-clock time
+    let totalTimeMs = 0;
+    if (entries.length > 0) {
+        const maxEnd = Math.max(...entries.map((e) => e.startTimeMs + e.totalDuration));
+        const minStart = Math.min(...entries.map((e) => e.startTimeMs));
+        totalTimeMs = Math.round(maxEnd - minStart);
+    }
+    return {
+        entries,
+        findings,
+        rootCause,
+        warnings,
+        metadata: {
+            rulesEvaluated: Object.keys(builtinRules?.rules ?? {}).length +
+                (options?.customRulesData?.length ?? 0) + 1, // +1 for unbatched detect
+            customRulesLoaded: options?.customRulesData?.length ?? 0,
+            analysisTimeMs,
+            totalRequests: entries.length,
+            totalTimeMs,
+        },
+    };
+}

package/dist/lib/classifier.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Root cause classifier: weighted scoring across findings.
+ * Produces client/network/server scores from rule-defined weights.
+ */
+import type { Finding, RootCauseResult, NormalizedEntry } from './types.js';
+import type { IssueRulesFile } from './schema.js';
+export declare function classifyRootCause(findings: Finding[], entries: NormalizedEntry[], rulesFile?: IssueRulesFile, customWeights?: Map<string, Record<string, number>>): RootCauseResult;
+//# sourceMappingURL=classifier.d.ts.map

package/dist/lib/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../../src/lib/classifier.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AASjD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,eAAe,EAAE,EAC1B,SAAS,CAAC,EAAE,cAAc,EAC1B,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAClD,eAAe,CAqDjB"}

package/dist/lib/classifier.js

@@ -0,0 +1,74 @@
+import { getRootCauseWeights } from './rule-engine.js';
+const SEVERITY_MULTIPLIER = {
+    critical: 3,
+    warning: 2,
+    info: 1,
+};
+export function classifyRootCause(findings, entries, rulesFile, customWeights) {
+    const scores = { client: 0, network: 0, server: 0 };
+    // Merge weights from rules file + custom weights
+    const weights = new Map();
+    if (rulesFile) {
+        for (const [id, w] of getRootCauseWeights(rulesFile)) {
+            weights.set(id, w);
+        }
+    }
+    if (customWeights) {
+        for (const [id, w] of customWeights) {
+            weights.set(id, w);
+        }
+    }
+    for (const finding of findings) {
+        // Skip WebSocket-only findings from root cause scoring
+        if (finding.affectedEntries.length > 0) {
+            const allWebSocket = finding.affectedEntries.every((idx) => entries[idx]?.isWebSocket);
+            if (allWebSocket)
+                continue;
+        }
+        const ruleWeights = weights.get(finding.ruleId);
+        const severityMult = SEVERITY_MULTIPLIER[finding.severity] ?? 1;
+        const countFactor = Math.min(finding.affectedEntries.length, 20) / 20 + 0.5;
+        if (ruleWeights) {
+            scores.client += (ruleWeights.client ?? 0) * severityMult * countFactor;
+            scores.network += (ruleWeights.network ?? 0) * severityMult * countFactor;
+            scores.server += (ruleWeights.server ?? 0) * severityMult * countFactor;
+        }
+        else {
+            // Default weights based on category
+            const defaultWeights = getDefaultWeights(finding.category);
+            scores.client += defaultWeights.client * severityMult * countFactor;
+            scores.network += defaultWeights.network * severityMult * countFactor;
+            scores.server += defaultWeights.server * severityMult * countFactor;
+        }
+    }
+    // Normalize to 0-1 range
+    const total = scores.client + scores.network + scores.server;
+    if (total === 0) {
+        return { client: 0, network: 0, server: 0 };
+    }
+    return {
+        client: Math.round((scores.client / total) * 100) / 100,
+        network: Math.round((scores.network / total) * 100) / 100,
+        server: Math.round((scores.server / total) * 100) / 100,
+    };
+}
+function getDefaultWeights(category) {
+    switch (category) {
+        case 'server':
+            return { client: 0, network: 0, server: 2 };
+        case 'network':
+            return { client: 0, network: 2, server: 0 };
+        case 'client':
+            return { client: 2, network: 0, server: 0 };
+        case 'errors':
+            return { client: 0, network: 1, server: 2 };
+        case 'optimization':
+            return { client: 1, network: 0, server: 1 };
+        case 'security':
+            return { client: 0, network: 1, server: 1 };
+        case 'performance':
+            return { client: 1, network: 1, server: 1 };
+        default:
+            return { client: 1, network: 1, server: 1 };
+    }
+}

package/dist/lib/diff.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Diff engine: compare two HAR analyses.
+ *
+ * URL-based grouping: strip query params, normalize numeric/UUID path segments.
+ * Statistical comparison of timing groups + finding diffing.
+ */
+import type { AnalysisResult, DiffResult } from './types.js';
+/**
+ * Normalize a URL for grouping. Strip query params and fragments.
+ * Replace purely numeric path segments and UUIDs with '*'.
+ * Mixed alphanumeric segments (e.g., /v2/, /page3/) are preserved.
+ */
+export declare function normalizeUrlForGrouping(url: string): string;
+export declare function diff(before: AnalysisResult, after: AnalysisResult): DiffResult;
+//# sourceMappingURL=diff.d.ts.map

package/dist/lib/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/lib/diff.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EAKX,MAAM,YAAY,CAAA;AAQnB;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAwB3D;AAgED,wBAAgB,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG,UAAU,CA4D9E"}

package/dist/lib/diff.js

@@ -0,0 +1,130 @@
+import { computeHealthScore } from './health-score.js';
+// ── URL normalization ───────────────────────────────────────────
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const PURE_NUMERIC = /^\d+$/;
+/**
+ * Normalize a URL for grouping. Strip query params and fragments.
+ * Replace purely numeric path segments and UUIDs with '*'.
+ * Mixed alphanumeric segments (e.g., /v2/, /page3/) are preserved.
+ */
+export function normalizeUrlForGrouping(url) {
+    let pathname;
+    let origin;
+    try {
+        const parsed = new URL(url);
+        pathname = parsed.pathname;
+        origin = parsed.origin;
+    }
+    catch {
+        // Fallback for malformed URLs
+        const protoEnd = url.indexOf('//') + 2;
+        const pathStart = url.indexOf('/', protoEnd);
+        const queryStart = url.indexOf('?');
+        if (pathStart === -1)
+            return url;
+        origin = url.slice(0, pathStart);
+        pathname = queryStart === -1 ? url.slice(pathStart) : url.slice(pathStart, queryStart);
+    }
+    const segments = pathname.split('/').map((seg) => {
+        if (PURE_NUMERIC.test(seg))
+            return '*';
+        if (UUID_PATTERN.test(seg))
+            return '*';
+        return seg;
+    });
+    return origin + segments.join('/');
+}
+function groupByUrl(entries) {
+    const groups = new Map();
+    for (const entry of entries) {
+        const pattern = normalizeUrlForGrouping(entry.entry.request?.url ?? '');
+        const existing = groups.get(pattern);
+        if (existing) {
+            existing.entries.push(entry);
+        }
+        else {
+            groups.set(pattern, { pattern, entries: [entry] });
+        }
+    }
+    return groups;
+}
+function avgDuration(entries) {
+    if (entries.length === 0)
+        return 0;
+    const sum = entries.reduce((acc, e) => acc + e.totalDuration, 0);
+    return Math.round(sum / entries.length);
+}
+// ── Finding diff ────────────────────────────────────────────────
+function diffFindings(before, after) {
+    const beforeIds = new Set(before.map((f) => f.ruleId));
+    const afterIds = new Set(after.map((f) => f.ruleId));
+    const beforeMap = new Map(before.map((f) => [f.ruleId, f]));
+    const afterMap = new Map(after.map((f) => [f.ruleId, f]));
+    const newFindings = after.filter((f) => !beforeIds.has(f.ruleId));
+    const resolvedFindings = before.filter((f) => !afterIds.has(f.ruleId));
+    const persistedFindings = [];
+    for (const ruleId of beforeIds) {
+        if (!afterIds.has(ruleId))
+            continue;
+        const b = beforeMap.get(ruleId);
+        const a = afterMap.get(ruleId);
+        persistedFindings.push({
+            ruleId,
+            beforeSeverity: b.severity,
+            afterSeverity: a.severity,
+            beforeCount: b.affectedEntries.length,
+            afterCount: a.affectedEntries.length,
+        });
+    }
+    return { newFindings, resolvedFindings, persistedFindings };
+}
+// ── Main diff ───────────────────────────────────────────────────
+export function diff(before, after) {
+    const beforeScore = computeHealthScore(before);
+    const afterScore = computeHealthScore(after);
+    const beforeGroups = groupByUrl(before.entries);
+    const afterGroups = groupByUrl(after.entries);
+    // Compute timing deltas for URL patterns that appear in both
+    const allPatterns = new Set([...beforeGroups.keys(), ...afterGroups.keys()]);
+    const timingDeltas = [];
+    for (const pattern of allPatterns) {
+        const bg = beforeGroups.get(pattern);
+        const ag = afterGroups.get(pattern);
+        const beforeAvg = bg ? avgDuration(bg.entries) : 0;
+        const afterAvg = ag ? avgDuration(ag.entries) : 0;
+        const beforeCount = bg?.entries.length ?? 0;
+        const afterCount = ag?.entries.length ?? 0;
+        // Only include if there's something meaningful to compare
+        if (beforeCount === 0 && afterCount === 0)
+            continue;
+        const deltaMs = afterAvg - beforeAvg;
+        const deltaPercent = beforeAvg > 0 ? Math.round((deltaMs / beforeAvg) * 100) : 0;
+        timingDeltas.push({
+            urlPattern: pattern,
+            beforeCount,
+            afterCount,
+            beforeAvgMs: beforeAvg,
+            afterAvgMs: afterAvg,
+            deltaMs,
+            deltaPercent,
+        });
+    }
+    // Sort by absolute delta descending (biggest changes first)
+    timingDeltas.sort((a, b) => Math.abs(b.deltaMs) - Math.abs(a.deltaMs));
+    const { newFindings, resolvedFindings, persistedFindings } = diffFindings(before.findings, after.findings);
+    const beforeTime = before.entries.length > 0
+        ? Math.max(...before.entries.map((e) => e.startTimeMs + e.totalDuration)) - Math.min(...before.entries.map((e) => e.startTimeMs))
+        : 0;
+    const afterTime = after.entries.length > 0
+        ? Math.max(...after.entries.map((e) => e.startTimeMs + e.totalDuration)) - Math.min(...after.entries.map((e) => e.startTimeMs))
+        : 0;
+    return {
+        scoreDelta: afterScore.score - beforeScore.score,
+        newFindings,
+        resolvedFindings,
+        persistedFindings,
+        timingDeltas,
+        requestCountDelta: after.entries.length - before.entries.length,
+        totalTimeDelta: Math.round(afterTime - beforeTime),
+    };
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Error system for har-o-scope.
+ * Two channels: thrown HarError for fatal, result.warnings[] for non-fatal.
+ */
+export interface HarErrorOptions {
+    code: string;
+    message: string;
+    help: string;
+    docsUrl?: string;
+}
+export declare class HarError extends Error {
+    readonly code: string;
+    readonly help: string;
+    readonly docsUrl: string;
+    constructor(opts: HarErrorOptions);
+}
+/** HAR parse/validation errors */
+export declare const HAR_ERRORS: {
+    /** Input is not valid JSON */
+    readonly HAR001: "HAR001";
+    /** Valid JSON but not a valid HAR file (missing log property) */
+    readonly HAR002: "HAR002";
+    /** HAR file has no entries */
+    readonly HAR003: "HAR003";
+    /** HAR file exceeds size limit */
+    readonly HAR004: "HAR004";
+};
+/** Rule engine errors */
+export declare const RULE_ERRORS: {
+    /** Invalid YAML syntax in rule file */
+    readonly RULE001: "RULE001";
+    /** Unknown field path in rule condition */
+    readonly RULE002: "RULE002";
+    /** Circular inheritance in rule composition */
+    readonly RULE003: "RULE003";
+    /** Invalid rule schema (missing required fields) */
+    readonly RULE004: "RULE004";
+    /** Contradictory conditions detected */
+    readonly RULE005: "RULE005";
+    /** Condition nesting too deep (>5 levels) */
+    readonly RULE006: "RULE006";
+    /** Unknown operator in condition */
+    readonly RULE007: "RULE007";
+    /** Invalid severity value */
+    readonly RULE008: "RULE008";
+};
+/** CLI-specific errors */
+export declare const CLI_ERRORS: {
+    /** File not found */
+    readonly CLI001: "CLI001";
+    /** Invalid CLI arguments */
+    readonly CLI002: "CLI002";
+};
+import type { AnalysisWarning } from './types.js';
+export declare function createWarning(code: string, message: string, help: string): AnalysisWarning;
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/lib/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAID,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;gBAEZ,IAAI,EAAE,eAAe;CAUlC;AAID,kCAAkC;AAClC,eAAO,MAAM,UAAU;IACrB,8BAA8B;;IAE9B,iEAAiE;;IAEjE,8BAA8B;;IAE9B,kCAAkC;;CAE1B,CAAA;AAEV,yBAAyB;AACzB,eAAO,MAAM,WAAW;IACtB,uCAAuC;;IAEvC,2CAA2C;;IAE3C,+CAA+C;;IAE/C,oDAAoD;;IAEpD,wCAAwC;;IAExC,6CAA6C;;IAE7C,oCAAoC;;IAEpC,6BAA6B;;CAErB,CAAA;AAEV,0BAA0B;AAC1B,eAAO,MAAM,UAAU;IACrB,qBAAqB;;IAErB,4BAA4B;;CAEpB,CAAA;AAIV,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,eAAe,CAOjB"}

package/dist/lib/errors.js

@@ -0,0 +1,65 @@
+/**
+ * Error system for har-o-scope.
+ * Two channels: thrown HarError for fatal, result.warnings[] for non-fatal.
+ */
+const DOCS_BASE = 'https://github.com/vegaPDX/har-o-scope/blob/main/docs/errors';
+export class HarError extends Error {
+    code;
+    help;
+    docsUrl;
+    constructor(opts) {
+        super(opts.message);
+        this.name = 'HarError';
+        this.code = opts.code;
+        this.help = opts.help;
+        this.docsUrl = opts.docsUrl ?? `${DOCS_BASE}/${opts.code}.md`;
+        // Maintain proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, HarError.prototype);
+    }
+}
+// ── Error code constants ───────────────────────────────────────
+/** HAR parse/validation errors */
+export const HAR_ERRORS = {
+    /** Input is not valid JSON */
+    HAR001: 'HAR001',
+    /** Valid JSON but not a valid HAR file (missing log property) */
+    HAR002: 'HAR002',
+    /** HAR file has no entries */
+    HAR003: 'HAR003',
+    /** HAR file exceeds size limit */
+    HAR004: 'HAR004',
+};
+/** Rule engine errors */
+export const RULE_ERRORS = {
+    /** Invalid YAML syntax in rule file */
+    RULE001: 'RULE001',
+    /** Unknown field path in rule condition */
+    RULE002: 'RULE002',
+    /** Circular inheritance in rule composition */
+    RULE003: 'RULE003',
+    /** Invalid rule schema (missing required fields) */
+    RULE004: 'RULE004',
+    /** Contradictory conditions detected */
+    RULE005: 'RULE005',
+    /** Condition nesting too deep (>5 levels) */
+    RULE006: 'RULE006',
+    /** Unknown operator in condition */
+    RULE007: 'RULE007',
+    /** Invalid severity value */
+    RULE008: 'RULE008',
+};
+/** CLI-specific errors */
+export const CLI_ERRORS = {
+    /** File not found */
+    CLI001: 'CLI001',
+    /** Invalid CLI arguments */
+    CLI002: 'CLI002',
+};
+export function createWarning(code, message, help) {
+    return {
+        code,
+        message,
+        help,
+        docsUrl: `${DOCS_BASE}/${code}.md`,
+    };
+}

package/dist/lib/evaluate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure rule evaluation functions. No DOM dependencies.
+ * Works in Web Worker, Node.js CLI, and library consumers.
+ *
+ * Adapted from the reference engine (yaml_base evaluate.ts).
+ * Generalized: DisplayEntry -> NormalizedEntry, stripped SF-specific fields.
+ */
+import type { FieldCondition, ResponseHeaderCondition, ConditionGroup, ConditionNode, SeverityEscalation, ImpactSpec } from './schema.js';
+import type { IssueSeverity } from './types.js';
+export declare function getField(obj: unknown, path: string): unknown;
+export declare function isFieldCondition(node: ConditionNode): node is FieldCondition;
+export declare function isHeaderCondition(node: ConditionNode): node is ResponseHeaderCondition;
+export declare function isConditionGroup(node: ConditionNode): node is ConditionGroup;
+export declare function evaluateFieldCondition(entry: unknown, cond: FieldCondition): boolean;
+export declare function evaluateCondition(entry: unknown, node: ConditionNode): boolean;
+export declare function computeSeverity(baseSeverity: IssueSeverity, escalation: SeverityEscalation | undefined, affectedCount: number, totalCount: number): IssueSeverity;
+export declare function computeImpact(entries: unknown[], affectedIndices: number[], impactSpec: ImpactSpec | undefined): number;
+export declare function interpolate(template: string, vars: Record<string, string | number>): string;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/lib/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/lib/evaluate.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,UAAU,EACX,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAM/C,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAS5D;AAoCD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,IAAI,cAAc,CAE5E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,IAAI,uBAAuB,CAEtF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,IAAI,cAAc,CAE5E;AAWD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAsBpF;AAmCD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAQ9E;AAUD,wBAAgB,eAAe,CAC7B,YAAY,EAAE,aAAa,EAC3B,UAAU,EAAE,kBAAkB,GAAG,SAAS,EAC1C,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,GACjB,aAAa,CAmBf;AAID,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,EAAE,EAClB,eAAe,EAAE,MAAM,EAAE,EACzB,UAAU,EAAE,UAAU,GAAG,SAAS,GACjC,MAAM,CAwBR;AAID,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GACpC,MAAM,CAKR"}