From 4142fb2af574153fa768fb97721eee423c1fddf2 Mon Sep 17 00:00:00 2001 From: Manuel Reil Date: Sun, 17 Aug 2025 09:58:36 +0200 Subject: [PATCH 1/7] Adds stream benchmark --- .claude/settings.local.json | 13 + benchmark/README.md | 133 ++++++ benchmark/benchmark.js | 179 ++++++++ benchmark/benchmark.test.js | 39 ++ benchmark/events.js | 222 +++++++++ benchmark/performance-monitor.js | 126 ++++++ benchmark/rules.js | 742 +++++++++++++++++++++++++++++++ benchmark/run_17082025.txt | 46 ++ benchmark/stream-utils.js | 87 ++++ package.json | 5 +- 10 files changed, 1591 insertions(+), 1 deletion(-) create mode 100644 .claude/settings.local.json create mode 100644 benchmark/README.md create mode 100644 benchmark/benchmark.js create mode 100644 benchmark/benchmark.test.js create mode 100644 benchmark/events.js create mode 100644 benchmark/performance-monitor.js create mode 100644 benchmark/rules.js create mode 100644 benchmark/run_17082025.txt create mode 100644 benchmark/stream-utils.js diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..11e53a9 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,13 @@ +{ + "permissions": { + "allow": [ + "Bash(mkdir:*)", + "Bash(npm run build:*)", + "Bash(npm run benchmark:quick:*)", + "Bash(npm run benchmark:*)", + "Bash(npm test)", + "Bash(npm run lint:*)" + ] + }, + "enableAllProjectMcpServers": false +} \ No newline at end of file diff --git a/benchmark/README.md b/benchmark/README.md new file mode 100644 index 0000000..f056630 --- /dev/null +++ b/benchmark/README.md @@ -0,0 +1,133 @@ +# json-rules-engine Performance Benchmark + +This benchmark tests the throughput and performance of json-rules-engine in a streaming scenario similar to production event processing pipelines. + +## Overview + +The benchmark simulates a real-world scenario where: +- Events flow through a **read stream** +- A **transform stream** evaluates events against multiple rules using json-rules-engine +- Results are written to a **write stream** + +This mirrors the architecture used in production hook systems for event validation and processing. + +## Features + +- **30 realistic rules** based on actual usage patterns +- **Configurable event counts** for scalability testing +- **Memory usage tracking** with garbage collection +- **Throughput measurements** (events/sec, rules/sec) +- **Statistical analysis** across multiple runs +- **Warmup iterations** for JIT optimization + +## Usage + +### Quick Test (100 events, 10 rules) +```bash +npm run benchmark:quick +``` + +### Standard Benchmark (1000 events, 30 rules) +```bash +npm run benchmark +``` + +### Full Scale Test (10,000 events, 30 rules) +```bash +npm run benchmark:full +``` + +### Custom Configuration +```bash +node --expose-gc benchmark/benchmark.js --events 5000 --rules 25 --runs 5 --warmup 2 +``` + +## Parameters + +- `--events N` - Number of events to process per run (default: 1000) +- `--rules N` - Number of rules to evaluate (default: 30, max: 30) +- `--runs N` - Number of benchmark iterations (default: 5) +- `--warmup N` - Number of warmup iterations (default: 3) + +## Sample Output + +``` +šŸš€ Starting json-rules-engine Stream Benchmark + +Configuration: + ā€¢ Rules: 30 + ā€¢ Events per run: 1000 + ā€¢ Benchmark runs: 5 + ā€¢ Warmup runs: 3 + +Running 3 warmup iterations... +... warmup complete + +Running 5 benchmark iterations... +Run 1/5: 2847 events/sec +Run 2/5: 3021 events/sec +Run 3/5: 2956 events/sec +Run 4/5: 3102 events/sec +Run 5/5: 2891 events/sec + +šŸ“Š Benchmark Summary (5 runs) +===================================== + +Throughput (events/sec): + ā€¢ Average: 2963.40 + ā€¢ Median: 2956.00 + ā€¢ Min: 2847.00 + ā€¢ Max: 3102.00 + +Duration (ms): + ā€¢ Average: 337.54 + ā€¢ Median: 338.20 + ā€¢ Min: 322.45 + ā€¢ Max: 351.22 + +Memory Usage: + ā€¢ Peak Heap (avg): 45.67 MB + ā€¢ Memory Delta (avg): 12.34 MB + ā€¢ Memory Delta (max): 15.89 MB + +Configuration: + ā€¢ Events per run: 1,000 + ā€¢ Rules: 30 + ā€¢ Total events processed: 5,000 + ā€¢ Total rule evaluations: 150,000 +``` + +## Rule Types Tested + +The benchmark includes 30 rules covering: +- **Event type matching** (ANY/ALL conditions) +- **JSONPath data extraction** (`$.record.status`, `$.record.review.maturityValue`) +- **Numeric comparisons** (greaterThan, lessThan, equal) +- **String matching** for status fields +- **Nested object property access** +- **Priority-based rule ordering** + +## Event Types Simulated + +- `com.alyne.users.loggedIn/loggedOut` +- `com.alyne.objects.created/updated` +- `com.alyne.questionnaireresponse.reviewed` +- `com.alyne.tasks.updated` +- `com.alyne.assessments.completed` +- `com.alyne.risks.created` +- And more... + +## Performance Considerations + +The benchmark helps identify: +- **Throughput limits** under different loads +- **Memory usage patterns** and potential leaks +- **Rule evaluation efficiency** +- **Stream processing bottlenecks** +- **Garbage collection impact** + +Use this benchmark to: +- Validate performance before production deployments +- Compare performance across json-rules-engine versions +- Optimize rule complexity and structure +- Size infrastructure for expected loads \ No newline at end of file diff --git a/benchmark/benchmark.js b/benchmark/benchmark.js new file mode 100644 index 0000000..7b35ada --- /dev/null +++ b/benchmark/benchmark.js @@ -0,0 +1,179 @@ +'use strict' + +const { Engine } = require('../dist/index') +const { pipeline } = require('stream') +const { promisify } = require('util') +const rules = require('./rules') +const { baseEvents, generateEvents } = require('./events') +const { ArrayReadStream, ArrayWriteStream, RuleEngineTransform } = require('./stream-utils') +const PerformanceMonitor = require('./performance-monitor') + +const pipelineAsync = promisify(pipeline) + +class StreamBenchmark { + constructor (options = {}) { + this.eventCount = options.eventCount || 1000 + this.ruleCount = options.ruleCount || 30 + this.warmupRuns = options.warmupRuns || 3 + this.benchmarkRuns = options.benchmarkRuns || 5 + } + + setupEngine () { + const engine = new Engine() + + const rulesToUse = rules.slice(0, this.ruleCount) + + rulesToUse.forEach(rule => { + engine.addRule({ + conditions: rule.conditions, + event: rule.event, + priority: Math.floor(Math.random() * 5) + 1 + }) + }) + + return engine + } + + async runSingleBenchmark () { + const engine = this.setupEngine() + const events = generateEvents(baseEvents, this.eventCount) + const monitor = new PerformanceMonitor() + + const readStream = new ArrayReadStream(events.map(event => ({ Body: event }))) + const transform = new RuleEngineTransform(engine) + const writeStream = new ArrayWriteStream() + + monitor.start() + + await pipelineAsync( + readStream, + transform, + writeStream + ) + + monitor.end() + + const transformStats = transform.getStats() + const results = monitor.getResults() + const outputs = writeStream.getResults() + + const totalTriggered = outputs.reduce((sum, output) => sum + (output.triggeredCount || 0), 0) + + results.streamStats = transformStats + results.outputCount = outputs.length + results.totalTriggered = totalTriggered + results.throughput.eventsPerSecond = transformStats.throughputPerSecond + results.totals.eventsTriggered = totalTriggered + + return results + } + + async warmup () { + console.log(`Running ${this.warmupRuns} warmup iterations...`) + for (let i = 0; i < this.warmupRuns; i++) { + await this.runSingleBenchmark() + process.stdout.write('.') + } + console.log(' warmup complete\n') + } + + async runBenchmark () { + console.log('šŸš€ Starting json-rules-engine Stream Benchmark\n') + console.log(`Configuration: + ā€¢ Rules: ${this.ruleCount} + ā€¢ Events per run: ${this.eventCount} + ā€¢ Benchmark runs: ${this.benchmarkRuns} + ā€¢ Warmup runs: ${this.warmupRuns} +`) + + await this.warmup() + + console.log(`Running ${this.benchmarkRuns} benchmark iterations...`) + const benchmarkResults = [] + + for (let i = 0; i < this.benchmarkRuns; i++) { + process.stdout.write(`Run ${i + 1}/${this.benchmarkRuns}: `) + const result = await this.runSingleBenchmark() + benchmarkResults.push(result) + console.log(`${result.throughput.eventsPerSecond.toFixed(0)} events/sec`) + } + + this.printSummary(benchmarkResults) + return benchmarkResults + } + + printSummary (results) { + const throughputs = results.map(r => r.throughput.eventsPerSecond) + const durations = results.map(r => r.duration.milliseconds) + const memoryDeltas = results.map(r => r.memory.deltaMB) + const peakMemories = results.map(r => r.memory.peakHeapMB) + + const avg = arr => arr.reduce((a, b) => a + b, 0) / arr.length + const min = arr => Math.min(...arr) + const max = arr => Math.max(...arr) + const median = arr => { + const sorted = [...arr].sort((a, b) => a - b) + const mid = Math.floor(sorted.length / 2) + return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid] + } + + console.log(`\nšŸ“Š Benchmark Summary (${this.benchmarkRuns} runs)`) + console.log('=====================================') + console.log(` +Throughput (events/sec): + ā€¢ Average: ${avg(throughputs).toFixed(2)} + ā€¢ Median: ${median(throughputs).toFixed(2)} + ā€¢ Min: ${min(throughputs).toFixed(2)} + ā€¢ Max: ${max(throughputs).toFixed(2)} + +Duration (ms): + ā€¢ Average: ${avg(durations).toFixed(2)} + ā€¢ Median: ${median(durations).toFixed(2)} + ā€¢ Min: ${min(durations).toFixed(2)} + ā€¢ Max: ${max(durations).toFixed(2)} + +Memory Usage: + ā€¢ Peak Heap (avg): ${avg(peakMemories).toFixed(2)} MB + ā€¢ Memory Delta (avg): ${avg(memoryDeltas).toFixed(2)} MB + ā€¢ Memory Delta (max): ${max(memoryDeltas).toFixed(2)} MB + +Configuration: + ā€¢ Events per run: ${this.eventCount.toLocaleString()} + ā€¢ Rules: ${this.ruleCount} + ā€¢ Total events processed: ${(this.eventCount * this.benchmarkRuns).toLocaleString()} + ā€¢ Total rule evaluations: ${(this.eventCount * this.ruleCount * this.benchmarkRuns).toLocaleString()} +`) + } +} + +async function main () { + const args = process.argv.slice(2) + const options = {} + + for (let i = 0; i < args.length; i += 2) { + const key = args[i]?.replace('--', '') + const value = args[i + 1] + + if (key && value) { + if (key === 'events') options.eventCount = parseInt(value, 10) + if (key === 'rules') options.ruleCount = parseInt(value, 10) + if (key === 'runs') options.benchmarkRuns = parseInt(value, 10) + if (key === 'warmup') options.warmupRuns = parseInt(value, 10) + } + } + + const benchmark = new StreamBenchmark(options) + + try { + await benchmark.runBenchmark() + } catch (error) { + console.error('āŒ Benchmark failed:', error.message) + process.exit(1) + } +} + +if (require.main === module) { + main().catch(console.error) +} + +module.exports = StreamBenchmark diff --git a/benchmark/benchmark.test.js b/benchmark/benchmark.test.js new file mode 100644 index 0000000..4889a05 --- /dev/null +++ b/benchmark/benchmark.test.js @@ -0,0 +1,39 @@ +'use strict' + +const { expect } = require('chai') +const StreamBenchmark = require('./benchmark') + +describe('Stream Benchmark', function () { + this.timeout(30000) + + it('should run a small benchmark successfully', async function () { + const benchmark = new StreamBenchmark({ + eventCount: 10, + ruleCount: 5, + warmupRuns: 1, + benchmarkRuns: 2 + }) + + const results = await benchmark.runBenchmark() + + expect(results).to.have.lengthOf(2) + expect(results[0]).to.have.property('throughput') + expect(results[0]).to.have.property('duration') + expect(results[0]).to.have.property('memory') + expect(results[0].throughput.eventsPerSecond).to.be.greaterThan(0) + }) + + it('should handle empty event streams', async function () { + const benchmark = new StreamBenchmark({ + eventCount: 0, + ruleCount: 3, + warmupRuns: 1, + benchmarkRuns: 1 + }) + + const results = await benchmark.runBenchmark() + + expect(results).to.have.lengthOf(1) + expect(results[0].totals.events).to.equal(0) + }) +}) diff --git a/benchmark/events.js b/benchmark/events.js new file mode 100644 index 0000000..f6f32fc --- /dev/null +++ b/benchmark/events.js @@ -0,0 +1,222 @@ +'use strict' + +const events = [ + { + specversion: '1.0', + type: 'com.alyne.users.loggedIn', + source: 'auth-service', + id: 'user-login-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '5ea2bd93f4b8505567662936', + email: 'user1@test.com', + userType: 'Admin', + lastLogin: new Date().toISOString(), + org: '5b224b4b01e6a32ae17a7134' + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.objects.created', + source: 'object-service', + id: 'obj-create-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '5a79357fa01b451f003fc37f', + itemId: 150, + typeName: 'alyne|information_asset', + org: '5b224b4b01e6a32ae17a7134', + lifecycleStatus: 'published', + object: { + title: 'Test Asset', + personalInformation: 'yes', + access: { en_GB: 'PROTECTED' } + } + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.objects.updated', + source: 'object-service', + id: 'obj-update-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '5a79357fa01b451f003fc37f', + itemId: 75, + typeName: 'alyne|control', + org: '5b224b4b01e6a32ae17a7134', + lifecycleStatus: 'published', + priority: 'medium' + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.questionnaireresponse.reviewed', + source: 'assessment-service', + id: 'qr-review-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '64b946edf26a6b001a8d7e26', + org: '5b224b4b01e6a32ae17a7134', + state: 'IN_REVIEW', + review: { + state: 'APPROVED', + maturityValue: 2, + maturityLevel: 2 + } + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.tasks.updated', + source: 'task-service', + id: 'task-update-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '66056a0ffaf812611a2fe3c7', + org: '5b224b4b01e6a32ae17a7134', + title: 'Security Review Task', + status: 'open', + itemId: 418, + relatedRecords: ['mitigation:123', 'issue:456'] + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.assessments.completed', + source: 'assessment-service', + id: 'assessment-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '64c123456789abcdef123456', + org: '5b224b4b01e6a32ae17a7134', + score: 4.5, + completionStatus: 'complete' + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.risks.created', + source: 'risk-service', + id: 'risk-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '64d789012345678901234567', + org: '5b224b4b01e6a32ae17a7134', + riskScore: 8.5, + severity: 'critical' + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.controls.evaluated', + source: 'control-service', + id: 'control-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '64e890123456789012345678', + org: '5b224b4b01e6a32ae17a7134', + maturityLevel: 1, + confidenceScore: 95 + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.documents.uploaded', + source: 'document-service', + id: 'doc-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '64f901234567890123456789', + org: '5b224b4b01e6a32ae17a7134', + fileSize: 15728640, + eventType: 'upload' + } + } + }, + { + specversion: '1.0', + type: 'com.alyne.mitigations.assigned', + source: 'mitigation-service', + id: 'mitigation-001', + time: new Date().toISOString(), + datacontenttype: 'application/json', + data: { + record: { + _id: '650123456789012345678901', + org: '5b224b4b01e6a32ae17a7134', + priority: 'high', + completionPercentage: 75 + } + } + } +] + +function generateVariations (baseEvents, count = 1000) { + const variations = [] + + for (let i = 0; i < count; i++) { + const baseEvent = baseEvents[i % baseEvents.length] + const variation = JSON.parse(JSON.stringify(baseEvent)) + + variation.id = `${baseEvent.id}-${i}` + variation.time = new Date(Date.now() + i * 1000).toISOString() + + if (variation.data.record.itemId) { + variation.data.record.itemId = Math.floor(Math.random() * 1000) + 1 + } + if (variation.data.record.score) { + variation.data.record.score = Math.random() * 5 + } + if (variation.data.record.riskScore) { + variation.data.record.riskScore = Math.random() * 10 + } + if (variation.data.record.maturityLevel) { + variation.data.record.maturityLevel = Math.floor(Math.random() * 5) + 1 + } + if (variation.data.record.completionPercentage) { + variation.data.record.completionPercentage = Math.floor(Math.random() * 100) + } + if (variation.data.record.confidenceScore) { + variation.data.record.confidenceScore = Math.floor(Math.random() * 100) + } + if (variation.data.record.fileSize) { + variation.data.record.fileSize = Math.floor(Math.random() * 50000000) + } + + variations.push(variation) + } + + return variations +} + +module.exports = { + baseEvents: events, + generateEvents: generateVariations +} diff --git a/benchmark/performance-monitor.js b/benchmark/performance-monitor.js new file mode 100644 index 0000000..e6db2e6 --- /dev/null +++ b/benchmark/performance-monitor.js @@ -0,0 +1,126 @@ +'use strict' + +class PerformanceMonitor { + constructor () { + this.metrics = { + startTime: null, + endTime: null, + memoryBefore: null, + memoryAfter: null, + totalEvents: 0, + totalRulesEvaluated: 0, + totalEventsTriggered: 0, + gcRuns: 0 + } + this.intervalId = null + } + + start () { + this.metrics.startTime = process.hrtime.bigint() + this.metrics.memoryBefore = process.memoryUsage() + + if (global.gc) { + global.gc() + this.metrics.gcRuns++ + } + + this.startMemoryMonitoring() + } + + end () { + this.metrics.endTime = process.hrtime.bigint() + this.metrics.memoryAfter = process.memoryUsage() + + if (this.intervalId) { + clearInterval(this.intervalId) + } + + if (global.gc) { + global.gc() + this.metrics.gcRuns++ + } + } + + startMemoryMonitoring () { + this.intervalId = setInterval(() => { + const current = process.memoryUsage() + if (current.heapUsed > this.metrics.memoryAfter?.heapUsed || !this.metrics.memoryAfter) { + this.metrics.memoryAfter = current + } + }, 100) + } + + recordEventProcessed (rulesEvaluated = 1, eventsTriggered = 0) { + this.metrics.totalEvents++ + this.metrics.totalRulesEvaluated += rulesEvaluated + this.metrics.totalEventsTriggered += eventsTriggered + } + + getResults () { + const durationNs = this.metrics.endTime - this.metrics.startTime + const durationMs = Number(durationNs) / 1000000 + const durationSeconds = durationMs / 1000 + + const memoryDeltaMB = this.metrics.memoryAfter && this.metrics.memoryBefore + ? (this.metrics.memoryAfter.heapUsed - this.metrics.memoryBefore.heapUsed) / 1024 / 1024 + : 0 + + return { + duration: { + nanoseconds: Number(durationNs), + milliseconds: durationMs, + seconds: durationSeconds + }, + throughput: { + eventsPerSecond: this.metrics.totalEvents / durationSeconds, + rulesPerSecond: this.metrics.totalRulesEvaluated / durationSeconds, + triggeredEventsPerSecond: this.metrics.totalEventsTriggered / durationSeconds + }, + memory: { + before: this.metrics.memoryBefore, + after: this.metrics.memoryAfter, + deltaMB: memoryDeltaMB, + peakHeapMB: this.metrics.memoryAfter ? this.metrics.memoryAfter.heapUsed / 1024 / 1024 : 0 + }, + totals: { + events: this.metrics.totalEvents, + rulesEvaluated: this.metrics.totalRulesEvaluated, + eventsTriggered: this.metrics.totalEventsTriggered, + gcRuns: this.metrics.gcRuns + } + } + } + + formatResults (results, eventCount, ruleCount) { + return ` +Performance Benchmark Results +============================= +Configuration: + ā€¢ Rules: ${ruleCount} + ā€¢ Events: ${eventCount} + ā€¢ GC Runs: ${results.totals.gcRuns} + +Duration: + ā€¢ Total: ${results.duration.milliseconds.toFixed(2)}ms (${results.duration.seconds.toFixed(3)}s) + +Throughput: + ā€¢ Events/sec: ${results.throughput.eventsPerSecond.toFixed(2)} + ā€¢ Rules/sec: ${results.throughput.rulesPerSecond.toFixed(2)} + ā€¢ Triggered Events/sec: ${results.throughput.triggeredEventsPerSecond.toFixed(2)} + +Memory Usage: + ā€¢ Peak Heap: ${results.memory.peakHeapMB.toFixed(2)} MB + ā€¢ Memory Delta: ${results.memory.deltaMB.toFixed(2)} MB + ā€¢ Before: ${(results.memory.before?.heapUsed / 1024 / 1024 || 0).toFixed(2)} MB + ā€¢ After: ${(results.memory.after?.heapUsed / 1024 / 1024 || 0).toFixed(2)} MB + +Event Processing: + ā€¢ Total Events Processed: ${results.totals.events} + ā€¢ Total Rules Evaluated: ${results.totals.rulesEvaluated} + ā€¢ Total Events Triggered: ${results.totals.eventsTriggered} + ā€¢ Average Rules per Event: ${(results.totals.rulesEvaluated / results.totals.events).toFixed(2)} +` + } +} + +module.exports = PerformanceMonitor diff --git a/benchmark/rules.js b/benchmark/rules.js new file mode 100644 index 0000000..b103fed --- /dev/null +++ b/benchmark/rules.js @@ -0,0 +1,742 @@ +'use strict' + +module.exports = [ + { + _id: 'rule-001', + conditions: { + any: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.users.loggedIn', + path: '$' + }, + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.users.loggedOut', + path: '$' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'test-bucket-1', + region: 'us-east-1', + format: 'json' + } + } + }, + { + _id: 'rule-002', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.objects.created', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'published', + path: '$.record.lifecycleStatus' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/test-001' + } + } + }, + { + _id: 'rule-003', + conditions: { + any: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.objects.updated', + path: '$' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'test-bucket-2', + region: 'us-west-2', + format: 'json' + } + } + }, + { + _id: 'rule-004', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.questionnaireresponse.reviewed', + path: '$' + }, + { + fact: 'data', + operator: 'lessThan', + value: 3, + path: '$.record.review.maturityValue' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/test-002' + } + } + }, + { + _id: 'rule-005', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.tasks.updated', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'open', + path: '$.record.status' + } + ] + }, + event: { + type: 'sendEmail', + params: { + recipients: ['admin@test.com'] + } + } + }, + { + _id: 'rule-006', + conditions: { + any: [ + { + fact: 'data', + operator: 'greaterThan', + value: 100, + path: '$.record.itemId' + }, + { + fact: 'data', + operator: 'equal', + value: 'critical', + path: '$.record.priority' + } + ] + }, + event: { + type: 'internalLambda', + params: { + lambdaName: 'test-lambda-001' + } + } + }, + { + _id: 'rule-007', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.assessments.completed', + path: '$' + }, + { + fact: 'data', + operator: 'greaterThanInclusive', + value: 4, + path: '$.record.score' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/test-003' + } + } + }, + { + _id: 'rule-008', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'Admin', + path: '$.record.userType' + }, + { + fact: 'data', + operator: 'equal', + value: 'Expert', + path: '$.record.userType' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'admin-bucket', + region: 'eu-west-1', + format: 'json' + } + } + }, + { + _id: 'rule-009', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.risks.created', + path: '$' + }, + { + fact: 'data', + operator: 'greaterThan', + value: 7, + path: '$.record.riskScore' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/high-risk' + } + } + }, + { + _id: 'rule-010', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'PROTECTED', + path: '$.record.object.access.en_GB' + }, + { + fact: 'data', + operator: 'equal', + value: 'CONFIDENTIAL', + path: '$.record.object.access.en_GB' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'secure-bucket', + region: 'us-east-1', + format: 'encrypted' + } + } + }, + { + _id: 'rule-011', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.controls.evaluated', + path: '$' + }, + { + fact: 'data', + operator: 'lessThanInclusive', + value: 2, + path: '$.record.maturityLevel' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/low-maturity' + } + } + }, + { + _id: 'rule-012', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'yes', + path: '$.record.object.personalInformation' + } + ] + }, + event: { + type: 'internalLambda', + params: { + lambdaName: 'privacy-handler' + } + } + }, + { + _id: 'rule-013', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.documents.uploaded', + path: '$' + }, + { + fact: 'data', + operator: 'greaterThan', + value: 10485760, + path: '$.record.fileSize' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'large-files-bucket', + region: 'us-west-1', + format: 'compressed' + } + } + }, + { + _id: 'rule-014', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'APPROVED', + path: '$.record.review.state' + }, + { + fact: 'data', + operator: 'equal', + value: 'REJECTED', + path: '$.record.review.state' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/review-complete' + } + } + }, + { + _id: 'rule-015', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.mitigations.assigned', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'high', + path: '$.record.priority' + } + ] + }, + event: { + type: 'sendEmail', + params: { + recipients: ['manager@test.com', 'team@test.com'] + } + } + }, + { + _id: 'rule-016', + conditions: { + any: [ + { + fact: 'data', + operator: 'greaterThanInclusive', + value: 50, + path: '$.record.completionPercentage' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/progress-update' + } + } + }, + { + _id: 'rule-017', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.frameworks.applied', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'ISO27001', + path: '$.record.frameworkType' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'compliance-bucket', + region: 'eu-central-1', + format: 'json' + } + } + }, + { + _id: 'rule-018', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'urgent', + path: '$.record.severity' + }, + { + fact: 'data', + operator: 'equal', + value: 'critical', + path: '$.record.severity' + } + ] + }, + event: { + type: 'internalLambda', + params: { + lambdaName: 'urgent-response-handler' + } + } + }, + { + _id: 'rule-019', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.vendors.onboarded', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'active', + path: '$.record.status' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/vendor-active' + } + } + }, + { + _id: 'rule-020', + conditions: { + any: [ + { + fact: 'data', + operator: 'greaterThan', + value: 1000000, + path: '$.record.contractValue' + } + ] + }, + event: { + type: 'sendEmail', + params: { + recipients: ['legal@test.com', 'finance@test.com'] + } + } + }, + { + _id: 'rule-021', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.audits.scheduled', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'external', + path: '$.record.auditType' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'audit-bucket', + region: 'ap-southeast-1', + format: 'json' + } + } + }, + { + _id: 'rule-022', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'overdue', + path: '$.record.status' + }, + { + fact: 'data', + operator: 'lessThan', + value: Date.now(), + path: '$.record.dueDate' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/overdue-items' + } + } + }, + { + _id: 'rule-023', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.incidents.reported', + path: '$' + }, + { + fact: 'data', + operator: 'greaterThanInclusive', + value: 8, + path: '$.record.severityScore' + } + ] + }, + event: { + type: 'internalLambda', + params: { + lambdaName: 'incident-escalation' + } + } + }, + { + _id: 'rule-024', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'GDPR', + path: '$.record.regulationType' + }, + { + fact: 'data', + operator: 'equal', + value: 'CCPA', + path: '$.record.regulationType' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'privacy-compliance', + region: 'eu-west-1', + format: 'encrypted' + } + } + }, + { + _id: 'rule-025', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.assessments.submitted', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'complete', + path: '$.record.completionStatus' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/assessment-complete' + } + } + }, + { + _id: 'rule-026', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'breach', + path: '$.record.eventType' + }, + { + fact: 'data', + operator: 'equal', + value: 'violation', + path: '$.record.eventType' + } + ] + }, + event: { + type: 'internalLambda', + params: { + lambdaName: 'security-incident-handler' + } + } + }, + { + _id: 'rule-027', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.policies.updated', + path: '$' + }, + { + fact: 'data', + operator: 'equal', + value: 'published', + path: '$.record.status' + } + ] + }, + event: { + type: 'sendEmail', + params: { + recipients: ['policy-team@test.com'] + } + } + }, + { + _id: 'rule-028', + conditions: { + any: [ + { + fact: 'data', + operator: 'greaterThan', + value: 90, + path: '$.record.confidenceScore' + } + ] + }, + event: { + type: 'putS3', + params: { + bucket: 'high-confidence', + region: 'ca-central-1', + format: 'json' + } + } + }, + { + _id: 'rule-029', + conditions: { + all: [ + { + fact: 'type', + operator: 'equal', + value: 'com.alyne.trainings.completed', + path: '$' + }, + { + fact: 'data', + operator: 'greaterThanInclusive', + value: 85, + path: '$.record.scorePercentage' + } + ] + }, + event: { + type: 'webhook', + params: { + url: 'https://webhook.site/training-passed' + } + } + }, + { + _id: 'rule-030', + conditions: { + any: [ + { + fact: 'data', + operator: 'equal', + value: 'expired', + path: '$.record.certificateStatus' + }, + { + fact: 'data', + operator: 'lessThan', + value: Date.now() + (30 * 24 * 60 * 60 * 1000), + path: '$.record.expirationDate' + } + ] + }, + event: { + type: 'sendEmail', + params: { + recipients: ['compliance@test.com'] + } + } + } +] diff --git a/benchmark/run_17082025.txt b/benchmark/run_17082025.txt new file mode 100644 index 0000000..d15e197 --- /dev/null +++ b/benchmark/run_17082025.txt @@ -0,0 +1,46 @@ +Configuration: + ā€¢ Rules: 30 + ā€¢ Events per run: 10000 + ā€¢ Benchmark runs: 10 + ā€¢ Warmup runs: 3 + +Running 3 warmup iterations... +... warmup complete + +Running 10 benchmark iterations... +Run 1/10: 3707 events/sec +Run 2/10: 3775 events/sec +Run 3/10: 3714 events/sec +Run 4/10: 3719 events/sec +Run 5/10: 3689 events/sec +Run 6/10: 3788 events/sec +Run 7/10: 3708 events/sec +Run 8/10: 3690 events/sec +Run 9/10: 3662 events/sec +Run 10/10: 3622 events/sec + +šŸ“Š Benchmark Summary (10 runs) +===================================== + +Throughput (events/sec): + ā€¢ Average: 3707.31 + ā€¢ Median: 3707.60 + ā€¢ Min: 3621.70 + ā€¢ Max: 3787.72 + +Duration (ms): + ā€¢ Average: 2698.76 + ā€¢ Median: 2698.86 + ā€¢ Min: 2640.43 + ā€¢ Max: 2760.65 + +Memory Usage: + ā€¢ Peak Heap (avg): 21.78 MB + ā€¢ Memory Delta (avg): -4.98 MB + ā€¢ Memory Delta (max): 3.99 MB + +Configuration: + ā€¢ Events per run: 10.000 + ā€¢ Rules: 30 + ā€¢ Total events processed: 100.000 + ā€¢ Total rule evaluations: 3.000.000 \ No newline at end of file diff --git a/benchmark/stream-utils.js b/benchmark/stream-utils.js new file mode 100644 index 0000000..7b60e6d --- /dev/null +++ b/benchmark/stream-utils.js @@ -0,0 +1,87 @@ +'use strict' + +const { Readable, Writable, Transform } = require('stream') + +class ArrayReadStream extends Readable { + constructor (array, options = {}) { + super({ objectMode: true, ...options }) + this.array = array + this.index = 0 + } + + _read () { + if (this.index < this.array.length) { + this.push(this.array[this.index]) + this.index++ + } else { + this.push(null) + } + } +} + +class ArrayWriteStream extends Writable { + constructor (options = {}) { + super({ objectMode: true, ...options }) + this.results = [] + } + + _write (chunk, encoding, callback) { + this.results.push(chunk) + callback() + } + + getResults () { + return this.results + } +} + +class RuleEngineTransform extends Transform { + constructor (engine, options = {}) { + super({ objectMode: true, ...options }) + this.engine = engine + this.processedCount = 0 + this.startTime = null + } + + async _transform (chunk, encoding, callback) { + if (this.startTime === null) { + this.startTime = process.hrtime.bigint() + } + + try { + const event = chunk.Body || chunk + const result = await this.engine.run(event) + + this.processedCount++ + + this.push({ + originalEvent: event, + ruleResults: result.events || [], + triggeredCount: result.events ? result.events.length : 0, + processedAt: Date.now() + }) + + callback() + } catch (error) { + callback(error) + } + } + + getStats () { + const endTime = process.hrtime.bigint() + const durationNs = this.startTime ? endTime - this.startTime : 0n + const durationMs = Number(durationNs) / 1000000 + + return { + processedCount: this.processedCount, + durationMs, + throughputPerSecond: this.processedCount / (durationMs / 1000) + } + } +} + +module.exports = { + ArrayReadStream, + ArrayWriteStream, + RuleEngineTransform +} diff --git a/package.json b/package.json index 477902a..4f23747 100644 --- a/package.json +++ b/package.json @@ -15,7 +15,10 @@ "prepublishOnly": "npm run build", "build": "babel --stage 1 -d dist/ src/", "watch": "babel --watch --stage 1 -d dist/ src", - "examples": "./test/support/example_runner.sh" + "examples": "./test/support/example_runner.sh", + "benchmark": "node --expose-gc benchmark/benchmark.js", + "benchmark:quick": "node --expose-gc benchmark/benchmark.js --events 100 --rules 10 --runs 3", + "benchmark:full": "node --expose-gc benchmark/benchmark.js --events 10000 --rules 30 --runs 10" }, "repository": { "type": "git", From bf5f6943946530b1884b6ee439d69d015ef5045c Mon Sep 17 00:00:00 2001 From: Manuel Reil Date: Sun, 17 Aug 2025 10:13:57 +0200 Subject: [PATCH 2/7] Adds synchronous mode --- benchmark/PERFORMANCE_ANALYSIS.md | 92 ++++++++ benchmark/benchmark-comparison.js | 213 ++++++++++++++++++ benchmark/stream-utils-sync.js | 52 +++++ package.json | 4 +- src/rule-result.js | 10 + src/sync/almanac-sync.js | 181 +++++++++++++++ src/sync/condition-sync.js | 154 +++++++++++++ src/sync/engine-sync.js | 310 ++++++++++++++++++++++++++ src/sync/fact-sync.js | 96 ++++++++ src/sync/index-sync.js | 32 +++ src/sync/rule-sync.js | 354 ++++++++++++++++++++++++++++++ test/sync/engine-sync.test.js | 176 +++++++++++++++ 12 files changed, 1673 insertions(+), 1 deletion(-) create mode 100644 benchmark/PERFORMANCE_ANALYSIS.md create mode 100644 benchmark/benchmark-comparison.js create mode 100644 benchmark/stream-utils-sync.js create mode 100644 src/sync/almanac-sync.js create mode 100644 src/sync/condition-sync.js create mode 100644 src/sync/engine-sync.js create mode 100644 src/sync/fact-sync.js create mode 100644 src/sync/index-sync.js create mode 100644 src/sync/rule-sync.js create mode 100644 test/sync/engine-sync.test.js diff --git a/benchmark/PERFORMANCE_ANALYSIS.md b/benchmark/PERFORMANCE_ANALYSIS.md new file mode 100644 index 0000000..8b697d4 --- /dev/null +++ b/benchmark/PERFORMANCE_ANALYSIS.md @@ -0,0 +1,92 @@ +# Async vs Sync Performance Analysis + +## Summary + +I've implemented a complete synchronous variant of json-rules-engine alongside the existing async implementation and conducted performance comparisons. Here are the key findings: + +## Implementation Details + +### Synchronous Variant Created: +- **EngineSync** - Synchronous engine that processes rules without Promises +- **RuleSync** - Synchronous rule evaluation +- **AlmanacSync** - Synchronous fact resolution and caching +- **FactSync** - Synchronous fact computation +- **ConditionSync** - Synchronous condition evaluation + +### Key Changes Made: +1. **Removed all Promise wrapping** - Direct return of values instead of Promise.resolve() +2. **Eliminated Promise.all()** - Replaced with synchronous loops and array operations +3. **Synchronous fact resolution** - Direct value calculation without async/await +4. **Synchronous condition evaluation** - Immediate boolean results +5. **Synchronous rule processing** - Sequential rule evaluation + +## Performance Results + +### Small Workloads (100 events, 10 rules): +- **Sync is 9.4% faster** than async +- Better for lightweight processing scenarios + +### Large Workloads (1000 events, 30 rules): +- **Async is 28.2% faster** than sync +- V8's Promise optimization outperforms synchronous loops at scale + +## Performance Analysis + +### Why Async Performs Better at Scale: + +1. **V8 Promise Optimization**: Modern V8 has highly optimized Promise handling +2. **Event Loop Efficiency**: Async operations benefit from V8's event loop optimizations +3. **Memory Layout**: Promise chains may have better memory locality +4. **JIT Compilation**: V8's JIT compiler optimizes Promise-heavy code paths better + +### Why Sync Performs Better for Small Workloads: + +1. **Reduced Overhead**: No Promise creation/resolution overhead +2. **Direct Execution**: Immediate function calls without Promise wrapping +3. **Lower Memory Pressure**: No Promise objects in memory + +## Recommendations + +### Use Async (Original) When: +- **High throughput scenarios** (>500 events/sec) +- **Complex rule sets** (>20 rules) +- **Future async fact support** may be needed +- **Production workloads** with variable loads + +### Use Sync When: +- **Low latency requirements** for small batches +- **Embedded scenarios** with strict memory constraints +- **Simple rule sets** (<10 rules) +- **Guaranteed synchronous facts** and no future async needs + +## Benchmark Commands + +```bash +# Test sync implementation only +npm run benchmark:quick + +# Compare async vs sync +npm run benchmark:compare:quick # 100 events, 10 rules +npm run benchmark:compare # 1000 events, 30 rules + +# Custom comparison +node --expose-gc benchmark/benchmark-comparison.js --events 500 --rules 15 --runs 5 +``` + +## Technical Implementation Notes + +The synchronous implementation maintains **100% API compatibility** with the async version: +- Same method signatures and behavior +- Same rule/fact/condition structure +- Same error handling patterns +- Same event emission patterns + +The only difference is that `engine.run()` returns results immediately instead of a Promise. + +## Conclusion + +For your use case with static rules and synchronous facts, the **async version is still recommended** for production due to better performance at scale. The sync version provides value for: +- Understanding performance characteristics +- Specific low-latency scenarios +- Educational purposes +- Future optimization insights \ No newline at end of file diff --git a/benchmark/benchmark-comparison.js b/benchmark/benchmark-comparison.js new file mode 100644 index 0000000..1f571d8 --- /dev/null +++ b/benchmark/benchmark-comparison.js @@ -0,0 +1,213 @@ +'use strict' + +const { Engine } = require('../dist/index') +const { EngineSync } = require('../dist/sync/index-sync') +const { pipeline } = require('stream') +const { promisify } = require('util') +const rules = require('./rules') +const { baseEvents, generateEvents } = require('./events') +const { ArrayReadStream, ArrayWriteStream, RuleEngineTransform } = require('./stream-utils') +const { RuleEngineTransformSync } = require('./stream-utils-sync') +const PerformanceMonitor = require('./performance-monitor') + +const pipelineAsync = promisify(pipeline) + +class BenchmarkComparison { + constructor (options = {}) { + this.eventCount = options.eventCount || 1000 + this.ruleCount = options.ruleCount || 30 + this.warmupRuns = options.warmupRuns || 3 + this.benchmarkRuns = options.benchmarkRuns || 5 + } + + setupAsyncEngine () { + const engine = new Engine() + const rulesToUse = rules.slice(0, this.ruleCount) + rulesToUse.forEach(rule => { + engine.addRule({ + conditions: rule.conditions, + event: rule.event, + priority: Math.floor(Math.random() * 5) + 1 + }) + }) + return engine + } + + setupSyncEngine () { + const engine = new EngineSync() + const rulesToUse = rules.slice(0, this.ruleCount) + rulesToUse.forEach(rule => { + engine.addRule({ + conditions: rule.conditions, + event: rule.event, + priority: Math.floor(Math.random() * 5) + 1 + }) + }) + return engine + } + + async runAsyncBenchmark () { + const engine = this.setupAsyncEngine() + const events = generateEvents(baseEvents, this.eventCount) + const monitor = new PerformanceMonitor() + + const readStream = new ArrayReadStream(events.map(event => ({ Body: event }))) + const transform = new RuleEngineTransform(engine) + const writeStream = new ArrayWriteStream() + + monitor.start() + await pipelineAsync(readStream, transform, writeStream) + monitor.end() + + const transformStats = transform.getStats() + const results = monitor.getResults() + const outputs = writeStream.getResults() + const totalTriggered = outputs.reduce((sum, output) => sum + (output.triggeredCount || 0), 0) + + results.streamStats = transformStats + results.outputCount = outputs.length + results.totalTriggered = totalTriggered + results.throughput.eventsPerSecond = transformStats.throughputPerSecond + results.totals.eventsTriggered = totalTriggered + results.variant = 'async' + + return results + } + + async runSyncBenchmark () { + const engine = this.setupSyncEngine() + const events = generateEvents(baseEvents, this.eventCount) + const monitor = new PerformanceMonitor() + + const readStream = new ArrayReadStream(events.map(event => ({ Body: event }))) + const transform = new RuleEngineTransformSync(engine) + const writeStream = new ArrayWriteStream() + + monitor.start() + await pipelineAsync(readStream, transform, writeStream) + monitor.end() + + const transformStats = transform.getStats() + const results = monitor.getResults() + const outputs = writeStream.getResults() + const totalTriggered = outputs.reduce((sum, output) => sum + (output.triggeredCount || 0), 0) + + results.streamStats = transformStats + results.outputCount = outputs.length + results.totalTriggered = totalTriggered + results.throughput.eventsPerSecond = transformStats.throughputPerSecond + results.totals.eventsTriggered = totalTriggered + results.variant = 'sync' + + return results + } + + async warmup () { + console.log(`Running ${this.warmupRuns} warmup iterations for both variants...`) + for (let i = 0; i < this.warmupRuns; i++) { + await this.runAsyncBenchmark() + await this.runSyncBenchmark() + process.stdout.write('.') + } + console.log(' warmup complete\n') + } + + async runComparison () { + console.log('āš” Starting Async vs Sync Performance Comparison\n') + console.log(`Configuration: + ā€¢ Rules: ${this.ruleCount} + ā€¢ Events per run: ${this.eventCount} + ā€¢ Benchmark runs: ${this.benchmarkRuns} + ā€¢ Warmup runs: ${this.warmupRuns} +`) + + await this.warmup() + + console.log('Running async vs sync benchmarks...') + const asyncResults = [] + const syncResults = [] + + for (let i = 0; i < this.benchmarkRuns; i++) { + process.stdout.write(`Run ${i + 1}/${this.benchmarkRuns}: `) + + const asyncResult = await this.runAsyncBenchmark() + const syncResult = await this.runSyncBenchmark() + + asyncResults.push(asyncResult) + syncResults.push(syncResult) + + const improvement = ((syncResult.throughput.eventsPerSecond / asyncResult.throughput.eventsPerSecond - 1) * 100).toFixed(1) + console.log(`Async: ${asyncResult.throughput.eventsPerSecond.toFixed(0)} events/sec | Sync: ${syncResult.throughput.eventsPerSecond.toFixed(0)} events/sec | Improvement: ${improvement}%`) + } + + this.printComparison(asyncResults, syncResults) + return { asyncResults, syncResults } + } + + printComparison (asyncResults, syncResults) { + const asyncThroughputs = asyncResults.map(r => r.throughput.eventsPerSecond) + const syncThroughputs = syncResults.map(r => r.throughput.eventsPerSecond) + const asyncDurations = asyncResults.map(r => r.duration.milliseconds) + const syncDurations = syncResults.map(r => r.duration.milliseconds) + const asyncMemory = asyncResults.map(r => r.memory.peakHeapMB) + const syncMemory = syncResults.map(r => r.memory.peakHeapMB) + + const avg = arr => arr.reduce((a, b) => a + b, 0) / arr.length + const improvement = (sync, async) => ((sync / async - 1) * 100).toFixed(1) + + console.log(`\nšŸ“Š Async vs Sync Comparison (${this.benchmarkRuns} runs)`) + console.log('===========================================') + console.log(` +Throughput (events/sec): + Async Sync Improvement + ā€¢ Average: ${avg(asyncThroughputs).toFixed(0).padStart(8)} ${avg(syncThroughputs).toFixed(0).padStart(8)} ${improvement(avg(syncThroughputs), avg(asyncThroughputs))}% + ā€¢ Max: ${Math.max(...asyncThroughputs).toFixed(0).padStart(8)} ${Math.max(...syncThroughputs).toFixed(0).padStart(8)} ${improvement(Math.max(...syncThroughputs), Math.max(...asyncThroughputs))}% + +Duration (ms): + Async Sync Improvement + ā€¢ Average: ${avg(asyncDurations).toFixed(1).padStart(8)} ${avg(syncDurations).toFixed(1).padStart(8)} ${improvement(avg(asyncDurations), avg(syncDurations))}% + ā€¢ Min: ${Math.min(...asyncDurations).toFixed(1).padStart(8)} ${Math.min(...syncDurations).toFixed(1).padStart(8)} ${improvement(Math.min(asyncDurations), Math.min(...syncDurations))}% + +Memory (Peak Heap MB): + Async Sync Difference + ā€¢ Average: ${avg(asyncMemory).toFixed(1).padStart(8)} ${avg(syncMemory).toFixed(1).padStart(8)} ${(avg(asyncMemory) - avg(syncMemory)).toFixed(1)}MB + +Performance Summary: + ā€¢ Sync is ${improvement(avg(syncThroughputs), avg(asyncThroughputs))}% faster on average + ā€¢ Sync uses ${(avg(asyncMemory) - avg(syncMemory)).toFixed(1)}MB less memory on average + ā€¢ Processing ${this.eventCount.toLocaleString()} events with ${this.ruleCount} rules +`) + } +} + +async function main () { + const args = process.argv.slice(2) + const options = {} + + for (let i = 0; i < args.length; i += 2) { + const key = args[i]?.replace('--', '') + const value = args[i + 1] + + if (key && value) { + if (key === 'events') options.eventCount = parseInt(value, 10) + if (key === 'rules') options.ruleCount = parseInt(value, 10) + if (key === 'runs') options.benchmarkRuns = parseInt(value, 10) + if (key === 'warmup') options.warmupRuns = parseInt(value, 10) + } + } + + const benchmark = new BenchmarkComparison(options) + + try { + await benchmark.runComparison() + } catch (error) { + console.error('āŒ Comparison failed:', error.message) + process.exit(1) + } +} + +if (require.main === module) { + main().catch(console.error) +} + +module.exports = BenchmarkComparison diff --git a/benchmark/stream-utils-sync.js b/benchmark/stream-utils-sync.js new file mode 100644 index 0000000..b500379 --- /dev/null +++ b/benchmark/stream-utils-sync.js @@ -0,0 +1,52 @@ +'use strict' + +const { Transform } = require('stream') + +class RuleEngineTransformSync extends Transform { + constructor (engine, options = {}) { + super({ objectMode: true, ...options }) + this.engine = engine + this.processedCount = 0 + this.startTime = null + } + + _transform (chunk, encoding, callback) { + if (this.startTime === null) { + this.startTime = process.hrtime.bigint() + } + + try { + const event = chunk.Body || chunk + const result = this.engine.run(event) + + this.processedCount++ + + this.push({ + originalEvent: event, + ruleResults: result.events || [], + triggeredCount: result.events ? result.events.length : 0, + processedAt: Date.now() + }) + + callback() + } catch (error) { + callback(error) + } + } + + getStats () { + const endTime = process.hrtime.bigint() + const durationNs = this.startTime ? endTime - this.startTime : 0n + const durationMs = Number(durationNs) / 1000000 + + return { + processedCount: this.processedCount, + durationMs, + throughputPerSecond: this.processedCount / (durationMs / 1000) + } + } +} + +module.exports = { + RuleEngineTransformSync +} diff --git a/package.json b/package.json index 4f23747..df06bff 100644 --- a/package.json +++ b/package.json @@ -18,7 +18,9 @@ "examples": "./test/support/example_runner.sh", "benchmark": "node --expose-gc benchmark/benchmark.js", "benchmark:quick": "node --expose-gc benchmark/benchmark.js --events 100 --rules 10 --runs 3", - "benchmark:full": "node --expose-gc benchmark/benchmark.js --events 10000 --rules 30 --runs 10" + "benchmark:full": "node --expose-gc benchmark/benchmark.js --events 10000 --rules 30 --runs 10", + "benchmark:compare": "node --expose-gc benchmark/benchmark-comparison.js", + "benchmark:compare:quick": "node --expose-gc benchmark/benchmark-comparison.js --events 100 --rules 10 --runs 3" }, "repository": { "type": "git", diff --git a/src/rule-result.js b/src/rule-result.js index 09350c7..837d863 100644 --- a/src/rule-result.js +++ b/src/rule-result.js @@ -32,6 +32,16 @@ export default class RuleResult { return Promise.resolve() } + resolveEventParamsSync (almanac) { + if (this.event.params !== null && typeof this.event.params === 'object') { + for (const key in this.event.params) { + if (Object.prototype.hasOwnProperty.call(this.event.params, key)) { + this.event.params[key] = almanac.getValue(this.event.params[key]) + } + } + } + } + toJSON (stringify = true) { const props = { conditions: this.conditions.toJSON(false), diff --git a/src/sync/almanac-sync.js b/src/sync/almanac-sync.js new file mode 100644 index 0000000..f05b017 --- /dev/null +++ b/src/sync/almanac-sync.js @@ -0,0 +1,181 @@ +'use strict' + +import FactSync from './fact-sync' +import { UndefinedFactError } from '../errors' +import debug from '../debug' + +import { JSONPath } from 'jsonpath-plus' + +function defaultPathResolver (value, path) { + return JSONPath({ path, json: value, wrap: false }) +} + +/** + * Synchronous fact results lookup + * Triggers fact computations and saves the results + * A new almanac is used for every engine run() + */ +export default class AlmanacSync { + constructor (options = {}) { + this.factMap = new Map() + this.factResultsCache = new Map() // { cacheKey: factValue } + this.allowUndefinedFacts = Boolean(options.allowUndefinedFacts) + this.pathResolver = options.pathResolver || defaultPathResolver + this.events = { success: [], failure: [] } + this.ruleResults = [] + } + + /** + * Adds a success event + * @param {Object} event + */ + addEvent (event, outcome) { + if (!outcome) throw new Error('outcome required: "success" | "failure"]') + this.events[outcome].push(event) + } + + /** + * retrieve successful events + */ + getEvents (outcome = '') { + if (outcome) return this.events[outcome] + return this.events.success.concat(this.events.failure) + } + + /** + * Adds a rule result + * @param {Object} event + */ + addResult (ruleResult) { + this.ruleResults.push(ruleResult) + } + + /** + * retrieve successful events + */ + getResults () { + return this.ruleResults + } + + /** + * Retrieve fact by id, raising an exception if it DNE + * @param {String} factId + * @return {FactSync} + */ + _getFact (factId) { + return this.factMap.get(factId) + } + + /** + * Registers fact with the almanac + * @param {[type]} fact [description] + */ + _addConstantFact (fact) { + this.factMap.set(fact.id, fact) + this._setFactValue(fact, {}, fact.value) + } + + /** + * Sets the computed value of a fact (synchronous) + * @param {FactSync} fact + * @param {Object} params - values for differentiating this fact value from others, used for cache key + * @param {Mixed} value - computed value + */ + _setFactValue (fact, params, value) { + const cacheKey = fact.getCacheKey(params) + if (cacheKey) { + this.factResultsCache.set(cacheKey, value) + } + return value + } + + /** + * Add a fact definition to the engine. Facts are called by rules as they are evaluated. + * @param {object|FactSync} id - fact identifier or instance of FactSync + * @param {function} definitionFunc - function to be called when computing the fact value for a given rule + * @param {Object} options - options to initialize the fact with. used when "id" is not a FactSync instance + */ + addFact (id, valueOrMethod, options) { + let factId = id + let fact + if (id instanceof FactSync) { + factId = id.id + fact = id + } else { + fact = new FactSync(id, valueOrMethod, options) + } + debug('almanac::addFact', { id: factId }) + this.factMap.set(factId, fact) + if (fact.isConstant()) { + this._setFactValue(fact, {}, fact.value) + } + return this + } + + /** + * Adds a constant fact during runtime. Can be used mid-run() to add additional information + * @deprecated use addFact + * @param {String} fact - fact identifier + * @param {Mixed} value - constant value of the fact + */ + addRuntimeFact (factId, value) { + debug('almanac::addRuntimeFact', { id: factId }) + const fact = new FactSync(factId, value) + return this._addConstantFact(fact) + } + + /** + * Returns the value of a fact, based on the given parameters (synchronous) + * @param {string} factId - fact identifier + * @param {Object} params - parameters to feed into the fact + * @param {String} path - object path + * @return {any} fact computation result + */ + factValue (factId, params = {}, path = '') { + let factValue + const fact = this._getFact(factId) + if (fact === undefined) { + if (this.allowUndefinedFacts) { + return undefined + } else { + throw new UndefinedFactError(`Undefined fact: ${factId}`) + } + } + if (fact.isConstant()) { + factValue = fact.calculate(params, this) + } else { + const cacheKey = fact.getCacheKey(params) + const cacheVal = cacheKey && this.factResultsCache.get(cacheKey) + if (cacheVal !== undefined) { + factValue = cacheVal + debug('almanac::factValue cache hit for fact', { id: factId }) + } else { + debug('almanac::factValue cache miss, calculating', { id: factId }) + factValue = this._setFactValue(fact, params, fact.calculate(params, this)) + } + } + if (path) { + debug('condition::evaluate extracting object', { property: path }) + if (factValue != null && typeof factValue === 'object') { + const pathValue = this.pathResolver(factValue, path) + debug('condition::evaluate extracting object', { property: path, received: pathValue }) + return pathValue + } else { + debug('condition::evaluate could not compute object path of non-object', { path, factValue, type: typeof factValue }) + return factValue + } + } + + return factValue + } + + /** + * Interprets value as either a primitive, or if a fact, retrieves the fact value (synchronous) + */ + getValue (value) { + if (value != null && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'fact')) { + return this.factValue(value.fact, value.params, value.path) + } + return value + } +} diff --git a/src/sync/condition-sync.js b/src/sync/condition-sync.js new file mode 100644 index 0000000..d54f05d --- /dev/null +++ b/src/sync/condition-sync.js @@ -0,0 +1,154 @@ +'use strict' + +import debug from '../debug' + +export default class ConditionSync { + constructor (properties) { + if (!properties) throw new Error('Condition: constructor options required') + const booleanOperator = ConditionSync.booleanOperator(properties) + Object.assign(this, properties) + if (booleanOperator) { + const subConditions = properties[booleanOperator] + const subConditionsIsArray = Array.isArray(subConditions) + if (booleanOperator !== 'not' && !subConditionsIsArray) { throw new Error(`"${booleanOperator}" must be an array`) } + if (booleanOperator === 'not' && subConditionsIsArray) { throw new Error(`"${booleanOperator}" cannot be an array`) } + this.operator = booleanOperator + this.priority = parseInt(properties.priority, 10) || 1 + if (subConditionsIsArray) { + this[booleanOperator] = subConditions.map((c) => new ConditionSync(c)) + } else { + this[booleanOperator] = new ConditionSync(subConditions) + } + } else if (!Object.prototype.hasOwnProperty.call(properties, 'condition')) { + if (!Object.prototype.hasOwnProperty.call(properties, 'fact')) { throw new Error('Condition: constructor "fact" property required') } + if (!Object.prototype.hasOwnProperty.call(properties, 'operator')) { throw new Error('Condition: constructor "operator" property required') } + if (!Object.prototype.hasOwnProperty.call(properties, 'value')) { throw new Error('Condition: constructor "value" property required') } + + if (Object.prototype.hasOwnProperty.call(properties, 'priority')) { + properties.priority = parseInt(properties.priority, 10) + } + } + } + + /** + * Converts the condition into a json-friendly structure + * @param {Boolean} stringify - whether to return as a json string + * @returns {string,object} json string or json-friendly object + */ + toJSON (stringify = true) { + const props = {} + if (this.priority) { + props.priority = this.priority + } + if (this.name) { + props.name = this.name + } + const oper = ConditionSync.booleanOperator(this) + if (oper) { + if (Array.isArray(this[oper])) { + props[oper] = this[oper].map((c) => c.toJSON(false)) + } else { + props[oper] = this[oper].toJSON(false) + } + } else if (this.isConditionReference()) { + props.condition = this.condition + } else { + props.operator = this.operator + props.value = this.value + props.fact = this.fact + if (this.factResult !== undefined) { + props.factResult = this.factResult + } + if (this.valueResult !== undefined) { + props.valueResult = this.valueResult + } + if (this.result !== undefined) { + props.result = this.result + } + if (this.params) { + props.params = this.params + } + if (this.path) { + props.path = this.path + } + } + if (stringify) { + return JSON.stringify(props) + } + return props + } + + /** + * Takes the fact result and compares it to the condition 'value', using the operator (synchronous) + * @param {AlmanacSync} almanac + * @param {Map} operatorMap - map of available operators, keyed by operator name + * @returns {Object} - evaluation result + */ + evaluate (almanac, operatorMap) { + if (!almanac) throw new Error('almanac required') + if (!operatorMap) throw new Error('operatorMap required') + if (this.isBooleanOperator()) { throw new Error('Cannot evaluate() a boolean condition') } + + const op = operatorMap.get(this.operator) + if (!op) { throw new Error(`Unknown operator: ${this.operator}`) } + + const rightHandSideValue = almanac.getValue(this.value) + const leftHandSideValue = almanac.factValue(this.fact, this.params, this.path) + + const result = op.evaluate(leftHandSideValue, rightHandSideValue) + debug( + 'condition::evaluate', { + leftHandSideValue, + operator: this.operator, + rightHandSideValue, + result + } + ) + return { + result, + leftHandSideValue, + rightHandSideValue, + operator: this.operator + } + } + + /** + * Returns the boolean operator for the condition + * If the condition is not a boolean condition, the result will be 'undefined' + * @return {string 'all', 'any', or 'not'} + */ + static booleanOperator (condition) { + if (Object.prototype.hasOwnProperty.call(condition, 'any')) { + return 'any' + } else if (Object.prototype.hasOwnProperty.call(condition, 'all')) { + return 'all' + } else if (Object.prototype.hasOwnProperty.call(condition, 'not')) { + return 'not' + } + } + + /** + * Returns the condition's boolean operator + * Instance version of ConditionSync.isBooleanOperator + * @returns {string,undefined} - 'any', 'all', 'not' or undefined (if not a boolean condition) + */ + booleanOperator () { + return ConditionSync.booleanOperator(this) + } + + /** + * Whether the operator is boolean ('all', 'any', 'not') + * @returns {Boolean} + */ + isBooleanOperator () { + return ConditionSync.booleanOperator(this) !== undefined + } + + /** + * Whether the condition represents a reference to a condition + * @returns {Boolean} + */ + isConditionReference () { + return Object.prototype.hasOwnProperty.call(this, 'condition') + } +} diff --git a/src/sync/engine-sync.js b/src/sync/engine-sync.js new file mode 100644 index 0000000..7b45ce5 --- /dev/null +++ b/src/sync/engine-sync.js @@ -0,0 +1,310 @@ +'use strict' + +import FactSync from './fact-sync' +import RuleSync from './rule-sync' +import AlmanacSync from './almanac-sync' +import EventEmitter from 'eventemitter2' +import defaultOperators from '../engine-default-operators' +import defaultDecorators from '../engine-default-operator-decorators' +import debug from '../debug' +import ConditionSync from './condition-sync' +import OperatorMap from '../operator-map' + +export const READY = 'READY' +export const RUNNING = 'RUNNING' +export const FINISHED = 'FINISHED' + +class EngineSync extends EventEmitter { + /** + * Returns a new EngineSync instance + * @param {RuleSync[]} rules - array of rules to initialize with + */ + constructor (rules = [], options = {}) { + super() + this.rules = [] + this.allowUndefinedFacts = options.allowUndefinedFacts || false + this.allowUndefinedConditions = options.allowUndefinedConditions || false + this.replaceFactsInEventParams = options.replaceFactsInEventParams || false + this.pathResolver = options.pathResolver + this.operators = new OperatorMap() + this.facts = new Map() + this.conditions = new Map() + this.status = READY + rules.map(r => this.addRule(r)) + defaultOperators.map(o => this.addOperator(o)) + defaultDecorators.map(d => this.addOperatorDecorator(d)) + } + + /** + * Add a rule definition to the engine + * @param {object|RuleSync} properties - rule definition + */ + addRule (properties) { + if (!properties) throw new Error('Engine: addRule() requires options') + + let rule + if (properties instanceof RuleSync) { + rule = properties + } else { + if (!Object.prototype.hasOwnProperty.call(properties, 'event')) throw new Error('Engine: addRule() argument requires "event" property') + if (!Object.prototype.hasOwnProperty.call(properties, 'conditions')) throw new Error('Engine: addRule() argument requires "conditions" property') + rule = new RuleSync(properties) + } + rule.setEngine(this) + this.rules.push(rule) + this.prioritizedRules = null + return this + } + + /** + * update a rule in the engine + * @param {object|RuleSync} rule - rule definition + */ + updateRule (rule) { + const ruleIndex = this.rules.findIndex(ruleInEngine => ruleInEngine.name === rule.name) + if (ruleIndex > -1) { + this.rules.splice(ruleIndex, 1) + this.addRule(rule) + this.prioritizedRules = null + } else { + throw new Error('Engine: updateRule() rule not found') + } + } + + /** + * Remove a rule from the engine + * @param {object|RuleSync|string} rule - rule definition + */ + removeRule (rule) { + let ruleRemoved = false + if (!(rule instanceof RuleSync)) { + const filteredRules = this.rules.filter(ruleInEngine => ruleInEngine.name !== rule) + ruleRemoved = filteredRules.length !== this.rules.length + this.rules = filteredRules + } else { + const index = this.rules.indexOf(rule) + if (index > -1) { + ruleRemoved = Boolean(this.rules.splice(index, 1).length) + } + } + if (ruleRemoved) { + this.prioritizedRules = null + } + return ruleRemoved + } + + /** + * sets a condition that can be referenced by the given name + * @param {string} name - the name of the condition to be referenced by rules + * @param {object} conditions - the conditions to use when the condition is referenced + */ + setCondition (name, conditions) { + if (!name) throw new Error('Engine: setCondition() requires name') + if (!conditions) throw new Error('Engine: setCondition() requires conditions') + if (!Object.prototype.hasOwnProperty.call(conditions, 'all') && !Object.prototype.hasOwnProperty.call(conditions, 'any') && !Object.prototype.hasOwnProperty.call(conditions, 'not') && !Object.prototype.hasOwnProperty.call(conditions, 'condition')) { + throw new Error('"conditions" root must contain a single instance of "all", "any", "not", or "condition"') + } + this.conditions.set(name, new ConditionSync(conditions)) + return this + } + + /** + * Removes a condition that has previously been added to this engine + * @param {string} name - the name of the condition to remove + * @returns true if the condition existed, otherwise false + */ + removeCondition (name) { + return this.conditions.delete(name) + } + + /** + * Add a custom operator definition + * @param {string} operatorOrName - operator identifier + * @param {function(factValue, jsonValue)} callback - the method to execute when the operator is encountered + */ + addOperator (operatorOrName, cb) { + this.operators.addOperator(operatorOrName, cb) + } + + /** + * Remove a custom operator definition + * @param {string} operatorOrName - operator identifier + */ + removeOperator (operatorOrName) { + return this.operators.removeOperator(operatorOrName) + } + + /** + * Add a custom operator decorator + * @param {string} decoratorOrName - decorator identifier + * @param {function(factValue, jsonValue, next)} callback - the method to execute when the decorator is encountered + */ + addOperatorDecorator (decoratorOrName, cb) { + this.operators.addOperatorDecorator(decoratorOrName, cb) + } + + /** + * Remove a custom operator decorator + * @param {string} decoratorOrName - decorator identifier + */ + removeOperatorDecorator (decoratorOrName) { + return this.operators.removeOperatorDecorator(decoratorOrName) + } + + /** + * Add a fact definition to the engine + * @param {object|FactSync} id - fact identifier or instance of FactSync + * @param {function} definitionFunc - function to be called when computing the fact value for a given rule + * @param {Object} options - options to initialize the fact with + */ + addFact (id, valueOrMethod, options) { + let factId = id + let fact + if (id instanceof FactSync) { + factId = id.id + fact = id + } else { + fact = new FactSync(id, valueOrMethod, options) + } + debug('engine::addFact', { id: factId }) + this.facts.set(factId, fact) + return this + } + + /** + * Remove a fact definition to the engine + * @param {object|FactSync} id - fact identifier or instance of FactSync + */ + removeFact (factOrId) { + let factId + if (!(factOrId instanceof FactSync)) { + factId = factOrId + } else { + factId = factOrId.id + } + + return this.facts.delete(factId) + } + + /** + * Iterates over the engine rules, organizing them by highest -> lowest priority + * @return {RuleSync[][]} two dimensional array of Rules + */ + prioritizeRules () { + if (!this.prioritizedRules) { + const ruleSets = this.rules.reduce((sets, rule) => { + const priority = rule.priority + if (!sets[priority]) sets[priority] = [] + sets[priority].push(rule) + return sets + }, {}) + this.prioritizedRules = Object.keys(ruleSets).sort((a, b) => { + return Number(a) > Number(b) ? -1 : 1 + }).map((priority) => ruleSets[priority]) + } + return this.prioritizedRules + } + + /** + * Stops the rules engine from running the next priority set of Rules + * @return {EngineSync} + */ + stop () { + this.status = FINISHED + return this + } + + /** + * Returns a fact by fact-id + * @param {string} factId - fact identifier + * @return {FactSync} fact instance, or undefined if no such fact exists + */ + getFact (factId) { + return this.facts.get(factId) + } + + /** + * Runs an array of rules (synchronous) + * @param {RuleSync[]} array of rules to be evaluated + * @return {Object} evaluation results + */ + evaluateRules (ruleArray, almanac) { + const results = [] + for (const rule of ruleArray) { + if (this.status !== RUNNING) { + debug('engine::run, skipping remaining rules', { status: this.status }) + break + } + const ruleResult = rule.evaluate(almanac) + debug('engine::run', { ruleResult: ruleResult.result }) + almanac.addResult(ruleResult) + if (ruleResult.result) { + almanac.addEvent(ruleResult.event, 'success') + this.emit('success', ruleResult.event, almanac, ruleResult) + this.emit(ruleResult.event.type, ruleResult.event.params, almanac, ruleResult) + } else { + almanac.addEvent(ruleResult.event, 'failure') + this.emit('failure', ruleResult.event, almanac, ruleResult) + } + results.push(ruleResult) + } + return results + } + + /** + * Runs the rules engine (synchronous) + * @param {Object} runtimeFacts - fact values known at runtime + * @param {Object} runOptions - run options + * @return {Object} evaluation results + */ + run (runtimeFacts = {}, runOptions = {}) { + debug('engine::run started') + this.status = RUNNING + + const almanac = runOptions.almanac || new AlmanacSync({ + allowUndefinedFacts: this.allowUndefinedFacts, + pathResolver: this.pathResolver + }) + + this.facts.forEach(fact => { + almanac.addFact(fact) + }) + for (const factId in runtimeFacts) { + let fact + if (runtimeFacts[factId] instanceof FactSync) { + fact = runtimeFacts[factId] + } else { + fact = new FactSync(factId, runtimeFacts[factId]) + } + + almanac.addFact(fact) + debug('engine::run initialized runtime fact', { id: fact.id, value: fact.value, type: typeof fact.value }) + } + + const orderedSets = this.prioritizeRules() + + for (const set of orderedSets) { + this.evaluateRules(set, almanac) + if (this.status === FINISHED) break + } + + this.status = FINISHED + debug('engine::run completed') + const ruleResults = almanac.getResults() + const { results, failureResults } = ruleResults.reduce((hash, ruleResult) => { + const group = ruleResult.result ? 'results' : 'failureResults' + hash[group].push(ruleResult) + return hash + }, { results: [], failureResults: [] }) + + return { + almanac, + results, + failureResults, + events: almanac.getEvents('success'), + failureEvents: almanac.getEvents('failure') + } + } +} + +export default EngineSync diff --git a/src/sync/fact-sync.js b/src/sync/fact-sync.js new file mode 100644 index 0000000..0bd18da --- /dev/null +++ b/src/sync/fact-sync.js @@ -0,0 +1,96 @@ +'use strict' + +import hash from 'hash-it' + +class FactSync { + /** + * Returns a new fact instance + * @param {string} id - fact unique identifer + * @param {object} options + * @param {boolean} options.cache - whether to cache the fact's value for future rules + * @param {primitive|function} valueOrMethod - constant primitive, or method to call when computing the fact's value + * @return {FactSync} + */ + constructor (id, valueOrMethod, options) { + this.id = id + const defaultOptions = { cache: true } + if (typeof options === 'undefined') { + options = defaultOptions + } + if (typeof valueOrMethod !== 'function') { + this.value = valueOrMethod + this.type = this.constructor.CONSTANT + } else { + this.calculationMethod = valueOrMethod + this.type = this.constructor.DYNAMIC + } + + if (!this.id) throw new Error('factId required') + + this.priority = parseInt(options.priority || 1, 10) + this.options = Object.assign({}, defaultOptions, options) + this.cacheKeyMethod = this.defaultCacheKeys + return this + } + + isConstant () { + return this.type === this.constructor.CONSTANT + } + + isDynamic () { + return this.type === this.constructor.DYNAMIC + } + + /** + * Return the fact value, based on provided parameters (synchronous) + * @param {object} params + * @param {AlmanacSync} almanac + * @return {any} calculation method results + */ + calculate (params, almanac) { + if (Object.prototype.hasOwnProperty.call(this, 'value')) { + return this.value + } + return this.calculationMethod(params, almanac) + } + + /** + * Return a cache key (MD5 string) based on parameters + * @param {object} obj - properties to generate a hash key from + * @return {string} MD5 string based on the hash'd object + */ + static hashFromObject (obj) { + return hash(obj) + } + + /** + * Default properties to use when caching a fact + * Assumes every fact is a pure function, whose computed value will only + * change when input params are modified + * @param {string} id - fact unique identifer + * @param {object} params - parameters passed to fact calcution method + * @return {object} id + params + */ + defaultCacheKeys (id, params) { + return { params, id } + } + + /** + * Generates the fact's cache key(MD5 string) + * Returns nothing if the fact's caching has been disabled + * @param {object} params - parameters that would be passed to the computation method + * @return {string} cache key + */ + getCacheKey (params) { + if (this.options.cache === true) { + const cacheProperties = this.cacheKeyMethod(this.id, params) + const hash = FactSync.hashFromObject(cacheProperties) + return hash + } + } +} + +FactSync.CONSTANT = 'CONSTANT' +FactSync.DYNAMIC = 'DYNAMIC' + +export default FactSync diff --git a/src/sync/index-sync.js b/src/sync/index-sync.js new file mode 100644 index 0000000..e8c8ee6 --- /dev/null +++ b/src/sync/index-sync.js @@ -0,0 +1,32 @@ +'use strict' + +import EngineSync from './engine-sync' +import RuleSync from './rule-sync' +import FactSync from './fact-sync' +import AlmanacSync from './almanac-sync' +import ConditionSync from './condition-sync' +import Operator from '../operator' +import OperatorDecorator from '../operator-decorator' + +/** + * Basic engine interface + * @param {Rule[]} rules - rules to initialize with + * @param {Object} options - engine options + * @return {EngineSync} engine instance + */ +function engineSync (rules, options) { + return new EngineSync(rules, options) +} + +export { + EngineSync, + RuleSync, + FactSync, + AlmanacSync, + ConditionSync, + Operator, + OperatorDecorator, + engineSync +} + +export default engineSync diff --git a/src/sync/rule-sync.js b/src/sync/rule-sync.js new file mode 100644 index 0000000..7e13e7b --- /dev/null +++ b/src/sync/rule-sync.js @@ -0,0 +1,354 @@ +'use strict' + +import ConditionSync from './condition-sync' +import RuleResult from '../rule-result' +import debug from '../debug' +import deepClone from 'clone' +import EventEmitter from 'eventemitter2' + +class RuleSync extends EventEmitter { + /** + * returns a new Rule instance + * @param {object,string} options, or json string that can be parsed into options + * @param {integer} options.priority (>1) - higher runs sooner. + * @param {Object} options.event - event to fire when rule evaluates as successful + * @param {string} options.event.type - name of event to emit + * @param {string} options.event.params - parameters to pass to the event listener + * @param {Object} options.conditions - conditions to evaluate when processing this rule + * @param {any} options.name - identifier for a particular rule, particularly valuable in RuleResult output + * @return {RuleSync} instance + */ + constructor (options) { + super() + if (typeof options === 'string') { + options = JSON.parse(options) + } + if (options && options.conditions) { + this.setConditions(options.conditions) + } + if (options && options.onSuccess) { + this.on('success', options.onSuccess) + } + if (options && options.onFailure) { + this.on('failure', options.onFailure) + } + if (options && (options.name || options.name === 0)) { + this.setName(options.name) + } + + const priority = (options && options.priority) || 1 + this.setPriority(priority) + + const event = (options && options.event) || { type: 'unknown' } + this.setEvent(event) + } + + /** + * Sets the priority of the rule + * @param {integer} priority (>=1) - increasing the priority causes the rule to be run prior to other rules + */ + setPriority (priority) { + priority = parseInt(priority, 10) + if (priority <= 0) throw new Error('Priority must be greater than zero') + this.priority = priority + return this + } + + /** + * Sets the name of the rule + * @param {any} name - any truthy input and zero is allowed + */ + setName (name) { + if (!name && name !== 0) { + throw new Error('Rule "name" must be defined') + } + this.name = name + return this + } + + /** + * Sets the conditions to run when evaluating the rule. + * @param {object} conditions - conditions, root element must be a boolean operator + */ + setConditions (conditions) { + if ( + !Object.prototype.hasOwnProperty.call(conditions, 'all') && + !Object.prototype.hasOwnProperty.call(conditions, 'any') && + !Object.prototype.hasOwnProperty.call(conditions, 'not') && + !Object.prototype.hasOwnProperty.call(conditions, 'condition') + ) { + throw new Error( + '"conditions" root must contain a single instance of "all", "any", "not", or "condition"' + ) + } + this.conditions = new ConditionSync(conditions) + return this + } + + /** + * Sets the event to emit when the conditions evaluate truthy + * @param {object} event - event to emit + * @param {string} event.type - event name to emit on + * @param {string} event.params - parameters to emit as the argument of the event emission + */ + setEvent (event) { + if (!event) throw new Error('Rule: setEvent() requires event object') + if (!Object.prototype.hasOwnProperty.call(event, 'type')) { + throw new Error( + 'Rule: setEvent() requires event object with "type" property' + ) + } + this.ruleEvent = { + type: event.type + } + this.event = this.ruleEvent + if (event.params) this.ruleEvent.params = event.params + return this + } + + /** + * returns the event object + * @returns {Object} event + */ + getEvent () { + return this.ruleEvent + } + + /** + * returns the priority + * @returns {Number} priority + */ + getPriority () { + return this.priority + } + + /** + * returns the event object + * @returns {Object} event + */ + getConditions () { + return this.conditions + } + + /** + * returns the engine object + * @returns {Object} engine + */ + getEngine () { + return this.engine + } + + /** + * Sets the engine to run the rules under + * @param {object} engine + * @returns {RuleSync} + */ + setEngine (engine) { + this.engine = engine + return this + } + + toJSON (stringify = true) { + const props = { + conditions: this.conditions.toJSON(false), + priority: this.priority, + event: this.ruleEvent, + name: this.name + } + if (stringify) { + return JSON.stringify(props) + } + return props + } + + /** + * Priorizes an array of conditions based on "priority" + * @param {ConditionSync[]} conditions + * @return {ConditionSync[][]} prioritized two-dimensional array of conditions + */ + prioritizeConditions (conditions) { + const factSets = conditions.reduce((sets, condition) => { + let priority = condition.priority + if (!priority) { + const fact = this.engine.getFact(condition.fact) + priority = (fact && fact.priority) || 1 + } + if (!sets[priority]) sets[priority] = [] + sets[priority].push(condition) + return sets + }, {}) + return Object.keys(factSets) + .sort((a, b) => { + return Number(a) > Number(b) ? -1 : 1 + }) + .map((priority) => factSets[priority]) + } + + /** + * Evaluates the rule, starting with the root boolean operator and recursing down (synchronous) + * @return {RuleResult} rule evaluation result + */ + evaluate (almanac) { + const ruleResult = new RuleResult( + this.conditions, + this.ruleEvent, + this.priority, + this.name + ) + + /** + * Evaluates the rule conditions (synchronous) + * @param {ConditionSync} condition - condition to evaluate + * @return {boolean} - result of the condition evaluation + */ + const evaluateCondition = (condition) => { + if (condition.isConditionReference()) { + return realize(condition) + } else if (condition.isBooleanOperator()) { + const subConditions = condition[condition.operator] + let comparisonValue + if (condition.operator === 'all') { + comparisonValue = all(subConditions) + } else if (condition.operator === 'any') { + comparisonValue = any(subConditions) + } else { + comparisonValue = not(subConditions) + } + const passes = comparisonValue === true + condition.result = passes + return passes + } else { + const evaluationResult = condition.evaluate(almanac, this.engine.operators) + const passes = evaluationResult.result + condition.factResult = evaluationResult.leftHandSideValue + condition.valueResult = evaluationResult.rightHandSideValue + condition.result = passes + return passes + } + } + + /** + * Evalutes an array of conditions, using an 'every' or 'some' array operation (synchronous) + * @param {ConditionSync[]} conditions + * @param {string(every|some)} array method to call for determining result + * @return {boolean} whether conditions evaluated truthy or falsey + */ + const evaluateConditions = (conditions, method) => { + if (!Array.isArray(conditions)) conditions = [conditions] + + const conditionResults = conditions.map((condition) => evaluateCondition(condition)) + debug('rule::evaluateConditions', { results: conditionResults }) + return method.call(conditionResults, (result) => result === true) + } + + /** + * Evaluates a set of conditions based on an 'all', 'any', or 'not' operator (synchronous) + * @param {ConditionSync[]} conditions - conditions to be evaluated + * @param {string('all'|'any'|'not')} operator + * @return {boolean} rule evaluation result + */ + const prioritizeAndRun = (conditions, operator) => { + if (conditions.length === 0) { + return true + } + if (conditions.length === 1) { + return evaluateCondition(conditions[0]) + } + const orderedSets = this.prioritizeConditions(conditions) + let result = operator === 'all' + + for (let i = 0; i < orderedSets.length; i++) { + const set = orderedSets[i] + if (operator === 'any') { + result = result || evaluateConditions(set, Array.prototype.some) + if (result) break // short-circuit for 'any' + } else { + result = result && evaluateConditions(set, Array.prototype.every) + if (!result) break // short-circuit for 'all' + } + } + return result + } + + /** + * Runs an 'any' boolean operator on an array of conditions (synchronous) + * @param {ConditionSync[]} conditions to be evaluated + * @return {boolean} condition evaluation result + */ + const any = (conditions) => { + return prioritizeAndRun(conditions, 'any') + } + + /** + * Runs an 'all' boolean operator on an array of conditions (synchronous) + * @param {ConditionSync[]} conditions to be evaluated + * @return {boolean} condition evaluation result + */ + const all = (conditions) => { + return prioritizeAndRun(conditions, 'all') + } + + /** + * Runs a 'not' boolean operator on a single condition (synchronous) + * @param {ConditionSync} condition to be evaluated + * @return {boolean} condition evaluation result + */ + const not = (condition) => { + return !prioritizeAndRun([condition], 'not') + } + + /** + * Dereferences the condition reference and then evaluates it (synchronous) + * @param {ConditionSync} conditionReference + * @returns {boolean} condition evaluation result + */ + const realize = (conditionReference) => { + const condition = this.engine.conditions.get(conditionReference.condition) + if (!condition) { + if (this.engine.allowUndefinedConditions) { + conditionReference.result = false + return false + } else { + throw new Error( + `No condition ${conditionReference.condition} exists` + ) + } + } else { + delete conditionReference.condition + Object.assign(conditionReference, deepClone(condition)) + return evaluateCondition(conditionReference) + } + } + + /** + * Emits based on rule evaluation result, and decorates ruleResult with 'result' property (synchronous) + * @param {boolean} result + */ + const processResult = (result) => { + ruleResult.setResult(result) + + if (this.engine.replaceFactsInEventParams) { + ruleResult.resolveEventParamsSync(almanac) + } + const event = result ? 'success' : 'failure' + this.emit(event, ruleResult.event, almanac, ruleResult) + return ruleResult + } + + if (ruleResult.conditions.any) { + const result = any(ruleResult.conditions.any) + return processResult(result) + } else if (ruleResult.conditions.all) { + const result = all(ruleResult.conditions.all) + return processResult(result) + } else if (ruleResult.conditions.not) { + const result = not(ruleResult.conditions.not) + return processResult(result) + } else { + const result = realize(ruleResult.conditions) + return processResult(result) + } + } +} + +export default RuleSync diff --git a/test/sync/engine-sync.test.js b/test/sync/engine-sync.test.js new file mode 100644 index 0000000..6e98973 --- /dev/null +++ b/test/sync/engine-sync.test.js @@ -0,0 +1,176 @@ +'use strict' + +import sinon from 'sinon' +import engineSyncFactory, { Operator } from '../../src/sync/index-sync' +import defaultOperators from '../../src/engine-default-operators' + +describe('EngineSync', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + beforeEach(() => { + engine = engineSyncFactory() + }) + + it('has methods for managing facts and rules, and running itself', () => { + expect(engine).to.have.property('addRule') + expect(engine).to.have.property('removeRule') + expect(engine).to.have.property('addOperator') + expect(engine).to.have.property('removeOperator') + expect(engine).to.have.property('addFact') + expect(engine).to.have.property('removeFact') + expect(engine).to.have.property('run') + expect(engine).to.have.property('stop') + }) + + describe('constructor', () => { + it('initializes with the default state', () => { + expect(engine.status).to.equal('READY') + expect(engine.rules.length).to.equal(0) + defaultOperators.forEach(op => { + expect(engine.operators.get(op.name)).to.be.an.instanceof(Operator) + }) + }) + + it('can be initialized with rules', () => { + const rules = [ + { conditions: { all: [{ fact: 'test', operator: 'equal', value: 1 }] }, event: { type: 'test' } }, + { conditions: { all: [{ fact: 'test', operator: 'equal', value: 2 }] }, event: { type: 'test' } }, + { conditions: { all: [{ fact: 'test', operator: 'equal', value: 3 }] }, event: { type: 'test' } } + ] + engine = engineSyncFactory(rules) + expect(engine.rules.length).to.equal(rules.length) + }) + }) + + describe('basic functionality', () => { + it('runs synchronously and returns results immediately', () => { + engine.addRule({ + conditions: { + all: [{ + fact: 'testFact', + operator: 'equal', + value: 'testValue' + }] + }, + event: { + type: 'testEvent', + params: { + message: 'Test message' + } + } + }) + + const result = engine.run({ testFact: 'testValue' }) + + expect(result).to.have.property('events') + expect(result).to.have.property('results') + expect(result).to.have.property('failureEvents') + expect(result).to.have.property('failureResults') + expect(result.events).to.have.lengthOf(1) + expect(result.events[0].type).to.equal('testEvent') + expect(result.events[0].params.message).to.equal('Test message') + }) + + it('handles failing conditions', () => { + engine.addRule({ + conditions: { + all: [{ + fact: 'testFact', + operator: 'equal', + value: 'expectedValue' + }] + }, + event: { + type: 'testEvent' + } + }) + + const result = engine.run({ testFact: 'actualValue' }) + + expect(result.events).to.have.lengthOf(0) + expect(result.failureEvents).to.have.lengthOf(1) + }) + + it('handles multiple rules with different priorities', () => { + engine.addRule({ + priority: 2, + conditions: { + all: [{ + fact: 'priority', + operator: 'equal', + value: 'high' + }] + }, + event: { + type: 'highPriority' + } + }) + + engine.addRule({ + priority: 1, + conditions: { + all: [{ + fact: 'priority', + operator: 'equal', + value: 'high' + }] + }, + event: { + type: 'lowPriority' + } + }) + + const result = engine.run({ priority: 'high' }) + + expect(result.events).to.have.lengthOf(2) + expect(result.events[0].type).to.equal('highPriority') + expect(result.events[1].type).to.equal('lowPriority') + }) + }) + + describe('fact management', () => { + it('adds and uses constant facts', () => { + engine.addFact('constantFact', 42) + engine.addRule({ + conditions: { + all: [{ + fact: 'constantFact', + operator: 'equal', + value: 42 + }] + }, + event: { type: 'success' } + }) + + const result = engine.run({}) + expect(result.events).to.have.lengthOf(1) + }) + + it('adds and uses dynamic facts', () => { + engine.addFact('dynamicFact', (params, almanac) => { + return params.multiplier * 2 + }) + + engine.addRule({ + conditions: { + all: [{ + fact: 'dynamicFact', + operator: 'equal', + value: 10, + params: { multiplier: 5 } + }] + }, + event: { type: 'success' } + }) + + const result = engine.run({}) + expect(result.events).to.have.lengthOf(1) + }) + }) +}) From 0cc46c1a01f6976ba761e05dbf6ea992fc8edcbc Mon Sep 17 00:00:00 2001 From: Manuel Reil Date: Sun, 17 Aug 2025 10:24:13 +0200 Subject: [PATCH 3/7] Harmonizes import --- src/json-rules-engine.js | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/src/json-rules-engine.js b/src/json-rules-engine.js index bed371d..6eb93ba 100644 --- a/src/json-rules-engine.js +++ b/src/json-rules-engine.js @@ -5,7 +5,28 @@ import Operator from './operator' import Almanac from './almanac' import OperatorDecorator from './operator-decorator' -export { Fact, Rule, Operator, Engine, Almanac, OperatorDecorator } +// Import sync variants +import EngineSync from './sync/engine-sync' +import FactSync from './sync/fact-sync' +import RuleSync from './sync/rule-sync' +import AlmanacSync from './sync/almanac-sync' +import ConditionSync from './sync/condition-sync' + +export { + Fact, + Rule, + Operator, + Engine, + Almanac, + OperatorDecorator, + // Sync variants + EngineSync, + FactSync, + RuleSync, + AlmanacSync, + ConditionSync +} + export default function (rules, options) { return new Engine(rules, options) } From 644383e1e93c1c60089eb385d15648c1a309f990 Mon Sep 17 00:00:00 2001 From: Manuel Reil Date: Sun, 17 Aug 2025 12:13:39 +0200 Subject: [PATCH 4/7] Adds fast async variatn for the engine --- .gitignore | 1 + benchmark/benchmark-optimized.js | 107 ++++++ coverage/coverage-final.json | 26 ++ src/optimized/almanac-fast.js | 189 ++++++++++ src/optimized/condition-fast.js | 228 ++++++++++++ src/optimized/engine-fast.js | 266 ++++++++++++++ src/optimized/rule-fast.js | 221 ++++++++++++ test/optimized/engine-fast-all.test.js | 111 ++++++ test/optimized/engine-fast-any.test.js | 107 ++++++ .../engine-fast-comprehensive.test.js | 202 +++++++++++ test/optimized/engine-fast-run.test.js | 136 +++++++ test/optimized/engine-fast.test.js | 333 ++++++++++++++++++ 12 files changed, 1927 insertions(+) create mode 100644 benchmark/benchmark-optimized.js create mode 100644 coverage/coverage-final.json create mode 100644 src/optimized/almanac-fast.js create mode 100644 src/optimized/condition-fast.js create mode 100644 src/optimized/engine-fast.js create mode 100644 src/optimized/rule-fast.js create mode 100644 test/optimized/engine-fast-all.test.js create mode 100644 test/optimized/engine-fast-any.test.js create mode 100644 test/optimized/engine-fast-comprehensive.test.js create mode 100644 test/optimized/engine-fast-run.test.js create mode 100644 test/optimized/engine-fast.test.js diff --git a/.gitignore b/.gitignore index fdb75dd..5bdc2c6 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,4 @@ npm-debug.log dist *.tgz package-lock.json +.nyc_output \ No newline at end of file diff --git a/benchmark/benchmark-optimized.js b/benchmark/benchmark-optimized.js new file mode 100644 index 0000000..adfe106 --- /dev/null +++ b/benchmark/benchmark-optimized.js @@ -0,0 +1,107 @@ +const { Engine, EngineFast } = require('../dist/index') +const { performance } = require('perf_hooks') +const rules = require('./rules') + +async function benchmarkEngine (EngineClass, engineName, numEvents = 1000, numRules = 30) { + console.log(`\n=== ${engineName} Benchmark ===`) + + // Create engine with rules + const engine = new EngineClass() + rules.slice(0, numRules).forEach(rule => engine.addRule(rule)) + + // Generate test events + const { generateEvents } = require('./events') + const events = generateEvents(require('./events').baseEvents, numEvents) + + // Warm-up run with proper fact structure + await engine.run(events[0]) + + // Benchmark run + const startTime = performance.now() + let totalSuccessEvents = 0 + let totalFailureEvents = 0 + + for (const event of events) { + // Pass the event as facts to the engine + const result = await engine.run(event) + totalSuccessEvents += result.events.length + totalFailureEvents += result.failureEvents.length + } + + const endTime = performance.now() + const duration = endTime - startTime + const eventsPerSecond = Math.round(numEvents / (duration / 1000)) + + console.log(`Events processed: ${numEvents}`) + console.log(`Rules per event: ${numRules}`) + console.log(`Total time: ${Math.round(duration)}ms`) + console.log(`Events/second: ${eventsPerSecond}`) + console.log(`Success events: ${totalSuccessEvents}`) + console.log(`Failure events: ${totalFailureEvents}`) + console.log(`Avg time per event: ${Math.round(duration / numEvents * 100) / 100}ms`) + + return { + engineName, + numEvents, + numRules, + duration, + eventsPerSecond, + totalSuccessEvents, + totalFailureEvents, + avgTimePerEvent: duration / numEvents + } +} + +async function runComparison () { + console.log('Performance Comparison: Original vs Optimized Async Engine') + console.log('==========================================================') + + const results = [] + + // Test small workload + console.log('\n--- Small Workload Test (100 events, 10 rules) ---') + results.push(await benchmarkEngine(Engine, 'Original Engine', 100, 10)) + results.push(await benchmarkEngine(EngineFast, 'Optimized Engine (EngineFast)', 100, 10)) + + // Test medium workload + console.log('\n--- Medium Workload Test (500 events, 20 rules) ---') + results.push(await benchmarkEngine(Engine, 'Original Engine', 500, 20)) + results.push(await benchmarkEngine(EngineFast, 'Optimized Engine (EngineFast)', 500, 20)) + + // Test large workload + console.log('\n--- Large Workload Test (1000 events, 30 rules) ---') + results.push(await benchmarkEngine(Engine, 'Original Engine', 1000, 30)) + results.push(await benchmarkEngine(EngineFast, 'Optimized Engine (EngineFast)', 1000, 30)) + + // Performance comparison summary + console.log('\n\n=== PERFORMANCE COMPARISON SUMMARY ===') + + for (let i = 0; i < results.length; i += 2) { + const original = results[i] + const optimized = results[i + 1] + const improvement = ((original.duration - optimized.duration) / original.duration) * 100 + const throughputImprovement = ((optimized.eventsPerSecond - original.eventsPerSecond) / original.eventsPerSecond) * 100 + + console.log(`\n${original.numEvents} events, ${original.numRules} rules:`) + console.log(` Original: ${Math.round(original.duration)}ms (${original.eventsPerSecond} events/sec)`) + console.log(` Optimized: ${Math.round(optimized.duration)}ms (${optimized.eventsPerSecond} events/sec)`) + console.log(` Performance: ${improvement > 0 ? '+' : ''}${Math.round(improvement * 100) / 100}% ${improvement > 0 ? 'faster' : 'slower'}`) + console.log(` Throughput: ${throughputImprovement > 0 ? '+' : ''}${Math.round(throughputImprovement * 100) / 100}% ${throughputImprovement > 0 ? 'better' : 'worse'}`) + } + + // Overall assessment + const totalOriginalTime = results.filter((_, i) => i % 2 === 0).reduce((sum, r) => sum + r.duration, 0) + const totalOptimizedTime = results.filter((_, i) => i % 2 === 1).reduce((sum, r) => sum + r.duration, 0) + const overallImprovement = ((totalOriginalTime - totalOptimizedTime) / totalOriginalTime) * 100 + + console.log('\n=== OVERALL PERFORMANCE ===') + console.log(`Total Original Time: ${Math.round(totalOriginalTime)}ms`) + console.log(`Total Optimized Time: ${Math.round(totalOptimizedTime)}ms`) + console.log(`Overall Improvement: ${overallImprovement > 0 ? '+' : ''}${Math.round(overallImprovement * 100) / 100}% ${overallImprovement > 0 ? 'faster' : 'slower'}`) +} + +if (require.main === module) { + runComparison().catch(console.error) +} + +module.exports = { benchmarkEngine, runComparison } diff --git a/coverage/coverage-final.json b/coverage/coverage-final.json new file mode 100644 index 0000000..6a8b26c --- /dev/null +++ b/coverage/coverage-final.json @@ -0,0 +1,26 @@ +{"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/almanac.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/almanac.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"4":{"start":{"line":10,"column":2},"end":{"line":10,"column":9}},"5":{"start":{"line":19,"column":29},"end":{"line":19,"column":28}},"6":{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},"7":{"start":{"line":20,"column":4},"end":{"line":20,"column":9}},"8":{"start":{"line":21,"column":4},"end":{"line":21,"column":9}},"9":{"start":{"line":22,"column":4},"end":{"line":22,"column":9}},"10":{"start":{"line":23,"column":4},"end":{"line":23,"column":9}},"11":{"start":{"line":24,"column":4},"end":{"line":24,"column":9}},"12":{"start":{"line":25,"column":4},"end":{"line":25,"column":9}},"13":{"start":{"line":33,"column":4},"end":{"line":33,"column":24}},"14":{"start":{"line":33,"column":18},"end":{"line":33,"column":24}},"15":{"start":{"line":34,"column":4},"end":{"line":34,"column":9}},"16":{"start":{"line":40,"column":27},"end":{"line":40,"column":26}},"17":{"start":{"line":41,"column":4},"end":{"line":41,"column":24}},"18":{"start":{"line":41,"column":17},"end":{"line":41,"column":24}},"19":{"start":{"line":42,"column":4},"end":{"line":42,"column":11}},"20":{"start":{"line":50,"column":4},"end":{"line":50,"column":9}},"21":{"start":{"line":57,"column":4},"end":{"line":57,"column":11}},"22":{"start":{"line":66,"column":4},"end":{"line":66,"column":11}},"23":{"start":{"line":74,"column":4},"end":{"line":74,"column":9}},"24":{"start":{"line":75,"column":4},"end":{"line":75,"column":9}},"25":{"start":{"line":85,"column":21},"end":{"line":85,"column":26}},"26":{"start":{"line":86,"column":22},"end":{"line":86,"column":30}},"27":{"start":{"line":87,"column":4},"end":{"line":89,"column":null}},"28":{"start":{"line":88,"column":6},"end":{"line":88,"column":11}},"29":{"start":{"line":90,"column":4},"end":{"line":90,"column":11}},"30":{"start":{"line":100,"column":17},"end":{"line":100,"column":null}},"31":{"start":{"line":101,"column":8},"end":{"line":101,"column":null}},"32":{"start":{"line":102,"column":4},"end":{"line":107,"column":null}},"33":{"start":{"line":103,"column":6},"end":{"line":103,"column":15}},"34":{"start":{"line":104,"column":6},"end":{"line":104,"column":13}},"35":{"start":{"line":106,"column":6},"end":{"line":106,"column":13}},"36":{"start":{"line":108,"column":4},"end":{"line":108,"column":10}},"37":{"start":{"line":109,"column":4},"end":{"line":109,"column":9}},"38":{"start":{"line":110,"column":4},"end":{"line":112,"column":null}},"39":{"start":{"line":111,"column":6},"end":{"line":111,"column":11}},"40":{"start":{"line":113,"column":4},"end":{"line":113,"column":11}},"41":{"start":{"line":123,"column":4},"end":{"line":123,"column":10}},"42":{"start":{"line":124,"column":17},"end":{"line":124,"column":21}},"43":{"start":{"line":125,"column":4},"end":{"line":125,"column":11}},"44":{"start":{"line":136,"column":45},"end":{"line":136,"column":null}},"45":{"start":{"line":136,"column":45},"end":{"line":136,"column":34}},"46":{"start":{"line":136,"column":45},"end":{"line":136,"column":44}},"47":{"start":{"line":137,"column":8},"end":{"line":137,"column":null}},"48":{"start":{"line":138,"column":17},"end":{"line":138,"column":22}},"49":{"start":{"line":139,"column":4},"end":{"line":145,"column":null}},"50":{"start":{"line":140,"column":6},"end":{"line":144,"column":null}},"51":{"start":{"line":141,"column":8},"end":{"line":141,"column":15}},"52":{"start":{"line":143,"column":8},"end":{"line":143,"column":15}},"53":{"start":{"line":146,"column":4},"end":{"line":158,"column":null}},"54":{"start":{"line":147,"column":6},"end":{"line":147,"column":25}},"55":{"start":{"line":149,"column":23},"end":{"line":149,"column":28}},"56":{"start":{"line":150,"column":23},"end":{"line":150,"column":40}},"57":{"start":{"line":151,"column":6},"end":{"line":157,"column":null}},"58":{"start":{"line":152,"column":8},"end":{"line":152,"column":27}},"59":{"start":{"line":153,"column":8},"end":{"line":153,"column":14}},"60":{"start":{"line":155,"column":8},"end":{"line":155,"column":14}},"61":{"start":{"line":156,"column":8},"end":{"line":156,"column":27}},"62":{"start":{"line":159,"column":4},"end":{"line":172,"column":null}},"63":{"start":{"line":160,"column":6},"end":{"line":160,"column":12}},"64":{"start":{"line":161,"column":6},"end":{"line":161,"column":13}},"65":{"start":{"line":163,"column":10},"end":{"line":170,"column":null}},"66":{"start":{"line":164,"column":30},"end":{"line":164,"column":35}},"67":{"start":{"line":165,"column":12},"end":{"line":165,"column":18}},"68":{"start":{"line":166,"column":12},"end":{"line":166,"column":19}},"69":{"start":{"line":168,"column":12},"end":{"line":168,"column":18}},"70":{"start":{"line":169,"column":12},"end":{"line":169,"column":19}},"71":{"start":{"line":174,"column":4},"end":{"line":174,"column":11}},"72":{"start":{"line":181,"column":4},"end":{"line":183,"column":null}},"73":{"start":{"line":182,"column":6},"end":{"line":182,"column":13}},"74":{"start":{"line":184,"column":4},"end":{"line":184,"column":11}}},"fnMap":{"0":{"name":"defaultPathResolver","decl":{"start":{"line":9,"column":9},"end":{"line":9,"column":30}},"loc":{"start":{"line":9,"column":43},"end":{"line":11,"column":null}}},"1":{"name":"Almanac","decl":{"start":{"line":19,"column":2},"end":{"line":19,"column":15}},"loc":{"start":{"line":19,"column":29},"end":{"line":26,"column":null}}},"2":{"name":"addEvent","decl":{"start":{"line":32,"column":12},"end":{"line":32,"column":19}},"loc":{"start":{"line":32,"column":28},"end":{"line":35,"column":null}}},"3":{"name":"getEvents","decl":{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},"loc":{"start":{"line":40,"column":27},"end":{"line":43,"column":null}}},"4":{"name":"addResult","decl":{"start":{"line":49,"column":13},"end":{"line":49,"column":25}},"loc":{"start":{"line":49,"column":25},"end":{"line":51,"column":null}}},"5":{"name":"getResults","decl":{"start":{"line":56,"column":16},"end":{"line":56,"column":null}},"loc":{"start":{"line":56,"column":16},"end":{"line":58,"column":null}}},"6":{"name":"_getFact","decl":{"start":{"line":65,"column":12},"end":{"line":65,"column":20}},"loc":{"start":{"line":65,"column":20},"end":{"line":67,"column":null}}},"7":{"name":"_addConstantFact","decl":{"start":{"line":73,"column":20},"end":{"line":73,"column":26}},"loc":{"start":{"line":73,"column":26},"end":{"line":76,"column":null}}},"8":{"name":"_setFactValue","decl":{"start":{"line":84,"column":17},"end":{"line":84,"column":23}},"loc":{"start":{"line":84,"column":38},"end":{"line":91,"column":null}}},"9":{"name":"addFact","decl":{"start":{"line":99,"column":11},"end":{"line":99,"column":15}},"loc":{"start":{"line":99,"column":39},"end":{"line":114,"column":null}}},"10":{"name":"addRuntimeFact","decl":{"start":{"line":122,"column":18},"end":{"line":122,"column":26}},"loc":{"start":{"line":122,"column":33},"end":{"line":126,"column":null}}},"11":{"name":"factValue","decl":{"start":{"line":136,"column":13},"end":{"line":136,"column":21}},"loc":{"start":{"line":136,"column":45},"end":{"line":175,"column":null}}},"12":{"name":"(anonymous_20)","decl":{"start":{"line":162,"column":14},"end":{"line":162,"column":27}},"loc":{"start":{"line":162,"column":27},"end":{"line":171,"column":null}}},"13":{"name":"getValue","decl":{"start":{"line":180,"column":12},"end":{"line":180,"column":19}},"loc":{"start":{"line":180,"column":19},"end":{"line":185,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":19,"column":29},"end":{"line":19,"column":28}},"type":"cond-expr","locations":[{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},{"start":{"line":19,"column":25},"end":{"line":19,"column":29}}]},"1":{"loc":{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},"type":"binary-expr","locations":[{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},{"start":{"line":19,"column":29},"end":{"line":19,"column":null}}]},"2":{"loc":{"start":{"line":23,"column":24},"end":{"line":23,"column":null}},"type":"binary-expr","locations":[{"start":{"line":23,"column":24},"end":{"line":23,"column":48}},{"start":{"line":23,"column":48},"end":{"line":23,"column":null}}]},"3":{"loc":{"start":{"line":33,"column":4},"end":{"line":33,"column":24}},"type":"if","locations":[{"start":{"line":33,"column":4},"end":{"line":33,"column":24}}]},"4":{"loc":{"start":{"line":40,"column":27},"end":{"line":40,"column":26}},"type":"cond-expr","locations":[{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},{"start":{"line":40,"column":23},"end":{"line":40,"column":27}}]},"5":{"loc":{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},"type":"binary-expr","locations":[{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},{"start":{"line":40,"column":27},"end":{"line":40,"column":null}}]},"6":{"loc":{"start":{"line":41,"column":4},"end":{"line":41,"column":24}},"type":"if","locations":[{"start":{"line":41,"column":4},"end":{"line":41,"column":24}}]},"7":{"loc":{"start":{"line":87,"column":4},"end":{"line":89,"column":null}},"type":"if","locations":[{"start":{"line":87,"column":4},"end":{"line":89,"column":null}}]},"8":{"loc":{"start":{"line":102,"column":4},"end":{"line":107,"column":null}},"type":"if","locations":[{"start":{"line":102,"column":4},"end":{"line":107,"column":null}},{"start":{"line":105,"column":11},"end":{"line":107,"column":null}}]},"9":{"loc":{"start":{"line":110,"column":4},"end":{"line":112,"column":null}},"type":"if","locations":[{"start":{"line":110,"column":4},"end":{"line":112,"column":null}}]},"10":{"loc":{"start":{"line":136,"column":45},"end":{"line":136,"column":34}},"type":"cond-expr","locations":[{"start":{"line":136,"column":45},"end":{"line":136,"column":null}},{"start":{"line":136,"column":30},"end":{"line":136,"column":34}}]},"11":{"loc":{"start":{"line":136,"column":45},"end":{"line":136,"column":null}},"type":"binary-expr","locations":[{"start":{"line":136,"column":45},"end":{"line":136,"column":null}},{"start":{"line":136,"column":45},"end":{"line":136,"column":null}}]},"12":{"loc":{"start":{"line":136,"column":45},"end":{"line":136,"column":44}},"type":"cond-expr","locations":[{"start":{"line":136,"column":45},"end":{"line":136,"column":null}},{"start":{"line":136,"column":41},"end":{"line":136,"column":45}}]},"13":{"loc":{"start":{"line":139,"column":4},"end":{"line":145,"column":null}},"type":"if","locations":[{"start":{"line":139,"column":4},"end":{"line":145,"column":null}}]},"14":{"loc":{"start":{"line":140,"column":6},"end":{"line":144,"column":null}},"type":"if","locations":[{"start":{"line":140,"column":6},"end":{"line":144,"column":null}},{"start":{"line":142,"column":13},"end":{"line":144,"column":null}}]},"15":{"loc":{"start":{"line":146,"column":4},"end":{"line":158,"column":null}},"type":"if","locations":[{"start":{"line":146,"column":4},"end":{"line":158,"column":null}},{"start":{"line":148,"column":11},"end":{"line":158,"column":null}}]},"16":{"loc":{"start":{"line":150,"column":23},"end":{"line":150,"column":40}},"type":"binary-expr","locations":[{"start":{"line":150,"column":23},"end":{"line":150,"column":35}},{"start":{"line":150,"column":35},"end":{"line":150,"column":40}}]},"17":{"loc":{"start":{"line":151,"column":6},"end":{"line":157,"column":null}},"type":"if","locations":[{"start":{"line":151,"column":6},"end":{"line":157,"column":null}},{"start":{"line":154,"column":13},"end":{"line":157,"column":null}}]},"18":{"loc":{"start":{"line":159,"column":4},"end":{"line":172,"column":null}},"type":"if","locations":[{"start":{"line":159,"column":4},"end":{"line":172,"column":null}}]},"19":{"loc":{"start":{"line":163,"column":10},"end":{"line":170,"column":null}},"type":"if","locations":[{"start":{"line":163,"column":10},"end":{"line":170,"column":null}},{"start":{"line":167,"column":17},"end":{"line":170,"column":null}}]},"20":{"loc":{"start":{"line":163,"column":14},"end":{"line":163,"column":66}},"type":"binary-expr","locations":[{"start":{"line":163,"column":14},"end":{"line":163,"column":35}},{"start":{"line":163,"column":35},"end":{"line":163,"column":66}}]},"21":{"loc":{"start":{"line":163,"column":35},"end":{"line":163,"column":42}},"type":"cond-expr","locations":[{"start":{"line":163,"column":35},"end":{"line":163,"column":42}},{"start":{"line":163,"column":35},"end":{"line":163,"column":42}}]},"22":{"loc":{"start":{"line":168,"column":104},"end":{"line":168,"column":117}},"type":"cond-expr","locations":[{"start":{"line":168,"column":104},"end":{"line":168,"column":117}},{"start":{"line":168,"column":104},"end":{"line":168,"column":117}}]},"23":{"loc":{"start":{"line":181,"column":4},"end":{"line":183,"column":null}},"type":"if","locations":[{"start":{"line":181,"column":4},"end":{"line":183,"column":null}}]},"24":{"loc":{"start":{"line":181,"column":8},"end":{"line":181,"column":61}},"type":"binary-expr","locations":[{"start":{"line":181,"column":8},"end":{"line":181,"column":25}},{"start":{"line":181,"column":25},"end":{"line":181,"column":54}},{"start":{"line":181,"column":54},"end":{"line":181,"column":61}}]},"25":{"loc":{"start":{"line":181,"column":25},"end":{"line":181,"column":32}},"type":"cond-expr","locations":[{"start":{"line":181,"column":25},"end":{"line":181,"column":32}},{"start":{"line":181,"column":25},"end":{"line":181,"column":32}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0},"b":{"0":[0,0],"1":[0,0],"2":[0,0],"3":[0],"4":[0,0],"5":[0,0],"6":[0],"7":[0],"8":[0,0],"9":[0],"10":[0,0],"11":[0,0],"12":[0,0],"13":[0],"14":[0,0],"15":[0,0],"16":[0,0],"17":[0,0],"18":[0],"19":[0,0],"20":[0,0],"21":[0,0],"22":[0,0],"23":[0],"24":[0,0,0],"25":[0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/condition.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/condition.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":6,"column":27},"end":{"line":6,"column":null}},"2":{"start":{"line":7,"column":4},"end":{"line":7,"column":27}},"3":{"start":{"line":7,"column":21},"end":{"line":7,"column":27}},"4":{"start":{"line":8,"column":28},"end":{"line":8,"column":38}},"5":{"start":{"line":9,"column":4},"end":{"line":9,"column":11}},"6":{"start":{"line":10,"column":4},"end":{"line":33,"column":null}},"7":{"start":{"line":11,"column":28},"end":{"line":11,"column":39}},"8":{"start":{"line":12,"column":35},"end":{"line":12,"column":41}},"9":{"start":{"line":13,"column":6},"end":{"line":13,"column":null}},"10":{"start":{"line":13,"column":64},"end":{"line":13,"column":70}},"11":{"start":{"line":14,"column":6},"end":{"line":14,"column":null}},"12":{"start":{"line":14,"column":63},"end":{"line":14,"column":69}},"13":{"start":{"line":15,"column":6},"end":{"line":15,"column":11}},"14":{"start":{"line":17,"column":6},"end":{"line":17,"column":11}},"15":{"start":{"line":18,"column":6},"end":{"line":22,"column":null}},"16":{"start":{"line":19,"column":8},"end":{"line":19,"column":13}},"17":{"start":{"line":19,"column":50},"end":{"line":19,"column":51}},"18":{"start":{"line":21,"column":8},"end":{"line":21,"column":13}},"19":{"start":{"line":23,"column":11},"end":{"line":33,"column":null}},"20":{"start":{"line":24,"column":6},"end":{"line":24,"column":null}},"21":{"start":{"line":24,"column":71},"end":{"line":24,"column":77}},"22":{"start":{"line":25,"column":6},"end":{"line":25,"column":null}},"23":{"start":{"line":25,"column":75},"end":{"line":25,"column":81}},"24":{"start":{"line":26,"column":6},"end":{"line":26,"column":null}},"25":{"start":{"line":26,"column":72},"end":{"line":26,"column":78}},"26":{"start":{"line":30,"column":6},"end":{"line":32,"column":null}},"27":{"start":{"line":31,"column":8},"end":{"line":31,"column":19}},"28":{"start":{"line":41,"column":28},"end":{"line":41,"column":27}},"29":{"start":{"line":42,"column":18},"end":{"line":42,"column":null}},"30":{"start":{"line":43,"column":4},"end":{"line":45,"column":null}},"31":{"start":{"line":44,"column":6},"end":{"line":44,"column":12}},"32":{"start":{"line":46,"column":4},"end":{"line":48,"column":null}},"33":{"start":{"line":47,"column":6},"end":{"line":47,"column":12}},"34":{"start":{"line":49,"column":17},"end":{"line":49,"column":27}},"35":{"start":{"line":50,"column":4},"end":{"line":77,"column":null}},"36":{"start":{"line":51,"column":6},"end":{"line":55,"column":null}},"37":{"start":{"line":52,"column":8},"end":{"line":52,"column":14}},"38":{"start":{"line":52,"column":37},"end":{"line":52,"column":38}},"39":{"start":{"line":54,"column":8},"end":{"line":54,"column":14}},"40":{"start":{"line":56,"column":11},"end":{"line":77,"column":null}},"41":{"start":{"line":57,"column":6},"end":{"line":57,"column":12}},"42":{"start":{"line":59,"column":6},"end":{"line":59,"column":12}},"43":{"start":{"line":60,"column":6},"end":{"line":60,"column":12}},"44":{"start":{"line":61,"column":6},"end":{"line":61,"column":12}},"45":{"start":{"line":62,"column":6},"end":{"line":64,"column":null}},"46":{"start":{"line":63,"column":8},"end":{"line":63,"column":14}},"47":{"start":{"line":65,"column":6},"end":{"line":67,"column":null}},"48":{"start":{"line":66,"column":8},"end":{"line":66,"column":14}},"49":{"start":{"line":68,"column":6},"end":{"line":70,"column":null}},"50":{"start":{"line":69,"column":8},"end":{"line":69,"column":14}},"51":{"start":{"line":71,"column":6},"end":{"line":73,"column":null}},"52":{"start":{"line":72,"column":8},"end":{"line":72,"column":14}},"53":{"start":{"line":74,"column":6},"end":{"line":76,"column":null}},"54":{"start":{"line":75,"column":8},"end":{"line":75,"column":14}},"55":{"start":{"line":78,"column":4},"end":{"line":80,"column":null}},"56":{"start":{"line":79,"column":6},"end":{"line":79,"column":13}},"57":{"start":{"line":81,"column":4},"end":{"line":81,"column":11}},"58":{"start":{"line":93,"column":34},"end":{"line":93,"column":null}},"59":{"start":{"line":94,"column":4},"end":{"line":94,"column":25}},"60":{"start":{"line":94,"column":18},"end":{"line":94,"column":25}},"61":{"start":{"line":95,"column":4},"end":{"line":95,"column":29}},"62":{"start":{"line":95,"column":22},"end":{"line":95,"column":29}},"63":{"start":{"line":96,"column":4},"end":{"line":96,"column":null}},"64":{"start":{"line":96,"column":36},"end":{"line":96,"column":43}},"65":{"start":{"line":98,"column":15},"end":{"line":98,"column":27}},"66":{"start":{"line":99,"column":4},"end":{"line":99,"column":null}},"67":{"start":{"line":99,"column":15},"end":{"line":99,"column":22}},"68":{"start":{"line":101,"column":4},"end":{"line":101,"column":11}},"69":{"start":{"line":104,"column":57},"end":{"line":104,"column":null}},"70":{"start":{"line":105,"column":21},"end":{"line":105,"column":24}},"71":{"start":{"line":106,"column":6},"end":{"line":106,"column":null}},"72":{"start":{"line":114,"column":6},"end":{"line":114,"column":13}},"73":{"start":{"line":144,"column":4},"end":{"line":144,"column":11}},"74":{"start":{"line":152,"column":4},"end":{"line":152,"column":11}},"75":{"start":{"line":160,"column":4},"end":{"line":160,"column":11}},"76":{"start":{"line":129,"column":4},"end":{"line":135,"column":null}},"77":{"start":{"line":130,"column":6},"end":{"line":130,"column":13}},"78":{"start":{"line":131,"column":11},"end":{"line":135,"column":null}},"79":{"start":{"line":132,"column":6},"end":{"line":132,"column":13}},"80":{"start":{"line":133,"column":11},"end":{"line":135,"column":null}},"81":{"start":{"line":134,"column":6},"end":{"line":134,"column":13}}},"fnMap":{"0":{"name":"Condition","decl":{"start":{"line":6,"column":2},"end":{"line":6,"column":15}},"loc":{"start":{"line":6,"column":27},"end":{"line":34,"column":null}}},"1":{"name":"(anonymous_10)","decl":{"start":{"line":19,"column":50},"end":{"line":19,"column":51}},"loc":{"start":{"line":19,"column":50},"end":{"line":19,"column":51}}},"2":{"name":"toJSON","decl":{"start":{"line":41,"column":28},"end":{"line":41,"column":null}},"loc":{"start":{"line":41,"column":28},"end":{"line":82,"column":null}}},"3":{"name":"(anonymous_12)","decl":{"start":{"line":52,"column":37},"end":{"line":52,"column":38}},"loc":{"start":{"line":52,"column":37},"end":{"line":52,"column":38}}},"4":{"name":"evaluate","decl":{"start":{"line":93,"column":12},"end":{"line":93,"column":21}},"loc":{"start":{"line":93,"column":34},"end":{"line":121,"column":null}}},"5":{"name":"(anonymous_14)","decl":{"start":{"line":104,"column":12},"end":{"line":104,"column":14}},"loc":{"start":{"line":104,"column":57},"end":{"line":120,"column":null}}},"6":{"name":"booleanOperator","decl":{"start":{"line":143,"column":21},"end":{"line":143,"column":null}},"loc":{"start":{"line":143,"column":21},"end":{"line":145,"column":null}}},"7":{"name":"isBooleanOperator","decl":{"start":{"line":151,"column":23},"end":{"line":151,"column":null}},"loc":{"start":{"line":151,"column":23},"end":{"line":153,"column":null}}},"8":{"name":"isConditionReference","decl":{"start":{"line":159,"column":26},"end":{"line":159,"column":null}},"loc":{"start":{"line":159,"column":26},"end":{"line":161,"column":null}}},"9":{"name":"booleanOperator","decl":{"start":{"line":128,"column":26},"end":{"line":128,"column":37}},"loc":{"start":{"line":128,"column":37},"end":{"line":136,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":7,"column":4},"end":{"line":7,"column":27}},"type":"if","locations":[{"start":{"line":7,"column":4},"end":{"line":7,"column":27}}]},"1":{"loc":{"start":{"line":10,"column":4},"end":{"line":33,"column":null}},"type":"if","locations":[{"start":{"line":10,"column":4},"end":{"line":33,"column":null}},{"start":{"line":23,"column":11},"end":{"line":33,"column":null}}]},"2":{"loc":{"start":{"line":13,"column":6},"end":{"line":13,"column":null}},"type":"if","locations":[{"start":{"line":13,"column":6},"end":{"line":13,"column":null}}]},"3":{"loc":{"start":{"line":13,"column":10},"end":{"line":13,"column":62}},"type":"binary-expr","locations":[{"start":{"line":13,"column":10},"end":{"line":13,"column":39}},{"start":{"line":13,"column":39},"end":{"line":13,"column":62}}]},"4":{"loc":{"start":{"line":14,"column":6},"end":{"line":14,"column":null}},"type":"if","locations":[{"start":{"line":14,"column":6},"end":{"line":14,"column":null}}]},"5":{"loc":{"start":{"line":14,"column":10},"end":{"line":14,"column":61}},"type":"binary-expr","locations":[{"start":{"line":14,"column":10},"end":{"line":14,"column":39}},{"start":{"line":14,"column":39},"end":{"line":14,"column":61}}]},"6":{"loc":{"start":{"line":17,"column":22},"end":{"line":17,"column":null}},"type":"binary-expr","locations":[{"start":{"line":17,"column":22},"end":{"line":17,"column":31}},{"start":{"line":17,"column":59},"end":{"line":17,"column":null}}]},"7":{"loc":{"start":{"line":18,"column":6},"end":{"line":22,"column":null}},"type":"if","locations":[{"start":{"line":18,"column":6},"end":{"line":22,"column":null}},{"start":{"line":20,"column":13},"end":{"line":22,"column":null}}]},"8":{"loc":{"start":{"line":23,"column":11},"end":{"line":33,"column":null}},"type":"if","locations":[{"start":{"line":23,"column":11},"end":{"line":33,"column":null}}]},"9":{"loc":{"start":{"line":24,"column":6},"end":{"line":24,"column":null}},"type":"if","locations":[{"start":{"line":24,"column":6},"end":{"line":24,"column":null}}]},"10":{"loc":{"start":{"line":25,"column":6},"end":{"line":25,"column":null}},"type":"if","locations":[{"start":{"line":25,"column":6},"end":{"line":25,"column":null}}]},"11":{"loc":{"start":{"line":26,"column":6},"end":{"line":26,"column":null}},"type":"if","locations":[{"start":{"line":26,"column":6},"end":{"line":26,"column":null}}]},"12":{"loc":{"start":{"line":30,"column":6},"end":{"line":32,"column":null}},"type":"if","locations":[{"start":{"line":30,"column":6},"end":{"line":32,"column":null}}]},"13":{"loc":{"start":{"line":41,"column":28},"end":{"line":41,"column":27}},"type":"cond-expr","locations":[{"start":{"line":41,"column":28},"end":{"line":41,"column":null}},{"start":{"line":41,"column":22},"end":{"line":41,"column":28}}]},"14":{"loc":{"start":{"line":41,"column":28},"end":{"line":41,"column":null}},"type":"binary-expr","locations":[{"start":{"line":41,"column":28},"end":{"line":41,"column":null}},{"start":{"line":41,"column":28},"end":{"line":41,"column":null}}]},"15":{"loc":{"start":{"line":43,"column":4},"end":{"line":45,"column":null}},"type":"if","locations":[{"start":{"line":43,"column":4},"end":{"line":45,"column":null}}]},"16":{"loc":{"start":{"line":46,"column":4},"end":{"line":48,"column":null}},"type":"if","locations":[{"start":{"line":46,"column":4},"end":{"line":48,"column":null}}]},"17":{"loc":{"start":{"line":50,"column":4},"end":{"line":77,"column":null}},"type":"if","locations":[{"start":{"line":50,"column":4},"end":{"line":77,"column":null}},{"start":{"line":56,"column":11},"end":{"line":77,"column":null}}]},"18":{"loc":{"start":{"line":51,"column":6},"end":{"line":55,"column":null}},"type":"if","locations":[{"start":{"line":51,"column":6},"end":{"line":55,"column":null}},{"start":{"line":53,"column":13},"end":{"line":55,"column":null}}]},"19":{"loc":{"start":{"line":56,"column":11},"end":{"line":77,"column":null}},"type":"if","locations":[{"start":{"line":56,"column":11},"end":{"line":77,"column":null}},{"start":{"line":58,"column":11},"end":{"line":77,"column":null}}]},"20":{"loc":{"start":{"line":62,"column":6},"end":{"line":64,"column":null}},"type":"if","locations":[{"start":{"line":62,"column":6},"end":{"line":64,"column":null}}]},"21":{"loc":{"start":{"line":65,"column":6},"end":{"line":67,"column":null}},"type":"if","locations":[{"start":{"line":65,"column":6},"end":{"line":67,"column":null}}]},"22":{"loc":{"start":{"line":68,"column":6},"end":{"line":70,"column":null}},"type":"if","locations":[{"start":{"line":68,"column":6},"end":{"line":70,"column":null}}]},"23":{"loc":{"start":{"line":71,"column":6},"end":{"line":73,"column":null}},"type":"if","locations":[{"start":{"line":71,"column":6},"end":{"line":73,"column":null}}]},"24":{"loc":{"start":{"line":74,"column":6},"end":{"line":76,"column":null}},"type":"if","locations":[{"start":{"line":74,"column":6},"end":{"line":76,"column":null}}]},"25":{"loc":{"start":{"line":78,"column":4},"end":{"line":80,"column":null}},"type":"if","locations":[{"start":{"line":78,"column":4},"end":{"line":80,"column":null}}]},"26":{"loc":{"start":{"line":94,"column":4},"end":{"line":94,"column":25}},"type":"if","locations":[{"start":{"line":94,"column":4},"end":{"line":94,"column":25}}]},"27":{"loc":{"start":{"line":95,"column":4},"end":{"line":95,"column":29}},"type":"if","locations":[{"start":{"line":95,"column":4},"end":{"line":95,"column":29}}]},"28":{"loc":{"start":{"line":96,"column":4},"end":{"line":96,"column":null}},"type":"if","locations":[{"start":{"line":96,"column":4},"end":{"line":96,"column":null}}]},"29":{"loc":{"start":{"line":99,"column":4},"end":{"line":99,"column":null}},"type":"if","locations":[{"start":{"line":99,"column":4},"end":{"line":99,"column":null}}]},"30":{"loc":{"start":{"line":129,"column":4},"end":{"line":135,"column":null}},"type":"if","locations":[{"start":{"line":129,"column":4},"end":{"line":135,"column":null}},{"start":{"line":131,"column":11},"end":{"line":135,"column":null}}]},"31":{"loc":{"start":{"line":131,"column":11},"end":{"line":135,"column":null}},"type":"if","locations":[{"start":{"line":131,"column":11},"end":{"line":135,"column":null}},{"start":{"line":133,"column":11},"end":{"line":135,"column":null}}]},"32":{"loc":{"start":{"line":133,"column":11},"end":{"line":135,"column":null}},"type":"if","locations":[{"start":{"line":133,"column":11},"end":{"line":135,"column":null}}]}},"s":{"0":1,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0,"81":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0},"b":{"0":[0],"1":[0,0],"2":[0],"3":[0,0],"4":[0],"5":[0,0],"6":[0,0],"7":[0,0],"8":[0],"9":[0],"10":[0],"11":[0],"12":[0],"13":[0,0],"14":[0,0],"15":[0],"16":[0],"17":[0,0],"18":[0,0],"19":[0,0],"20":[0],"21":[0],"22":[0],"23":[0],"24":[0],"25":[0],"26":[0],"27":[0],"28":[0],"29":[0],"30":[0,0],"31":[0,0],"32":[0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/debug.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/debug.js","statementMap":{"0":{"start":{"line":3,"column":2},"end":{"line":10,"column":null}},"1":{"start":{"line":4,"column":4},"end":{"line":7,"column":null}},"2":{"start":{"line":6,"column":6},"end":{"line":6,"column":13}},"3":{"start":{"line":11,"column":2},"end":{"line":11,"column":9}}},"fnMap":{"0":{"name":"createDebug","decl":{"start":{"line":2,"column":9},"end":{"line":2,"column":24}},"loc":{"start":{"line":2,"column":24},"end":{"line":12,"column":null}}},"1":{"name":"(anonymous_1)","decl":{"start":{"line":11,"column":9},"end":{"line":11,"column":15}},"loc":{"start":{"line":11,"column":15},"end":{"line":11,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":4,"column":4},"end":{"line":7,"column":null}},"type":"if","locations":[{"start":{"line":4,"column":4},"end":{"line":7,"column":null}}]},"1":{"loc":{"start":{"line":4,"column":9},"end":{"line":5,"column":101}},"type":"binary-expr","locations":[{"start":{"line":4,"column":9},"end":{"line":4,"column":43}},{"start":{"line":4,"column":43},"end":{"line":4,"column":58}},{"start":{"line":4,"column":58},"end":{"line":4,"column":79}},{"start":{"line":4,"column":79},"end":{"line":4,"column":87}},{"start":{"line":5,"column":9},"end":{"line":5,"column":42}},{"start":{"line":5,"column":42},"end":{"line":5,"column":65}},{"start":{"line":5,"column":65},"end":{"line":5,"column":94}},{"start":{"line":5,"column":94},"end":{"line":5,"column":101}}]}},"s":{"0":1,"1":1,"2":0,"3":1},"f":{"0":1,"1":415},"b":{"0":[0],"1":[1,1,1,0,1,0,0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/engine-default-operator-decorators.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/engine-default-operator-decorators.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":5,"column":27},"end":{"line":5,"column":null}},"2":{"start":{"line":7,"column":0},"end":{"line":7,"column":19}},"3":{"start":{"line":7,"column":58},"end":{"line":7,"column":59}},"4":{"start":{"line":7,"column":105},"end":{"line":7,"column":111}},"5":{"start":{"line":8,"column":0},"end":{"line":8,"column":19}},"6":{"start":{"line":8,"column":59},"end":{"line":8,"column":60}},"7":{"start":{"line":8,"column":106},"end":{"line":8,"column":112}},"8":{"start":{"line":9,"column":0},"end":{"line":9,"column":19}},"9":{"start":{"line":9,"column":59},"end":{"line":9,"column":60}},"10":{"start":{"line":9,"column":107},"end":{"line":9,"column":113}},"11":{"start":{"line":10,"column":0},"end":{"line":10,"column":19}},"12":{"start":{"line":10,"column":60},"end":{"line":10,"column":61}},"13":{"start":{"line":10,"column":108},"end":{"line":10,"column":114}},"14":{"start":{"line":11,"column":0},"end":{"line":11,"column":19}},"15":{"start":{"line":11,"column":54},"end":{"line":11,"column":55}},"16":{"start":{"line":12,"column":0},"end":{"line":12,"column":19}},"17":{"start":{"line":12,"column":53},"end":{"line":12,"column":54}}},"fnMap":{"0":{"name":"(anonymous_1)","decl":{"start":{"line":7,"column":58},"end":{"line":7,"column":59}},"loc":{"start":{"line":7,"column":58},"end":{"line":7,"column":59}}},"1":{"name":"(anonymous_2)","decl":{"start":{"line":7,"column":105},"end":{"line":7,"column":111}},"loc":{"start":{"line":7,"column":105},"end":{"line":7,"column":111}}},"2":{"name":"(anonymous_3)","decl":{"start":{"line":8,"column":59},"end":{"line":8,"column":60}},"loc":{"start":{"line":8,"column":59},"end":{"line":8,"column":60}}},"3":{"name":"(anonymous_4)","decl":{"start":{"line":8,"column":106},"end":{"line":8,"column":112}},"loc":{"start":{"line":8,"column":106},"end":{"line":8,"column":112}}},"4":{"name":"(anonymous_5)","decl":{"start":{"line":9,"column":59},"end":{"line":9,"column":60}},"loc":{"start":{"line":9,"column":59},"end":{"line":9,"column":60}}},"5":{"name":"(anonymous_6)","decl":{"start":{"line":9,"column":107},"end":{"line":9,"column":113}},"loc":{"start":{"line":9,"column":107},"end":{"line":9,"column":113}}},"6":{"name":"(anonymous_7)","decl":{"start":{"line":10,"column":60},"end":{"line":10,"column":61}},"loc":{"start":{"line":10,"column":60},"end":{"line":10,"column":61}}},"7":{"name":"(anonymous_8)","decl":{"start":{"line":10,"column":108},"end":{"line":10,"column":114}},"loc":{"start":{"line":10,"column":108},"end":{"line":10,"column":114}}},"8":{"name":"(anonymous_9)","decl":{"start":{"line":11,"column":54},"end":{"line":11,"column":55}},"loc":{"start":{"line":11,"column":54},"end":{"line":11,"column":55}}},"9":{"name":"(anonymous_10)","decl":{"start":{"line":12,"column":53},"end":{"line":12,"column":54}},"loc":{"start":{"line":12,"column":53},"end":{"line":12,"column":54}}}},"branchMap":{},"s":{"0":1,"1":1,"2":1,"3":0,"4":0,"5":1,"6":0,"7":0,"8":1,"9":0,"10":0,"11":1,"12":0,"13":0,"14":1,"15":0,"16":1,"17":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0},"b":{}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/engine-default-operators.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/engine-default-operators.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":5,"column":18},"end":{"line":5,"column":null}},"2":{"start":{"line":6,"column":0},"end":{"line":6,"column":10}},"3":{"start":{"line":6,"column":37},"end":{"line":6,"column":38}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":10}},"5":{"start":{"line":7,"column":40},"end":{"line":7,"column":41}},"6":{"start":{"line":8,"column":0},"end":{"line":8,"column":10}},"7":{"start":{"line":8,"column":34},"end":{"line":8,"column":35}},"8":{"start":{"line":9,"column":0},"end":{"line":9,"column":10}},"9":{"start":{"line":9,"column":37},"end":{"line":9,"column":38}},"10":{"start":{"line":11,"column":0},"end":{"line":11,"column":10}},"11":{"start":{"line":11,"column":40},"end":{"line":11,"column":41}},"12":{"start":{"line":12,"column":0},"end":{"line":12,"column":10}},"13":{"start":{"line":12,"column":46},"end":{"line":12,"column":47}},"14":{"start":{"line":15,"column":2},"end":{"line":15,"column":9}},"15":{"start":{"line":17,"column":0},"end":{"line":17,"column":10}},"16":{"start":{"line":17,"column":40},"end":{"line":17,"column":41}},"17":{"start":{"line":18,"column":0},"end":{"line":18,"column":10}},"18":{"start":{"line":18,"column":49},"end":{"line":18,"column":50}},"19":{"start":{"line":19,"column":0},"end":{"line":19,"column":10}},"20":{"start":{"line":19,"column":43},"end":{"line":19,"column":44}},"21":{"start":{"line":20,"column":0},"end":{"line":20,"column":10}},"22":{"start":{"line":20,"column":52},"end":{"line":20,"column":53}}},"fnMap":{"0":{"name":"(anonymous_1)","decl":{"start":{"line":6,"column":37},"end":{"line":6,"column":38}},"loc":{"start":{"line":6,"column":37},"end":{"line":6,"column":38}}},"1":{"name":"(anonymous_2)","decl":{"start":{"line":7,"column":40},"end":{"line":7,"column":41}},"loc":{"start":{"line":7,"column":40},"end":{"line":7,"column":41}}},"2":{"name":"(anonymous_3)","decl":{"start":{"line":8,"column":34},"end":{"line":8,"column":35}},"loc":{"start":{"line":8,"column":34},"end":{"line":8,"column":35}}},"3":{"name":"(anonymous_4)","decl":{"start":{"line":9,"column":37},"end":{"line":9,"column":38}},"loc":{"start":{"line":9,"column":37},"end":{"line":9,"column":38}}},"4":{"name":"(anonymous_5)","decl":{"start":{"line":11,"column":40},"end":{"line":11,"column":41}},"loc":{"start":{"line":11,"column":40},"end":{"line":11,"column":41}}},"5":{"name":"(anonymous_6)","decl":{"start":{"line":12,"column":46},"end":{"line":12,"column":47}},"loc":{"start":{"line":12,"column":46},"end":{"line":12,"column":47}}},"6":{"name":"numberValidator","decl":{"start":{"line":14,"column":9},"end":{"line":14,"column":26}},"loc":{"start":{"line":14,"column":37},"end":{"line":16,"column":null}}},"7":{"name":"(anonymous_8)","decl":{"start":{"line":17,"column":40},"end":{"line":17,"column":41}},"loc":{"start":{"line":17,"column":40},"end":{"line":17,"column":41}}},"8":{"name":"(anonymous_9)","decl":{"start":{"line":18,"column":49},"end":{"line":18,"column":50}},"loc":{"start":{"line":18,"column":49},"end":{"line":18,"column":50}}},"9":{"name":"(anonymous_10)","decl":{"start":{"line":19,"column":43},"end":{"line":19,"column":44}},"loc":{"start":{"line":19,"column":43},"end":{"line":19,"column":44}}},"10":{"name":"(anonymous_11)","decl":{"start":{"line":20,"column":52},"end":{"line":20,"column":53}},"loc":{"start":{"line":20,"column":52},"end":{"line":20,"column":53}}}},"branchMap":{},"s":{"0":1,"1":1,"2":1,"3":16,"4":1,"5":0,"6":1,"7":0,"8":1,"9":0,"10":1,"11":0,"12":1,"13":0,"14":2,"15":1,"16":0,"17":1,"18":0,"19":1,"20":2,"21":1,"22":0},"f":{"0":16,"1":0,"2":0,"3":0,"4":0,"5":0,"6":2,"7":0,"8":0,"9":2,"10":0},"b":{}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/engine.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/engine.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"5":{"start":{"line":8,"column":0},"end":{"line":8,"column":null}},"6":{"start":{"line":9,"column":0},"end":{"line":9,"column":null}},"7":{"start":{"line":10,"column":0},"end":{"line":10,"column":null}},"8":{"start":{"line":11,"column":0},"end":{"line":11,"column":null}},"9":{"start":{"line":13,"column":13},"end":{"line":13,"column":null}},"10":{"start":{"line":14,"column":13},"end":{"line":14,"column":null}},"11":{"start":{"line":15,"column":13},"end":{"line":15,"column":null}},"12":{"start":{"line":22,"column":41},"end":{"line":22,"column":27}},"13":{"start":{"line":22,"column":41},"end":{"line":22,"column":40}},"14":{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},"15":{"start":{"line":24,"column":4},"end":{"line":24,"column":9}},"16":{"start":{"line":25,"column":4},"end":{"line":25,"column":9}},"17":{"start":{"line":26,"column":4},"end":{"line":26,"column":9}},"18":{"start":{"line":27,"column":4},"end":{"line":27,"column":9}},"19":{"start":{"line":28,"column":4},"end":{"line":28,"column":9}},"20":{"start":{"line":29,"column":4},"end":{"line":29,"column":9}},"21":{"start":{"line":30,"column":4},"end":{"line":30,"column":9}},"22":{"start":{"line":31,"column":4},"end":{"line":31,"column":9}},"23":{"start":{"line":32,"column":4},"end":{"line":32,"column":9}},"24":{"start":{"line":33,"column":4},"end":{"line":33,"column":10}},"25":{"start":{"line":33,"column":14},"end":{"line":33,"column":19}},"26":{"start":{"line":34,"column":4},"end":{"line":34,"column":21}},"27":{"start":{"line":34,"column":25},"end":{"line":34,"column":30}},"28":{"start":{"line":35,"column":4},"end":{"line":35,"column":22}},"29":{"start":{"line":35,"column":26},"end":{"line":35,"column":31}},"30":{"start":{"line":48,"column":4},"end":{"line":48,"column":27}},"31":{"start":{"line":48,"column":21},"end":{"line":48,"column":27}},"32":{"start":{"line":50,"column":8},"end":{"line":50,"column":null}},"33":{"start":{"line":51,"column":4},"end":{"line":57,"column":null}},"34":{"start":{"line":52,"column":6},"end":{"line":52,"column":13}},"35":{"start":{"line":54,"column":6},"end":{"line":54,"column":76}},"36":{"start":{"line":54,"column":70},"end":{"line":54,"column":76}},"37":{"start":{"line":55,"column":6},"end":{"line":55,"column":81}},"38":{"start":{"line":55,"column":75},"end":{"line":55,"column":81}},"39":{"start":{"line":56,"column":6},"end":{"line":56,"column":13}},"40":{"start":{"line":58,"column":4},"end":{"line":58,"column":9}},"41":{"start":{"line":59,"column":4},"end":{"line":59,"column":9}},"42":{"start":{"line":60,"column":4},"end":{"line":60,"column":9}},"43":{"start":{"line":61,"column":4},"end":{"line":61,"column":11}},"44":{"start":{"line":69,"column":22},"end":{"line":69,"column":27}},"45":{"start":{"line":69,"column":43},"end":{"line":69,"column":59}},"46":{"start":{"line":70,"column":4},"end":{"line":76,"column":null}},"47":{"start":{"line":71,"column":6},"end":{"line":71,"column":11}},"48":{"start":{"line":72,"column":6},"end":{"line":72,"column":11}},"49":{"start":{"line":73,"column":6},"end":{"line":73,"column":11}},"50":{"start":{"line":75,"column":6},"end":{"line":75,"column":12}},"51":{"start":{"line":84,"column":22},"end":{"line":84,"column":null}},"52":{"start":{"line":85,"column":4},"end":{"line":94,"column":null}},"53":{"start":{"line":86,"column":28},"end":{"line":86,"column":33}},"54":{"start":{"line":86,"column":46},"end":{"line":86,"column":62}},"55":{"start":{"line":87,"column":6},"end":{"line":87,"column":20}},"56":{"start":{"line":88,"column":6},"end":{"line":88,"column":11}},"57":{"start":{"line":90,"column":20},"end":{"line":90,"column":25}},"58":{"start":{"line":91,"column":6},"end":{"line":93,"column":null}},"59":{"start":{"line":92,"column":8},"end":{"line":92,"column":22}},"60":{"start":{"line":95,"column":4},"end":{"line":97,"column":null}},"61":{"start":{"line":96,"column":6},"end":{"line":96,"column":11}},"62":{"start":{"line":98,"column":4},"end":{"line":98,"column":11}},"63":{"start":{"line":108,"column":4},"end":{"line":108,"column":21}},"64":{"start":{"line":108,"column":15},"end":{"line":108,"column":21}},"65":{"start":{"line":109,"column":4},"end":{"line":109,"column":27}},"66":{"start":{"line":109,"column":21},"end":{"line":109,"column":27}},"67":{"start":{"line":110,"column":4},"end":{"line":112,"column":null}},"68":{"start":{"line":111,"column":6},"end":{"line":111,"column":12}},"69":{"start":{"line":113,"column":4},"end":{"line":113,"column":9}},"70":{"start":{"line":114,"column":4},"end":{"line":114,"column":11}},"71":{"start":{"line":123,"column":4},"end":{"line":123,"column":11}},"72":{"start":{"line":132,"column":4},"end":{"line":132,"column":9}},"73":{"start":{"line":140,"column":4},"end":{"line":140,"column":11}},"74":{"start":{"line":149,"column":4},"end":{"line":149,"column":9}},"75":{"start":{"line":157,"column":4},"end":{"line":157,"column":11}},"76":{"start":{"line":167,"column":17},"end":{"line":167,"column":null}},"77":{"start":{"line":168,"column":8},"end":{"line":168,"column":null}},"78":{"start":{"line":169,"column":4},"end":{"line":174,"column":null}},"79":{"start":{"line":170,"column":6},"end":{"line":170,"column":15}},"80":{"start":{"line":171,"column":6},"end":{"line":171,"column":13}},"81":{"start":{"line":173,"column":6},"end":{"line":173,"column":13}},"82":{"start":{"line":175,"column":4},"end":{"line":175,"column":10}},"83":{"start":{"line":176,"column":4},"end":{"line":176,"column":9}},"84":{"start":{"line":177,"column":4},"end":{"line":177,"column":11}},"85":{"start":{"line":185,"column":8},"end":{"line":185,"column":null}},"86":{"start":{"line":186,"column":4},"end":{"line":190,"column":null}},"87":{"start":{"line":187,"column":6},"end":{"line":187,"column":15}},"88":{"start":{"line":189,"column":6},"end":{"line":189,"column":15}},"89":{"start":{"line":192,"column":4},"end":{"line":192,"column":11}},"90":{"start":{"line":202,"column":4},"end":{"line":212,"column":null}},"91":{"start":{"line":203,"column":23},"end":{"line":203,"column":28}},"92":{"start":{"line":204,"column":25},"end":{"line":204,"column":null}},"93":{"start":{"line":205,"column":8},"end":{"line":205,"column":34}},"94":{"start":{"line":205,"column":29},"end":{"line":205,"column":34}},"95":{"start":{"line":206,"column":8},"end":{"line":206,"column":13}},"96":{"start":{"line":207,"column":8},"end":{"line":207,"column":15}},"97":{"start":{"line":209,"column":6},"end":{"line":209,"column":11}},"98":{"start":{"line":210,"column":8},"end":{"line":210,"column":15}},"99":{"start":{"line":211,"column":13},"end":{"line":211,"column":14}},"100":{"start":{"line":213,"column":4},"end":{"line":213,"column":11}},"101":{"start":{"line":223,"column":4},"end":{"line":223,"column":9}},"102":{"start":{"line":224,"column":4},"end":{"line":224,"column":11}},"103":{"start":{"line":233,"column":4},"end":{"line":233,"column":11}},"104":{"start":{"line":241,"column":37},"end":{"line":241,"column":null}},"105":{"start":{"line":242,"column":4},"end":{"line":242,"column":11}},"106":{"start":{"line":243,"column":6},"end":{"line":246,"column":null}},"107":{"start":{"line":244,"column":8},"end":{"line":244,"column":14}},"108":{"start":{"line":245,"column":8},"end":{"line":245,"column":15}},"109":{"start":{"line":247,"column":6},"end":{"line":247,"column":13}},"110":{"start":{"line":248,"column":8},"end":{"line":248,"column":14}},"111":{"start":{"line":249,"column":8},"end":{"line":249,"column":16}},"112":{"start":{"line":250,"column":8},"end":{"line":257,"column":null}},"113":{"start":{"line":251,"column":10},"end":{"line":251,"column":18}},"114":{"start":{"line":252,"column":10},"end":{"line":252,"column":17}},"115":{"start":{"line":253,"column":18},"end":{"line":253,"column":24}},"116":{"start":{"line":255,"column":10},"end":{"line":255,"column":18}},"117":{"start":{"line":256,"column":10},"end":{"line":256,"column":17}},"118":{"start":{"line":268,"column":43},"end":{"line":268,"column":null}},"119":{"start":{"line":268,"column":43},"end":{"line":268,"column":26}},"120":{"start":{"line":268,"column":43},"end":{"line":268,"column":42}},"121":{"start":{"line":269,"column":4},"end":{"line":269,"column":10}},"122":{"start":{"line":270,"column":4},"end":{"line":270,"column":9}},"123":{"start":{"line":272,"column":20},"end":{"line":272,"column":46}},"124":{"start":{"line":277,"column":4},"end":{"line":277,"column":9}},"125":{"start":{"line":278,"column":6},"end":{"line":278,"column":14}},"126":{"start":{"line":280,"column":4},"end":{"line":290,"column":null}},"127":{"start":{"line":281,"column":10},"end":{"line":281,"column":null}},"128":{"start":{"line":282,"column":6},"end":{"line":286,"column":null}},"129":{"start":{"line":283,"column":8},"end":{"line":283,"column":15}},"130":{"start":{"line":285,"column":8},"end":{"line":285,"column":15}},"131":{"start":{"line":288,"column":6},"end":{"line":288,"column":14}},"132":{"start":{"line":289,"column":6},"end":{"line":289,"column":12}},"133":{"start":{"line":291,"column":24},"end":{"line":291,"column":29}},"134":{"start":{"line":292,"column":17},"end":{"line":292,"column":25}},"135":{"start":{"line":295,"column":4},"end":{"line":295,"column":11}},"136":{"start":{"line":296,"column":6},"end":{"line":296,"column":18}},"137":{"start":{"line":297,"column":8},"end":{"line":297,"column":17}},"138":{"start":{"line":298,"column":10},"end":{"line":298,"column":17}},"139":{"start":{"line":300,"column":8},"end":{"line":300,"column":15}},"140":{"start":{"line":302,"column":6},"end":{"line":302,"column":13}},"141":{"start":{"line":303,"column":8},"end":{"line":303,"column":13}},"142":{"start":{"line":304,"column":8},"end":{"line":304,"column":14}},"143":{"start":{"line":305,"column":28},"end":{"line":305,"column":36}},"144":{"start":{"line":306,"column":44},"end":{"line":306,"column":56}},"145":{"start":{"line":307,"column":24},"end":{"line":307,"column":null}},"146":{"start":{"line":308,"column":10},"end":{"line":308,"column":15}},"147":{"start":{"line":309,"column":10},"end":{"line":309,"column":17}},"148":{"start":{"line":302,"column":24},"end":{"line":306,"column":25}},"149":{"start":{"line":302,"column":24},"end":{"line":306,"column":44}},"150":{"start":{"line":312,"column":8},"end":{"line":312,"column":16}}},"fnMap":{"0":{"name":"Engine","decl":{"start":{"line":22,"column":2},"end":{"line":22,"column":15}},"loc":{"start":{"line":22,"column":41},"end":{"line":36,"column":null}}},"1":{"name":"(anonymous_11)","decl":{"start":{"line":33,"column":14},"end":{"line":33,"column":19}},"loc":{"start":{"line":33,"column":14},"end":{"line":33,"column":19}}},"2":{"name":"(anonymous_12)","decl":{"start":{"line":34,"column":25},"end":{"line":34,"column":30}},"loc":{"start":{"line":34,"column":25},"end":{"line":34,"column":30}}},"3":{"name":"(anonymous_13)","decl":{"start":{"line":35,"column":26},"end":{"line":35,"column":31}},"loc":{"start":{"line":35,"column":26},"end":{"line":35,"column":31}}},"4":{"name":"addRule","decl":{"start":{"line":47,"column":11},"end":{"line":47,"column":23}},"loc":{"start":{"line":47,"column":23},"end":{"line":62,"column":null}}},"5":{"name":"updateRule","decl":{"start":{"line":68,"column":14},"end":{"line":68,"column":20}},"loc":{"start":{"line":68,"column":20},"end":{"line":77,"column":null}}},"6":{"name":"(anonymous_16)","decl":{"start":{"line":69,"column":43},"end":{"line":69,"column":59}},"loc":{"start":{"line":69,"column":43},"end":{"line":69,"column":59}}},"7":{"name":"removeRule","decl":{"start":{"line":83,"column":14},"end":{"line":83,"column":20}},"loc":{"start":{"line":83,"column":20},"end":{"line":99,"column":null}}},"8":{"name":"(anonymous_18)","decl":{"start":{"line":86,"column":46},"end":{"line":86,"column":62}},"loc":{"start":{"line":86,"column":46},"end":{"line":86,"column":62}}},"9":{"name":"setCondition","decl":{"start":{"line":107,"column":16},"end":{"line":107,"column":22}},"loc":{"start":{"line":107,"column":34},"end":{"line":115,"column":null}}},"10":{"name":"removeCondition","decl":{"start":{"line":122,"column":19},"end":{"line":122,"column":25}},"loc":{"start":{"line":122,"column":25},"end":{"line":124,"column":null}}},"11":{"name":"addOperator","decl":{"start":{"line":131,"column":15},"end":{"line":131,"column":31}},"loc":{"start":{"line":131,"column":35},"end":{"line":133,"column":null}}},"12":{"name":"removeOperator","decl":{"start":{"line":139,"column":18},"end":{"line":139,"column":34}},"loc":{"start":{"line":139,"column":34},"end":{"line":141,"column":null}}},"13":{"name":"addOperatorDecorator","decl":{"start":{"line":148,"column":24},"end":{"line":148,"column":41}},"loc":{"start":{"line":148,"column":45},"end":{"line":150,"column":null}}},"14":{"name":"removeOperatorDecorator","decl":{"start":{"line":156,"column":27},"end":{"line":156,"column":44}},"loc":{"start":{"line":156,"column":44},"end":{"line":158,"column":null}}},"15":{"name":"addFact","decl":{"start":{"line":166,"column":11},"end":{"line":166,"column":15}},"loc":{"start":{"line":166,"column":39},"end":{"line":178,"column":null}}},"16":{"name":"removeFact","decl":{"start":{"line":184,"column":14},"end":{"line":184,"column":24}},"loc":{"start":{"line":184,"column":24},"end":{"line":193,"column":null}}},"17":{"name":"prioritizeRules","decl":{"start":{"line":201,"column":21},"end":{"line":201,"column":null}},"loc":{"start":{"line":201,"column":21},"end":{"line":214,"column":null}}},"18":{"name":"(anonymous_28)","decl":{"start":{"line":203,"column":41},"end":{"line":203,"column":42}},"loc":{"start":{"line":203,"column":57},"end":{"line":208,"column":9}}},"19":{"name":"(anonymous_29)","decl":{"start":{"line":209,"column":57},"end":{"line":209,"column":58}},"loc":{"start":{"line":209,"column":67},"end":{"line":211,"column":9}}},"20":{"name":"(anonymous_30)","decl":{"start":{"line":211,"column":13},"end":{"line":211,"column":14}},"loc":{"start":{"line":211,"column":13},"end":{"line":211,"column":14}}},"21":{"name":"stop","decl":{"start":{"line":222,"column":10},"end":{"line":222,"column":null}},"loc":{"start":{"line":222,"column":10},"end":{"line":225,"column":null}}},"22":{"name":"getFact","decl":{"start":{"line":232,"column":11},"end":{"line":232,"column":19}},"loc":{"start":{"line":232,"column":19},"end":{"line":234,"column":null}}},"23":{"name":"evaluateRules","decl":{"start":{"line":241,"column":17},"end":{"line":241,"column":28}},"loc":{"start":{"line":241,"column":37},"end":{"line":260,"column":null}}},"24":{"name":"(anonymous_34)","decl":{"start":{"line":242,"column":37},"end":{"line":242,"column":38}},"loc":{"start":{"line":242,"column":47},"end":{"line":259,"column":null}}},"25":{"name":"(anonymous_35)","decl":{"start":{"line":247,"column":41},"end":{"line":247,"column":42}},"loc":{"start":{"line":247,"column":57},"end":{"line":258,"column":null}}},"26":{"name":"(anonymous_36)","decl":{"start":{"line":253,"column":18},"end":{"line":253,"column":24}},"loc":{"start":{"line":253,"column":18},"end":{"line":253,"column":24}}},"27":{"name":"run","decl":{"start":{"line":268,"column":43},"end":{"line":268,"column":null}},"loc":{"start":{"line":268,"column":43},"end":{"line":321,"column":null}}},"28":{"name":"(anonymous_38)","decl":{"start":{"line":277,"column":23},"end":{"line":277,"column":31}},"loc":{"start":{"line":277,"column":31},"end":{"line":279,"column":null}}},"29":{"name":"(anonymous_39)","decl":{"start":{"line":295,"column":23},"end":{"line":295,"column":24}},"loc":{"start":{"line":295,"column":44},"end":{"line":320,"column":null}}},"30":{"name":"(anonymous_40)","decl":{"start":{"line":296,"column":22},"end":{"line":296,"column":23}},"loc":{"start":{"line":296,"column":31},"end":{"line":301,"column":null}}},"31":{"name":"(anonymous_41)","decl":{"start":{"line":297,"column":29},"end":{"line":297,"column":35}},"loc":{"start":{"line":297,"column":35},"end":{"line":299,"column":11}}},"32":{"name":"(anonymous_42)","decl":{"start":{"line":302,"column":18},"end":{"line":302,"column":24}},"loc":{"start":{"line":302,"column":24},"end":{"line":319,"column":9}}},"33":{"name":"(anonymous_43)","decl":{"start":{"line":306,"column":63},"end":{"line":306,"column":64}},"loc":{"start":{"line":306,"column":85},"end":{"line":310,"column":11}}}},"branchMap":{"0":{"loc":{"start":{"line":22,"column":41},"end":{"line":22,"column":27}},"type":"cond-expr","locations":[{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},{"start":{"line":22,"column":23},"end":{"line":22,"column":27}}]},"1":{"loc":{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},"type":"binary-expr","locations":[{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},{"start":{"line":22,"column":41},"end":{"line":22,"column":null}}]},"2":{"loc":{"start":{"line":22,"column":41},"end":{"line":22,"column":40}},"type":"cond-expr","locations":[{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},{"start":{"line":22,"column":37},"end":{"line":22,"column":41}}]},"3":{"loc":{"start":{"line":25,"column":31},"end":{"line":25,"column":null}},"type":"binary-expr","locations":[{"start":{"line":25,"column":31},"end":{"line":25,"column":62}},{"start":{"line":25,"column":62},"end":{"line":25,"column":null}}]},"4":{"loc":{"start":{"line":26,"column":36},"end":{"line":26,"column":null}},"type":"binary-expr","locations":[{"start":{"line":26,"column":36},"end":{"line":26,"column":72}},{"start":{"line":26,"column":72},"end":{"line":26,"column":null}}]},"5":{"loc":{"start":{"line":27,"column":37},"end":{"line":27,"column":null}},"type":"binary-expr","locations":[{"start":{"line":27,"column":37},"end":{"line":27,"column":74}},{"start":{"line":27,"column":74},"end":{"line":27,"column":null}}]},"6":{"loc":{"start":{"line":48,"column":4},"end":{"line":48,"column":27}},"type":"if","locations":[{"start":{"line":48,"column":4},"end":{"line":48,"column":27}}]},"7":{"loc":{"start":{"line":51,"column":4},"end":{"line":57,"column":null}},"type":"if","locations":[{"start":{"line":51,"column":4},"end":{"line":57,"column":null}},{"start":{"line":53,"column":11},"end":{"line":57,"column":null}}]},"8":{"loc":{"start":{"line":54,"column":6},"end":{"line":54,"column":76}},"type":"if","locations":[{"start":{"line":54,"column":6},"end":{"line":54,"column":76}}]},"9":{"loc":{"start":{"line":55,"column":6},"end":{"line":55,"column":81}},"type":"if","locations":[{"start":{"line":55,"column":6},"end":{"line":55,"column":81}}]},"10":{"loc":{"start":{"line":70,"column":4},"end":{"line":76,"column":null}},"type":"if","locations":[{"start":{"line":70,"column":4},"end":{"line":76,"column":null}},{"start":{"line":74,"column":11},"end":{"line":76,"column":null}}]},"11":{"loc":{"start":{"line":85,"column":4},"end":{"line":94,"column":null}},"type":"if","locations":[{"start":{"line":85,"column":4},"end":{"line":94,"column":null}},{"start":{"line":89,"column":11},"end":{"line":94,"column":null}}]},"12":{"loc":{"start":{"line":91,"column":6},"end":{"line":93,"column":null}},"type":"if","locations":[{"start":{"line":91,"column":6},"end":{"line":93,"column":null}}]},"13":{"loc":{"start":{"line":95,"column":4},"end":{"line":97,"column":null}},"type":"if","locations":[{"start":{"line":95,"column":4},"end":{"line":97,"column":null}}]},"14":{"loc":{"start":{"line":108,"column":4},"end":{"line":108,"column":21}},"type":"if","locations":[{"start":{"line":108,"column":4},"end":{"line":108,"column":21}}]},"15":{"loc":{"start":{"line":109,"column":4},"end":{"line":109,"column":27}},"type":"if","locations":[{"start":{"line":109,"column":4},"end":{"line":109,"column":27}}]},"16":{"loc":{"start":{"line":110,"column":4},"end":{"line":112,"column":null}},"type":"if","locations":[{"start":{"line":110,"column":4},"end":{"line":112,"column":null}}]},"17":{"loc":{"start":{"line":110,"column":8},"end":{"line":110,"column":196}},"type":"binary-expr","locations":[{"start":{"line":110,"column":8},"end":{"line":110,"column":16}},{"start":{"line":110,"column":68},"end":{"line":110,"column":76}},{"start":{"line":110,"column":128},"end":{"line":110,"column":136}},{"start":{"line":110,"column":188},"end":{"line":110,"column":196}}]},"18":{"loc":{"start":{"line":169,"column":4},"end":{"line":174,"column":null}},"type":"if","locations":[{"start":{"line":169,"column":4},"end":{"line":174,"column":null}},{"start":{"line":172,"column":11},"end":{"line":174,"column":null}}]},"19":{"loc":{"start":{"line":186,"column":4},"end":{"line":190,"column":null}},"type":"if","locations":[{"start":{"line":186,"column":4},"end":{"line":190,"column":null}},{"start":{"line":188,"column":11},"end":{"line":190,"column":null}}]},"20":{"loc":{"start":{"line":202,"column":4},"end":{"line":212,"column":null}},"type":"if","locations":[{"start":{"line":202,"column":4},"end":{"line":212,"column":null}}]},"21":{"loc":{"start":{"line":205,"column":8},"end":{"line":205,"column":34}},"type":"if","locations":[{"start":{"line":205,"column":8},"end":{"line":205,"column":34}}]},"22":{"loc":{"start":{"line":210,"column":15},"end":{"line":210,"column":46}},"type":"cond-expr","locations":[{"start":{"line":210,"column":39},"end":{"line":210,"column":44}},{"start":{"line":210,"column":44},"end":{"line":210,"column":46}}]},"23":{"loc":{"start":{"line":243,"column":6},"end":{"line":246,"column":null}},"type":"if","locations":[{"start":{"line":243,"column":6},"end":{"line":246,"column":null}}]},"24":{"loc":{"start":{"line":250,"column":8},"end":{"line":257,"column":null}},"type":"if","locations":[{"start":{"line":250,"column":8},"end":{"line":257,"column":null}},{"start":{"line":254,"column":15},"end":{"line":257,"column":null}}]},"25":{"loc":{"start":{"line":268,"column":43},"end":{"line":268,"column":26}},"type":"cond-expr","locations":[{"start":{"line":268,"column":43},"end":{"line":268,"column":null}},{"start":{"line":268,"column":22},"end":{"line":268,"column":26}}]},"26":{"loc":{"start":{"line":268,"column":43},"end":{"line":268,"column":null}},"type":"binary-expr","locations":[{"start":{"line":268,"column":43},"end":{"line":268,"column":null}},{"start":{"line":268,"column":43},"end":{"line":268,"column":null}}]},"27":{"loc":{"start":{"line":268,"column":43},"end":{"line":268,"column":42}},"type":"cond-expr","locations":[{"start":{"line":268,"column":43},"end":{"line":268,"column":null}},{"start":{"line":268,"column":39},"end":{"line":268,"column":43}}]},"28":{"loc":{"start":{"line":272,"column":20},"end":{"line":272,"column":46}},"type":"binary-expr","locations":[{"start":{"line":272,"column":20},"end":{"line":272,"column":42}},{"start":{"line":272,"column":42},"end":{"line":272,"column":46}}]},"29":{"loc":{"start":{"line":282,"column":6},"end":{"line":286,"column":null}},"type":"if","locations":[{"start":{"line":282,"column":6},"end":{"line":286,"column":null}},{"start":{"line":284,"column":13},"end":{"line":286,"column":null}}]},"30":{"loc":{"start":{"line":307,"column":24},"end":{"line":307,"column":null}},"type":"cond-expr","locations":[{"start":{"line":307,"column":44},"end":{"line":307,"column":56}},{"start":{"line":307,"column":56},"end":{"line":307,"column":null}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":1,"8":1,"9":1,"10":1,"11":1,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0,"81":0,"82":0,"83":0,"84":0,"85":0,"86":0,"87":0,"88":0,"89":0,"90":0,"91":0,"92":0,"93":0,"94":0,"95":0,"96":0,"97":0,"98":0,"99":0,"100":0,"101":0,"102":0,"103":0,"104":0,"105":0,"106":0,"107":0,"108":0,"109":0,"110":0,"111":0,"112":0,"113":0,"114":0,"115":0,"116":0,"117":0,"118":0,"119":0,"120":0,"121":0,"122":0,"123":0,"124":0,"125":0,"126":0,"127":0,"128":0,"129":0,"130":0,"131":0,"132":0,"133":0,"134":0,"135":0,"136":0,"137":0,"138":0,"139":0,"140":0,"141":0,"142":0,"143":0,"144":0,"145":0,"146":0,"147":0,"148":0,"149":0,"150":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0},"b":{"0":[0,0],"1":[0,0],"2":[0,0],"3":[0,0],"4":[0,0],"5":[0,0],"6":[0],"7":[0,0],"8":[0],"9":[0],"10":[0,0],"11":[0,0],"12":[0],"13":[0],"14":[0],"15":[0],"16":[0],"17":[0,0,0,0],"18":[0,0],"19":[0,0],"20":[0],"21":[0],"22":[0,0],"23":[0],"24":[0,0],"25":[0,0],"26":[0,0],"27":[0,0],"28":[0,0],"29":[0,0],"30":[0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/errors.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/errors.js","statementMap":{"0":{"start":{"line":4,"column":25},"end":{"line":4,"column":null}},"1":{"start":{"line":4,"column":18},"end":{"line":4,"column":null}},"2":{"start":{"line":6,"column":4},"end":{"line":6,"column":9}}},"fnMap":{"0":{"name":"UndefinedFactError","decl":{"start":{"line":4,"column":2},"end":{"line":4,"column":18}},"loc":{"start":{"line":4,"column":25},"end":{"line":7,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":4,"column":25},"end":{"line":4,"column":null}},"type":"binary-expr","locations":[{"start":{"line":4,"column":25},"end":{"line":4,"column":null}},{"start":{"line":4,"column":25},"end":{"line":4,"column":null}}]}},"s":{"0":0,"1":0,"2":0},"f":{"0":0},"b":{"0":[0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/fact.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/fact.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":14,"column":43},"end":{"line":14,"column":null}},"2":{"start":{"line":15,"column":4},"end":{"line":15,"column":9}},"3":{"start":{"line":16,"column":27},"end":{"line":16,"column":29}},"4":{"start":{"line":17,"column":4},"end":{"line":19,"column":null}},"5":{"start":{"line":18,"column":6},"end":{"line":18,"column":16}},"6":{"start":{"line":20,"column":4},"end":{"line":26,"column":null}},"7":{"start":{"line":21,"column":6},"end":{"line":21,"column":11}},"8":{"start":{"line":22,"column":6},"end":{"line":22,"column":11}},"9":{"start":{"line":24,"column":6},"end":{"line":24,"column":11}},"10":{"start":{"line":25,"column":6},"end":{"line":25,"column":11}},"11":{"start":{"line":28,"column":4},"end":{"line":28,"column":24}},"12":{"start":{"line":28,"column":18},"end":{"line":28,"column":24}},"13":{"start":{"line":30,"column":4},"end":{"line":30,"column":9}},"14":{"start":{"line":31,"column":4},"end":{"line":31,"column":9}},"15":{"start":{"line":32,"column":4},"end":{"line":32,"column":9}},"16":{"start":{"line":33,"column":4},"end":{"line":33,"column":11}},"17":{"start":{"line":37,"column":4},"end":{"line":37,"column":11}},"18":{"start":{"line":41,"column":4},"end":{"line":41,"column":11}},"19":{"start":{"line":52,"column":4},"end":{"line":54,"column":null}},"20":{"start":{"line":53,"column":6},"end":{"line":53,"column":13}},"21":{"start":{"line":55,"column":4},"end":{"line":55,"column":11}},"22":{"start":{"line":76,"column":4},"end":{"line":76,"column":11}},"23":{"start":{"line":86,"column":4},"end":{"line":90,"column":null}},"24":{"start":{"line":87,"column":30},"end":{"line":87,"column":35}},"25":{"start":{"line":88,"column":19},"end":{"line":88,"column":24}},"26":{"start":{"line":89,"column":6},"end":{"line":89,"column":13}},"27":{"start":{"line":64,"column":4},"end":{"line":64,"column":11}},"28":{"start":{"line":94,"column":0},"end":{"line":94,"column":5}},"29":{"start":{"line":95,"column":0},"end":{"line":95,"column":5}}},"fnMap":{"0":{"name":"Fact","decl":{"start":{"line":14,"column":2},"end":{"line":14,"column":15}},"loc":{"start":{"line":14,"column":43},"end":{"line":34,"column":null}}},"1":{"name":"isConstant","decl":{"start":{"line":36,"column":16},"end":{"line":36,"column":null}},"loc":{"start":{"line":36,"column":16},"end":{"line":38,"column":null}}},"2":{"name":"isDynamic","decl":{"start":{"line":40,"column":15},"end":{"line":40,"column":null}},"loc":{"start":{"line":40,"column":15},"end":{"line":42,"column":null}}},"3":{"name":"calculate","decl":{"start":{"line":50,"column":13},"end":{"line":50,"column":21}},"loc":{"start":{"line":50,"column":30},"end":{"line":56,"column":null}}},"4":{"name":"defaultCacheKeys","decl":{"start":{"line":75,"column":20},"end":{"line":75,"column":24}},"loc":{"start":{"line":75,"column":32},"end":{"line":77,"column":null}}},"5":{"name":"getCacheKey","decl":{"start":{"line":85,"column":15},"end":{"line":85,"column":23}},"loc":{"start":{"line":85,"column":23},"end":{"line":91,"column":null}}},"6":{"name":"hashFromObject","decl":{"start":{"line":63,"column":25},"end":{"line":63,"column":30}},"loc":{"start":{"line":63,"column":30},"end":{"line":65,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":17,"column":4},"end":{"line":19,"column":null}},"type":"if","locations":[{"start":{"line":17,"column":4},"end":{"line":19,"column":null}}]},"1":{"loc":{"start":{"line":20,"column":4},"end":{"line":26,"column":null}},"type":"if","locations":[{"start":{"line":20,"column":4},"end":{"line":26,"column":null}},{"start":{"line":23,"column":11},"end":{"line":26,"column":null}}]},"2":{"loc":{"start":{"line":28,"column":4},"end":{"line":28,"column":24}},"type":"if","locations":[{"start":{"line":28,"column":4},"end":{"line":28,"column":24}}]},"3":{"loc":{"start":{"line":30,"column":29},"end":{"line":30,"column":52}},"type":"binary-expr","locations":[{"start":{"line":30,"column":29},"end":{"line":30,"column":49}},{"start":{"line":30,"column":49},"end":{"line":30,"column":52}}]},"4":{"loc":{"start":{"line":52,"column":4},"end":{"line":54,"column":null}},"type":"if","locations":[{"start":{"line":52,"column":4},"end":{"line":54,"column":null}}]},"5":{"loc":{"start":{"line":86,"column":4},"end":{"line":90,"column":null}},"type":"if","locations":[{"start":{"line":86,"column":4},"end":{"line":90,"column":null}}]}},"s":{"0":1,"1":14,"2":14,"3":14,"4":14,"5":14,"6":14,"7":10,"8":10,"9":4,"10":4,"11":14,"12":0,"13":14,"14":14,"15":14,"16":14,"17":32,"18":0,"19":18,"20":16,"21":2,"22":14,"23":14,"24":14,"25":14,"26":14,"27":14,"28":1,"29":1},"f":{"0":14,"1":32,"2":0,"3":18,"4":14,"5":14,"6":14},"b":{"0":[14],"1":[10,4],"2":[0],"3":[14,14],"4":[16],"5":[14]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/index.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/index.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":7}}},"fnMap":{},"branchMap":{},"s":{"0":1},"f":{},"b":{}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/json-rules-engine.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/json-rules-engine.js","statementMap":{"0":{"start":{"line":42,"column":2},"end":{"line":42,"column":9}},"1":{"start":{"line":1,"column":0},"end":{"line":1,"column":null}},"2":{"start":{"line":2,"column":0},"end":{"line":2,"column":null}},"3":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"4":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"5":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"6":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"7":{"start":{"line":9,"column":0},"end":{"line":9,"column":null}},"8":{"start":{"line":10,"column":0},"end":{"line":10,"column":null}},"9":{"start":{"line":11,"column":0},"end":{"line":11,"column":null}},"10":{"start":{"line":12,"column":0},"end":{"line":12,"column":null}},"11":{"start":{"line":13,"column":0},"end":{"line":13,"column":null}},"12":{"start":{"line":16,"column":0},"end":{"line":16,"column":null}},"13":{"start":{"line":17,"column":0},"end":{"line":17,"column":null}},"14":{"start":{"line":18,"column":0},"end":{"line":18,"column":null}},"15":{"start":{"line":19,"column":0},"end":{"line":19,"column":null}}},"fnMap":{"0":{"name":"(anonymous_0)","decl":{"start":{"line":41,"column":15},"end":{"line":41,"column":25}},"loc":{"start":{"line":41,"column":41},"end":{"line":43,"column":null}}}},"branchMap":{},"s":{"0":0,"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":1,"8":1,"9":1,"10":1,"11":1,"12":1,"13":1,"14":1,"15":1},"f":{"0":0},"b":{}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/operator-decorator.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/operator-decorator.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":13,"column":45},"end":{"line":13,"column":null}},"2":{"start":{"line":14,"column":4},"end":{"line":14,"column":9}},"3":{"start":{"line":15,"column":4},"end":{"line":15,"column":21}},"4":{"start":{"line":15,"column":15},"end":{"line":15,"column":21}},"5":{"start":{"line":16,"column":4},"end":{"line":16,"column":40}},"6":{"start":{"line":16,"column":34},"end":{"line":16,"column":40}},"7":{"start":{"line":17,"column":4},"end":{"line":17,"column":9}},"8":{"start":{"line":18,"column":4},"end":{"line":18,"column":9}},"9":{"start":{"line":19,"column":4},"end":{"line":19,"column":39}},"10":{"start":{"line":19,"column":34},"end":{"line":19,"column":39}},"11":{"start":{"line":19,"column":60},"end":{"line":19,"column":66}},"12":{"start":{"line":27,"column":22},"end":{"line":27,"column":null}},"13":{"start":{"line":28,"column":17},"end":{"line":28,"column":26}},"14":{"start":{"line":29,"column":4},"end":{"line":29,"column":11}},"15":{"start":{"line":32,"column":10},"end":{"line":32,"column":17}}},"fnMap":{"0":{"name":"OperatorDecorator","decl":{"start":{"line":13,"column":2},"end":{"line":13,"column":15}},"loc":{"start":{"line":13,"column":45},"end":{"line":20,"column":null}}},"1":{"name":"(anonymous_7)","decl":{"start":{"line":19,"column":60},"end":{"line":19,"column":66}},"loc":{"start":{"line":19,"column":60},"end":{"line":19,"column":66}}},"2":{"name":"decorate","decl":{"start":{"line":27,"column":12},"end":{"line":27,"column":22}},"loc":{"start":{"line":27,"column":22},"end":{"line":36,"column":null}}},"3":{"name":"(anonymous_9)","decl":{"start":{"line":31,"column":8},"end":{"line":31,"column":9}},"loc":{"start":{"line":31,"column":34},"end":{"line":33,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":15,"column":4},"end":{"line":15,"column":21}},"type":"if","locations":[{"start":{"line":15,"column":4},"end":{"line":15,"column":21}}]},"1":{"loc":{"start":{"line":16,"column":4},"end":{"line":16,"column":40}},"type":"if","locations":[{"start":{"line":16,"column":4},"end":{"line":16,"column":40}}]},"2":{"loc":{"start":{"line":19,"column":4},"end":{"line":19,"column":39}},"type":"if","locations":[{"start":{"line":19,"column":4},"end":{"line":19,"column":39}}]}},"s":{"0":1,"1":8,"2":8,"3":8,"4":0,"5":8,"6":0,"7":8,"8":8,"9":8,"10":6,"11":0,"12":1,"13":1,"14":1,"15":0},"f":{"0":8,"1":0,"2":1,"3":0},"b":{"0":[0],"1":[0],"2":[6]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/operator-map.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/operator-map.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":8,"column":17},"end":{"line":8,"column":null}},"4":{"start":{"line":9,"column":4},"end":{"line":9,"column":9}},"5":{"start":{"line":10,"column":4},"end":{"line":10,"column":9}},"6":{"start":{"line":19,"column":8},"end":{"line":19,"column":null}},"7":{"start":{"line":20,"column":4},"end":{"line":24,"column":null}},"8":{"start":{"line":21,"column":6},"end":{"line":21,"column":17}},"9":{"start":{"line":23,"column":6},"end":{"line":23,"column":17}},"10":{"start":{"line":25,"column":4},"end":{"line":25,"column":10}},"11":{"start":{"line":26,"column":4},"end":{"line":26,"column":9}},"12":{"start":{"line":35,"column":8},"end":{"line":35,"column":null}},"13":{"start":{"line":36,"column":4},"end":{"line":40,"column":null}},"14":{"start":{"line":37,"column":6},"end":{"line":37,"column":21}},"15":{"start":{"line":39,"column":6},"end":{"line":39,"column":21}},"16":{"start":{"line":44,"column":19},"end":{"line":44,"column":null}},"17":{"start":{"line":45,"column":26},"end":{"line":45,"column":32}},"18":{"start":{"line":46,"column":4},"end":{"line":50,"column":null}},"19":{"start":{"line":46,"column":17},"end":{"line":46,"column":20}},"20":{"start":{"line":47,"column":6},"end":{"line":49,"column":null}},"21":{"start":{"line":48,"column":8},"end":{"line":48,"column":13}},"22":{"start":{"line":52,"column":4},"end":{"line":52,"column":11}},"23":{"start":{"line":61,"column":8},"end":{"line":61,"column":null}},"24":{"start":{"line":62,"column":4},"end":{"line":66,"column":null}},"25":{"start":{"line":63,"column":6},"end":{"line":63,"column":18}},"26":{"start":{"line":65,"column":6},"end":{"line":65,"column":18}},"27":{"start":{"line":67,"column":4},"end":{"line":67,"column":10}},"28":{"start":{"line":68,"column":4},"end":{"line":68,"column":9}},"29":{"start":{"line":76,"column":8},"end":{"line":76,"column":null}},"30":{"start":{"line":77,"column":4},"end":{"line":81,"column":null}},"31":{"start":{"line":78,"column":6},"end":{"line":78,"column":22}},"32":{"start":{"line":80,"column":6},"end":{"line":80,"column":22}},"33":{"start":{"line":85,"column":19},"end":{"line":85,"column":null}},"34":{"start":{"line":86,"column":26},"end":{"line":86,"column":32}},"35":{"start":{"line":87,"column":4},"end":{"line":91,"column":null}},"36":{"start":{"line":87,"column":17},"end":{"line":87,"column":20}},"37":{"start":{"line":88,"column":6},"end":{"line":90,"column":null}},"38":{"start":{"line":89,"column":8},"end":{"line":89,"column":13}},"39":{"start":{"line":93,"column":4},"end":{"line":93,"column":11}},"40":{"start":{"line":102,"column":23},"end":{"line":102,"column":null}},"41":{"start":{"line":103,"column":17},"end":{"line":103,"column":null}},"42":{"start":{"line":105,"column":4},"end":{"line":124,"column":null}},"43":{"start":{"line":107,"column":34},"end":{"line":107,"column":41}},"44":{"start":{"line":108,"column":6},"end":{"line":123,"column":null}},"45":{"start":{"line":110,"column":30},"end":{"line":110,"column":37}},"46":{"start":{"line":111,"column":26},"end":{"line":111,"column":31}},"47":{"start":{"line":112,"column":8},"end":{"line":115,"column":null}},"48":{"start":{"line":113,"column":10},"end":{"line":113,"column":16}},"49":{"start":{"line":114,"column":10},"end":{"line":114,"column":17}},"50":{"start":{"line":117,"column":8},"end":{"line":117,"column":19}},"51":{"start":{"line":119,"column":8},"end":{"line":119,"column":17}},"52":{"start":{"line":121,"column":8},"end":{"line":121,"column":14}},"53":{"start":{"line":122,"column":8},"end":{"line":122,"column":15}},"54":{"start":{"line":126,"column":13},"end":{"line":126,"column":18}},"55":{"start":{"line":128,"column":4},"end":{"line":133,"column":null}},"56":{"start":{"line":128,"column":17},"end":{"line":128,"column":20}},"57":{"start":{"line":129,"column":6},"end":{"line":129,"column":11}},"58":{"start":{"line":132,"column":6},"end":{"line":132,"column":11}},"59":{"start":{"line":135,"column":4},"end":{"line":135,"column":11}}},"fnMap":{"0":{"name":"OperatorMap","decl":{"start":{"line":8,"column":2},"end":{"line":8,"column":17}},"loc":{"start":{"line":8,"column":17},"end":{"line":11,"column":null}}},"1":{"name":"addOperator","decl":{"start":{"line":18,"column":15},"end":{"line":18,"column":31}},"loc":{"start":{"line":18,"column":35},"end":{"line":27,"column":null}}},"2":{"name":"removeOperator","decl":{"start":{"line":34,"column":18},"end":{"line":34,"column":34}},"loc":{"start":{"line":34,"column":34},"end":{"line":53,"column":null}}},"3":{"name":"addOperatorDecorator","decl":{"start":{"line":60,"column":24},"end":{"line":60,"column":41}},"loc":{"start":{"line":60,"column":45},"end":{"line":69,"column":null}}},"4":{"name":"removeOperatorDecorator","decl":{"start":{"line":75,"column":27},"end":{"line":75,"column":44}},"loc":{"start":{"line":75,"column":44},"end":{"line":94,"column":null}}},"5":{"name":"get","decl":{"start":{"line":101,"column":7},"end":{"line":101,"column":13}},"loc":{"start":{"line":101,"column":13},"end":{"line":136,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":20,"column":4},"end":{"line":24,"column":null}},"type":"if","locations":[{"start":{"line":20,"column":4},"end":{"line":24,"column":null}},{"start":{"line":22,"column":11},"end":{"line":24,"column":null}}]},"1":{"loc":{"start":{"line":36,"column":4},"end":{"line":40,"column":null}},"type":"if","locations":[{"start":{"line":36,"column":4},"end":{"line":40,"column":null}},{"start":{"line":38,"column":11},"end":{"line":40,"column":null}}]},"2":{"loc":{"start":{"line":47,"column":6},"end":{"line":49,"column":null}},"type":"if","locations":[{"start":{"line":47,"column":6},"end":{"line":49,"column":null}}]},"3":{"loc":{"start":{"line":62,"column":4},"end":{"line":66,"column":null}},"type":"if","locations":[{"start":{"line":62,"column":4},"end":{"line":66,"column":null}},{"start":{"line":64,"column":11},"end":{"line":66,"column":null}}]},"4":{"loc":{"start":{"line":77,"column":4},"end":{"line":81,"column":null}},"type":"if","locations":[{"start":{"line":77,"column":4},"end":{"line":81,"column":null}},{"start":{"line":79,"column":11},"end":{"line":81,"column":null}}]},"5":{"loc":{"start":{"line":88,"column":6},"end":{"line":90,"column":null}},"type":"if","locations":[{"start":{"line":88,"column":6},"end":{"line":90,"column":null}}]},"6":{"loc":{"start":{"line":108,"column":6},"end":{"line":123,"column":null}},"type":"if","locations":[{"start":{"line":108,"column":6},"end":{"line":123,"column":null}},{"start":{"line":120,"column":13},"end":{"line":123,"column":null}}]},"7":{"loc":{"start":{"line":112,"column":8},"end":{"line":115,"column":null}},"type":"if","locations":[{"start":{"line":112,"column":8},"end":{"line":115,"column":null}}]}},"s":{"0":1,"1":1,"2":1,"3":19,"4":19,"5":19,"6":190,"7":190,"8":190,"9":0,"10":190,"11":190,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":114,"24":114,"25":114,"26":0,"27":114,"28":114,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":28,"41":28,"42":28,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":28,"55":28,"56":28,"57":0,"58":0,"59":28},"f":{"0":19,"1":190,"2":0,"3":114,"4":0,"5":28},"b":{"0":[190,0],"1":[0,0],"2":[0],"3":[114,0],"4":[0,0],"5":[0],"6":[0,0],"7":[0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/operator.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/operator.js","statementMap":{"0":{"start":{"line":11,"column":45},"end":{"line":11,"column":null}},"1":{"start":{"line":12,"column":4},"end":{"line":12,"column":9}},"2":{"start":{"line":13,"column":4},"end":{"line":13,"column":21}},"3":{"start":{"line":13,"column":15},"end":{"line":13,"column":21}},"4":{"start":{"line":14,"column":4},"end":{"line":14,"column":40}},"5":{"start":{"line":14,"column":34},"end":{"line":14,"column":40}},"6":{"start":{"line":15,"column":4},"end":{"line":15,"column":9}},"7":{"start":{"line":16,"column":4},"end":{"line":16,"column":9}},"8":{"start":{"line":17,"column":4},"end":{"line":17,"column":39}},"9":{"start":{"line":17,"column":34},"end":{"line":17,"column":39}},"10":{"start":{"line":17,"column":60},"end":{"line":17,"column":66}},"11":{"start":{"line":27,"column":4},"end":{"line":27,"column":11}}},"fnMap":{"0":{"name":"Operator","decl":{"start":{"line":11,"column":2},"end":{"line":11,"column":15}},"loc":{"start":{"line":11,"column":45},"end":{"line":18,"column":null}}},"1":{"name":"(anonymous_6)","decl":{"start":{"line":17,"column":60},"end":{"line":17,"column":66}},"loc":{"start":{"line":17,"column":60},"end":{"line":17,"column":66}}},"2":{"name":"evaluate","decl":{"start":{"line":26,"column":12},"end":{"line":26,"column":23}},"loc":{"start":{"line":26,"column":34},"end":{"line":28,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":13,"column":4},"end":{"line":13,"column":21}},"type":"if","locations":[{"start":{"line":13,"column":4},"end":{"line":13,"column":21}}]},"1":{"loc":{"start":{"line":14,"column":4},"end":{"line":14,"column":40}},"type":"if","locations":[{"start":{"line":14,"column":4},"end":{"line":14,"column":40}}]},"2":{"loc":{"start":{"line":17,"column":4},"end":{"line":17,"column":39}},"type":"if","locations":[{"start":{"line":17,"column":4},"end":{"line":17,"column":39}}]},"3":{"loc":{"start":{"line":27,"column":11},"end":{"line":27,"column":54}},"type":"binary-expr","locations":[{"start":{"line":27,"column":11},"end":{"line":27,"column":16}},{"start":{"line":27,"column":49},"end":{"line":27,"column":54}}]}},"s":{"0":13,"1":13,"2":13,"3":0,"4":13,"5":0,"6":13,"7":13,"8":13,"9":6,"10":16,"11":18},"f":{"0":13,"1":16,"2":18},"b":{"0":[0],"1":[0],"2":[6],"3":[18,18]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/rule-result.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/rule-result.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":6,"column":50},"end":{"line":6,"column":null}},"2":{"start":{"line":7,"column":4},"end":{"line":7,"column":9}},"3":{"start":{"line":8,"column":4},"end":{"line":8,"column":9}},"4":{"start":{"line":9,"column":4},"end":{"line":9,"column":9}},"5":{"start":{"line":10,"column":4},"end":{"line":10,"column":9}},"6":{"start":{"line":11,"column":4},"end":{"line":11,"column":9}},"7":{"start":{"line":15,"column":4},"end":{"line":15,"column":9}},"8":{"start":{"line":18,"column":31},"end":{"line":18,"column":null}},"9":{"start":{"line":19,"column":4},"end":{"line":31,"column":null}},"10":{"start":{"line":20,"column":22},"end":{"line":20,"column":null}},"11":{"start":{"line":19,"column":77},"end":{"line":19,"column":null}},"12":{"start":{"line":22,"column":8},"end":{"line":28,"column":null}},"13":{"start":{"line":23,"column":10},"end":{"line":23,"column":18}},"14":{"start":{"line":26,"column":20},"end":{"line":26,"column":21}},"15":{"start":{"line":21,"column":6},"end":{"line":29,"column":null}},"16":{"start":{"line":21,"column":43},"end":{"line":21,"column":null}},"17":{"start":{"line":30,"column":6},"end":{"line":30,"column":13}},"18":{"start":{"line":32,"column":4},"end":{"line":32,"column":11}},"19":{"start":{"line":36,"column":4},"end":{"line":42,"column":null}},"20":{"start":{"line":37,"column":6},"end":{"line":41,"column":null}},"21":{"start":{"line":38,"column":8},"end":{"line":40,"column":null}},"22":{"start":{"line":39,"column":10},"end":{"line":39,"column":15}},"23":{"start":{"line":45,"column":28},"end":{"line":45,"column":27}},"24":{"start":{"line":46,"column":18},"end":{"line":46,"column":null}},"25":{"start":{"line":53,"column":4},"end":{"line":55,"column":null}},"26":{"start":{"line":54,"column":6},"end":{"line":54,"column":13}},"27":{"start":{"line":56,"column":4},"end":{"line":56,"column":11}}},"fnMap":{"0":{"name":"RuleResult","decl":{"start":{"line":6,"column":2},"end":{"line":6,"column":15}},"loc":{"start":{"line":6,"column":50},"end":{"line":12,"column":null}}},"1":{"name":"setResult","decl":{"start":{"line":14,"column":13},"end":{"line":14,"column":21}},"loc":{"start":{"line":14,"column":21},"end":{"line":16,"column":null}}},"2":{"name":"resolveEventParams","decl":{"start":{"line":18,"column":22},"end":{"line":18,"column":31}},"loc":{"start":{"line":18,"column":31},"end":{"line":33,"column":null}}},"3":{"name":"_loop","decl":{"start":{"line":19,"column":77},"end":{"line":19,"column":null}},"loc":{"start":{"line":19,"column":77},"end":{"line":19,"column":null}}},"4":{"name":"(anonymous_12)","decl":{"start":{"line":26,"column":20},"end":{"line":26,"column":21}},"loc":{"start":{"line":26,"column":20},"end":{"line":26,"column":21}}},"5":{"name":"resolveEventParamsSync","decl":{"start":{"line":35,"column":26},"end":{"line":35,"column":35}},"loc":{"start":{"line":35,"column":35},"end":{"line":43,"column":null}}},"6":{"name":"toJSON","decl":{"start":{"line":45,"column":28},"end":{"line":45,"column":null}},"loc":{"start":{"line":45,"column":28},"end":{"line":57,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":19,"column":4},"end":{"line":31,"column":null}},"type":"if","locations":[{"start":{"line":19,"column":4},"end":{"line":31,"column":null}}]},"1":{"loc":{"start":{"line":19,"column":8},"end":{"line":19,"column":77}},"type":"binary-expr","locations":[{"start":{"line":19,"column":8},"end":{"line":19,"column":38}},{"start":{"line":19,"column":38},"end":{"line":19,"column":77}}]},"2":{"loc":{"start":{"line":22,"column":8},"end":{"line":28,"column":null}},"type":"if","locations":[{"start":{"line":22,"column":8},"end":{"line":28,"column":null}}]},"3":{"loc":{"start":{"line":36,"column":4},"end":{"line":42,"column":null}},"type":"if","locations":[{"start":{"line":36,"column":4},"end":{"line":42,"column":null}}]},"4":{"loc":{"start":{"line":36,"column":8},"end":{"line":36,"column":77}},"type":"binary-expr","locations":[{"start":{"line":36,"column":8},"end":{"line":36,"column":38}},{"start":{"line":36,"column":38},"end":{"line":36,"column":77}}]},"5":{"loc":{"start":{"line":38,"column":8},"end":{"line":40,"column":null}},"type":"if","locations":[{"start":{"line":38,"column":8},"end":{"line":40,"column":null}}]},"6":{"loc":{"start":{"line":45,"column":28},"end":{"line":45,"column":27}},"type":"cond-expr","locations":[{"start":{"line":45,"column":28},"end":{"line":45,"column":null}},{"start":{"line":45,"column":22},"end":{"line":45,"column":28}}]},"7":{"loc":{"start":{"line":45,"column":28},"end":{"line":45,"column":null}},"type":"binary-expr","locations":[{"start":{"line":45,"column":28},"end":{"line":45,"column":null}},{"start":{"line":45,"column":28},"end":{"line":45,"column":null}}]},"8":{"loc":{"start":{"line":53,"column":4},"end":{"line":55,"column":null}},"type":"if","locations":[{"start":{"line":53,"column":4},"end":{"line":55,"column":null}}]}},"s":{"0":1,"1":17,"2":17,"3":17,"4":17,"5":17,"6":17,"7":17,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0},"f":{"0":17,"1":17,"2":0,"3":0,"4":0,"5":0,"6":0},"b":{"0":[0],"1":[0,0],"2":[0],"3":[0],"4":[0,0],"5":[0],"6":[0,0],"7":[0,0],"8":[0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/rule.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/rule.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"5":{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},"6":{"start":{"line":23,"column":4},"end":{"line":25,"column":null}},"7":{"start":{"line":24,"column":6},"end":{"line":24,"column":16}},"8":{"start":{"line":26,"column":4},"end":{"line":28,"column":null}},"9":{"start":{"line":27,"column":6},"end":{"line":27,"column":11}},"10":{"start":{"line":29,"column":4},"end":{"line":31,"column":null}},"11":{"start":{"line":30,"column":6},"end":{"line":30,"column":11}},"12":{"start":{"line":32,"column":4},"end":{"line":34,"column":null}},"13":{"start":{"line":33,"column":6},"end":{"line":33,"column":11}},"14":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"15":{"start":{"line":36,"column":6},"end":{"line":36,"column":11}},"16":{"start":{"line":39,"column":22},"end":{"line":39,"column":null}},"17":{"start":{"line":40,"column":4},"end":{"line":40,"column":9}},"18":{"start":{"line":42,"column":19},"end":{"line":42,"column":50}},"19":{"start":{"line":43,"column":4},"end":{"line":43,"column":9}},"20":{"start":{"line":51,"column":4},"end":{"line":51,"column":15}},"21":{"start":{"line":52,"column":4},"end":{"line":52,"column":29}},"22":{"start":{"line":52,"column":23},"end":{"line":52,"column":29}},"23":{"start":{"line":53,"column":4},"end":{"line":53,"column":9}},"24":{"start":{"line":54,"column":4},"end":{"line":54,"column":11}},"25":{"start":{"line":62,"column":4},"end":{"line":64,"column":null}},"26":{"start":{"line":63,"column":6},"end":{"line":63,"column":12}},"27":{"start":{"line":65,"column":4},"end":{"line":65,"column":9}},"28":{"start":{"line":66,"column":4},"end":{"line":66,"column":11}},"29":{"start":{"line":74,"column":4},"end":{"line":83,"column":null}},"30":{"start":{"line":80,"column":6},"end":{"line":80,"column":12}},"31":{"start":{"line":84,"column":4},"end":{"line":84,"column":9}},"32":{"start":{"line":85,"column":4},"end":{"line":85,"column":11}},"33":{"start":{"line":95,"column":4},"end":{"line":95,"column":22}},"34":{"start":{"line":95,"column":16},"end":{"line":95,"column":22}},"35":{"start":{"line":96,"column":4},"end":{"line":100,"column":null}},"36":{"start":{"line":97,"column":6},"end":{"line":97,"column":12}},"37":{"start":{"line":101,"column":4},"end":{"line":101,"column":9}},"38":{"start":{"line":104,"column":4},"end":{"line":104,"column":9}},"39":{"start":{"line":105,"column":4},"end":{"line":105,"column":27}},"40":{"start":{"line":105,"column":22},"end":{"line":105,"column":27}},"41":{"start":{"line":106,"column":4},"end":{"line":106,"column":11}},"42":{"start":{"line":114,"column":4},"end":{"line":114,"column":11}},"43":{"start":{"line":122,"column":4},"end":{"line":122,"column":11}},"44":{"start":{"line":130,"column":4},"end":{"line":130,"column":11}},"45":{"start":{"line":138,"column":4},"end":{"line":138,"column":11}},"46":{"start":{"line":147,"column":4},"end":{"line":147,"column":9}},"47":{"start":{"line":148,"column":4},"end":{"line":148,"column":11}},"48":{"start":{"line":151,"column":28},"end":{"line":151,"column":27}},"49":{"start":{"line":152,"column":18},"end":{"line":152,"column":null}},"50":{"start":{"line":158,"column":4},"end":{"line":160,"column":null}},"51":{"start":{"line":159,"column":6},"end":{"line":159,"column":13}},"52":{"start":{"line":161,"column":4},"end":{"line":161,"column":11}},"53":{"start":{"line":172,"column":36},"end":{"line":172,"column":null}},"54":{"start":{"line":173,"column":21},"end":{"line":173,"column":32}},"55":{"start":{"line":176,"column":21},"end":{"line":176,"column":null}},"56":{"start":{"line":177,"column":6},"end":{"line":180,"column":null}},"57":{"start":{"line":178,"column":21},"end":{"line":178,"column":26}},"58":{"start":{"line":179,"column":8},"end":{"line":179,"column":19}},"59":{"start":{"line":181,"column":6},"end":{"line":181,"column":32}},"60":{"start":{"line":181,"column":27},"end":{"line":181,"column":32}},"61":{"start":{"line":182,"column":6},"end":{"line":182,"column":11}},"62":{"start":{"line":183,"column":6},"end":{"line":183,"column":13}},"63":{"start":{"line":185,"column":4},"end":{"line":185,"column":11}},"64":{"start":{"line":187,"column":8},"end":{"line":187,"column":15}},"65":{"start":{"line":189,"column":11},"end":{"line":189,"column":12}},"66":{"start":{"line":197,"column":21},"end":{"line":197,"column":null}},"67":{"start":{"line":198,"column":23},"end":{"line":198,"column":27}},"68":{"start":{"line":210,"column":30},"end":{"line":240,"column":null}},"69":{"start":{"line":211,"column":6},"end":{"line":239,"column":null}},"70":{"start":{"line":212,"column":8},"end":{"line":212,"column":15}},"71":{"start":{"line":213,"column":13},"end":{"line":239,"column":null}},"72":{"start":{"line":214,"column":30},"end":{"line":214,"column":40}},"73":{"start":{"line":215,"column":12},"end":{"line":215,"column":null}},"74":{"start":{"line":216,"column":8},"end":{"line":222,"column":null}},"75":{"start":{"line":217,"column":10},"end":{"line":217,"column":30}},"76":{"start":{"line":218,"column":15},"end":{"line":222,"column":null}},"77":{"start":{"line":219,"column":10},"end":{"line":219,"column":30}},"78":{"start":{"line":221,"column":10},"end":{"line":221,"column":30}},"79":{"start":{"line":224,"column":8},"end":{"line":224,"column":15}},"80":{"start":{"line":225,"column":25},"end":{"line":225,"column":null}},"81":{"start":{"line":226,"column":10},"end":{"line":226,"column":20}},"82":{"start":{"line":227,"column":10},"end":{"line":227,"column":17}},"83":{"start":{"line":230,"column":8},"end":{"line":230,"column":15}},"84":{"start":{"line":233,"column":27},"end":{"line":233,"column":null}},"85":{"start":{"line":234,"column":12},"end":{"line":234,"column":22}},"86":{"start":{"line":235,"column":12},"end":{"line":235,"column":22}},"87":{"start":{"line":236,"column":12},"end":{"line":236,"column":22}},"88":{"start":{"line":237,"column":12},"end":{"line":237,"column":19}},"89":{"start":{"line":248,"column":31},"end":{"line":257,"column":null}},"90":{"start":{"line":249,"column":6},"end":{"line":249,"column":51}},"91":{"start":{"line":249,"column":38},"end":{"line":249,"column":51}},"92":{"start":{"line":251,"column":6},"end":{"line":251,"column":13}},"93":{"start":{"line":252,"column":23},"end":{"line":252,"column":24}},"94":{"start":{"line":254,"column":8},"end":{"line":254,"column":14}},"95":{"start":{"line":255,"column":8},"end":{"line":255,"column":15}},"96":{"start":{"line":255,"column":45},"end":{"line":255,"column":46}},"97":{"start":{"line":269,"column":29},"end":{"line":292,"column":null}},"98":{"start":{"line":270,"column":6},"end":{"line":272,"column":null}},"99":{"start":{"line":271,"column":8},"end":{"line":271,"column":15}},"100":{"start":{"line":273,"column":6},"end":{"line":278,"column":null}},"101":{"start":{"line":277,"column":8},"end":{"line":277,"column":15}},"102":{"start":{"line":279,"column":26},"end":{"line":279,"column":31}},"103":{"start":{"line":280,"column":19},"end":{"line":280,"column":27}},"104":{"start":{"line":269,"column":55},"end":{"line":269,"column":null}},"105":{"start":{"line":283,"column":20},"end":{"line":283,"column":32}},"106":{"start":{"line":284,"column":8},"end":{"line":284,"column":17}},"107":{"start":{"line":286,"column":10},"end":{"line":286,"column":17}},"108":{"start":{"line":282,"column":6},"end":{"line":290,"column":null}},"109":{"start":{"line":282,"column":19},"end":{"line":282,"column":22}},"110":{"start":{"line":282,"column":51},"end":{"line":282,"column":null}},"111":{"start":{"line":291,"column":6},"end":{"line":291,"column":13}},"112":{"start":{"line":299,"column":16},"end":{"line":301,"column":null}},"113":{"start":{"line":300,"column":6},"end":{"line":300,"column":13}},"114":{"start":{"line":308,"column":16},"end":{"line":310,"column":null}},"115":{"start":{"line":309,"column":6},"end":{"line":309,"column":13}},"116":{"start":{"line":317,"column":16},"end":{"line":319,"column":null}},"117":{"start":{"line":318,"column":6},"end":{"line":318,"column":13}},"118":{"start":{"line":318,"column":55},"end":{"line":318,"column":56}},"119":{"start":{"line":326,"column":20},"end":{"line":344,"column":null}},"120":{"start":{"line":327,"column":24},"end":{"line":327,"column":29}},"121":{"start":{"line":328,"column":6},"end":{"line":343,"column":null}},"122":{"start":{"line":329,"column":8},"end":{"line":337,"column":null}},"123":{"start":{"line":331,"column":10},"end":{"line":331,"column":29}},"124":{"start":{"line":332,"column":10},"end":{"line":332,"column":17}},"125":{"start":{"line":334,"column":10},"end":{"line":334,"column":16}},"126":{"start":{"line":340,"column":8},"end":{"line":340,"column":15}},"127":{"start":{"line":341,"column":8},"end":{"line":341,"column":15}},"128":{"start":{"line":342,"column":8},"end":{"line":342,"column":15}},"129":{"start":{"line":350,"column":26},"end":{"line":360,"column":null}},"130":{"start":{"line":351,"column":6},"end":{"line":351,"column":17}},"131":{"start":{"line":352,"column":25},"end":{"line":352,"column":33}},"132":{"start":{"line":353,"column":6},"end":{"line":355,"column":null}},"133":{"start":{"line":354,"column":8},"end":{"line":354,"column":23}},"134":{"start":{"line":356,"column":20},"end":{"line":356,"column":null}},"135":{"start":{"line":357,"column":6},"end":{"line":357,"column":13}},"136":{"start":{"line":357,"column":31},"end":{"line":357,"column":37}},"137":{"start":{"line":358,"column":8},"end":{"line":358,"column":14}},"138":{"start":{"line":362,"column":4},"end":{"line":378,"column":null}},"139":{"start":{"line":363,"column":6},"end":{"line":363,"column":13}},"140":{"start":{"line":363,"column":49},"end":{"line":363,"column":50}},"141":{"start":{"line":366,"column":11},"end":{"line":378,"column":null}},"142":{"start":{"line":367,"column":6},"end":{"line":367,"column":13}},"143":{"start":{"line":367,"column":49},"end":{"line":367,"column":50}},"144":{"start":{"line":370,"column":11},"end":{"line":378,"column":null}},"145":{"start":{"line":371,"column":6},"end":{"line":371,"column":13}},"146":{"start":{"line":371,"column":49},"end":{"line":371,"column":50}},"147":{"start":{"line":375,"column":6},"end":{"line":375,"column":13}},"148":{"start":{"line":377,"column":13},"end":{"line":377,"column":14}}},"fnMap":{"0":{"name":"Rule","decl":{"start":{"line":21,"column":2},"end":{"line":21,"column":15}},"loc":{"start":{"line":21,"column":24},"end":{"line":44,"column":null}}},"1":{"name":"setPriority","decl":{"start":{"line":50,"column":15},"end":{"line":50,"column":25}},"loc":{"start":{"line":50,"column":25},"end":{"line":55,"column":null}}},"2":{"name":"setName","decl":{"start":{"line":61,"column":11},"end":{"line":61,"column":17}},"loc":{"start":{"line":61,"column":17},"end":{"line":67,"column":null}}},"3":{"name":"setConditions","decl":{"start":{"line":73,"column":17},"end":{"line":73,"column":29}},"loc":{"start":{"line":73,"column":29},"end":{"line":86,"column":null}}},"4":{"name":"setEvent","decl":{"start":{"line":94,"column":12},"end":{"line":94,"column":19}},"loc":{"start":{"line":94,"column":19},"end":{"line":107,"column":null}}},"5":{"name":"getEvent","decl":{"start":{"line":113,"column":14},"end":{"line":113,"column":null}},"loc":{"start":{"line":113,"column":14},"end":{"line":115,"column":null}}},"6":{"name":"getPriority","decl":{"start":{"line":121,"column":17},"end":{"line":121,"column":null}},"loc":{"start":{"line":121,"column":17},"end":{"line":123,"column":null}}},"7":{"name":"getConditions","decl":{"start":{"line":129,"column":19},"end":{"line":129,"column":null}},"loc":{"start":{"line":129,"column":19},"end":{"line":131,"column":null}}},"8":{"name":"getEngine","decl":{"start":{"line":137,"column":15},"end":{"line":137,"column":null}},"loc":{"start":{"line":137,"column":15},"end":{"line":139,"column":null}}},"9":{"name":"setEngine","decl":{"start":{"line":146,"column":13},"end":{"line":146,"column":21}},"loc":{"start":{"line":146,"column":21},"end":{"line":149,"column":null}}},"10":{"name":"toJSON","decl":{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},"loc":{"start":{"line":151,"column":28},"end":{"line":162,"column":null}}},"11":{"name":"prioritizeConditions","decl":{"start":{"line":172,"column":24},"end":{"line":172,"column":36}},"loc":{"start":{"line":172,"column":36},"end":{"line":190,"column":null}}},"12":{"name":"(anonymous_20)","decl":{"start":{"line":173,"column":39},"end":{"line":173,"column":40}},"loc":{"start":{"line":173,"column":60},"end":{"line":184,"column":7}}},"13":{"name":"(anonymous_21)","decl":{"start":{"line":186,"column":12},"end":{"line":186,"column":13}},"loc":{"start":{"line":186,"column":22},"end":{"line":188,"column":null}}},"14":{"name":"(anonymous_22)","decl":{"start":{"line":189,"column":11},"end":{"line":189,"column":12}},"loc":{"start":{"line":189,"column":11},"end":{"line":189,"column":12}}},"15":{"name":"evaluate","decl":{"start":{"line":197,"column":12},"end":{"line":197,"column":21}},"loc":{"start":{"line":197,"column":21},"end":{"line":379,"column":null}}},"16":{"name":"evaluateCondition","decl":{"start":{"line":210,"column":10},"end":{"line":210,"column":30}},"loc":{"start":{"line":210,"column":45},"end":{"line":240,"column":null}}},"17":{"name":"(anonymous_25)","decl":{"start":{"line":224,"column":38},"end":{"line":224,"column":39}},"loc":{"start":{"line":224,"column":59},"end":{"line":228,"column":null}}},"18":{"name":"(anonymous_26)","decl":{"start":{"line":232,"column":16},"end":{"line":232,"column":17}},"loc":{"start":{"line":232,"column":38},"end":{"line":238,"column":null}}},"19":{"name":"evaluateConditions","decl":{"start":{"line":248,"column":10},"end":{"line":248,"column":31}},"loc":{"start":{"line":248,"column":55},"end":{"line":257,"column":null}}},"20":{"name":"(anonymous_28)","decl":{"start":{"line":252,"column":23},"end":{"line":252,"column":24}},"loc":{"start":{"line":252,"column":23},"end":{"line":252,"column":24}}},"21":{"name":"(anonymous_29)","decl":{"start":{"line":253,"column":13},"end":{"line":253,"column":14}},"loc":{"start":{"line":253,"column":35},"end":{"line":256,"column":null}}},"22":{"name":"(anonymous_30)","decl":{"start":{"line":255,"column":45},"end":{"line":255,"column":46}},"loc":{"start":{"line":255,"column":45},"end":{"line":255,"column":46}}},"23":{"name":"prioritizeAndRun","decl":{"start":{"line":269,"column":10},"end":{"line":269,"column":29}},"loc":{"start":{"line":269,"column":55},"end":{"line":292,"column":null}}},"24":{"name":"_loop","decl":{"start":{"line":269,"column":55},"end":{"line":269,"column":null}},"loc":{"start":{"line":269,"column":55},"end":{"line":269,"column":null}}},"25":{"name":"(anonymous_33)","decl":{"start":{"line":284,"column":29},"end":{"line":284,"column":30}},"loc":{"start":{"line":284,"column":44},"end":{"line":289,"column":null}}},"26":{"name":"any","decl":{"start":{"line":299,"column":10},"end":{"line":299,"column":16}},"loc":{"start":{"line":299,"column":32},"end":{"line":301,"column":null}}},"27":{"name":"all","decl":{"start":{"line":308,"column":10},"end":{"line":308,"column":16}},"loc":{"start":{"line":308,"column":32},"end":{"line":310,"column":null}}},"28":{"name":"not","decl":{"start":{"line":317,"column":10},"end":{"line":317,"column":16}},"loc":{"start":{"line":317,"column":31},"end":{"line":319,"column":null}}},"29":{"name":"(anonymous_37)","decl":{"start":{"line":318,"column":55},"end":{"line":318,"column":56}},"loc":{"start":{"line":318,"column":55},"end":{"line":318,"column":56}}},"30":{"name":"realize","decl":{"start":{"line":326,"column":10},"end":{"line":326,"column":20}},"loc":{"start":{"line":326,"column":44},"end":{"line":344,"column":null}}},"31":{"name":"processResult","decl":{"start":{"line":350,"column":10},"end":{"line":350,"column":26}},"loc":{"start":{"line":350,"column":38},"end":{"line":360,"column":null}}},"32":{"name":"(anonymous_40)","decl":{"start":{"line":357,"column":31},"end":{"line":357,"column":37}},"loc":{"start":{"line":357,"column":31},"end":{"line":357,"column":37}}},"33":{"name":"(anonymous_41)","decl":{"start":{"line":358,"column":8},"end":{"line":358,"column":14}},"loc":{"start":{"line":358,"column":8},"end":{"line":358,"column":14}}},"34":{"name":"(anonymous_42)","decl":{"start":{"line":363,"column":49},"end":{"line":363,"column":50}},"loc":{"start":{"line":363,"column":49},"end":{"line":363,"column":50}}},"35":{"name":"(anonymous_43)","decl":{"start":{"line":367,"column":49},"end":{"line":367,"column":50}},"loc":{"start":{"line":367,"column":49},"end":{"line":367,"column":50}}},"36":{"name":"(anonymous_44)","decl":{"start":{"line":371,"column":49},"end":{"line":371,"column":50}},"loc":{"start":{"line":371,"column":49},"end":{"line":371,"column":50}}},"37":{"name":"(anonymous_45)","decl":{"start":{"line":377,"column":13},"end":{"line":377,"column":14}},"loc":{"start":{"line":377,"column":13},"end":{"line":377,"column":14}}}},"branchMap":{"0":{"loc":{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},"type":"binary-expr","locations":[{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},{"start":{"line":21,"column":24},"end":{"line":21,"column":null}}]},"1":{"loc":{"start":{"line":23,"column":4},"end":{"line":25,"column":null}},"type":"if","locations":[{"start":{"line":23,"column":4},"end":{"line":25,"column":null}}]},"2":{"loc":{"start":{"line":26,"column":4},"end":{"line":28,"column":null}},"type":"if","locations":[{"start":{"line":26,"column":4},"end":{"line":28,"column":null}}]},"3":{"loc":{"start":{"line":26,"column":8},"end":{"line":26,"column":39}},"type":"binary-expr","locations":[{"start":{"line":26,"column":8},"end":{"line":26,"column":19}},{"start":{"line":26,"column":19},"end":{"line":26,"column":39}}]},"4":{"loc":{"start":{"line":29,"column":4},"end":{"line":31,"column":null}},"type":"if","locations":[{"start":{"line":29,"column":4},"end":{"line":31,"column":null}}]},"5":{"loc":{"start":{"line":29,"column":8},"end":{"line":29,"column":38}},"type":"binary-expr","locations":[{"start":{"line":29,"column":8},"end":{"line":29,"column":19}},{"start":{"line":29,"column":19},"end":{"line":29,"column":38}}]},"6":{"loc":{"start":{"line":32,"column":4},"end":{"line":34,"column":null}},"type":"if","locations":[{"start":{"line":32,"column":4},"end":{"line":34,"column":null}}]},"7":{"loc":{"start":{"line":32,"column":8},"end":{"line":32,"column":38}},"type":"binary-expr","locations":[{"start":{"line":32,"column":8},"end":{"line":32,"column":19}},{"start":{"line":32,"column":19},"end":{"line":32,"column":38}}]},"8":{"loc":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"type":"if","locations":[{"start":{"line":35,"column":4},"end":{"line":37,"column":null}}]},"9":{"loc":{"start":{"line":35,"column":8},"end":{"line":35,"column":20}},"type":"binary-expr","locations":[{"start":{"line":35,"column":8},"end":{"line":35,"column":20}},{"start":{"line":35,"column":20},"end":{"line":35,"column":36}},{"start":{"line":35,"column":36},"end":{"line":35,"column":57}}]},"10":{"loc":{"start":{"line":39,"column":22},"end":{"line":39,"column":null}},"type":"binary-expr","locations":[{"start":{"line":39,"column":22},"end":{"line":39,"column":33}},{"start":{"line":39,"column":33},"end":{"line":39,"column":54}},{"start":{"line":39,"column":54},"end":{"line":39,"column":null}}]},"11":{"loc":{"start":{"line":42,"column":19},"end":{"line":42,"column":50}},"type":"binary-expr","locations":[{"start":{"line":42,"column":19},"end":{"line":42,"column":30}},{"start":{"line":42,"column":30},"end":{"line":42,"column":48}},{"start":{"line":42,"column":48},"end":{"line":42,"column":50}}]},"12":{"loc":{"start":{"line":52,"column":4},"end":{"line":52,"column":29}},"type":"if","locations":[{"start":{"line":52,"column":4},"end":{"line":52,"column":29}}]},"13":{"loc":{"start":{"line":62,"column":4},"end":{"line":64,"column":null}},"type":"if","locations":[{"start":{"line":62,"column":4},"end":{"line":64,"column":null}}]},"14":{"loc":{"start":{"line":62,"column":8},"end":{"line":62,"column":29}},"type":"binary-expr","locations":[{"start":{"line":62,"column":8},"end":{"line":62,"column":17}},{"start":{"line":62,"column":17},"end":{"line":62,"column":29}}]},"15":{"loc":{"start":{"line":74,"column":4},"end":{"line":83,"column":null}},"type":"if","locations":[{"start":{"line":74,"column":4},"end":{"line":83,"column":null}}]},"16":{"loc":{"start":{"line":75,"column":6},"end":{"line":78,"column":14}},"type":"binary-expr","locations":[{"start":{"line":75,"column":6},"end":{"line":75,"column":14}},{"start":{"line":76,"column":6},"end":{"line":76,"column":14}},{"start":{"line":77,"column":6},"end":{"line":77,"column":14}},{"start":{"line":78,"column":6},"end":{"line":78,"column":14}}]},"17":{"loc":{"start":{"line":95,"column":4},"end":{"line":95,"column":22}},"type":"if","locations":[{"start":{"line":95,"column":4},"end":{"line":95,"column":22}}]},"18":{"loc":{"start":{"line":96,"column":4},"end":{"line":100,"column":null}},"type":"if","locations":[{"start":{"line":96,"column":4},"end":{"line":100,"column":null}}]},"19":{"loc":{"start":{"line":105,"column":4},"end":{"line":105,"column":27}},"type":"if","locations":[{"start":{"line":105,"column":4},"end":{"line":105,"column":27}}]},"20":{"loc":{"start":{"line":151,"column":28},"end":{"line":151,"column":27}},"type":"cond-expr","locations":[{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},{"start":{"line":151,"column":22},"end":{"line":151,"column":28}}]},"21":{"loc":{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},"type":"binary-expr","locations":[{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},{"start":{"line":151,"column":28},"end":{"line":151,"column":null}}]},"22":{"loc":{"start":{"line":158,"column":4},"end":{"line":160,"column":null}},"type":"if","locations":[{"start":{"line":158,"column":4},"end":{"line":160,"column":null}}]},"23":{"loc":{"start":{"line":177,"column":6},"end":{"line":180,"column":null}},"type":"if","locations":[{"start":{"line":177,"column":6},"end":{"line":180,"column":null}}]},"24":{"loc":{"start":{"line":179,"column":20},"end":{"line":179,"column":null}},"type":"binary-expr","locations":[{"start":{"line":179,"column":20},"end":{"line":179,"column":28}},{"start":{"line":179,"column":28},"end":{"line":179,"column":46}},{"start":{"line":179,"column":46},"end":{"line":179,"column":null}}]},"25":{"loc":{"start":{"line":181,"column":6},"end":{"line":181,"column":32}},"type":"if","locations":[{"start":{"line":181,"column":6},"end":{"line":181,"column":32}}]},"26":{"loc":{"start":{"line":187,"column":15},"end":{"line":187,"column":46}},"type":"cond-expr","locations":[{"start":{"line":187,"column":39},"end":{"line":187,"column":44}},{"start":{"line":187,"column":44},"end":{"line":187,"column":46}}]},"27":{"loc":{"start":{"line":211,"column":6},"end":{"line":239,"column":null}},"type":"if","locations":[{"start":{"line":211,"column":6},"end":{"line":239,"column":null}},{"start":{"line":213,"column":13},"end":{"line":239,"column":null}}]},"28":{"loc":{"start":{"line":213,"column":13},"end":{"line":239,"column":null}},"type":"if","locations":[{"start":{"line":213,"column":13},"end":{"line":239,"column":null}},{"start":{"line":229,"column":13},"end":{"line":239,"column":null}}]},"29":{"loc":{"start":{"line":216,"column":8},"end":{"line":222,"column":null}},"type":"if","locations":[{"start":{"line":216,"column":8},"end":{"line":222,"column":null}},{"start":{"line":218,"column":15},"end":{"line":222,"column":null}}]},"30":{"loc":{"start":{"line":218,"column":15},"end":{"line":222,"column":null}},"type":"if","locations":[{"start":{"line":218,"column":15},"end":{"line":222,"column":null}},{"start":{"line":220,"column":15},"end":{"line":222,"column":null}}]},"31":{"loc":{"start":{"line":249,"column":6},"end":{"line":249,"column":51}},"type":"if","locations":[{"start":{"line":249,"column":6},"end":{"line":249,"column":51}}]},"32":{"loc":{"start":{"line":270,"column":6},"end":{"line":272,"column":null}},"type":"if","locations":[{"start":{"line":270,"column":6},"end":{"line":272,"column":null}}]},"33":{"loc":{"start":{"line":273,"column":6},"end":{"line":278,"column":null}},"type":"if","locations":[{"start":{"line":273,"column":6},"end":{"line":278,"column":null}}]},"34":{"loc":{"start":{"line":286,"column":17},"end":{"line":288,"column":47}},"type":"cond-expr","locations":[{"start":{"line":287,"column":15},"end":{"line":287,"column":47}},{"start":{"line":288,"column":15},"end":{"line":288,"column":47}}]},"35":{"loc":{"start":{"line":287,"column":15},"end":{"line":287,"column":47}},"type":"binary-expr","locations":[{"start":{"line":287,"column":15},"end":{"line":287,"column":28}},{"start":{"line":287,"column":28},"end":{"line":287,"column":47}}]},"36":{"loc":{"start":{"line":288,"column":15},"end":{"line":288,"column":47}},"type":"binary-expr","locations":[{"start":{"line":288,"column":15},"end":{"line":288,"column":28}},{"start":{"line":288,"column":28},"end":{"line":288,"column":47}}]},"37":{"loc":{"start":{"line":328,"column":6},"end":{"line":343,"column":null}},"type":"if","locations":[{"start":{"line":328,"column":6},"end":{"line":343,"column":null}},{"start":{"line":338,"column":13},"end":{"line":343,"column":null}}]},"38":{"loc":{"start":{"line":329,"column":8},"end":{"line":337,"column":null}},"type":"if","locations":[{"start":{"line":329,"column":8},"end":{"line":337,"column":null}},{"start":{"line":333,"column":15},"end":{"line":337,"column":null}}]},"39":{"loc":{"start":{"line":353,"column":6},"end":{"line":355,"column":null}},"type":"if","locations":[{"start":{"line":353,"column":6},"end":{"line":355,"column":null}}]},"40":{"loc":{"start":{"line":356,"column":20},"end":{"line":356,"column":null}},"type":"cond-expr","locations":[{"start":{"line":356,"column":29},"end":{"line":356,"column":41}},{"start":{"line":356,"column":41},"end":{"line":356,"column":null}}]},"41":{"loc":{"start":{"line":362,"column":4},"end":{"line":378,"column":null}},"type":"if","locations":[{"start":{"line":362,"column":4},"end":{"line":378,"column":null}},{"start":{"line":366,"column":11},"end":{"line":378,"column":null}}]},"42":{"loc":{"start":{"line":366,"column":11},"end":{"line":378,"column":null}},"type":"if","locations":[{"start":{"line":366,"column":11},"end":{"line":378,"column":null}},{"start":{"line":370,"column":11},"end":{"line":378,"column":null}}]},"43":{"loc":{"start":{"line":370,"column":11},"end":{"line":378,"column":null}},"type":"if","locations":[{"start":{"line":370,"column":11},"end":{"line":378,"column":null}},{"start":{"line":374,"column":11},"end":{"line":378,"column":null}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":1,"5":3,"6":1,"7":0,"8":1,"9":0,"10":1,"11":0,"12":1,"13":0,"14":1,"15":0,"16":1,"17":1,"18":1,"19":1,"20":1,"21":1,"22":0,"23":1,"24":1,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":1,"34":0,"35":1,"36":0,"37":1,"38":1,"39":1,"40":0,"41":1,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0,"81":0,"82":0,"83":0,"84":0,"85":0,"86":0,"87":0,"88":0,"89":0,"90":0,"91":0,"92":0,"93":0,"94":0,"95":0,"96":0,"97":0,"98":0,"99":0,"100":0,"101":0,"102":0,"103":0,"104":0,"105":0,"106":0,"107":0,"108":0,"109":0,"110":0,"111":0,"112":0,"113":0,"114":0,"115":0,"116":0,"117":0,"118":0,"119":0,"120":0,"121":0,"122":0,"123":0,"124":0,"125":0,"126":0,"127":0,"128":0,"129":0,"130":0,"131":0,"132":0,"133":0,"134":0,"135":0,"136":0,"137":0,"138":0,"139":0,"140":0,"141":0,"142":0,"143":0,"144":0,"145":0,"146":0,"147":0,"148":0},"f":{"0":1,"1":1,"2":0,"3":0,"4":1,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0},"b":{"0":[1,0],"1":[0],"2":[0],"3":[1,0],"4":[0],"5":[1,0],"6":[0],"7":[1,0],"8":[0],"9":[1,0,0],"10":[1,0,1],"11":[1,0,1],"12":[0],"13":[0],"14":[0,0],"15":[0],"16":[0,0,0,0],"17":[0],"18":[0],"19":[0],"20":[0,0],"21":[0,0],"22":[0],"23":[0],"24":[0,0,0],"25":[0],"26":[0,0],"27":[0,0],"28":[0,0],"29":[0,0],"30":[0,0],"31":[0],"32":[0],"33":[0],"34":[0,0],"35":[0,0],"36":[0,0],"37":[0,0],"38":[0,0],"39":[0],"40":[0,0],"41":[0,0],"42":[0,0],"43":[0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/almanac-fast.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/almanac-fast.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":9,"column":2},"end":{"line":9,"column":9}},"5":{"start":{"line":16,"column":29},"end":{"line":16,"column":28}},"6":{"start":{"line":16,"column":29},"end":{"line":16,"column":null}},"7":{"start":{"line":17,"column":4},"end":{"line":17,"column":9}},"8":{"start":{"line":18,"column":4},"end":{"line":18,"column":9}},"9":{"start":{"line":19,"column":4},"end":{"line":19,"column":9}},"10":{"start":{"line":20,"column":4},"end":{"line":20,"column":9}},"11":{"start":{"line":21,"column":4},"end":{"line":21,"column":9}},"12":{"start":{"line":22,"column":4},"end":{"line":22,"column":9}},"13":{"start":{"line":23,"column":4},"end":{"line":23,"column":9}},"14":{"start":{"line":24,"column":4},"end":{"line":24,"column":9}},"15":{"start":{"line":28,"column":4},"end":{"line":28,"column":24}},"16":{"start":{"line":28,"column":18},"end":{"line":28,"column":24}},"17":{"start":{"line":29,"column":4},"end":{"line":29,"column":9}},"18":{"start":{"line":32,"column":27},"end":{"line":32,"column":26}},"19":{"start":{"line":33,"column":4},"end":{"line":33,"column":24}},"20":{"start":{"line":33,"column":17},"end":{"line":33,"column":24}},"21":{"start":{"line":34,"column":4},"end":{"line":34,"column":11}},"22":{"start":{"line":38,"column":4},"end":{"line":38,"column":9}},"23":{"start":{"line":42,"column":4},"end":{"line":42,"column":11}},"24":{"start":{"line":46,"column":4},"end":{"line":46,"column":11}},"25":{"start":{"line":50,"column":4},"end":{"line":50,"column":9}},"26":{"start":{"line":52,"column":4},"end":{"line":52,"column":9}},"27":{"start":{"line":58,"column":38},"end":{"line":58,"column":null}},"28":{"start":{"line":59,"column":21},"end":{"line":59,"column":26}},"29":{"start":{"line":60,"column":4},"end":{"line":74,"column":null}},"30":{"start":{"line":62,"column":6},"end":{"line":73,"column":null}},"31":{"start":{"line":63,"column":8},"end":{"line":63,"column":13}},"32":{"start":{"line":64,"column":8},"end":{"line":64,"column":15}},"33":{"start":{"line":65,"column":10},"end":{"line":65,"column":15}},"34":{"start":{"line":66,"column":10},"end":{"line":66,"column":15}},"35":{"start":{"line":67,"column":10},"end":{"line":67,"column":17}},"36":{"start":{"line":71,"column":8},"end":{"line":71,"column":13}},"37":{"start":{"line":72,"column":8},"end":{"line":72,"column":15}},"38":{"start":{"line":75,"column":4},"end":{"line":75,"column":11}},"39":{"start":{"line":79,"column":17},"end":{"line":79,"column":null}},"40":{"start":{"line":80,"column":8},"end":{"line":80,"column":null}},"41":{"start":{"line":81,"column":4},"end":{"line":86,"column":null}},"42":{"start":{"line":82,"column":6},"end":{"line":82,"column":15}},"43":{"start":{"line":83,"column":6},"end":{"line":83,"column":13}},"44":{"start":{"line":85,"column":6},"end":{"line":85,"column":13}},"45":{"start":{"line":87,"column":4},"end":{"line":87,"column":10}},"46":{"start":{"line":88,"column":4},"end":{"line":88,"column":9}},"47":{"start":{"line":89,"column":4},"end":{"line":91,"column":null}},"48":{"start":{"line":90,"column":6},"end":{"line":90,"column":11}},"49":{"start":{"line":92,"column":4},"end":{"line":92,"column":11}},"50":{"start":{"line":96,"column":4},"end":{"line":96,"column":10}},"51":{"start":{"line":97,"column":17},"end":{"line":97,"column":21}},"52":{"start":{"line":98,"column":4},"end":{"line":98,"column":11}},"53":{"start":{"line":104,"column":45},"end":{"line":104,"column":34}},"54":{"start":{"line":104,"column":45},"end":{"line":104,"column":44}},"55":{"start":{"line":105,"column":17},"end":{"line":105,"column":22}},"56":{"start":{"line":106,"column":4},"end":{"line":112,"column":null}},"57":{"start":{"line":107,"column":6},"end":{"line":111,"column":null}},"58":{"start":{"line":108,"column":8},"end":{"line":108,"column":15}},"59":{"start":{"line":110,"column":8},"end":{"line":110,"column":15}},"60":{"start":{"line":114,"column":8},"end":{"line":114,"column":null}},"61":{"start":{"line":115,"column":4},"end":{"line":137,"column":null}},"62":{"start":{"line":117,"column":20},"end":{"line":117,"column":25}},"63":{"start":{"line":118,"column":6},"end":{"line":118,"column":25}},"64":{"start":{"line":120,"column":23},"end":{"line":120,"column":28}},"65":{"start":{"line":123,"column":26},"end":{"line":123,"column":43}},"66":{"start":{"line":124,"column":6},"end":{"line":136,"column":null}},"67":{"start":{"line":125,"column":8},"end":{"line":125,"column":14}},"68":{"start":{"line":126,"column":8},"end":{"line":126,"column":27}},"69":{"start":{"line":129,"column":31},"end":{"line":129,"column":48}},"70":{"start":{"line":130,"column":8},"end":{"line":135,"column":null}},"71":{"start":{"line":131,"column":10},"end":{"line":131,"column":29}},"72":{"start":{"line":133,"column":10},"end":{"line":133,"column":16}},"73":{"start":{"line":134,"column":10},"end":{"line":134,"column":29}},"74":{"start":{"line":139,"column":4},"end":{"line":141,"column":null}},"75":{"start":{"line":140,"column":6},"end":{"line":140,"column":13}},"76":{"start":{"line":143,"column":4},"end":{"line":143,"column":11}},"77":{"start":{"line":149,"column":38},"end":{"line":149,"column":null}},"78":{"start":{"line":150,"column":4},"end":{"line":150,"column":11}},"79":{"start":{"line":151,"column":6},"end":{"line":166,"column":null}},"80":{"start":{"line":153,"column":27},"end":{"line":153,"column":32}},"81":{"start":{"line":154,"column":8},"end":{"line":157,"column":null}},"82":{"start":{"line":155,"column":10},"end":{"line":155,"column":25}},"83":{"start":{"line":156,"column":10},"end":{"line":156,"column":15}},"84":{"start":{"line":159,"column":8},"end":{"line":159,"column":21}},"85":{"start":{"line":160,"column":26},"end":{"line":160,"column":35}},"86":{"start":{"line":161,"column":8},"end":{"line":161,"column":14}},"87":{"start":{"line":162,"column":8},"end":{"line":162,"column":15}},"88":{"start":{"line":164,"column":8},"end":{"line":164,"column":14}},"89":{"start":{"line":165,"column":8},"end":{"line":165,"column":15}},"90":{"start":{"line":174,"column":4},"end":{"line":176,"column":null}},"91":{"start":{"line":175,"column":6},"end":{"line":175,"column":13}},"92":{"start":{"line":177,"column":4},"end":{"line":177,"column":11}},"93":{"start":{"line":183,"column":29},"end":{"line":183,"column":null}},"94":{"start":{"line":184,"column":21},"end":{"line":184,"column":30}},"95":{"start":{"line":184,"column":34},"end":{"line":184,"column":45}},"96":{"start":{"line":184,"column":34},"end":{"line":184,"column":53}},"97":{"start":{"line":184,"column":34},"end":{"line":184,"column":null}},"98":{"start":{"line":184,"column":34},"end":{"line":184,"column":37}},"99":{"start":{"line":187,"column":4},"end":{"line":187,"column":11}}},"fnMap":{"0":{"name":"defaultPathResolver","decl":{"start":{"line":8,"column":9},"end":{"line":8,"column":30}},"loc":{"start":{"line":8,"column":43},"end":{"line":10,"column":null}}},"1":{"name":"AlmanacFast","decl":{"start":{"line":16,"column":2},"end":{"line":16,"column":15}},"loc":{"start":{"line":16,"column":29},"end":{"line":25,"column":null}}},"2":{"name":"addEvent","decl":{"start":{"line":27,"column":12},"end":{"line":27,"column":19}},"loc":{"start":{"line":27,"column":28},"end":{"line":30,"column":null}}},"3":{"name":"getEvents","decl":{"start":{"line":32,"column":27},"end":{"line":32,"column":null}},"loc":{"start":{"line":32,"column":27},"end":{"line":35,"column":null}}},"4":{"name":"addResult","decl":{"start":{"line":37,"column":13},"end":{"line":37,"column":25}},"loc":{"start":{"line":37,"column":25},"end":{"line":39,"column":null}}},"5":{"name":"getResults","decl":{"start":{"line":41,"column":16},"end":{"line":41,"column":null}},"loc":{"start":{"line":41,"column":16},"end":{"line":43,"column":null}}},"6":{"name":"_getFact","decl":{"start":{"line":45,"column":12},"end":{"line":45,"column":20}},"loc":{"start":{"line":45,"column":20},"end":{"line":47,"column":null}}},"7":{"name":"_addConstantFact","decl":{"start":{"line":49,"column":20},"end":{"line":49,"column":26}},"loc":{"start":{"line":49,"column":26},"end":{"line":53,"column":null}}},"8":{"name":"_setFactValue","decl":{"start":{"line":58,"column":17},"end":{"line":58,"column":23}},"loc":{"start":{"line":58,"column":38},"end":{"line":76,"column":null}}},"9":{"name":"(anonymous_17)","decl":{"start":{"line":64,"column":26},"end":{"line":64,"column":43}},"loc":{"start":{"line":64,"column":43},"end":{"line":68,"column":null}}},"10":{"name":"addFact","decl":{"start":{"line":78,"column":11},"end":{"line":78,"column":15}},"loc":{"start":{"line":78,"column":39},"end":{"line":93,"column":null}}},"11":{"name":"addRuntimeFact","decl":{"start":{"line":95,"column":18},"end":{"line":95,"column":26}},"loc":{"start":{"line":95,"column":33},"end":{"line":99,"column":null}}},"12":{"name":"factValue","decl":{"start":{"line":104,"column":13},"end":{"line":104,"column":21}},"loc":{"start":{"line":104,"column":45},"end":{"line":144,"column":null}}},"13":{"name":"_applyPath","decl":{"start":{"line":149,"column":14},"end":{"line":149,"column":32}},"loc":{"start":{"line":149,"column":38},"end":{"line":168,"column":null}}},"14":{"name":"(anonymous_22)","decl":{"start":{"line":150,"column":33},"end":{"line":150,"column":46}},"loc":{"start":{"line":150,"column":46},"end":{"line":167,"column":null}}},"15":{"name":"getValue","decl":{"start":{"line":173,"column":12},"end":{"line":173,"column":19}},"loc":{"start":{"line":173,"column":19},"end":{"line":178,"column":null}}},"16":{"name":"batchFactValues","decl":{"start":{"line":183,"column":19},"end":{"line":183,"column":29}},"loc":{"start":{"line":183,"column":29},"end":{"line":188,"column":null}}},"17":{"name":"(anonymous_25)","decl":{"start":{"line":184,"column":34},"end":{"line":184,"column":37}},"loc":{"start":{"line":184,"column":34},"end":{"line":184,"column":37}}}},"branchMap":{"0":{"loc":{"start":{"line":16,"column":29},"end":{"line":16,"column":28}},"type":"cond-expr","locations":[{"start":{"line":16,"column":29},"end":{"line":16,"column":null}},{"start":{"line":16,"column":25},"end":{"line":16,"column":29}}]},"1":{"loc":{"start":{"line":16,"column":29},"end":{"line":16,"column":null}},"type":"binary-expr","locations":[{"start":{"line":16,"column":29},"end":{"line":16,"column":null}},{"start":{"line":16,"column":29},"end":{"line":16,"column":null}}]},"2":{"loc":{"start":{"line":22,"column":24},"end":{"line":22,"column":null}},"type":"binary-expr","locations":[{"start":{"line":22,"column":24},"end":{"line":22,"column":48}},{"start":{"line":22,"column":48},"end":{"line":22,"column":null}}]},"3":{"loc":{"start":{"line":28,"column":4},"end":{"line":28,"column":24}},"type":"if","locations":[{"start":{"line":28,"column":4},"end":{"line":28,"column":24}}]},"4":{"loc":{"start":{"line":32,"column":27},"end":{"line":32,"column":26}},"type":"cond-expr","locations":[{"start":{"line":32,"column":27},"end":{"line":32,"column":null}},{"start":{"line":32,"column":23},"end":{"line":32,"column":27}}]},"5":{"loc":{"start":{"line":32,"column":27},"end":{"line":32,"column":null}},"type":"binary-expr","locations":[{"start":{"line":32,"column":27},"end":{"line":32,"column":null}},{"start":{"line":32,"column":27},"end":{"line":32,"column":null}}]},"6":{"loc":{"start":{"line":33,"column":4},"end":{"line":33,"column":24}},"type":"if","locations":[{"start":{"line":33,"column":4},"end":{"line":33,"column":24}}]},"7":{"loc":{"start":{"line":60,"column":4},"end":{"line":74,"column":null}},"type":"if","locations":[{"start":{"line":60,"column":4},"end":{"line":74,"column":null}}]},"8":{"loc":{"start":{"line":62,"column":6},"end":{"line":73,"column":null}},"type":"if","locations":[{"start":{"line":62,"column":6},"end":{"line":73,"column":null}},{"start":{"line":69,"column":13},"end":{"line":73,"column":null}}]},"9":{"loc":{"start":{"line":62,"column":10},"end":{"line":62,"column":53}},"type":"binary-expr","locations":[{"start":{"line":62,"column":10},"end":{"line":62,"column":19}},{"start":{"line":62,"column":19},"end":{"line":62,"column":53}}]},"10":{"loc":{"start":{"line":81,"column":4},"end":{"line":86,"column":null}},"type":"if","locations":[{"start":{"line":81,"column":4},"end":{"line":86,"column":null}},{"start":{"line":84,"column":11},"end":{"line":86,"column":null}}]},"11":{"loc":{"start":{"line":89,"column":4},"end":{"line":91,"column":null}},"type":"if","locations":[{"start":{"line":89,"column":4},"end":{"line":91,"column":null}}]},"12":{"loc":{"start":{"line":104,"column":45},"end":{"line":104,"column":34}},"type":"cond-expr","locations":[{"start":{"line":104,"column":45},"end":{"line":104,"column":null}},{"start":{"line":104,"column":30},"end":{"line":104,"column":34}}]},"13":{"loc":{"start":{"line":104,"column":45},"end":{"line":104,"column":null}},"type":"binary-expr","locations":[{"start":{"line":104,"column":45},"end":{"line":104,"column":null}},{"start":{"line":104,"column":45},"end":{"line":104,"column":null}}]},"14":{"loc":{"start":{"line":104,"column":45},"end":{"line":104,"column":44}},"type":"cond-expr","locations":[{"start":{"line":104,"column":45},"end":{"line":104,"column":null}},{"start":{"line":104,"column":41},"end":{"line":104,"column":45}}]},"15":{"loc":{"start":{"line":106,"column":4},"end":{"line":112,"column":null}},"type":"if","locations":[{"start":{"line":106,"column":4},"end":{"line":112,"column":null}}]},"16":{"loc":{"start":{"line":107,"column":6},"end":{"line":111,"column":null}},"type":"if","locations":[{"start":{"line":107,"column":6},"end":{"line":111,"column":null}},{"start":{"line":109,"column":13},"end":{"line":111,"column":null}}]},"17":{"loc":{"start":{"line":115,"column":4},"end":{"line":137,"column":null}},"type":"if","locations":[{"start":{"line":115,"column":4},"end":{"line":137,"column":null}},{"start":{"line":119,"column":11},"end":{"line":137,"column":null}}]},"18":{"loc":{"start":{"line":123,"column":26},"end":{"line":123,"column":43}},"type":"binary-expr","locations":[{"start":{"line":123,"column":26},"end":{"line":123,"column":38}},{"start":{"line":123,"column":38},"end":{"line":123,"column":43}}]},"19":{"loc":{"start":{"line":124,"column":6},"end":{"line":136,"column":null}},"type":"if","locations":[{"start":{"line":124,"column":6},"end":{"line":136,"column":null}},{"start":{"line":127,"column":13},"end":{"line":136,"column":null}}]},"20":{"loc":{"start":{"line":129,"column":31},"end":{"line":129,"column":48}},"type":"binary-expr","locations":[{"start":{"line":129,"column":31},"end":{"line":129,"column":43}},{"start":{"line":129,"column":43},"end":{"line":129,"column":48}}]},"21":{"loc":{"start":{"line":130,"column":8},"end":{"line":135,"column":null}},"type":"if","locations":[{"start":{"line":130,"column":8},"end":{"line":135,"column":null}},{"start":{"line":132,"column":15},"end":{"line":135,"column":null}}]},"22":{"loc":{"start":{"line":139,"column":4},"end":{"line":141,"column":null}},"type":"if","locations":[{"start":{"line":139,"column":4},"end":{"line":141,"column":null}}]},"23":{"loc":{"start":{"line":151,"column":6},"end":{"line":166,"column":null}},"type":"if","locations":[{"start":{"line":151,"column":6},"end":{"line":166,"column":null}},{"start":{"line":163,"column":13},"end":{"line":166,"column":null}}]},"24":{"loc":{"start":{"line":151,"column":10},"end":{"line":151,"column":62}},"type":"binary-expr","locations":[{"start":{"line":151,"column":10},"end":{"line":151,"column":31}},{"start":{"line":151,"column":31},"end":{"line":151,"column":62}}]},"25":{"loc":{"start":{"line":151,"column":31},"end":{"line":151,"column":38}},"type":"cond-expr","locations":[{"start":{"line":151,"column":31},"end":{"line":151,"column":38}},{"start":{"line":151,"column":31},"end":{"line":151,"column":38}}]},"26":{"loc":{"start":{"line":154,"column":8},"end":{"line":157,"column":null}},"type":"if","locations":[{"start":{"line":154,"column":8},"end":{"line":157,"column":null}}]},"27":{"loc":{"start":{"line":164,"column":100},"end":{"line":164,"column":113}},"type":"cond-expr","locations":[{"start":{"line":164,"column":100},"end":{"line":164,"column":113}},{"start":{"line":164,"column":100},"end":{"line":164,"column":113}}]},"28":{"loc":{"start":{"line":174,"column":4},"end":{"line":176,"column":null}},"type":"if","locations":[{"start":{"line":174,"column":4},"end":{"line":176,"column":null}}]},"29":{"loc":{"start":{"line":174,"column":8},"end":{"line":174,"column":61}},"type":"binary-expr","locations":[{"start":{"line":174,"column":8},"end":{"line":174,"column":25}},{"start":{"line":174,"column":25},"end":{"line":174,"column":54}},{"start":{"line":174,"column":54},"end":{"line":174,"column":61}}]},"30":{"loc":{"start":{"line":174,"column":25},"end":{"line":174,"column":32}},"type":"cond-expr","locations":[{"start":{"line":174,"column":25},"end":{"line":174,"column":32}},{"start":{"line":174,"column":25},"end":{"line":174,"column":32}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":0,"5":11,"6":11,"7":11,"8":11,"9":11,"10":11,"11":11,"12":11,"13":11,"14":11,"15":17,"16":0,"17":17,"18":22,"19":22,"20":22,"21":0,"22":17,"23":11,"24":18,"25":0,"26":0,"27":12,"28":12,"29":12,"30":12,"31":0,"32":0,"33":0,"34":0,"35":0,"36":12,"37":12,"38":0,"39":14,"40":14,"41":14,"42":14,"43":14,"44":0,"45":14,"46":14,"47":14,"48":10,"49":14,"50":0,"51":0,"52":0,"53":18,"54":18,"55":18,"56":18,"57":0,"58":0,"59":0,"60":18,"61":18,"62":16,"63":16,"64":2,"65":2,"66":2,"67":0,"68":0,"69":2,"70":2,"71":0,"72":2,"73":2,"74":18,"75":4,"76":14,"77":4,"78":4,"79":4,"80":4,"81":4,"82":2,"83":2,"84":4,"85":4,"86":4,"87":4,"88":0,"89":0,"90":0,"91":0,"92":0,"93":0,"94":0,"95":0,"96":0,"97":0,"98":0,"99":0},"f":{"0":0,"1":11,"2":17,"3":22,"4":17,"5":11,"6":18,"7":0,"8":12,"9":0,"10":14,"11":0,"12":18,"13":4,"14":4,"15":0,"16":0,"17":0},"b":{"0":[11,0],"1":[11,11],"2":[11,11],"3":[0],"4":[22,0],"5":[22,22],"6":[22],"7":[12],"8":[0,12],"9":[12,12],"10":[14,0],"11":[10],"12":[1,17],"13":[36,36],"14":[4,14],"15":[0],"16":[0,0],"17":[16,2],"18":[2,2],"19":[0,2],"20":[2,2],"21":[0,2],"22":[4],"23":[4,0],"24":[4,4],"25":[0,4],"26":[2],"27":[0,0],"28":[0],"29":[0,0,0],"30":[0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/condition-fast.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/condition-fast.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":6,"column":27},"end":{"line":6,"column":null}},"2":{"start":{"line":7,"column":4},"end":{"line":7,"column":27}},"3":{"start":{"line":7,"column":21},"end":{"line":7,"column":27}},"4":{"start":{"line":8,"column":28},"end":{"line":8,"column":42}},"5":{"start":{"line":9,"column":4},"end":{"line":9,"column":11}},"6":{"start":{"line":10,"column":4},"end":{"line":30,"column":null}},"7":{"start":{"line":11,"column":28},"end":{"line":11,"column":39}},"8":{"start":{"line":12,"column":35},"end":{"line":12,"column":41}},"9":{"start":{"line":13,"column":6},"end":{"line":13,"column":null}},"10":{"start":{"line":13,"column":64},"end":{"line":13,"column":70}},"11":{"start":{"line":14,"column":6},"end":{"line":14,"column":null}},"12":{"start":{"line":14,"column":63},"end":{"line":14,"column":69}},"13":{"start":{"line":15,"column":6},"end":{"line":15,"column":11}},"14":{"start":{"line":16,"column":6},"end":{"line":16,"column":11}},"15":{"start":{"line":17,"column":6},"end":{"line":21,"column":null}},"16":{"start":{"line":18,"column":8},"end":{"line":18,"column":13}},"17":{"start":{"line":18,"column":50},"end":{"line":18,"column":51}},"18":{"start":{"line":20,"column":8},"end":{"line":20,"column":13}},"19":{"start":{"line":22,"column":11},"end":{"line":30,"column":null}},"20":{"start":{"line":23,"column":6},"end":{"line":23,"column":null}},"21":{"start":{"line":23,"column":71},"end":{"line":23,"column":77}},"22":{"start":{"line":24,"column":6},"end":{"line":24,"column":null}},"23":{"start":{"line":24,"column":75},"end":{"line":24,"column":81}},"24":{"start":{"line":25,"column":6},"end":{"line":25,"column":null}},"25":{"start":{"line":25,"column":72},"end":{"line":25,"column":78}},"26":{"start":{"line":27,"column":6},"end":{"line":29,"column":null}},"27":{"start":{"line":28,"column":8},"end":{"line":28,"column":19}},"28":{"start":{"line":33,"column":28},"end":{"line":33,"column":27}},"29":{"start":{"line":34,"column":18},"end":{"line":34,"column":null}},"30":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"31":{"start":{"line":36,"column":6},"end":{"line":36,"column":12}},"32":{"start":{"line":38,"column":4},"end":{"line":40,"column":null}},"33":{"start":{"line":39,"column":6},"end":{"line":39,"column":12}},"34":{"start":{"line":41,"column":17},"end":{"line":41,"column":31}},"35":{"start":{"line":42,"column":4},"end":{"line":69,"column":null}},"36":{"start":{"line":43,"column":6},"end":{"line":47,"column":null}},"37":{"start":{"line":44,"column":8},"end":{"line":44,"column":14}},"38":{"start":{"line":44,"column":37},"end":{"line":44,"column":38}},"39":{"start":{"line":46,"column":8},"end":{"line":46,"column":14}},"40":{"start":{"line":48,"column":11},"end":{"line":69,"column":null}},"41":{"start":{"line":49,"column":6},"end":{"line":49,"column":12}},"42":{"start":{"line":51,"column":6},"end":{"line":51,"column":12}},"43":{"start":{"line":52,"column":6},"end":{"line":52,"column":12}},"44":{"start":{"line":53,"column":6},"end":{"line":53,"column":12}},"45":{"start":{"line":54,"column":6},"end":{"line":56,"column":null}},"46":{"start":{"line":55,"column":8},"end":{"line":55,"column":14}},"47":{"start":{"line":57,"column":6},"end":{"line":59,"column":null}},"48":{"start":{"line":58,"column":8},"end":{"line":58,"column":14}},"49":{"start":{"line":60,"column":6},"end":{"line":62,"column":null}},"50":{"start":{"line":61,"column":8},"end":{"line":61,"column":14}},"51":{"start":{"line":63,"column":6},"end":{"line":65,"column":null}},"52":{"start":{"line":64,"column":8},"end":{"line":64,"column":14}},"53":{"start":{"line":66,"column":6},"end":{"line":68,"column":null}},"54":{"start":{"line":67,"column":8},"end":{"line":67,"column":14}},"55":{"start":{"line":70,"column":4},"end":{"line":72,"column":null}},"56":{"start":{"line":71,"column":6},"end":{"line":71,"column":13}},"57":{"start":{"line":73,"column":4},"end":{"line":73,"column":11}},"58":{"start":{"line":79,"column":34},"end":{"line":79,"column":null}},"59":{"start":{"line":80,"column":4},"end":{"line":80,"column":25}},"60":{"start":{"line":80,"column":18},"end":{"line":80,"column":25}},"61":{"start":{"line":81,"column":4},"end":{"line":81,"column":29}},"62":{"start":{"line":81,"column":22},"end":{"line":81,"column":29}},"63":{"start":{"line":82,"column":4},"end":{"line":82,"column":null}},"64":{"start":{"line":82,"column":36},"end":{"line":82,"column":43}},"65":{"start":{"line":84,"column":15},"end":{"line":84,"column":27}},"66":{"start":{"line":85,"column":4},"end":{"line":85,"column":null}},"67":{"start":{"line":85,"column":15},"end":{"line":85,"column":22}},"68":{"start":{"line":88,"column":28},"end":{"line":88,"column":30}},"69":{"start":{"line":91,"column":4},"end":{"line":129,"column":null}},"70":{"start":{"line":93,"column":6},"end":{"line":93,"column":13}},"71":{"start":{"line":95,"column":25},"end":{"line":95,"column":28}},"72":{"start":{"line":96,"column":10},"end":{"line":96,"column":16}},"73":{"start":{"line":102,"column":10},"end":{"line":102,"column":17}},"74":{"start":{"line":111,"column":6},"end":{"line":111,"column":13}},"75":{"start":{"line":114,"column":59},"end":{"line":114,"column":null}},"76":{"start":{"line":115,"column":23},"end":{"line":115,"column":26}},"77":{"start":{"line":116,"column":8},"end":{"line":116,"column":14}},"78":{"start":{"line":122,"column":8},"end":{"line":122,"column":15}},"79":{"start":{"line":136,"column":4},"end":{"line":138,"column":null}},"80":{"start":{"line":137,"column":6},"end":{"line":137,"column":13}},"81":{"start":{"line":140,"column":21},"end":{"line":140,"column":26}},"82":{"start":{"line":141,"column":23},"end":{"line":141,"column":28}},"83":{"start":{"line":143,"column":4},"end":{"line":143,"column":10}},"84":{"start":{"line":145,"column":4},"end":{"line":148,"column":null}},"85":{"start":{"line":146,"column":6},"end":{"line":146,"column":13}},"86":{"start":{"line":147,"column":14},"end":{"line":147,"column":24}},"87":{"start":{"line":151,"column":4},"end":{"line":173,"column":null}},"88":{"start":{"line":153,"column":27},"end":{"line":171,"column":null}},"89":{"start":{"line":154,"column":8},"end":{"line":156,"column":null}},"90":{"start":{"line":155,"column":10},"end":{"line":155,"column":17}},"91":{"start":{"line":158,"column":26},"end":{"line":158,"column":37}},"92":{"start":{"line":159,"column":27},"end":{"line":161,"column":22}},"93":{"start":{"line":163,"column":8},"end":{"line":163,"column":15}},"94":{"start":{"line":164,"column":25},"end":{"line":164,"column":null}},"95":{"start":{"line":165,"column":10},"end":{"line":168,"column":null}},"96":{"start":{"line":166,"column":12},"end":{"line":166,"column":18}},"97":{"start":{"line":167,"column":12},"end":{"line":167,"column":19}},"98":{"start":{"line":169,"column":10},"end":{"line":169,"column":17}},"99":{"start":{"line":172,"column":6},"end":{"line":172,"column":13}},"100":{"start":{"line":175,"column":4},"end":{"line":197,"column":null}},"101":{"start":{"line":177,"column":27},"end":{"line":195,"column":null}},"102":{"start":{"line":178,"column":8},"end":{"line":180,"column":null}},"103":{"start":{"line":179,"column":10},"end":{"line":179,"column":17}},"104":{"start":{"line":182,"column":26},"end":{"line":182,"column":37}},"105":{"start":{"line":183,"column":27},"end":{"line":185,"column":22}},"106":{"start":{"line":187,"column":8},"end":{"line":187,"column":15}},"107":{"start":{"line":188,"column":26},"end":{"line":188,"column":null}},"108":{"start":{"line":189,"column":10},"end":{"line":192,"column":null}},"109":{"start":{"line":190,"column":12},"end":{"line":190,"column":18}},"110":{"start":{"line":191,"column":12},"end":{"line":191,"column":19}},"111":{"start":{"line":193,"column":10},"end":{"line":193,"column":17}},"112":{"start":{"line":196,"column":6},"end":{"line":196,"column":13}},"113":{"start":{"line":199,"column":4},"end":{"line":199,"column":11}},"114":{"start":{"line":213,"column":4},"end":{"line":213,"column":11}},"115":{"start":{"line":217,"column":4},"end":{"line":217,"column":11}},"116":{"start":{"line":221,"column":4},"end":{"line":221,"column":11}},"117":{"start":{"line":203,"column":4},"end":{"line":209,"column":null}},"118":{"start":{"line":204,"column":6},"end":{"line":204,"column":13}},"119":{"start":{"line":205,"column":11},"end":{"line":209,"column":null}},"120":{"start":{"line":206,"column":6},"end":{"line":206,"column":13}},"121":{"start":{"line":207,"column":11},"end":{"line":209,"column":null}},"122":{"start":{"line":208,"column":6},"end":{"line":208,"column":13}}},"fnMap":{"0":{"name":"ConditionFast","decl":{"start":{"line":6,"column":2},"end":{"line":6,"column":15}},"loc":{"start":{"line":6,"column":27},"end":{"line":31,"column":null}}},"1":{"name":"(anonymous_12)","decl":{"start":{"line":18,"column":50},"end":{"line":18,"column":51}},"loc":{"start":{"line":18,"column":50},"end":{"line":18,"column":51}}},"2":{"name":"toJSON","decl":{"start":{"line":33,"column":28},"end":{"line":33,"column":null}},"loc":{"start":{"line":33,"column":28},"end":{"line":74,"column":null}}},"3":{"name":"(anonymous_14)","decl":{"start":{"line":44,"column":37},"end":{"line":44,"column":38}},"loc":{"start":{"line":44,"column":37},"end":{"line":44,"column":38}}},"4":{"name":"evaluate","decl":{"start":{"line":79,"column":12},"end":{"line":79,"column":21}},"loc":{"start":{"line":79,"column":34},"end":{"line":130,"column":null}}},"5":{"name":"(anonymous_16)","decl":{"start":{"line":94,"column":14},"end":{"line":94,"column":35}},"loc":{"start":{"line":94,"column":35},"end":{"line":108,"column":null}}},"6":{"name":"(anonymous_17)","decl":{"start":{"line":114,"column":14},"end":{"line":114,"column":16}},"loc":{"start":{"line":114,"column":59},"end":{"line":128,"column":null}}},"7":{"name":"evaluateBooleanCondition","decl":{"start":{"line":135,"column":28},"end":{"line":135,"column":37}},"loc":{"start":{"line":135,"column":50},"end":{"line":200,"column":null}}},"8":{"name":"(anonymous_19)","decl":{"start":{"line":147,"column":14},"end":{"line":147,"column":24}},"loc":{"start":{"line":147,"column":14},"end":{"line":147,"column":24}}},"9":{"name":"evaluateNext","decl":{"start":{"line":153,"column":12},"end":{"line":153,"column":27}},"loc":{"start":{"line":153,"column":38},"end":{"line":171,"column":null}}},"10":{"name":"(anonymous_21)","decl":{"start":{"line":163,"column":31},"end":{"line":163,"column":41}},"loc":{"start":{"line":163,"column":41},"end":{"line":170,"column":null}}},"11":{"name":"_evaluateNext","decl":{"start":{"line":177,"column":12},"end":{"line":177,"column":27}},"loc":{"start":{"line":177,"column":38},"end":{"line":195,"column":null}}},"12":{"name":"(anonymous_23)","decl":{"start":{"line":187,"column":31},"end":{"line":187,"column":41}},"loc":{"start":{"line":187,"column":41},"end":{"line":194,"column":null}}},"13":{"name":"booleanOperator","decl":{"start":{"line":212,"column":21},"end":{"line":212,"column":null}},"loc":{"start":{"line":212,"column":21},"end":{"line":214,"column":null}}},"14":{"name":"isBooleanOperator","decl":{"start":{"line":216,"column":23},"end":{"line":216,"column":null}},"loc":{"start":{"line":216,"column":23},"end":{"line":218,"column":null}}},"15":{"name":"isConditionReference","decl":{"start":{"line":220,"column":26},"end":{"line":220,"column":null}},"loc":{"start":{"line":220,"column":26},"end":{"line":222,"column":null}}},"16":{"name":"booleanOperator","decl":{"start":{"line":202,"column":26},"end":{"line":202,"column":37}},"loc":{"start":{"line":202,"column":37},"end":{"line":210,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":7,"column":4},"end":{"line":7,"column":27}},"type":"if","locations":[{"start":{"line":7,"column":4},"end":{"line":7,"column":27}}]},"1":{"loc":{"start":{"line":10,"column":4},"end":{"line":30,"column":null}},"type":"if","locations":[{"start":{"line":10,"column":4},"end":{"line":30,"column":null}},{"start":{"line":22,"column":11},"end":{"line":30,"column":null}}]},"2":{"loc":{"start":{"line":13,"column":6},"end":{"line":13,"column":null}},"type":"if","locations":[{"start":{"line":13,"column":6},"end":{"line":13,"column":null}}]},"3":{"loc":{"start":{"line":13,"column":10},"end":{"line":13,"column":62}},"type":"binary-expr","locations":[{"start":{"line":13,"column":10},"end":{"line":13,"column":39}},{"start":{"line":13,"column":39},"end":{"line":13,"column":62}}]},"4":{"loc":{"start":{"line":14,"column":6},"end":{"line":14,"column":null}},"type":"if","locations":[{"start":{"line":14,"column":6},"end":{"line":14,"column":null}}]},"5":{"loc":{"start":{"line":14,"column":10},"end":{"line":14,"column":61}},"type":"binary-expr","locations":[{"start":{"line":14,"column":10},"end":{"line":14,"column":39}},{"start":{"line":14,"column":39},"end":{"line":14,"column":61}}]},"6":{"loc":{"start":{"line":16,"column":22},"end":{"line":16,"column":null}},"type":"binary-expr","locations":[{"start":{"line":16,"column":22},"end":{"line":16,"column":31}},{"start":{"line":16,"column":59},"end":{"line":16,"column":null}}]},"7":{"loc":{"start":{"line":17,"column":6},"end":{"line":21,"column":null}},"type":"if","locations":[{"start":{"line":17,"column":6},"end":{"line":21,"column":null}},{"start":{"line":19,"column":13},"end":{"line":21,"column":null}}]},"8":{"loc":{"start":{"line":22,"column":11},"end":{"line":30,"column":null}},"type":"if","locations":[{"start":{"line":22,"column":11},"end":{"line":30,"column":null}}]},"9":{"loc":{"start":{"line":23,"column":6},"end":{"line":23,"column":null}},"type":"if","locations":[{"start":{"line":23,"column":6},"end":{"line":23,"column":null}}]},"10":{"loc":{"start":{"line":24,"column":6},"end":{"line":24,"column":null}},"type":"if","locations":[{"start":{"line":24,"column":6},"end":{"line":24,"column":null}}]},"11":{"loc":{"start":{"line":25,"column":6},"end":{"line":25,"column":null}},"type":"if","locations":[{"start":{"line":25,"column":6},"end":{"line":25,"column":null}}]},"12":{"loc":{"start":{"line":27,"column":6},"end":{"line":29,"column":null}},"type":"if","locations":[{"start":{"line":27,"column":6},"end":{"line":29,"column":null}}]},"13":{"loc":{"start":{"line":33,"column":28},"end":{"line":33,"column":27}},"type":"cond-expr","locations":[{"start":{"line":33,"column":28},"end":{"line":33,"column":null}},{"start":{"line":33,"column":22},"end":{"line":33,"column":28}}]},"14":{"loc":{"start":{"line":33,"column":28},"end":{"line":33,"column":null}},"type":"binary-expr","locations":[{"start":{"line":33,"column":28},"end":{"line":33,"column":null}},{"start":{"line":33,"column":28},"end":{"line":33,"column":null}}]},"15":{"loc":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"type":"if","locations":[{"start":{"line":35,"column":4},"end":{"line":37,"column":null}}]},"16":{"loc":{"start":{"line":38,"column":4},"end":{"line":40,"column":null}},"type":"if","locations":[{"start":{"line":38,"column":4},"end":{"line":40,"column":null}}]},"17":{"loc":{"start":{"line":42,"column":4},"end":{"line":69,"column":null}},"type":"if","locations":[{"start":{"line":42,"column":4},"end":{"line":69,"column":null}},{"start":{"line":48,"column":11},"end":{"line":69,"column":null}}]},"18":{"loc":{"start":{"line":43,"column":6},"end":{"line":47,"column":null}},"type":"if","locations":[{"start":{"line":43,"column":6},"end":{"line":47,"column":null}},{"start":{"line":45,"column":13},"end":{"line":47,"column":null}}]},"19":{"loc":{"start":{"line":48,"column":11},"end":{"line":69,"column":null}},"type":"if","locations":[{"start":{"line":48,"column":11},"end":{"line":69,"column":null}},{"start":{"line":50,"column":11},"end":{"line":69,"column":null}}]},"20":{"loc":{"start":{"line":54,"column":6},"end":{"line":56,"column":null}},"type":"if","locations":[{"start":{"line":54,"column":6},"end":{"line":56,"column":null}}]},"21":{"loc":{"start":{"line":57,"column":6},"end":{"line":59,"column":null}},"type":"if","locations":[{"start":{"line":57,"column":6},"end":{"line":59,"column":null}}]},"22":{"loc":{"start":{"line":60,"column":6},"end":{"line":62,"column":null}},"type":"if","locations":[{"start":{"line":60,"column":6},"end":{"line":62,"column":null}}]},"23":{"loc":{"start":{"line":63,"column":6},"end":{"line":65,"column":null}},"type":"if","locations":[{"start":{"line":63,"column":6},"end":{"line":65,"column":null}}]},"24":{"loc":{"start":{"line":66,"column":6},"end":{"line":68,"column":null}},"type":"if","locations":[{"start":{"line":66,"column":6},"end":{"line":68,"column":null}}]},"25":{"loc":{"start":{"line":70,"column":4},"end":{"line":72,"column":null}},"type":"if","locations":[{"start":{"line":70,"column":4},"end":{"line":72,"column":null}}]},"26":{"loc":{"start":{"line":80,"column":4},"end":{"line":80,"column":25}},"type":"if","locations":[{"start":{"line":80,"column":4},"end":{"line":80,"column":25}}]},"27":{"loc":{"start":{"line":81,"column":4},"end":{"line":81,"column":29}},"type":"if","locations":[{"start":{"line":81,"column":4},"end":{"line":81,"column":29}}]},"28":{"loc":{"start":{"line":82,"column":4},"end":{"line":82,"column":null}},"type":"if","locations":[{"start":{"line":82,"column":4},"end":{"line":82,"column":null}}]},"29":{"loc":{"start":{"line":85,"column":4},"end":{"line":85,"column":null}},"type":"if","locations":[{"start":{"line":85,"column":4},"end":{"line":85,"column":null}}]},"30":{"loc":{"start":{"line":88,"column":30},"end":{"line":89,"column":36}},"type":"binary-expr","locations":[{"start":{"line":88,"column":30},"end":{"line":88,"column":52}},{"start":{"line":88,"column":52},"end":{"line":88,"column":null}},{"start":{"line":89,"column":29},"end":{"line":89,"column":36}}]},"31":{"loc":{"start":{"line":91,"column":4},"end":{"line":129,"column":null}},"type":"if","locations":[{"start":{"line":91,"column":4},"end":{"line":129,"column":null}},{"start":{"line":109,"column":11},"end":{"line":129,"column":null}}]},"32":{"loc":{"start":{"line":136,"column":4},"end":{"line":138,"column":null}},"type":"if","locations":[{"start":{"line":136,"column":4},"end":{"line":138,"column":null}}]},"33":{"loc":{"start":{"line":145,"column":4},"end":{"line":148,"column":null}},"type":"if","locations":[{"start":{"line":145,"column":4},"end":{"line":148,"column":null}}]},"34":{"loc":{"start":{"line":151,"column":4},"end":{"line":173,"column":null}},"type":"if","locations":[{"start":{"line":151,"column":4},"end":{"line":173,"column":null}}]},"35":{"loc":{"start":{"line":154,"column":8},"end":{"line":156,"column":null}},"type":"if","locations":[{"start":{"line":154,"column":8},"end":{"line":156,"column":null}}]},"36":{"loc":{"start":{"line":159,"column":27},"end":{"line":161,"column":22}},"type":"cond-expr","locations":[{"start":{"line":160,"column":12},"end":{"line":160,"column":22}},{"start":{"line":161,"column":12},"end":{"line":161,"column":22}}]},"37":{"loc":{"start":{"line":164,"column":25},"end":{"line":164,"column":null}},"type":"binary-expr","locations":[{"start":{"line":164,"column":25},"end":{"line":164,"column":45}},{"start":{"line":164,"column":45},"end":{"line":164,"column":55}},{"start":{"line":164,"column":55},"end":{"line":164,"column":null}}]},"38":{"loc":{"start":{"line":165,"column":10},"end":{"line":168,"column":null}},"type":"if","locations":[{"start":{"line":165,"column":10},"end":{"line":168,"column":null}}]},"39":{"loc":{"start":{"line":175,"column":4},"end":{"line":197,"column":null}},"type":"if","locations":[{"start":{"line":175,"column":4},"end":{"line":197,"column":null}}]},"40":{"loc":{"start":{"line":178,"column":8},"end":{"line":180,"column":null}},"type":"if","locations":[{"start":{"line":178,"column":8},"end":{"line":180,"column":null}}]},"41":{"loc":{"start":{"line":183,"column":27},"end":{"line":185,"column":22}},"type":"cond-expr","locations":[{"start":{"line":184,"column":12},"end":{"line":184,"column":22}},{"start":{"line":185,"column":12},"end":{"line":185,"column":22}}]},"42":{"loc":{"start":{"line":188,"column":26},"end":{"line":188,"column":null}},"type":"binary-expr","locations":[{"start":{"line":188,"column":26},"end":{"line":188,"column":47}},{"start":{"line":188,"column":47},"end":{"line":188,"column":57}},{"start":{"line":188,"column":57},"end":{"line":188,"column":null}}]},"43":{"loc":{"start":{"line":189,"column":10},"end":{"line":192,"column":null}},"type":"if","locations":[{"start":{"line":189,"column":10},"end":{"line":192,"column":null}}]},"44":{"loc":{"start":{"line":203,"column":4},"end":{"line":209,"column":null}},"type":"if","locations":[{"start":{"line":203,"column":4},"end":{"line":209,"column":null}},{"start":{"line":205,"column":11},"end":{"line":209,"column":null}}]},"45":{"loc":{"start":{"line":205,"column":11},"end":{"line":209,"column":null}},"type":"if","locations":[{"start":{"line":205,"column":11},"end":{"line":209,"column":null}},{"start":{"line":207,"column":11},"end":{"line":209,"column":null}}]},"46":{"loc":{"start":{"line":207,"column":11},"end":{"line":209,"column":null}},"type":"if","locations":[{"start":{"line":207,"column":11},"end":{"line":209,"column":null}}]}},"s":{"0":1,"1":47,"2":47,"3":0,"4":47,"5":47,"6":47,"7":21,"8":21,"9":21,"10":0,"11":21,"12":0,"13":21,"14":21,"15":21,"16":21,"17":26,"18":0,"19":26,"20":26,"21":0,"22":26,"23":0,"24":26,"25":0,"26":26,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":18,"59":18,"60":0,"61":18,"62":0,"63":18,"64":0,"65":18,"66":18,"67":0,"68":18,"69":18,"70":18,"71":18,"72":18,"73":18,"74":0,"75":0,"76":0,"77":0,"78":0,"79":17,"80":0,"81":17,"82":17,"83":17,"84":17,"85":0,"86":0,"87":17,"88":1,"89":1,"90":0,"91":1,"92":1,"93":1,"94":1,"95":1,"96":1,"97":1,"98":0,"99":1,"100":16,"101":16,"102":31,"103":14,"104":17,"105":17,"106":17,"107":17,"108":17,"109":2,"110":2,"111":15,"112":16,"113":0,"114":17,"115":70,"116":17,"117":134,"118":4,"119":130,"120":68,"121":62,"122":0},"f":{"0":47,"1":26,"2":0,"3":0,"4":18,"5":18,"6":0,"7":17,"8":0,"9":1,"10":1,"11":31,"12":17,"13":17,"14":70,"15":17,"16":134},"b":{"0":[0],"1":[21,26],"2":[0],"3":[21,21],"4":[0],"5":[21,0],"6":[21,21],"7":[21,0],"8":[26],"9":[0],"10":[0],"11":[0],"12":[0],"13":[0,0],"14":[0,0],"15":[0],"16":[0],"17":[0,0],"18":[0,0],"19":[0,0],"20":[0],"21":[0],"22":[0],"23":[0],"24":[0],"25":[0],"26":[0],"27":[0],"28":[0],"29":[0],"30":[18,18,0],"31":[18,0],"32":[0],"33":[0],"34":[1],"35":[0],"36":[0,1],"37":[1,1,1],"38":[1],"39":[16],"40":[14],"41":[0,17],"42":[17,17,17],"43":[2],"44":[4,130],"45":[68,62],"46":[0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/engine-fast.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/engine-fast.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"5":{"start":{"line":8,"column":0},"end":{"line":8,"column":null}},"6":{"start":{"line":9,"column":0},"end":{"line":9,"column":null}},"7":{"start":{"line":10,"column":0},"end":{"line":10,"column":null}},"8":{"start":{"line":11,"column":0},"end":{"line":11,"column":null}},"9":{"start":{"line":13,"column":13},"end":{"line":13,"column":null}},"10":{"start":{"line":14,"column":13},"end":{"line":14,"column":null}},"11":{"start":{"line":15,"column":13},"end":{"line":15,"column":null}},"12":{"start":{"line":23,"column":41},"end":{"line":23,"column":27}},"13":{"start":{"line":23,"column":41},"end":{"line":23,"column":40}},"14":{"start":{"line":23,"column":41},"end":{"line":23,"column":null}},"15":{"start":{"line":25,"column":4},"end":{"line":25,"column":9}},"16":{"start":{"line":26,"column":4},"end":{"line":26,"column":9}},"17":{"start":{"line":27,"column":4},"end":{"line":27,"column":9}},"18":{"start":{"line":28,"column":4},"end":{"line":28,"column":9}},"19":{"start":{"line":29,"column":4},"end":{"line":29,"column":9}},"20":{"start":{"line":30,"column":4},"end":{"line":30,"column":9}},"21":{"start":{"line":31,"column":4},"end":{"line":31,"column":9}},"22":{"start":{"line":32,"column":4},"end":{"line":32,"column":9}},"23":{"start":{"line":33,"column":4},"end":{"line":33,"column":9}},"24":{"start":{"line":34,"column":4},"end":{"line":34,"column":10}},"25":{"start":{"line":34,"column":14},"end":{"line":34,"column":19}},"26":{"start":{"line":35,"column":4},"end":{"line":35,"column":21}},"27":{"start":{"line":35,"column":25},"end":{"line":35,"column":30}},"28":{"start":{"line":36,"column":4},"end":{"line":36,"column":22}},"29":{"start":{"line":36,"column":26},"end":{"line":36,"column":31}},"30":{"start":{"line":40,"column":4},"end":{"line":40,"column":27}},"31":{"start":{"line":40,"column":21},"end":{"line":40,"column":27}},"32":{"start":{"line":42,"column":8},"end":{"line":42,"column":null}},"33":{"start":{"line":43,"column":4},"end":{"line":49,"column":null}},"34":{"start":{"line":44,"column":6},"end":{"line":44,"column":13}},"35":{"start":{"line":46,"column":6},"end":{"line":46,"column":76}},"36":{"start":{"line":46,"column":70},"end":{"line":46,"column":76}},"37":{"start":{"line":47,"column":6},"end":{"line":47,"column":81}},"38":{"start":{"line":47,"column":75},"end":{"line":47,"column":81}},"39":{"start":{"line":48,"column":6},"end":{"line":48,"column":13}},"40":{"start":{"line":50,"column":4},"end":{"line":50,"column":9}},"41":{"start":{"line":51,"column":4},"end":{"line":51,"column":9}},"42":{"start":{"line":52,"column":4},"end":{"line":52,"column":9}},"43":{"start":{"line":53,"column":4},"end":{"line":53,"column":11}},"44":{"start":{"line":57,"column":22},"end":{"line":57,"column":27}},"45":{"start":{"line":57,"column":43},"end":{"line":57,"column":59}},"46":{"start":{"line":58,"column":4},"end":{"line":64,"column":null}},"47":{"start":{"line":59,"column":6},"end":{"line":59,"column":11}},"48":{"start":{"line":60,"column":6},"end":{"line":60,"column":11}},"49":{"start":{"line":61,"column":6},"end":{"line":61,"column":11}},"50":{"start":{"line":63,"column":6},"end":{"line":63,"column":12}},"51":{"start":{"line":68,"column":22},"end":{"line":68,"column":null}},"52":{"start":{"line":69,"column":4},"end":{"line":78,"column":null}},"53":{"start":{"line":70,"column":28},"end":{"line":70,"column":33}},"54":{"start":{"line":70,"column":46},"end":{"line":70,"column":62}},"55":{"start":{"line":71,"column":6},"end":{"line":71,"column":20}},"56":{"start":{"line":72,"column":6},"end":{"line":72,"column":11}},"57":{"start":{"line":74,"column":20},"end":{"line":74,"column":25}},"58":{"start":{"line":75,"column":6},"end":{"line":77,"column":null}},"59":{"start":{"line":76,"column":8},"end":{"line":76,"column":22}},"60":{"start":{"line":79,"column":4},"end":{"line":81,"column":null}},"61":{"start":{"line":80,"column":6},"end":{"line":80,"column":11}},"62":{"start":{"line":82,"column":4},"end":{"line":82,"column":11}},"63":{"start":{"line":86,"column":4},"end":{"line":86,"column":21}},"64":{"start":{"line":86,"column":15},"end":{"line":86,"column":21}},"65":{"start":{"line":87,"column":4},"end":{"line":87,"column":27}},"66":{"start":{"line":87,"column":21},"end":{"line":87,"column":27}},"67":{"start":{"line":88,"column":4},"end":{"line":90,"column":null}},"68":{"start":{"line":89,"column":6},"end":{"line":89,"column":12}},"69":{"start":{"line":91,"column":4},"end":{"line":91,"column":9}},"70":{"start":{"line":92,"column":4},"end":{"line":92,"column":11}},"71":{"start":{"line":96,"column":4},"end":{"line":96,"column":11}},"72":{"start":{"line":100,"column":4},"end":{"line":100,"column":9}},"73":{"start":{"line":104,"column":4},"end":{"line":104,"column":11}},"74":{"start":{"line":108,"column":4},"end":{"line":108,"column":9}},"75":{"start":{"line":112,"column":4},"end":{"line":112,"column":11}},"76":{"start":{"line":116,"column":17},"end":{"line":116,"column":null}},"77":{"start":{"line":117,"column":8},"end":{"line":117,"column":null}},"78":{"start":{"line":118,"column":4},"end":{"line":123,"column":null}},"79":{"start":{"line":119,"column":6},"end":{"line":119,"column":15}},"80":{"start":{"line":120,"column":6},"end":{"line":120,"column":13}},"81":{"start":{"line":122,"column":6},"end":{"line":122,"column":13}},"82":{"start":{"line":124,"column":4},"end":{"line":124,"column":10}},"83":{"start":{"line":125,"column":4},"end":{"line":125,"column":9}},"84":{"start":{"line":126,"column":4},"end":{"line":126,"column":11}},"85":{"start":{"line":130,"column":8},"end":{"line":130,"column":null}},"86":{"start":{"line":131,"column":4},"end":{"line":135,"column":null}},"87":{"start":{"line":132,"column":6},"end":{"line":132,"column":15}},"88":{"start":{"line":134,"column":6},"end":{"line":134,"column":15}},"89":{"start":{"line":136,"column":4},"end":{"line":136,"column":11}},"90":{"start":{"line":140,"column":4},"end":{"line":150,"column":null}},"91":{"start":{"line":141,"column":23},"end":{"line":141,"column":28}},"92":{"start":{"line":142,"column":25},"end":{"line":142,"column":null}},"93":{"start":{"line":143,"column":8},"end":{"line":143,"column":34}},"94":{"start":{"line":143,"column":29},"end":{"line":143,"column":34}},"95":{"start":{"line":144,"column":8},"end":{"line":144,"column":13}},"96":{"start":{"line":145,"column":8},"end":{"line":145,"column":15}},"97":{"start":{"line":147,"column":6},"end":{"line":147,"column":11}},"98":{"start":{"line":148,"column":8},"end":{"line":148,"column":15}},"99":{"start":{"line":149,"column":13},"end":{"line":149,"column":14}},"100":{"start":{"line":151,"column":4},"end":{"line":151,"column":11}},"101":{"start":{"line":155,"column":4},"end":{"line":155,"column":9}},"102":{"start":{"line":156,"column":4},"end":{"line":156,"column":11}},"103":{"start":{"line":160,"column":4},"end":{"line":160,"column":11}},"104":{"start":{"line":168,"column":37},"end":{"line":168,"column":null}},"105":{"start":{"line":169,"column":4},"end":{"line":169,"column":11}},"106":{"start":{"line":170,"column":6},"end":{"line":173,"column":null}},"107":{"start":{"line":171,"column":8},"end":{"line":171,"column":14}},"108":{"start":{"line":172,"column":8},"end":{"line":172,"column":15}},"109":{"start":{"line":175,"column":6},"end":{"line":175,"column":13}},"110":{"start":{"line":176,"column":8},"end":{"line":176,"column":14}},"111":{"start":{"line":177,"column":8},"end":{"line":177,"column":16}},"112":{"start":{"line":179,"column":8},"end":{"line":186,"column":null}},"113":{"start":{"line":180,"column":10},"end":{"line":180,"column":18}},"114":{"start":{"line":181,"column":10},"end":{"line":181,"column":17}},"115":{"start":{"line":182,"column":18},"end":{"line":182,"column":24}},"116":{"start":{"line":184,"column":10},"end":{"line":184,"column":18}},"117":{"start":{"line":185,"column":10},"end":{"line":185,"column":17}},"118":{"start":{"line":188,"column":8},"end":{"line":188,"column":14}},"119":{"start":{"line":189,"column":8},"end":{"line":189,"column":14}},"120":{"start":{"line":200,"column":43},"end":{"line":200,"column":null}},"121":{"start":{"line":200,"column":43},"end":{"line":200,"column":26}},"122":{"start":{"line":200,"column":43},"end":{"line":200,"column":42}},"123":{"start":{"line":201,"column":4},"end":{"line":201,"column":10}},"124":{"start":{"line":202,"column":4},"end":{"line":202,"column":9}},"125":{"start":{"line":205,"column":20},"end":{"line":205,"column":46}},"126":{"start":{"line":211,"column":4},"end":{"line":211,"column":9}},"127":{"start":{"line":212,"column":6},"end":{"line":212,"column":14}},"128":{"start":{"line":216,"column":4},"end":{"line":225,"column":null}},"129":{"start":{"line":217,"column":10},"end":{"line":217,"column":null}},"130":{"start":{"line":218,"column":6},"end":{"line":222,"column":null}},"131":{"start":{"line":219,"column":8},"end":{"line":219,"column":15}},"132":{"start":{"line":221,"column":8},"end":{"line":221,"column":15}},"133":{"start":{"line":223,"column":6},"end":{"line":223,"column":14}},"134":{"start":{"line":224,"column":6},"end":{"line":224,"column":12}},"135":{"start":{"line":227,"column":24},"end":{"line":227,"column":29}},"136":{"start":{"line":228,"column":17},"end":{"line":228,"column":25}},"137":{"start":{"line":231,"column":4},"end":{"line":231,"column":11}},"138":{"start":{"line":232,"column":6},"end":{"line":232,"column":18}},"139":{"start":{"line":233,"column":8},"end":{"line":233,"column":17}},"140":{"start":{"line":234,"column":10},"end":{"line":237,"column":null}},"141":{"start":{"line":235,"column":12},"end":{"line":235,"column":18}},"142":{"start":{"line":236,"column":12},"end":{"line":236,"column":19}},"143":{"start":{"line":238,"column":10},"end":{"line":238,"column":17}},"144":{"start":{"line":240,"column":8},"end":{"line":240,"column":15}},"145":{"start":{"line":243,"column":6},"end":{"line":243,"column":13}},"146":{"start":{"line":244,"column":8},"end":{"line":244,"column":13}},"147":{"start":{"line":245,"column":8},"end":{"line":245,"column":14}},"148":{"start":{"line":247,"column":28},"end":{"line":247,"column":36}},"149":{"start":{"line":248,"column":44},"end":{"line":248,"column":56}},"150":{"start":{"line":249,"column":24},"end":{"line":249,"column":null}},"151":{"start":{"line":250,"column":10},"end":{"line":250,"column":15}},"152":{"start":{"line":251,"column":10},"end":{"line":251,"column":17}},"153":{"start":{"line":243,"column":24},"end":{"line":248,"column":25}},"154":{"start":{"line":243,"column":24},"end":{"line":248,"column":44}},"155":{"start":{"line":254,"column":8},"end":{"line":254,"column":16}}},"fnMap":{"0":{"name":"EngineFast","decl":{"start":{"line":23,"column":2},"end":{"line":23,"column":15}},"loc":{"start":{"line":23,"column":41},"end":{"line":37,"column":null}}},"1":{"name":"(anonymous_11)","decl":{"start":{"line":34,"column":14},"end":{"line":34,"column":19}},"loc":{"start":{"line":34,"column":14},"end":{"line":34,"column":19}}},"2":{"name":"(anonymous_12)","decl":{"start":{"line":35,"column":25},"end":{"line":35,"column":30}},"loc":{"start":{"line":35,"column":25},"end":{"line":35,"column":30}}},"3":{"name":"(anonymous_13)","decl":{"start":{"line":36,"column":26},"end":{"line":36,"column":31}},"loc":{"start":{"line":36,"column":26},"end":{"line":36,"column":31}}},"4":{"name":"addRule","decl":{"start":{"line":39,"column":11},"end":{"line":39,"column":23}},"loc":{"start":{"line":39,"column":23},"end":{"line":54,"column":null}}},"5":{"name":"updateRule","decl":{"start":{"line":56,"column":14},"end":{"line":56,"column":20}},"loc":{"start":{"line":56,"column":20},"end":{"line":65,"column":null}}},"6":{"name":"(anonymous_16)","decl":{"start":{"line":57,"column":43},"end":{"line":57,"column":59}},"loc":{"start":{"line":57,"column":43},"end":{"line":57,"column":59}}},"7":{"name":"removeRule","decl":{"start":{"line":67,"column":14},"end":{"line":67,"column":20}},"loc":{"start":{"line":67,"column":20},"end":{"line":83,"column":null}}},"8":{"name":"(anonymous_18)","decl":{"start":{"line":70,"column":46},"end":{"line":70,"column":62}},"loc":{"start":{"line":70,"column":46},"end":{"line":70,"column":62}}},"9":{"name":"setCondition","decl":{"start":{"line":85,"column":16},"end":{"line":85,"column":22}},"loc":{"start":{"line":85,"column":34},"end":{"line":93,"column":null}}},"10":{"name":"removeCondition","decl":{"start":{"line":95,"column":19},"end":{"line":95,"column":25}},"loc":{"start":{"line":95,"column":25},"end":{"line":97,"column":null}}},"11":{"name":"addOperator","decl":{"start":{"line":99,"column":15},"end":{"line":99,"column":31}},"loc":{"start":{"line":99,"column":35},"end":{"line":101,"column":null}}},"12":{"name":"removeOperator","decl":{"start":{"line":103,"column":18},"end":{"line":103,"column":34}},"loc":{"start":{"line":103,"column":34},"end":{"line":105,"column":null}}},"13":{"name":"addOperatorDecorator","decl":{"start":{"line":107,"column":24},"end":{"line":107,"column":41}},"loc":{"start":{"line":107,"column":45},"end":{"line":109,"column":null}}},"14":{"name":"removeOperatorDecorator","decl":{"start":{"line":111,"column":27},"end":{"line":111,"column":44}},"loc":{"start":{"line":111,"column":44},"end":{"line":113,"column":null}}},"15":{"name":"addFact","decl":{"start":{"line":115,"column":11},"end":{"line":115,"column":15}},"loc":{"start":{"line":115,"column":39},"end":{"line":127,"column":null}}},"16":{"name":"removeFact","decl":{"start":{"line":129,"column":14},"end":{"line":129,"column":24}},"loc":{"start":{"line":129,"column":24},"end":{"line":137,"column":null}}},"17":{"name":"prioritizeRules","decl":{"start":{"line":139,"column":21},"end":{"line":139,"column":null}},"loc":{"start":{"line":139,"column":21},"end":{"line":152,"column":null}}},"18":{"name":"(anonymous_28)","decl":{"start":{"line":141,"column":41},"end":{"line":141,"column":42}},"loc":{"start":{"line":141,"column":57},"end":{"line":146,"column":9}}},"19":{"name":"(anonymous_29)","decl":{"start":{"line":147,"column":57},"end":{"line":147,"column":58}},"loc":{"start":{"line":147,"column":67},"end":{"line":149,"column":9}}},"20":{"name":"(anonymous_30)","decl":{"start":{"line":149,"column":13},"end":{"line":149,"column":14}},"loc":{"start":{"line":149,"column":13},"end":{"line":149,"column":14}}},"21":{"name":"stop","decl":{"start":{"line":154,"column":10},"end":{"line":154,"column":null}},"loc":{"start":{"line":154,"column":10},"end":{"line":157,"column":null}}},"22":{"name":"getFact","decl":{"start":{"line":159,"column":11},"end":{"line":159,"column":19}},"loc":{"start":{"line":159,"column":19},"end":{"line":161,"column":null}}},"23":{"name":"evaluateRules","decl":{"start":{"line":168,"column":17},"end":{"line":168,"column":28}},"loc":{"start":{"line":168,"column":37},"end":{"line":192,"column":null}}},"24":{"name":"(anonymous_34)","decl":{"start":{"line":169,"column":37},"end":{"line":169,"column":38}},"loc":{"start":{"line":169,"column":47},"end":{"line":191,"column":null}}},"25":{"name":"(anonymous_35)","decl":{"start":{"line":175,"column":41},"end":{"line":175,"column":42}},"loc":{"start":{"line":175,"column":57},"end":{"line":187,"column":9}}},"26":{"name":"(anonymous_36)","decl":{"start":{"line":182,"column":18},"end":{"line":182,"column":24}},"loc":{"start":{"line":182,"column":18},"end":{"line":182,"column":24}}},"27":{"name":"(anonymous_37)","decl":{"start":{"line":187,"column":15},"end":{"line":187,"column":24}},"loc":{"start":{"line":187,"column":24},"end":{"line":190,"column":null}}},"28":{"name":"run","decl":{"start":{"line":200,"column":43},"end":{"line":200,"column":null}},"loc":{"start":{"line":200,"column":43},"end":{"line":263,"column":null}}},"29":{"name":"(anonymous_39)","decl":{"start":{"line":211,"column":23},"end":{"line":211,"column":31}},"loc":{"start":{"line":211,"column":31},"end":{"line":213,"column":null}}},"30":{"name":"(anonymous_40)","decl":{"start":{"line":231,"column":23},"end":{"line":231,"column":24}},"loc":{"start":{"line":231,"column":44},"end":{"line":262,"column":null}}},"31":{"name":"(anonymous_41)","decl":{"start":{"line":232,"column":22},"end":{"line":232,"column":23}},"loc":{"start":{"line":232,"column":31},"end":{"line":241,"column":null}}},"32":{"name":"(anonymous_42)","decl":{"start":{"line":233,"column":29},"end":{"line":233,"column":35}},"loc":{"start":{"line":233,"column":35},"end":{"line":239,"column":11}}},"33":{"name":"(anonymous_43)","decl":{"start":{"line":243,"column":18},"end":{"line":243,"column":24}},"loc":{"start":{"line":243,"column":24},"end":{"line":261,"column":9}}},"34":{"name":"(anonymous_44)","decl":{"start":{"line":248,"column":63},"end":{"line":248,"column":64}},"loc":{"start":{"line":248,"column":85},"end":{"line":252,"column":11}}}},"branchMap":{"0":{"loc":{"start":{"line":23,"column":41},"end":{"line":23,"column":27}},"type":"cond-expr","locations":[{"start":{"line":23,"column":41},"end":{"line":23,"column":null}},{"start":{"line":23,"column":23},"end":{"line":23,"column":27}}]},"1":{"loc":{"start":{"line":23,"column":41},"end":{"line":23,"column":null}},"type":"binary-expr","locations":[{"start":{"line":23,"column":41},"end":{"line":23,"column":null}},{"start":{"line":23,"column":41},"end":{"line":23,"column":null}}]},"2":{"loc":{"start":{"line":23,"column":41},"end":{"line":23,"column":40}},"type":"cond-expr","locations":[{"start":{"line":23,"column":41},"end":{"line":23,"column":null}},{"start":{"line":23,"column":37},"end":{"line":23,"column":41}}]},"3":{"loc":{"start":{"line":26,"column":31},"end":{"line":26,"column":null}},"type":"binary-expr","locations":[{"start":{"line":26,"column":31},"end":{"line":26,"column":62}},{"start":{"line":26,"column":62},"end":{"line":26,"column":null}}]},"4":{"loc":{"start":{"line":27,"column":36},"end":{"line":27,"column":null}},"type":"binary-expr","locations":[{"start":{"line":27,"column":36},"end":{"line":27,"column":72}},{"start":{"line":27,"column":72},"end":{"line":27,"column":null}}]},"5":{"loc":{"start":{"line":28,"column":37},"end":{"line":28,"column":null}},"type":"binary-expr","locations":[{"start":{"line":28,"column":37},"end":{"line":28,"column":74}},{"start":{"line":28,"column":74},"end":{"line":28,"column":null}}]},"6":{"loc":{"start":{"line":40,"column":4},"end":{"line":40,"column":27}},"type":"if","locations":[{"start":{"line":40,"column":4},"end":{"line":40,"column":27}}]},"7":{"loc":{"start":{"line":43,"column":4},"end":{"line":49,"column":null}},"type":"if","locations":[{"start":{"line":43,"column":4},"end":{"line":49,"column":null}},{"start":{"line":45,"column":11},"end":{"line":49,"column":null}}]},"8":{"loc":{"start":{"line":46,"column":6},"end":{"line":46,"column":76}},"type":"if","locations":[{"start":{"line":46,"column":6},"end":{"line":46,"column":76}}]},"9":{"loc":{"start":{"line":47,"column":6},"end":{"line":47,"column":81}},"type":"if","locations":[{"start":{"line":47,"column":6},"end":{"line":47,"column":81}}]},"10":{"loc":{"start":{"line":58,"column":4},"end":{"line":64,"column":null}},"type":"if","locations":[{"start":{"line":58,"column":4},"end":{"line":64,"column":null}},{"start":{"line":62,"column":11},"end":{"line":64,"column":null}}]},"11":{"loc":{"start":{"line":69,"column":4},"end":{"line":78,"column":null}},"type":"if","locations":[{"start":{"line":69,"column":4},"end":{"line":78,"column":null}},{"start":{"line":73,"column":11},"end":{"line":78,"column":null}}]},"12":{"loc":{"start":{"line":75,"column":6},"end":{"line":77,"column":null}},"type":"if","locations":[{"start":{"line":75,"column":6},"end":{"line":77,"column":null}}]},"13":{"loc":{"start":{"line":79,"column":4},"end":{"line":81,"column":null}},"type":"if","locations":[{"start":{"line":79,"column":4},"end":{"line":81,"column":null}}]},"14":{"loc":{"start":{"line":86,"column":4},"end":{"line":86,"column":21}},"type":"if","locations":[{"start":{"line":86,"column":4},"end":{"line":86,"column":21}}]},"15":{"loc":{"start":{"line":87,"column":4},"end":{"line":87,"column":27}},"type":"if","locations":[{"start":{"line":87,"column":4},"end":{"line":87,"column":27}}]},"16":{"loc":{"start":{"line":88,"column":4},"end":{"line":90,"column":null}},"type":"if","locations":[{"start":{"line":88,"column":4},"end":{"line":90,"column":null}}]},"17":{"loc":{"start":{"line":88,"column":8},"end":{"line":88,"column":196}},"type":"binary-expr","locations":[{"start":{"line":88,"column":8},"end":{"line":88,"column":16}},{"start":{"line":88,"column":68},"end":{"line":88,"column":76}},{"start":{"line":88,"column":128},"end":{"line":88,"column":136}},{"start":{"line":88,"column":188},"end":{"line":88,"column":196}}]},"18":{"loc":{"start":{"line":118,"column":4},"end":{"line":123,"column":null}},"type":"if","locations":[{"start":{"line":118,"column":4},"end":{"line":123,"column":null}},{"start":{"line":121,"column":11},"end":{"line":123,"column":null}}]},"19":{"loc":{"start":{"line":131,"column":4},"end":{"line":135,"column":null}},"type":"if","locations":[{"start":{"line":131,"column":4},"end":{"line":135,"column":null}},{"start":{"line":133,"column":11},"end":{"line":135,"column":null}}]},"20":{"loc":{"start":{"line":140,"column":4},"end":{"line":150,"column":null}},"type":"if","locations":[{"start":{"line":140,"column":4},"end":{"line":150,"column":null}}]},"21":{"loc":{"start":{"line":143,"column":8},"end":{"line":143,"column":34}},"type":"if","locations":[{"start":{"line":143,"column":8},"end":{"line":143,"column":34}}]},"22":{"loc":{"start":{"line":148,"column":15},"end":{"line":148,"column":null}},"type":"cond-expr","locations":[{"start":{"line":148,"column":39},"end":{"line":148,"column":44}},{"start":{"line":148,"column":44},"end":{"line":148,"column":null}}]},"23":{"loc":{"start":{"line":170,"column":6},"end":{"line":173,"column":null}},"type":"if","locations":[{"start":{"line":170,"column":6},"end":{"line":173,"column":null}}]},"24":{"loc":{"start":{"line":179,"column":8},"end":{"line":186,"column":null}},"type":"if","locations":[{"start":{"line":179,"column":8},"end":{"line":186,"column":null}},{"start":{"line":183,"column":15},"end":{"line":186,"column":null}}]},"25":{"loc":{"start":{"line":200,"column":43},"end":{"line":200,"column":26}},"type":"cond-expr","locations":[{"start":{"line":200,"column":43},"end":{"line":200,"column":null}},{"start":{"line":200,"column":22},"end":{"line":200,"column":26}}]},"26":{"loc":{"start":{"line":200,"column":43},"end":{"line":200,"column":null}},"type":"binary-expr","locations":[{"start":{"line":200,"column":43},"end":{"line":200,"column":null}},{"start":{"line":200,"column":43},"end":{"line":200,"column":null}}]},"27":{"loc":{"start":{"line":200,"column":43},"end":{"line":200,"column":42}},"type":"cond-expr","locations":[{"start":{"line":200,"column":43},"end":{"line":200,"column":null}},{"start":{"line":200,"column":39},"end":{"line":200,"column":43}}]},"28":{"loc":{"start":{"line":205,"column":20},"end":{"line":205,"column":46}},"type":"binary-expr","locations":[{"start":{"line":205,"column":20},"end":{"line":205,"column":42}},{"start":{"line":205,"column":42},"end":{"line":205,"column":46}}]},"29":{"loc":{"start":{"line":218,"column":6},"end":{"line":222,"column":null}},"type":"if","locations":[{"start":{"line":218,"column":6},"end":{"line":222,"column":null}},{"start":{"line":220,"column":13},"end":{"line":222,"column":null}}]},"30":{"loc":{"start":{"line":234,"column":10},"end":{"line":237,"column":null}},"type":"if","locations":[{"start":{"line":234,"column":10},"end":{"line":237,"column":null}}]},"31":{"loc":{"start":{"line":249,"column":24},"end":{"line":249,"column":null}},"type":"cond-expr","locations":[{"start":{"line":249,"column":44},"end":{"line":249,"column":56}},{"start":{"line":249,"column":56},"end":{"line":249,"column":null}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":1,"8":1,"9":1,"10":1,"11":1,"12":19,"13":19,"14":57,"15":19,"16":19,"17":19,"18":19,"19":19,"20":19,"21":19,"22":19,"23":19,"24":19,"25":3,"26":19,"27":190,"28":19,"29":114,"30":23,"31":0,"32":23,"33":23,"34":1,"35":22,"36":1,"37":21,"38":1,"39":20,"40":21,"41":21,"42":21,"43":21,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":190,"73":0,"74":114,"75":0,"76":5,"77":5,"78":5,"79":0,"80":0,"81":5,"82":5,"83":5,"84":5,"85":0,"86":0,"87":0,"88":0,"89":0,"90":11,"91":11,"92":17,"93":17,"94":12,"95":17,"96":17,"97":11,"98":1,"99":12,"100":11,"101":1,"102":1,"103":0,"104":12,"105":12,"106":17,"107":0,"108":0,"109":17,"110":17,"111":17,"112":17,"113":15,"114":15,"115":15,"116":2,"117":2,"118":0,"119":0,"120":11,"121":11,"122":11,"123":11,"124":11,"125":11,"126":11,"127":5,"128":11,"129":9,"130":9,"131":0,"132":9,"133":9,"134":9,"135":11,"136":11,"137":11,"138":11,"139":12,"140":12,"141":0,"142":0,"143":12,"144":12,"145":11,"146":11,"147":11,"148":11,"149":11,"150":17,"151":17,"152":17,"153":11,"154":11,"155":11},"f":{"0":19,"1":3,"2":190,"3":114,"4":23,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":190,"12":0,"13":114,"14":0,"15":5,"16":0,"17":11,"18":17,"19":1,"20":12,"21":1,"22":0,"23":12,"24":17,"25":17,"26":15,"27":0,"28":11,"29":5,"30":11,"31":12,"32":12,"33":11,"34":17},"b":{"0":[1,18],"1":[57,1],"2":[0,19],"3":[19,19],"4":[19,19],"5":[19,19],"6":[0],"7":[1,22],"8":[1],"9":[1],"10":[0,0],"11":[0,0],"12":[0],"13":[0],"14":[0],"15":[0],"16":[0],"17":[0,0,0,0],"18":[0,5],"19":[0,0],"20":[11],"21":[12],"22":[1,0],"23":[0],"24":[15,2],"25":[11,0],"26":[22,11],"27":[0,11],"28":[11,11],"29":[0,9],"30":[0],"31":[15,2]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/rule-fast.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/optimized/rule-fast.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"5":{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},"6":{"start":{"line":23,"column":4},"end":{"line":25,"column":null}},"7":{"start":{"line":24,"column":6},"end":{"line":24,"column":16}},"8":{"start":{"line":26,"column":4},"end":{"line":28,"column":null}},"9":{"start":{"line":27,"column":6},"end":{"line":27,"column":11}},"10":{"start":{"line":29,"column":4},"end":{"line":31,"column":null}},"11":{"start":{"line":30,"column":6},"end":{"line":30,"column":11}},"12":{"start":{"line":32,"column":4},"end":{"line":34,"column":null}},"13":{"start":{"line":33,"column":6},"end":{"line":33,"column":11}},"14":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"15":{"start":{"line":36,"column":6},"end":{"line":36,"column":11}},"16":{"start":{"line":39,"column":22},"end":{"line":39,"column":null}},"17":{"start":{"line":40,"column":4},"end":{"line":40,"column":9}},"18":{"start":{"line":42,"column":19},"end":{"line":42,"column":50}},"19":{"start":{"line":43,"column":4},"end":{"line":43,"column":9}},"20":{"start":{"line":47,"column":4},"end":{"line":47,"column":15}},"21":{"start":{"line":48,"column":4},"end":{"line":48,"column":29}},"22":{"start":{"line":48,"column":23},"end":{"line":48,"column":29}},"23":{"start":{"line":49,"column":4},"end":{"line":49,"column":9}},"24":{"start":{"line":50,"column":4},"end":{"line":50,"column":11}},"25":{"start":{"line":54,"column":4},"end":{"line":56,"column":null}},"26":{"start":{"line":55,"column":6},"end":{"line":55,"column":12}},"27":{"start":{"line":57,"column":4},"end":{"line":57,"column":9}},"28":{"start":{"line":58,"column":4},"end":{"line":58,"column":11}},"29":{"start":{"line":62,"column":4},"end":{"line":71,"column":null}},"30":{"start":{"line":68,"column":6},"end":{"line":68,"column":12}},"31":{"start":{"line":72,"column":4},"end":{"line":72,"column":9}},"32":{"start":{"line":73,"column":4},"end":{"line":73,"column":11}},"33":{"start":{"line":77,"column":4},"end":{"line":77,"column":22}},"34":{"start":{"line":77,"column":16},"end":{"line":77,"column":22}},"35":{"start":{"line":78,"column":4},"end":{"line":82,"column":null}},"36":{"start":{"line":79,"column":6},"end":{"line":79,"column":12}},"37":{"start":{"line":83,"column":4},"end":{"line":83,"column":9}},"38":{"start":{"line":86,"column":4},"end":{"line":86,"column":9}},"39":{"start":{"line":87,"column":4},"end":{"line":87,"column":27}},"40":{"start":{"line":87,"column":22},"end":{"line":87,"column":27}},"41":{"start":{"line":88,"column":4},"end":{"line":88,"column":11}},"42":{"start":{"line":92,"column":4},"end":{"line":92,"column":11}},"43":{"start":{"line":96,"column":4},"end":{"line":96,"column":11}},"44":{"start":{"line":100,"column":4},"end":{"line":100,"column":11}},"45":{"start":{"line":104,"column":4},"end":{"line":104,"column":11}},"46":{"start":{"line":108,"column":4},"end":{"line":108,"column":9}},"47":{"start":{"line":109,"column":4},"end":{"line":109,"column":11}},"48":{"start":{"line":112,"column":28},"end":{"line":112,"column":27}},"49":{"start":{"line":113,"column":18},"end":{"line":113,"column":null}},"50":{"start":{"line":119,"column":4},"end":{"line":121,"column":null}},"51":{"start":{"line":120,"column":6},"end":{"line":120,"column":13}},"52":{"start":{"line":122,"column":4},"end":{"line":122,"column":11}},"53":{"start":{"line":125,"column":36},"end":{"line":125,"column":null}},"54":{"start":{"line":126,"column":21},"end":{"line":126,"column":32}},"55":{"start":{"line":127,"column":21},"end":{"line":127,"column":null}},"56":{"start":{"line":128,"column":6},"end":{"line":131,"column":null}},"57":{"start":{"line":129,"column":21},"end":{"line":129,"column":26}},"58":{"start":{"line":130,"column":8},"end":{"line":130,"column":19}},"59":{"start":{"line":132,"column":6},"end":{"line":132,"column":32}},"60":{"start":{"line":132,"column":27},"end":{"line":132,"column":32}},"61":{"start":{"line":133,"column":6},"end":{"line":133,"column":11}},"62":{"start":{"line":134,"column":6},"end":{"line":134,"column":13}},"63":{"start":{"line":136,"column":4},"end":{"line":136,"column":11}},"64":{"start":{"line":138,"column":8},"end":{"line":138,"column":15}},"65":{"start":{"line":140,"column":11},"end":{"line":140,"column":12}},"66":{"start":{"line":147,"column":21},"end":{"line":147,"column":null}},"67":{"start":{"line":148,"column":23},"end":{"line":148,"column":27}},"68":{"start":{"line":158,"column":30},"end":{"line":178,"column":null}},"69":{"start":{"line":159,"column":6},"end":{"line":177,"column":null}},"70":{"start":{"line":160,"column":8},"end":{"line":160,"column":15}},"71":{"start":{"line":161,"column":13},"end":{"line":177,"column":null}},"72":{"start":{"line":163,"column":8},"end":{"line":163,"column":15}},"73":{"start":{"line":165,"column":12},"end":{"line":165,"column":22}},"74":{"start":{"line":166,"column":12},"end":{"line":166,"column":19}},"75":{"start":{"line":169,"column":8},"end":{"line":169,"column":15}},"76":{"start":{"line":171,"column":27},"end":{"line":171,"column":null}},"77":{"start":{"line":172,"column":12},"end":{"line":172,"column":22}},"78":{"start":{"line":173,"column":12},"end":{"line":173,"column":22}},"79":{"start":{"line":174,"column":12},"end":{"line":174,"column":22}},"80":{"start":{"line":175,"column":12},"end":{"line":175,"column":19}},"81":{"start":{"line":183,"column":20},"end":{"line":199,"column":null}},"82":{"start":{"line":184,"column":24},"end":{"line":184,"column":29}},"83":{"start":{"line":185,"column":6},"end":{"line":198,"column":null}},"84":{"start":{"line":186,"column":8},"end":{"line":193,"column":null}},"85":{"start":{"line":187,"column":10},"end":{"line":187,"column":29}},"86":{"start":{"line":188,"column":10},"end":{"line":188,"column":17}},"87":{"start":{"line":190,"column":10},"end":{"line":190,"column":17}},"88":{"start":{"line":195,"column":8},"end":{"line":195,"column":15}},"89":{"start":{"line":196,"column":8},"end":{"line":196,"column":15}},"90":{"start":{"line":197,"column":8},"end":{"line":197,"column":15}},"91":{"start":{"line":204,"column":26},"end":{"line":214,"column":null}},"92":{"start":{"line":205,"column":6},"end":{"line":205,"column":17}},"93":{"start":{"line":206,"column":25},"end":{"line":206,"column":33}},"94":{"start":{"line":207,"column":6},"end":{"line":209,"column":null}},"95":{"start":{"line":208,"column":8},"end":{"line":208,"column":23}},"96":{"start":{"line":210,"column":20},"end":{"line":210,"column":null}},"97":{"start":{"line":211,"column":6},"end":{"line":211,"column":13}},"98":{"start":{"line":212,"column":14},"end":{"line":212,"column":20}},"99":{"start":{"line":213,"column":14},"end":{"line":213,"column":20}},"100":{"start":{"line":217,"column":4},"end":{"line":217,"column":11}},"101":{"start":{"line":218,"column":12},"end":{"line":218,"column":22}}},"fnMap":{"0":{"name":"RuleFast","decl":{"start":{"line":21,"column":2},"end":{"line":21,"column":15}},"loc":{"start":{"line":21,"column":24},"end":{"line":44,"column":null}}},"1":{"name":"setPriority","decl":{"start":{"line":46,"column":15},"end":{"line":46,"column":25}},"loc":{"start":{"line":46,"column":25},"end":{"line":51,"column":null}}},"2":{"name":"setName","decl":{"start":{"line":53,"column":11},"end":{"line":53,"column":17}},"loc":{"start":{"line":53,"column":17},"end":{"line":59,"column":null}}},"3":{"name":"setConditions","decl":{"start":{"line":61,"column":17},"end":{"line":61,"column":29}},"loc":{"start":{"line":61,"column":29},"end":{"line":74,"column":null}}},"4":{"name":"setEvent","decl":{"start":{"line":76,"column":12},"end":{"line":76,"column":19}},"loc":{"start":{"line":76,"column":19},"end":{"line":89,"column":null}}},"5":{"name":"getEvent","decl":{"start":{"line":91,"column":14},"end":{"line":91,"column":null}},"loc":{"start":{"line":91,"column":14},"end":{"line":93,"column":null}}},"6":{"name":"getPriority","decl":{"start":{"line":95,"column":17},"end":{"line":95,"column":null}},"loc":{"start":{"line":95,"column":17},"end":{"line":97,"column":null}}},"7":{"name":"getConditions","decl":{"start":{"line":99,"column":19},"end":{"line":99,"column":null}},"loc":{"start":{"line":99,"column":19},"end":{"line":101,"column":null}}},"8":{"name":"getEngine","decl":{"start":{"line":103,"column":15},"end":{"line":103,"column":null}},"loc":{"start":{"line":103,"column":15},"end":{"line":105,"column":null}}},"9":{"name":"setEngine","decl":{"start":{"line":107,"column":13},"end":{"line":107,"column":21}},"loc":{"start":{"line":107,"column":21},"end":{"line":110,"column":null}}},"10":{"name":"toJSON","decl":{"start":{"line":112,"column":28},"end":{"line":112,"column":null}},"loc":{"start":{"line":112,"column":28},"end":{"line":123,"column":null}}},"11":{"name":"prioritizeConditions","decl":{"start":{"line":125,"column":24},"end":{"line":125,"column":36}},"loc":{"start":{"line":125,"column":36},"end":{"line":141,"column":null}}},"12":{"name":"(anonymous_20)","decl":{"start":{"line":126,"column":39},"end":{"line":126,"column":40}},"loc":{"start":{"line":126,"column":60},"end":{"line":135,"column":7}}},"13":{"name":"(anonymous_21)","decl":{"start":{"line":137,"column":12},"end":{"line":137,"column":13}},"loc":{"start":{"line":137,"column":22},"end":{"line":139,"column":null}}},"14":{"name":"(anonymous_22)","decl":{"start":{"line":140,"column":11},"end":{"line":140,"column":12}},"loc":{"start":{"line":140,"column":11},"end":{"line":140,"column":12}}},"15":{"name":"evaluate","decl":{"start":{"line":147,"column":12},"end":{"line":147,"column":21}},"loc":{"start":{"line":147,"column":21},"end":{"line":219,"column":null}}},"16":{"name":"evaluateCondition","decl":{"start":{"line":158,"column":10},"end":{"line":158,"column":30}},"loc":{"start":{"line":158,"column":45},"end":{"line":178,"column":null}}},"17":{"name":"(anonymous_25)","decl":{"start":{"line":164,"column":16},"end":{"line":164,"column":26}},"loc":{"start":{"line":164,"column":26},"end":{"line":167,"column":null}}},"18":{"name":"(anonymous_26)","decl":{"start":{"line":170,"column":16},"end":{"line":170,"column":36}},"loc":{"start":{"line":170,"column":36},"end":{"line":176,"column":null}}},"19":{"name":"realize","decl":{"start":{"line":183,"column":10},"end":{"line":183,"column":20}},"loc":{"start":{"line":183,"column":44},"end":{"line":199,"column":null}}},"20":{"name":"processResult","decl":{"start":{"line":204,"column":10},"end":{"line":204,"column":26}},"loc":{"start":{"line":204,"column":38},"end":{"line":214,"column":null}}},"21":{"name":"(anonymous_29)","decl":{"start":{"line":212,"column":14},"end":{"line":212,"column":20}},"loc":{"start":{"line":212,"column":14},"end":{"line":212,"column":20}}},"22":{"name":"(anonymous_30)","decl":{"start":{"line":213,"column":14},"end":{"line":213,"column":20}},"loc":{"start":{"line":213,"column":14},"end":{"line":213,"column":20}}},"23":{"name":"(anonymous_31)","decl":{"start":{"line":218,"column":12},"end":{"line":218,"column":22}},"loc":{"start":{"line":218,"column":12},"end":{"line":218,"column":22}}}},"branchMap":{"0":{"loc":{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},"type":"binary-expr","locations":[{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},{"start":{"line":21,"column":24},"end":{"line":21,"column":null}}]},"1":{"loc":{"start":{"line":23,"column":4},"end":{"line":25,"column":null}},"type":"if","locations":[{"start":{"line":23,"column":4},"end":{"line":25,"column":null}}]},"2":{"loc":{"start":{"line":26,"column":4},"end":{"line":28,"column":null}},"type":"if","locations":[{"start":{"line":26,"column":4},"end":{"line":28,"column":null}}]},"3":{"loc":{"start":{"line":26,"column":8},"end":{"line":26,"column":39}},"type":"binary-expr","locations":[{"start":{"line":26,"column":8},"end":{"line":26,"column":19}},{"start":{"line":26,"column":19},"end":{"line":26,"column":39}}]},"4":{"loc":{"start":{"line":29,"column":4},"end":{"line":31,"column":null}},"type":"if","locations":[{"start":{"line":29,"column":4},"end":{"line":31,"column":null}}]},"5":{"loc":{"start":{"line":29,"column":8},"end":{"line":29,"column":38}},"type":"binary-expr","locations":[{"start":{"line":29,"column":8},"end":{"line":29,"column":19}},{"start":{"line":29,"column":19},"end":{"line":29,"column":38}}]},"6":{"loc":{"start":{"line":32,"column":4},"end":{"line":34,"column":null}},"type":"if","locations":[{"start":{"line":32,"column":4},"end":{"line":34,"column":null}}]},"7":{"loc":{"start":{"line":32,"column":8},"end":{"line":32,"column":38}},"type":"binary-expr","locations":[{"start":{"line":32,"column":8},"end":{"line":32,"column":19}},{"start":{"line":32,"column":19},"end":{"line":32,"column":38}}]},"8":{"loc":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"type":"if","locations":[{"start":{"line":35,"column":4},"end":{"line":37,"column":null}}]},"9":{"loc":{"start":{"line":35,"column":8},"end":{"line":35,"column":20}},"type":"binary-expr","locations":[{"start":{"line":35,"column":8},"end":{"line":35,"column":20}},{"start":{"line":35,"column":20},"end":{"line":35,"column":36}},{"start":{"line":35,"column":36},"end":{"line":35,"column":57}}]},"10":{"loc":{"start":{"line":39,"column":22},"end":{"line":39,"column":null}},"type":"binary-expr","locations":[{"start":{"line":39,"column":22},"end":{"line":39,"column":33}},{"start":{"line":39,"column":33},"end":{"line":39,"column":54}},{"start":{"line":39,"column":54},"end":{"line":39,"column":null}}]},"11":{"loc":{"start":{"line":42,"column":19},"end":{"line":42,"column":50}},"type":"binary-expr","locations":[{"start":{"line":42,"column":19},"end":{"line":42,"column":30}},{"start":{"line":42,"column":30},"end":{"line":42,"column":48}},{"start":{"line":42,"column":48},"end":{"line":42,"column":50}}]},"12":{"loc":{"start":{"line":48,"column":4},"end":{"line":48,"column":29}},"type":"if","locations":[{"start":{"line":48,"column":4},"end":{"line":48,"column":29}}]},"13":{"loc":{"start":{"line":54,"column":4},"end":{"line":56,"column":null}},"type":"if","locations":[{"start":{"line":54,"column":4},"end":{"line":56,"column":null}}]},"14":{"loc":{"start":{"line":54,"column":8},"end":{"line":54,"column":29}},"type":"binary-expr","locations":[{"start":{"line":54,"column":8},"end":{"line":54,"column":17}},{"start":{"line":54,"column":17},"end":{"line":54,"column":29}}]},"15":{"loc":{"start":{"line":62,"column":4},"end":{"line":71,"column":null}},"type":"if","locations":[{"start":{"line":62,"column":4},"end":{"line":71,"column":null}}]},"16":{"loc":{"start":{"line":63,"column":6},"end":{"line":66,"column":14}},"type":"binary-expr","locations":[{"start":{"line":63,"column":6},"end":{"line":63,"column":14}},{"start":{"line":64,"column":6},"end":{"line":64,"column":14}},{"start":{"line":65,"column":6},"end":{"line":65,"column":14}},{"start":{"line":66,"column":6},"end":{"line":66,"column":14}}]},"17":{"loc":{"start":{"line":77,"column":4},"end":{"line":77,"column":22}},"type":"if","locations":[{"start":{"line":77,"column":4},"end":{"line":77,"column":22}}]},"18":{"loc":{"start":{"line":78,"column":4},"end":{"line":82,"column":null}},"type":"if","locations":[{"start":{"line":78,"column":4},"end":{"line":82,"column":null}}]},"19":{"loc":{"start":{"line":87,"column":4},"end":{"line":87,"column":27}},"type":"if","locations":[{"start":{"line":87,"column":4},"end":{"line":87,"column":27}}]},"20":{"loc":{"start":{"line":112,"column":28},"end":{"line":112,"column":27}},"type":"cond-expr","locations":[{"start":{"line":112,"column":28},"end":{"line":112,"column":null}},{"start":{"line":112,"column":22},"end":{"line":112,"column":28}}]},"21":{"loc":{"start":{"line":112,"column":28},"end":{"line":112,"column":null}},"type":"binary-expr","locations":[{"start":{"line":112,"column":28},"end":{"line":112,"column":null}},{"start":{"line":112,"column":28},"end":{"line":112,"column":null}}]},"22":{"loc":{"start":{"line":119,"column":4},"end":{"line":121,"column":null}},"type":"if","locations":[{"start":{"line":119,"column":4},"end":{"line":121,"column":null}}]},"23":{"loc":{"start":{"line":128,"column":6},"end":{"line":131,"column":null}},"type":"if","locations":[{"start":{"line":128,"column":6},"end":{"line":131,"column":null}}]},"24":{"loc":{"start":{"line":130,"column":20},"end":{"line":130,"column":null}},"type":"binary-expr","locations":[{"start":{"line":130,"column":20},"end":{"line":130,"column":28}},{"start":{"line":130,"column":28},"end":{"line":130,"column":46}},{"start":{"line":130,"column":46},"end":{"line":130,"column":null}}]},"25":{"loc":{"start":{"line":132,"column":6},"end":{"line":132,"column":32}},"type":"if","locations":[{"start":{"line":132,"column":6},"end":{"line":132,"column":32}}]},"26":{"loc":{"start":{"line":138,"column":15},"end":{"line":138,"column":null}},"type":"cond-expr","locations":[{"start":{"line":138,"column":39},"end":{"line":138,"column":44}},{"start":{"line":138,"column":44},"end":{"line":138,"column":null}}]},"27":{"loc":{"start":{"line":159,"column":6},"end":{"line":177,"column":null}},"type":"if","locations":[{"start":{"line":159,"column":6},"end":{"line":177,"column":null}},{"start":{"line":161,"column":13},"end":{"line":177,"column":null}}]},"28":{"loc":{"start":{"line":161,"column":13},"end":{"line":177,"column":null}},"type":"if","locations":[{"start":{"line":161,"column":13},"end":{"line":177,"column":null}},{"start":{"line":168,"column":13},"end":{"line":177,"column":null}}]},"29":{"loc":{"start":{"line":185,"column":6},"end":{"line":198,"column":null}},"type":"if","locations":[{"start":{"line":185,"column":6},"end":{"line":198,"column":null}},{"start":{"line":194,"column":13},"end":{"line":198,"column":null}}]},"30":{"loc":{"start":{"line":186,"column":8},"end":{"line":193,"column":null}},"type":"if","locations":[{"start":{"line":186,"column":8},"end":{"line":193,"column":null}},{"start":{"line":189,"column":15},"end":{"line":193,"column":null}}]},"31":{"loc":{"start":{"line":207,"column":6},"end":{"line":209,"column":null}},"type":"if","locations":[{"start":{"line":207,"column":6},"end":{"line":209,"column":null}}]},"32":{"loc":{"start":{"line":210,"column":20},"end":{"line":210,"column":null}},"type":"cond-expr","locations":[{"start":{"line":210,"column":29},"end":{"line":210,"column":41}},{"start":{"line":210,"column":41},"end":{"line":210,"column":null}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":1,"5":63,"6":21,"7":0,"8":21,"9":21,"10":21,"11":0,"12":21,"13":0,"14":21,"15":0,"16":21,"17":21,"18":21,"19":21,"20":21,"21":21,"22":0,"23":21,"24":21,"25":0,"26":0,"27":0,"28":0,"29":21,"30":0,"31":21,"32":21,"33":21,"34":0,"35":21,"36":0,"37":21,"38":21,"39":21,"40":2,"41":21,"42":0,"43":0,"44":0,"45":0,"46":21,"47":21,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":17,"67":17,"68":17,"69":17,"70":0,"71":17,"72":17,"73":17,"74":17,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0,"81":17,"82":0,"83":0,"84":0,"85":0,"86":0,"87":0,"88":0,"89":0,"90":0,"91":17,"92":17,"93":17,"94":17,"95":0,"96":17,"97":17,"98":17,"99":17,"100":17,"101":17},"f":{"0":21,"1":21,"2":0,"3":21,"4":21,"5":0,"6":0,"7":0,"8":0,"9":21,"10":0,"11":0,"12":0,"13":0,"14":0,"15":17,"16":17,"17":17,"18":0,"19":0,"20":17,"21":17,"22":17,"23":17},"b":{"0":[21,0],"1":[0],"2":[21],"3":[21,21],"4":[0],"5":[21,21],"6":[0],"7":[21,21],"8":[0],"9":[21,21,21],"10":[21,21,19],"11":[21,21,0],"12":[0],"13":[0],"14":[0,0],"15":[0],"16":[21,1,0,0],"17":[0],"18":[0],"19":[2],"20":[0,0],"21":[0,0],"22":[0],"23":[0],"24":[0,0,0],"25":[0],"26":[0,0],"27":[0,17],"28":[17,0],"29":[0,0],"30":[0,0],"31":[0],"32":[15,2]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/almanac-sync.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/almanac-sync.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"4":{"start":{"line":10,"column":2},"end":{"line":10,"column":9}},"5":{"start":{"line":19,"column":29},"end":{"line":19,"column":28}},"6":{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},"7":{"start":{"line":20,"column":4},"end":{"line":20,"column":9}},"8":{"start":{"line":21,"column":4},"end":{"line":21,"column":9}},"9":{"start":{"line":22,"column":4},"end":{"line":22,"column":9}},"10":{"start":{"line":23,"column":4},"end":{"line":23,"column":9}},"11":{"start":{"line":24,"column":4},"end":{"line":24,"column":9}},"12":{"start":{"line":25,"column":4},"end":{"line":25,"column":9}},"13":{"start":{"line":33,"column":4},"end":{"line":33,"column":24}},"14":{"start":{"line":33,"column":18},"end":{"line":33,"column":24}},"15":{"start":{"line":34,"column":4},"end":{"line":34,"column":9}},"16":{"start":{"line":40,"column":27},"end":{"line":40,"column":26}},"17":{"start":{"line":41,"column":4},"end":{"line":41,"column":24}},"18":{"start":{"line":41,"column":17},"end":{"line":41,"column":24}},"19":{"start":{"line":42,"column":4},"end":{"line":42,"column":11}},"20":{"start":{"line":50,"column":4},"end":{"line":50,"column":9}},"21":{"start":{"line":57,"column":4},"end":{"line":57,"column":11}},"22":{"start":{"line":66,"column":4},"end":{"line":66,"column":11}},"23":{"start":{"line":74,"column":4},"end":{"line":74,"column":9}},"24":{"start":{"line":75,"column":4},"end":{"line":75,"column":9}},"25":{"start":{"line":85,"column":21},"end":{"line":85,"column":26}},"26":{"start":{"line":86,"column":4},"end":{"line":88,"column":null}},"27":{"start":{"line":87,"column":6},"end":{"line":87,"column":11}},"28":{"start":{"line":89,"column":4},"end":{"line":89,"column":11}},"29":{"start":{"line":99,"column":17},"end":{"line":99,"column":null}},"30":{"start":{"line":100,"column":8},"end":{"line":100,"column":null}},"31":{"start":{"line":101,"column":4},"end":{"line":106,"column":null}},"32":{"start":{"line":102,"column":6},"end":{"line":102,"column":15}},"33":{"start":{"line":103,"column":6},"end":{"line":103,"column":13}},"34":{"start":{"line":105,"column":6},"end":{"line":105,"column":13}},"35":{"start":{"line":107,"column":4},"end":{"line":107,"column":10}},"36":{"start":{"line":108,"column":4},"end":{"line":108,"column":9}},"37":{"start":{"line":109,"column":4},"end":{"line":111,"column":null}},"38":{"start":{"line":110,"column":6},"end":{"line":110,"column":11}},"39":{"start":{"line":112,"column":4},"end":{"line":112,"column":11}},"40":{"start":{"line":122,"column":4},"end":{"line":122,"column":10}},"41":{"start":{"line":123,"column":17},"end":{"line":123,"column":21}},"42":{"start":{"line":124,"column":4},"end":{"line":124,"column":11}},"43":{"start":{"line":134,"column":45},"end":{"line":134,"column":34}},"44":{"start":{"line":134,"column":45},"end":{"line":134,"column":44}},"45":{"start":{"line":135,"column":8},"end":{"line":135,"column":null}},"46":{"start":{"line":136,"column":17},"end":{"line":136,"column":22}},"47":{"start":{"line":137,"column":4},"end":{"line":143,"column":null}},"48":{"start":{"line":138,"column":6},"end":{"line":142,"column":null}},"49":{"start":{"line":139,"column":8},"end":{"line":139,"column":15}},"50":{"start":{"line":141,"column":8},"end":{"line":141,"column":14}},"51":{"start":{"line":144,"column":4},"end":{"line":156,"column":null}},"52":{"start":{"line":145,"column":6},"end":{"line":145,"column":18}},"53":{"start":{"line":147,"column":23},"end":{"line":147,"column":28}},"54":{"start":{"line":148,"column":23},"end":{"line":148,"column":40}},"55":{"start":{"line":149,"column":6},"end":{"line":155,"column":null}},"56":{"start":{"line":150,"column":8},"end":{"line":150,"column":20}},"57":{"start":{"line":151,"column":8},"end":{"line":151,"column":14}},"58":{"start":{"line":153,"column":8},"end":{"line":153,"column":14}},"59":{"start":{"line":154,"column":8},"end":{"line":154,"column":20}},"60":{"start":{"line":157,"column":4},"end":{"line":167,"column":null}},"61":{"start":{"line":158,"column":6},"end":{"line":158,"column":12}},"62":{"start":{"line":159,"column":6},"end":{"line":166,"column":null}},"63":{"start":{"line":160,"column":26},"end":{"line":160,"column":31}},"64":{"start":{"line":161,"column":8},"end":{"line":161,"column":14}},"65":{"start":{"line":162,"column":8},"end":{"line":162,"column":15}},"66":{"start":{"line":164,"column":8},"end":{"line":164,"column":14}},"67":{"start":{"line":165,"column":8},"end":{"line":165,"column":15}},"68":{"start":{"line":169,"column":4},"end":{"line":169,"column":11}},"69":{"start":{"line":176,"column":4},"end":{"line":178,"column":null}},"70":{"start":{"line":177,"column":6},"end":{"line":177,"column":13}},"71":{"start":{"line":179,"column":4},"end":{"line":179,"column":11}}},"fnMap":{"0":{"name":"defaultPathResolver","decl":{"start":{"line":9,"column":9},"end":{"line":9,"column":30}},"loc":{"start":{"line":9,"column":43},"end":{"line":11,"column":null}}},"1":{"name":"AlmanacSync","decl":{"start":{"line":19,"column":2},"end":{"line":19,"column":15}},"loc":{"start":{"line":19,"column":29},"end":{"line":26,"column":null}}},"2":{"name":"addEvent","decl":{"start":{"line":32,"column":12},"end":{"line":32,"column":19}},"loc":{"start":{"line":32,"column":28},"end":{"line":35,"column":null}}},"3":{"name":"getEvents","decl":{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},"loc":{"start":{"line":40,"column":27},"end":{"line":43,"column":null}}},"4":{"name":"addResult","decl":{"start":{"line":49,"column":13},"end":{"line":49,"column":25}},"loc":{"start":{"line":49,"column":25},"end":{"line":51,"column":null}}},"5":{"name":"getResults","decl":{"start":{"line":56,"column":16},"end":{"line":56,"column":null}},"loc":{"start":{"line":56,"column":16},"end":{"line":58,"column":null}}},"6":{"name":"_getFact","decl":{"start":{"line":65,"column":12},"end":{"line":65,"column":20}},"loc":{"start":{"line":65,"column":20},"end":{"line":67,"column":null}}},"7":{"name":"_addConstantFact","decl":{"start":{"line":73,"column":20},"end":{"line":73,"column":26}},"loc":{"start":{"line":73,"column":26},"end":{"line":76,"column":null}}},"8":{"name":"_setFactValue","decl":{"start":{"line":84,"column":17},"end":{"line":84,"column":23}},"loc":{"start":{"line":84,"column":38},"end":{"line":90,"column":null}}},"9":{"name":"addFact","decl":{"start":{"line":98,"column":11},"end":{"line":98,"column":15}},"loc":{"start":{"line":98,"column":39},"end":{"line":113,"column":null}}},"10":{"name":"addRuntimeFact","decl":{"start":{"line":121,"column":18},"end":{"line":121,"column":26}},"loc":{"start":{"line":121,"column":33},"end":{"line":125,"column":null}}},"11":{"name":"factValue","decl":{"start":{"line":134,"column":13},"end":{"line":134,"column":21}},"loc":{"start":{"line":134,"column":45},"end":{"line":170,"column":null}}},"12":{"name":"getValue","decl":{"start":{"line":175,"column":12},"end":{"line":175,"column":19}},"loc":{"start":{"line":175,"column":19},"end":{"line":180,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":19,"column":29},"end":{"line":19,"column":28}},"type":"cond-expr","locations":[{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},{"start":{"line":19,"column":25},"end":{"line":19,"column":29}}]},"1":{"loc":{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},"type":"binary-expr","locations":[{"start":{"line":19,"column":29},"end":{"line":19,"column":null}},{"start":{"line":19,"column":29},"end":{"line":19,"column":null}}]},"2":{"loc":{"start":{"line":23,"column":24},"end":{"line":23,"column":null}},"type":"binary-expr","locations":[{"start":{"line":23,"column":24},"end":{"line":23,"column":48}},{"start":{"line":23,"column":48},"end":{"line":23,"column":null}}]},"3":{"loc":{"start":{"line":33,"column":4},"end":{"line":33,"column":24}},"type":"if","locations":[{"start":{"line":33,"column":4},"end":{"line":33,"column":24}}]},"4":{"loc":{"start":{"line":40,"column":27},"end":{"line":40,"column":26}},"type":"cond-expr","locations":[{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},{"start":{"line":40,"column":23},"end":{"line":40,"column":27}}]},"5":{"loc":{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},"type":"binary-expr","locations":[{"start":{"line":40,"column":27},"end":{"line":40,"column":null}},{"start":{"line":40,"column":27},"end":{"line":40,"column":null}}]},"6":{"loc":{"start":{"line":41,"column":4},"end":{"line":41,"column":24}},"type":"if","locations":[{"start":{"line":41,"column":4},"end":{"line":41,"column":24}}]},"7":{"loc":{"start":{"line":86,"column":4},"end":{"line":88,"column":null}},"type":"if","locations":[{"start":{"line":86,"column":4},"end":{"line":88,"column":null}}]},"8":{"loc":{"start":{"line":101,"column":4},"end":{"line":106,"column":null}},"type":"if","locations":[{"start":{"line":101,"column":4},"end":{"line":106,"column":null}},{"start":{"line":104,"column":11},"end":{"line":106,"column":null}}]},"9":{"loc":{"start":{"line":109,"column":4},"end":{"line":111,"column":null}},"type":"if","locations":[{"start":{"line":109,"column":4},"end":{"line":111,"column":null}}]},"10":{"loc":{"start":{"line":134,"column":45},"end":{"line":134,"column":34}},"type":"cond-expr","locations":[{"start":{"line":134,"column":45},"end":{"line":134,"column":null}},{"start":{"line":134,"column":30},"end":{"line":134,"column":34}}]},"11":{"loc":{"start":{"line":134,"column":45},"end":{"line":134,"column":null}},"type":"binary-expr","locations":[{"start":{"line":134,"column":45},"end":{"line":134,"column":null}},{"start":{"line":134,"column":45},"end":{"line":134,"column":null}}]},"12":{"loc":{"start":{"line":134,"column":45},"end":{"line":134,"column":44}},"type":"cond-expr","locations":[{"start":{"line":134,"column":45},"end":{"line":134,"column":null}},{"start":{"line":134,"column":41},"end":{"line":134,"column":45}}]},"13":{"loc":{"start":{"line":137,"column":4},"end":{"line":143,"column":null}},"type":"if","locations":[{"start":{"line":137,"column":4},"end":{"line":143,"column":null}}]},"14":{"loc":{"start":{"line":138,"column":6},"end":{"line":142,"column":null}},"type":"if","locations":[{"start":{"line":138,"column":6},"end":{"line":142,"column":null}},{"start":{"line":140,"column":13},"end":{"line":142,"column":null}}]},"15":{"loc":{"start":{"line":144,"column":4},"end":{"line":156,"column":null}},"type":"if","locations":[{"start":{"line":144,"column":4},"end":{"line":156,"column":null}},{"start":{"line":146,"column":11},"end":{"line":156,"column":null}}]},"16":{"loc":{"start":{"line":148,"column":23},"end":{"line":148,"column":40}},"type":"binary-expr","locations":[{"start":{"line":148,"column":23},"end":{"line":148,"column":35}},{"start":{"line":148,"column":35},"end":{"line":148,"column":40}}]},"17":{"loc":{"start":{"line":149,"column":6},"end":{"line":155,"column":null}},"type":"if","locations":[{"start":{"line":149,"column":6},"end":{"line":155,"column":null}},{"start":{"line":152,"column":13},"end":{"line":155,"column":null}}]},"18":{"loc":{"start":{"line":157,"column":4},"end":{"line":167,"column":null}},"type":"if","locations":[{"start":{"line":157,"column":4},"end":{"line":167,"column":null}}]},"19":{"loc":{"start":{"line":159,"column":6},"end":{"line":166,"column":null}},"type":"if","locations":[{"start":{"line":159,"column":6},"end":{"line":166,"column":null}},{"start":{"line":163,"column":13},"end":{"line":166,"column":null}}]},"20":{"loc":{"start":{"line":159,"column":10},"end":{"line":159,"column":62}},"type":"binary-expr","locations":[{"start":{"line":159,"column":10},"end":{"line":159,"column":31}},{"start":{"line":159,"column":31},"end":{"line":159,"column":62}}]},"21":{"loc":{"start":{"line":159,"column":31},"end":{"line":159,"column":38}},"type":"cond-expr","locations":[{"start":{"line":159,"column":31},"end":{"line":159,"column":38}},{"start":{"line":159,"column":31},"end":{"line":159,"column":38}}]},"22":{"loc":{"start":{"line":164,"column":100},"end":{"line":164,"column":113}},"type":"cond-expr","locations":[{"start":{"line":164,"column":100},"end":{"line":164,"column":113}},{"start":{"line":164,"column":100},"end":{"line":164,"column":113}}]},"23":{"loc":{"start":{"line":176,"column":4},"end":{"line":178,"column":null}},"type":"if","locations":[{"start":{"line":176,"column":4},"end":{"line":178,"column":null}}]},"24":{"loc":{"start":{"line":176,"column":8},"end":{"line":176,"column":61}},"type":"binary-expr","locations":[{"start":{"line":176,"column":8},"end":{"line":176,"column":25}},{"start":{"line":176,"column":25},"end":{"line":176,"column":54}},{"start":{"line":176,"column":54},"end":{"line":176,"column":61}}]},"25":{"loc":{"start":{"line":176,"column":25},"end":{"line":176,"column":32}},"type":"cond-expr","locations":[{"start":{"line":176,"column":25},"end":{"line":176,"column":32}},{"start":{"line":176,"column":25},"end":{"line":176,"column":32}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0},"b":{"0":[0,0],"1":[0,0],"2":[0,0],"3":[0],"4":[0,0],"5":[0,0],"6":[0],"7":[0],"8":[0,0],"9":[0],"10":[0,0],"11":[0,0],"12":[0,0],"13":[0],"14":[0,0],"15":[0,0],"16":[0,0],"17":[0,0],"18":[0],"19":[0,0],"20":[0,0],"21":[0,0],"22":[0,0],"23":[0],"24":[0,0,0],"25":[0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/condition-sync.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/condition-sync.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":6,"column":27},"end":{"line":6,"column":null}},"2":{"start":{"line":7,"column":4},"end":{"line":7,"column":27}},"3":{"start":{"line":7,"column":21},"end":{"line":7,"column":27}},"4":{"start":{"line":8,"column":28},"end":{"line":8,"column":42}},"5":{"start":{"line":9,"column":4},"end":{"line":9,"column":11}},"6":{"start":{"line":10,"column":4},"end":{"line":30,"column":null}},"7":{"start":{"line":11,"column":28},"end":{"line":11,"column":39}},"8":{"start":{"line":12,"column":35},"end":{"line":12,"column":41}},"9":{"start":{"line":13,"column":6},"end":{"line":13,"column":null}},"10":{"start":{"line":13,"column":64},"end":{"line":13,"column":70}},"11":{"start":{"line":14,"column":6},"end":{"line":14,"column":null}},"12":{"start":{"line":14,"column":63},"end":{"line":14,"column":69}},"13":{"start":{"line":15,"column":6},"end":{"line":15,"column":11}},"14":{"start":{"line":16,"column":6},"end":{"line":16,"column":11}},"15":{"start":{"line":17,"column":6},"end":{"line":21,"column":null}},"16":{"start":{"line":18,"column":8},"end":{"line":18,"column":13}},"17":{"start":{"line":18,"column":50},"end":{"line":18,"column":51}},"18":{"start":{"line":20,"column":8},"end":{"line":20,"column":13}},"19":{"start":{"line":22,"column":11},"end":{"line":30,"column":null}},"20":{"start":{"line":23,"column":6},"end":{"line":23,"column":null}},"21":{"start":{"line":23,"column":71},"end":{"line":23,"column":77}},"22":{"start":{"line":24,"column":6},"end":{"line":24,"column":null}},"23":{"start":{"line":24,"column":75},"end":{"line":24,"column":81}},"24":{"start":{"line":25,"column":6},"end":{"line":25,"column":null}},"25":{"start":{"line":25,"column":72},"end":{"line":25,"column":78}},"26":{"start":{"line":27,"column":6},"end":{"line":29,"column":null}},"27":{"start":{"line":28,"column":8},"end":{"line":28,"column":19}},"28":{"start":{"line":38,"column":28},"end":{"line":38,"column":27}},"29":{"start":{"line":39,"column":18},"end":{"line":39,"column":null}},"30":{"start":{"line":40,"column":4},"end":{"line":42,"column":null}},"31":{"start":{"line":41,"column":6},"end":{"line":41,"column":12}},"32":{"start":{"line":43,"column":4},"end":{"line":45,"column":null}},"33":{"start":{"line":44,"column":6},"end":{"line":44,"column":12}},"34":{"start":{"line":46,"column":17},"end":{"line":46,"column":31}},"35":{"start":{"line":47,"column":4},"end":{"line":74,"column":null}},"36":{"start":{"line":48,"column":6},"end":{"line":52,"column":null}},"37":{"start":{"line":49,"column":8},"end":{"line":49,"column":14}},"38":{"start":{"line":49,"column":37},"end":{"line":49,"column":38}},"39":{"start":{"line":51,"column":8},"end":{"line":51,"column":14}},"40":{"start":{"line":53,"column":11},"end":{"line":74,"column":null}},"41":{"start":{"line":54,"column":6},"end":{"line":54,"column":12}},"42":{"start":{"line":56,"column":6},"end":{"line":56,"column":12}},"43":{"start":{"line":57,"column":6},"end":{"line":57,"column":12}},"44":{"start":{"line":58,"column":6},"end":{"line":58,"column":12}},"45":{"start":{"line":59,"column":6},"end":{"line":61,"column":null}},"46":{"start":{"line":60,"column":8},"end":{"line":60,"column":14}},"47":{"start":{"line":62,"column":6},"end":{"line":64,"column":null}},"48":{"start":{"line":63,"column":8},"end":{"line":63,"column":14}},"49":{"start":{"line":65,"column":6},"end":{"line":67,"column":null}},"50":{"start":{"line":66,"column":8},"end":{"line":66,"column":14}},"51":{"start":{"line":68,"column":6},"end":{"line":70,"column":null}},"52":{"start":{"line":69,"column":8},"end":{"line":69,"column":14}},"53":{"start":{"line":71,"column":6},"end":{"line":73,"column":null}},"54":{"start":{"line":72,"column":8},"end":{"line":72,"column":14}},"55":{"start":{"line":75,"column":4},"end":{"line":77,"column":null}},"56":{"start":{"line":76,"column":6},"end":{"line":76,"column":13}},"57":{"start":{"line":78,"column":4},"end":{"line":78,"column":11}},"58":{"start":{"line":88,"column":4},"end":{"line":88,"column":24}},"59":{"start":{"line":88,"column":18},"end":{"line":88,"column":24}},"60":{"start":{"line":89,"column":4},"end":{"line":89,"column":28}},"61":{"start":{"line":89,"column":22},"end":{"line":89,"column":28}},"62":{"start":{"line":90,"column":4},"end":{"line":90,"column":null}},"63":{"start":{"line":90,"column":36},"end":{"line":90,"column":42}},"64":{"start":{"line":92,"column":15},"end":{"line":92,"column":27}},"65":{"start":{"line":93,"column":4},"end":{"line":93,"column":null}},"66":{"start":{"line":93,"column":15},"end":{"line":93,"column":21}},"67":{"start":{"line":95,"column":31},"end":{"line":95,"column":39}},"68":{"start":{"line":96,"column":30},"end":{"line":96,"column":38}},"69":{"start":{"line":98,"column":19},"end":{"line":98,"column":22}},"70":{"start":{"line":99,"column":4},"end":{"line":99,"column":null}},"71":{"start":{"line":107,"column":4},"end":{"line":107,"column":11}},"72":{"start":{"line":136,"column":4},"end":{"line":136,"column":11}},"73":{"start":{"line":144,"column":4},"end":{"line":144,"column":11}},"74":{"start":{"line":152,"column":4},"end":{"line":152,"column":11}},"75":{"start":{"line":121,"column":4},"end":{"line":127,"column":null}},"76":{"start":{"line":122,"column":6},"end":{"line":122,"column":13}},"77":{"start":{"line":123,"column":11},"end":{"line":127,"column":null}},"78":{"start":{"line":124,"column":6},"end":{"line":124,"column":13}},"79":{"start":{"line":125,"column":11},"end":{"line":127,"column":null}},"80":{"start":{"line":126,"column":6},"end":{"line":126,"column":13}}},"fnMap":{"0":{"name":"ConditionSync","decl":{"start":{"line":6,"column":2},"end":{"line":6,"column":15}},"loc":{"start":{"line":6,"column":27},"end":{"line":31,"column":null}}},"1":{"name":"(anonymous_7)","decl":{"start":{"line":18,"column":50},"end":{"line":18,"column":51}},"loc":{"start":{"line":18,"column":50},"end":{"line":18,"column":51}}},"2":{"name":"toJSON","decl":{"start":{"line":38,"column":28},"end":{"line":38,"column":null}},"loc":{"start":{"line":38,"column":28},"end":{"line":79,"column":null}}},"3":{"name":"(anonymous_9)","decl":{"start":{"line":49,"column":37},"end":{"line":49,"column":38}},"loc":{"start":{"line":49,"column":37},"end":{"line":49,"column":38}}},"4":{"name":"evaluate","decl":{"start":{"line":87,"column":12},"end":{"line":87,"column":21}},"loc":{"start":{"line":87,"column":34},"end":{"line":113,"column":null}}},"5":{"name":"booleanOperator","decl":{"start":{"line":135,"column":21},"end":{"line":135,"column":null}},"loc":{"start":{"line":135,"column":21},"end":{"line":137,"column":null}}},"6":{"name":"isBooleanOperator","decl":{"start":{"line":143,"column":23},"end":{"line":143,"column":null}},"loc":{"start":{"line":143,"column":23},"end":{"line":145,"column":null}}},"7":{"name":"isConditionReference","decl":{"start":{"line":151,"column":26},"end":{"line":151,"column":null}},"loc":{"start":{"line":151,"column":26},"end":{"line":153,"column":null}}},"8":{"name":"booleanOperator","decl":{"start":{"line":120,"column":26},"end":{"line":120,"column":37}},"loc":{"start":{"line":120,"column":37},"end":{"line":128,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":7,"column":4},"end":{"line":7,"column":27}},"type":"if","locations":[{"start":{"line":7,"column":4},"end":{"line":7,"column":27}}]},"1":{"loc":{"start":{"line":10,"column":4},"end":{"line":30,"column":null}},"type":"if","locations":[{"start":{"line":10,"column":4},"end":{"line":30,"column":null}},{"start":{"line":22,"column":11},"end":{"line":30,"column":null}}]},"2":{"loc":{"start":{"line":13,"column":6},"end":{"line":13,"column":null}},"type":"if","locations":[{"start":{"line":13,"column":6},"end":{"line":13,"column":null}}]},"3":{"loc":{"start":{"line":13,"column":10},"end":{"line":13,"column":62}},"type":"binary-expr","locations":[{"start":{"line":13,"column":10},"end":{"line":13,"column":39}},{"start":{"line":13,"column":39},"end":{"line":13,"column":62}}]},"4":{"loc":{"start":{"line":14,"column":6},"end":{"line":14,"column":null}},"type":"if","locations":[{"start":{"line":14,"column":6},"end":{"line":14,"column":null}}]},"5":{"loc":{"start":{"line":14,"column":10},"end":{"line":14,"column":61}},"type":"binary-expr","locations":[{"start":{"line":14,"column":10},"end":{"line":14,"column":39}},{"start":{"line":14,"column":39},"end":{"line":14,"column":61}}]},"6":{"loc":{"start":{"line":16,"column":22},"end":{"line":16,"column":null}},"type":"binary-expr","locations":[{"start":{"line":16,"column":22},"end":{"line":16,"column":31}},{"start":{"line":16,"column":59},"end":{"line":16,"column":null}}]},"7":{"loc":{"start":{"line":17,"column":6},"end":{"line":21,"column":null}},"type":"if","locations":[{"start":{"line":17,"column":6},"end":{"line":21,"column":null}},{"start":{"line":19,"column":13},"end":{"line":21,"column":null}}]},"8":{"loc":{"start":{"line":22,"column":11},"end":{"line":30,"column":null}},"type":"if","locations":[{"start":{"line":22,"column":11},"end":{"line":30,"column":null}}]},"9":{"loc":{"start":{"line":23,"column":6},"end":{"line":23,"column":null}},"type":"if","locations":[{"start":{"line":23,"column":6},"end":{"line":23,"column":null}}]},"10":{"loc":{"start":{"line":24,"column":6},"end":{"line":24,"column":null}},"type":"if","locations":[{"start":{"line":24,"column":6},"end":{"line":24,"column":null}}]},"11":{"loc":{"start":{"line":25,"column":6},"end":{"line":25,"column":null}},"type":"if","locations":[{"start":{"line":25,"column":6},"end":{"line":25,"column":null}}]},"12":{"loc":{"start":{"line":27,"column":6},"end":{"line":29,"column":null}},"type":"if","locations":[{"start":{"line":27,"column":6},"end":{"line":29,"column":null}}]},"13":{"loc":{"start":{"line":38,"column":28},"end":{"line":38,"column":27}},"type":"cond-expr","locations":[{"start":{"line":38,"column":28},"end":{"line":38,"column":null}},{"start":{"line":38,"column":22},"end":{"line":38,"column":28}}]},"14":{"loc":{"start":{"line":38,"column":28},"end":{"line":38,"column":null}},"type":"binary-expr","locations":[{"start":{"line":38,"column":28},"end":{"line":38,"column":null}},{"start":{"line":38,"column":28},"end":{"line":38,"column":null}}]},"15":{"loc":{"start":{"line":40,"column":4},"end":{"line":42,"column":null}},"type":"if","locations":[{"start":{"line":40,"column":4},"end":{"line":42,"column":null}}]},"16":{"loc":{"start":{"line":43,"column":4},"end":{"line":45,"column":null}},"type":"if","locations":[{"start":{"line":43,"column":4},"end":{"line":45,"column":null}}]},"17":{"loc":{"start":{"line":47,"column":4},"end":{"line":74,"column":null}},"type":"if","locations":[{"start":{"line":47,"column":4},"end":{"line":74,"column":null}},{"start":{"line":53,"column":11},"end":{"line":74,"column":null}}]},"18":{"loc":{"start":{"line":48,"column":6},"end":{"line":52,"column":null}},"type":"if","locations":[{"start":{"line":48,"column":6},"end":{"line":52,"column":null}},{"start":{"line":50,"column":13},"end":{"line":52,"column":null}}]},"19":{"loc":{"start":{"line":53,"column":11},"end":{"line":74,"column":null}},"type":"if","locations":[{"start":{"line":53,"column":11},"end":{"line":74,"column":null}},{"start":{"line":55,"column":11},"end":{"line":74,"column":null}}]},"20":{"loc":{"start":{"line":59,"column":6},"end":{"line":61,"column":null}},"type":"if","locations":[{"start":{"line":59,"column":6},"end":{"line":61,"column":null}}]},"21":{"loc":{"start":{"line":62,"column":6},"end":{"line":64,"column":null}},"type":"if","locations":[{"start":{"line":62,"column":6},"end":{"line":64,"column":null}}]},"22":{"loc":{"start":{"line":65,"column":6},"end":{"line":67,"column":null}},"type":"if","locations":[{"start":{"line":65,"column":6},"end":{"line":67,"column":null}}]},"23":{"loc":{"start":{"line":68,"column":6},"end":{"line":70,"column":null}},"type":"if","locations":[{"start":{"line":68,"column":6},"end":{"line":70,"column":null}}]},"24":{"loc":{"start":{"line":71,"column":6},"end":{"line":73,"column":null}},"type":"if","locations":[{"start":{"line":71,"column":6},"end":{"line":73,"column":null}}]},"25":{"loc":{"start":{"line":75,"column":4},"end":{"line":77,"column":null}},"type":"if","locations":[{"start":{"line":75,"column":4},"end":{"line":77,"column":null}}]},"26":{"loc":{"start":{"line":88,"column":4},"end":{"line":88,"column":24}},"type":"if","locations":[{"start":{"line":88,"column":4},"end":{"line":88,"column":24}}]},"27":{"loc":{"start":{"line":89,"column":4},"end":{"line":89,"column":28}},"type":"if","locations":[{"start":{"line":89,"column":4},"end":{"line":89,"column":28}}]},"28":{"loc":{"start":{"line":90,"column":4},"end":{"line":90,"column":null}},"type":"if","locations":[{"start":{"line":90,"column":4},"end":{"line":90,"column":null}}]},"29":{"loc":{"start":{"line":93,"column":4},"end":{"line":93,"column":null}},"type":"if","locations":[{"start":{"line":93,"column":4},"end":{"line":93,"column":null}}]},"30":{"loc":{"start":{"line":121,"column":4},"end":{"line":127,"column":null}},"type":"if","locations":[{"start":{"line":121,"column":4},"end":{"line":127,"column":null}},{"start":{"line":123,"column":11},"end":{"line":127,"column":null}}]},"31":{"loc":{"start":{"line":123,"column":11},"end":{"line":127,"column":null}},"type":"if","locations":[{"start":{"line":123,"column":11},"end":{"line":127,"column":null}},{"start":{"line":125,"column":11},"end":{"line":127,"column":null}}]},"32":{"loc":{"start":{"line":125,"column":11},"end":{"line":127,"column":null}},"type":"if","locations":[{"start":{"line":125,"column":11},"end":{"line":127,"column":null}}]}},"s":{"0":1,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0},"b":{"0":[0],"1":[0,0],"2":[0],"3":[0,0],"4":[0],"5":[0,0],"6":[0,0],"7":[0,0],"8":[0],"9":[0],"10":[0],"11":[0],"12":[0],"13":[0,0],"14":[0,0],"15":[0],"16":[0],"17":[0,0],"18":[0,0],"19":[0,0],"20":[0],"21":[0],"22":[0],"23":[0],"24":[0],"25":[0],"26":[0],"27":[0],"28":[0],"29":[0],"30":[0,0],"31":[0,0],"32":[0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/engine-sync.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/engine-sync.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"5":{"start":{"line":8,"column":0},"end":{"line":8,"column":null}},"6":{"start":{"line":9,"column":0},"end":{"line":9,"column":null}},"7":{"start":{"line":10,"column":0},"end":{"line":10,"column":null}},"8":{"start":{"line":11,"column":0},"end":{"line":11,"column":null}},"9":{"start":{"line":13,"column":13},"end":{"line":13,"column":null}},"10":{"start":{"line":14,"column":13},"end":{"line":14,"column":null}},"11":{"start":{"line":15,"column":13},"end":{"line":15,"column":null}},"12":{"start":{"line":22,"column":41},"end":{"line":22,"column":27}},"13":{"start":{"line":22,"column":41},"end":{"line":22,"column":40}},"14":{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},"15":{"start":{"line":24,"column":4},"end":{"line":24,"column":9}},"16":{"start":{"line":25,"column":4},"end":{"line":25,"column":9}},"17":{"start":{"line":26,"column":4},"end":{"line":26,"column":9}},"18":{"start":{"line":27,"column":4},"end":{"line":27,"column":9}},"19":{"start":{"line":28,"column":4},"end":{"line":28,"column":9}},"20":{"start":{"line":29,"column":4},"end":{"line":29,"column":9}},"21":{"start":{"line":30,"column":4},"end":{"line":30,"column":9}},"22":{"start":{"line":31,"column":4},"end":{"line":31,"column":9}},"23":{"start":{"line":32,"column":4},"end":{"line":32,"column":9}},"24":{"start":{"line":33,"column":4},"end":{"line":33,"column":10}},"25":{"start":{"line":33,"column":14},"end":{"line":33,"column":19}},"26":{"start":{"line":34,"column":4},"end":{"line":34,"column":21}},"27":{"start":{"line":34,"column":25},"end":{"line":34,"column":30}},"28":{"start":{"line":35,"column":4},"end":{"line":35,"column":22}},"29":{"start":{"line":35,"column":26},"end":{"line":35,"column":31}},"30":{"start":{"line":43,"column":4},"end":{"line":43,"column":27}},"31":{"start":{"line":43,"column":21},"end":{"line":43,"column":27}},"32":{"start":{"line":45,"column":8},"end":{"line":45,"column":null}},"33":{"start":{"line":46,"column":4},"end":{"line":52,"column":null}},"34":{"start":{"line":47,"column":6},"end":{"line":47,"column":13}},"35":{"start":{"line":49,"column":6},"end":{"line":49,"column":76}},"36":{"start":{"line":49,"column":70},"end":{"line":49,"column":76}},"37":{"start":{"line":50,"column":6},"end":{"line":50,"column":81}},"38":{"start":{"line":50,"column":75},"end":{"line":50,"column":81}},"39":{"start":{"line":51,"column":6},"end":{"line":51,"column":13}},"40":{"start":{"line":53,"column":4},"end":{"line":53,"column":9}},"41":{"start":{"line":54,"column":4},"end":{"line":54,"column":9}},"42":{"start":{"line":55,"column":4},"end":{"line":55,"column":9}},"43":{"start":{"line":56,"column":4},"end":{"line":56,"column":11}},"44":{"start":{"line":64,"column":22},"end":{"line":64,"column":27}},"45":{"start":{"line":64,"column":43},"end":{"line":64,"column":59}},"46":{"start":{"line":65,"column":4},"end":{"line":71,"column":null}},"47":{"start":{"line":66,"column":6},"end":{"line":66,"column":11}},"48":{"start":{"line":67,"column":6},"end":{"line":67,"column":11}},"49":{"start":{"line":68,"column":6},"end":{"line":68,"column":11}},"50":{"start":{"line":70,"column":6},"end":{"line":70,"column":12}},"51":{"start":{"line":79,"column":22},"end":{"line":79,"column":null}},"52":{"start":{"line":80,"column":4},"end":{"line":89,"column":null}},"53":{"start":{"line":81,"column":28},"end":{"line":81,"column":33}},"54":{"start":{"line":81,"column":46},"end":{"line":81,"column":62}},"55":{"start":{"line":82,"column":6},"end":{"line":82,"column":20}},"56":{"start":{"line":83,"column":6},"end":{"line":83,"column":11}},"57":{"start":{"line":85,"column":20},"end":{"line":85,"column":25}},"58":{"start":{"line":86,"column":6},"end":{"line":88,"column":null}},"59":{"start":{"line":87,"column":8},"end":{"line":87,"column":22}},"60":{"start":{"line":90,"column":4},"end":{"line":92,"column":null}},"61":{"start":{"line":91,"column":6},"end":{"line":91,"column":11}},"62":{"start":{"line":93,"column":4},"end":{"line":93,"column":11}},"63":{"start":{"line":102,"column":4},"end":{"line":102,"column":21}},"64":{"start":{"line":102,"column":15},"end":{"line":102,"column":21}},"65":{"start":{"line":103,"column":4},"end":{"line":103,"column":27}},"66":{"start":{"line":103,"column":21},"end":{"line":103,"column":27}},"67":{"start":{"line":104,"column":4},"end":{"line":106,"column":null}},"68":{"start":{"line":105,"column":6},"end":{"line":105,"column":12}},"69":{"start":{"line":107,"column":4},"end":{"line":107,"column":9}},"70":{"start":{"line":108,"column":4},"end":{"line":108,"column":11}},"71":{"start":{"line":117,"column":4},"end":{"line":117,"column":11}},"72":{"start":{"line":126,"column":4},"end":{"line":126,"column":9}},"73":{"start":{"line":134,"column":4},"end":{"line":134,"column":11}},"74":{"start":{"line":143,"column":4},"end":{"line":143,"column":9}},"75":{"start":{"line":151,"column":4},"end":{"line":151,"column":11}},"76":{"start":{"line":161,"column":17},"end":{"line":161,"column":null}},"77":{"start":{"line":162,"column":8},"end":{"line":162,"column":null}},"78":{"start":{"line":163,"column":4},"end":{"line":168,"column":null}},"79":{"start":{"line":164,"column":6},"end":{"line":164,"column":15}},"80":{"start":{"line":165,"column":6},"end":{"line":165,"column":13}},"81":{"start":{"line":167,"column":6},"end":{"line":167,"column":13}},"82":{"start":{"line":169,"column":4},"end":{"line":169,"column":10}},"83":{"start":{"line":170,"column":4},"end":{"line":170,"column":9}},"84":{"start":{"line":171,"column":4},"end":{"line":171,"column":11}},"85":{"start":{"line":179,"column":8},"end":{"line":179,"column":null}},"86":{"start":{"line":180,"column":4},"end":{"line":184,"column":null}},"87":{"start":{"line":181,"column":6},"end":{"line":181,"column":15}},"88":{"start":{"line":183,"column":6},"end":{"line":183,"column":15}},"89":{"start":{"line":186,"column":4},"end":{"line":186,"column":11}},"90":{"start":{"line":194,"column":4},"end":{"line":204,"column":null}},"91":{"start":{"line":195,"column":23},"end":{"line":195,"column":28}},"92":{"start":{"line":196,"column":25},"end":{"line":196,"column":null}},"93":{"start":{"line":197,"column":8},"end":{"line":197,"column":34}},"94":{"start":{"line":197,"column":29},"end":{"line":197,"column":34}},"95":{"start":{"line":198,"column":8},"end":{"line":198,"column":13}},"96":{"start":{"line":199,"column":8},"end":{"line":199,"column":15}},"97":{"start":{"line":201,"column":6},"end":{"line":201,"column":11}},"98":{"start":{"line":202,"column":8},"end":{"line":202,"column":15}},"99":{"start":{"line":203,"column":13},"end":{"line":203,"column":14}},"100":{"start":{"line":205,"column":4},"end":{"line":205,"column":11}},"101":{"start":{"line":213,"column":4},"end":{"line":213,"column":9}},"102":{"start":{"line":214,"column":4},"end":{"line":214,"column":11}},"103":{"start":{"line":223,"column":4},"end":{"line":223,"column":11}},"104":{"start":{"line":232,"column":20},"end":{"line":232,"column":null}},"105":{"start":{"line":231,"column":37},"end":{"line":231,"column":null}},"106":{"start":{"line":233,"column":4},"end":{"line":250,"column":null}},"107":{"start":{"line":233,"column":23},"end":{"line":233,"column":15}},"108":{"start":{"line":233,"column":34},"end":{"line":233,"column":null}},"109":{"start":{"line":234,"column":6},"end":{"line":237,"column":null}},"110":{"start":{"line":235,"column":8},"end":{"line":235,"column":14}},"111":{"start":{"line":236,"column":8},"end":{"line":236,"column":null}},"112":{"start":{"line":238,"column":25},"end":{"line":238,"column":30}},"113":{"start":{"line":239,"column":6},"end":{"line":239,"column":12}},"114":{"start":{"line":240,"column":6},"end":{"line":240,"column":14}},"115":{"start":{"line":241,"column":6},"end":{"line":248,"column":null}},"116":{"start":{"line":242,"column":8},"end":{"line":242,"column":16}},"117":{"start":{"line":243,"column":8},"end":{"line":243,"column":13}},"118":{"start":{"line":244,"column":8},"end":{"line":244,"column":13}},"119":{"start":{"line":246,"column":8},"end":{"line":246,"column":16}},"120":{"start":{"line":247,"column":8},"end":{"line":247,"column":13}},"121":{"start":{"line":249,"column":6},"end":{"line":249,"column":14}},"122":{"start":{"line":251,"column":4},"end":{"line":251,"column":11}},"123":{"start":{"line":260,"column":43},"end":{"line":260,"column":26}},"124":{"start":{"line":260,"column":43},"end":{"line":260,"column":42}},"125":{"start":{"line":261,"column":4},"end":{"line":261,"column":10}},"126":{"start":{"line":262,"column":4},"end":{"line":262,"column":9}},"127":{"start":{"line":264,"column":20},"end":{"line":264,"column":46}},"128":{"start":{"line":269,"column":4},"end":{"line":269,"column":9}},"129":{"start":{"line":270,"column":6},"end":{"line":270,"column":14}},"130":{"start":{"line":272,"column":4},"end":{"line":282,"column":null}},"131":{"start":{"line":273,"column":10},"end":{"line":273,"column":null}},"132":{"start":{"line":274,"column":6},"end":{"line":278,"column":null}},"133":{"start":{"line":275,"column":8},"end":{"line":275,"column":15}},"134":{"start":{"line":277,"column":8},"end":{"line":277,"column":15}},"135":{"start":{"line":280,"column":6},"end":{"line":280,"column":14}},"136":{"start":{"line":281,"column":6},"end":{"line":281,"column":12}},"137":{"start":{"line":284,"column":24},"end":{"line":284,"column":29}},"138":{"start":{"line":260,"column":43},"end":{"line":260,"column":null}},"139":{"start":{"line":286,"column":4},"end":{"line":289,"column":null}},"140":{"start":{"line":286,"column":22},"end":{"line":286,"column":15}},"141":{"start":{"line":286,"column":35},"end":{"line":286,"column":null}},"142":{"start":{"line":287,"column":6},"end":{"line":287,"column":11}},"143":{"start":{"line":288,"column":6},"end":{"line":288,"column":null}},"144":{"start":{"line":288,"column":36},"end":{"line":288,"column":null}},"145":{"start":{"line":291,"column":4},"end":{"line":291,"column":9}},"146":{"start":{"line":292,"column":4},"end":{"line":292,"column":10}},"147":{"start":{"line":293,"column":24},"end":{"line":293,"column":32}},"148":{"start":{"line":294,"column":40},"end":{"line":294,"column":52}},"149":{"start":{"line":295,"column":20},"end":{"line":295,"column":null}},"150":{"start":{"line":296,"column":6},"end":{"line":296,"column":11}},"151":{"start":{"line":297,"column":6},"end":{"line":297,"column":13}},"152":{"start":{"line":260,"column":43},"end":{"line":294,"column":21}},"153":{"start":{"line":260,"column":43},"end":{"line":294,"column":40}},"154":{"start":{"line":300,"column":4},"end":{"line":300,"column":11}}},"fnMap":{"0":{"name":"EngineSync","decl":{"start":{"line":22,"column":2},"end":{"line":22,"column":15}},"loc":{"start":{"line":22,"column":41},"end":{"line":36,"column":null}}},"1":{"name":"(anonymous_11)","decl":{"start":{"line":33,"column":14},"end":{"line":33,"column":19}},"loc":{"start":{"line":33,"column":14},"end":{"line":33,"column":19}}},"2":{"name":"(anonymous_12)","decl":{"start":{"line":34,"column":25},"end":{"line":34,"column":30}},"loc":{"start":{"line":34,"column":25},"end":{"line":34,"column":30}}},"3":{"name":"(anonymous_13)","decl":{"start":{"line":35,"column":26},"end":{"line":35,"column":31}},"loc":{"start":{"line":35,"column":26},"end":{"line":35,"column":31}}},"4":{"name":"addRule","decl":{"start":{"line":42,"column":11},"end":{"line":42,"column":23}},"loc":{"start":{"line":42,"column":23},"end":{"line":57,"column":null}}},"5":{"name":"updateRule","decl":{"start":{"line":63,"column":14},"end":{"line":63,"column":20}},"loc":{"start":{"line":63,"column":20},"end":{"line":72,"column":null}}},"6":{"name":"(anonymous_16)","decl":{"start":{"line":64,"column":43},"end":{"line":64,"column":59}},"loc":{"start":{"line":64,"column":43},"end":{"line":64,"column":59}}},"7":{"name":"removeRule","decl":{"start":{"line":78,"column":14},"end":{"line":78,"column":20}},"loc":{"start":{"line":78,"column":20},"end":{"line":94,"column":null}}},"8":{"name":"(anonymous_18)","decl":{"start":{"line":81,"column":46},"end":{"line":81,"column":62}},"loc":{"start":{"line":81,"column":46},"end":{"line":81,"column":62}}},"9":{"name":"setCondition","decl":{"start":{"line":101,"column":16},"end":{"line":101,"column":22}},"loc":{"start":{"line":101,"column":34},"end":{"line":109,"column":null}}},"10":{"name":"removeCondition","decl":{"start":{"line":116,"column":19},"end":{"line":116,"column":25}},"loc":{"start":{"line":116,"column":25},"end":{"line":118,"column":null}}},"11":{"name":"addOperator","decl":{"start":{"line":125,"column":15},"end":{"line":125,"column":31}},"loc":{"start":{"line":125,"column":35},"end":{"line":127,"column":null}}},"12":{"name":"removeOperator","decl":{"start":{"line":133,"column":18},"end":{"line":133,"column":34}},"loc":{"start":{"line":133,"column":34},"end":{"line":135,"column":null}}},"13":{"name":"addOperatorDecorator","decl":{"start":{"line":142,"column":24},"end":{"line":142,"column":41}},"loc":{"start":{"line":142,"column":45},"end":{"line":144,"column":null}}},"14":{"name":"removeOperatorDecorator","decl":{"start":{"line":150,"column":27},"end":{"line":150,"column":44}},"loc":{"start":{"line":150,"column":44},"end":{"line":152,"column":null}}},"15":{"name":"addFact","decl":{"start":{"line":160,"column":11},"end":{"line":160,"column":15}},"loc":{"start":{"line":160,"column":39},"end":{"line":172,"column":null}}},"16":{"name":"removeFact","decl":{"start":{"line":178,"column":14},"end":{"line":178,"column":24}},"loc":{"start":{"line":178,"column":24},"end":{"line":187,"column":null}}},"17":{"name":"prioritizeRules","decl":{"start":{"line":193,"column":21},"end":{"line":193,"column":null}},"loc":{"start":{"line":193,"column":21},"end":{"line":206,"column":null}}},"18":{"name":"(anonymous_28)","decl":{"start":{"line":195,"column":41},"end":{"line":195,"column":42}},"loc":{"start":{"line":195,"column":57},"end":{"line":200,"column":9}}},"19":{"name":"(anonymous_29)","decl":{"start":{"line":201,"column":57},"end":{"line":201,"column":58}},"loc":{"start":{"line":201,"column":67},"end":{"line":203,"column":9}}},"20":{"name":"(anonymous_30)","decl":{"start":{"line":203,"column":13},"end":{"line":203,"column":14}},"loc":{"start":{"line":203,"column":13},"end":{"line":203,"column":14}}},"21":{"name":"stop","decl":{"start":{"line":212,"column":10},"end":{"line":212,"column":null}},"loc":{"start":{"line":212,"column":10},"end":{"line":215,"column":null}}},"22":{"name":"getFact","decl":{"start":{"line":222,"column":11},"end":{"line":222,"column":19}},"loc":{"start":{"line":222,"column":19},"end":{"line":224,"column":null}}},"23":{"name":"evaluateRules","decl":{"start":{"line":231,"column":17},"end":{"line":231,"column":28}},"loc":{"start":{"line":231,"column":37},"end":{"line":252,"column":null}}},"24":{"name":"run","decl":{"start":{"line":260,"column":43},"end":{"line":260,"column":null}},"loc":{"start":{"line":260,"column":43},"end":{"line":307,"column":null}}},"25":{"name":"(anonymous_35)","decl":{"start":{"line":269,"column":23},"end":{"line":269,"column":31}},"loc":{"start":{"line":269,"column":31},"end":{"line":271,"column":null}}},"26":{"name":"(anonymous_36)","decl":{"start":{"line":294,"column":59},"end":{"line":294,"column":60}},"loc":{"start":{"line":294,"column":81},"end":{"line":298,"column":7}}}},"branchMap":{"0":{"loc":{"start":{"line":22,"column":41},"end":{"line":22,"column":27}},"type":"cond-expr","locations":[{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},{"start":{"line":22,"column":23},"end":{"line":22,"column":27}}]},"1":{"loc":{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},"type":"binary-expr","locations":[{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},{"start":{"line":22,"column":41},"end":{"line":22,"column":null}}]},"2":{"loc":{"start":{"line":22,"column":41},"end":{"line":22,"column":40}},"type":"cond-expr","locations":[{"start":{"line":22,"column":41},"end":{"line":22,"column":null}},{"start":{"line":22,"column":37},"end":{"line":22,"column":41}}]},"3":{"loc":{"start":{"line":25,"column":31},"end":{"line":25,"column":null}},"type":"binary-expr","locations":[{"start":{"line":25,"column":31},"end":{"line":25,"column":62}},{"start":{"line":25,"column":62},"end":{"line":25,"column":null}}]},"4":{"loc":{"start":{"line":26,"column":36},"end":{"line":26,"column":null}},"type":"binary-expr","locations":[{"start":{"line":26,"column":36},"end":{"line":26,"column":72}},{"start":{"line":26,"column":72},"end":{"line":26,"column":null}}]},"5":{"loc":{"start":{"line":27,"column":37},"end":{"line":27,"column":null}},"type":"binary-expr","locations":[{"start":{"line":27,"column":37},"end":{"line":27,"column":74}},{"start":{"line":27,"column":74},"end":{"line":27,"column":null}}]},"6":{"loc":{"start":{"line":43,"column":4},"end":{"line":43,"column":27}},"type":"if","locations":[{"start":{"line":43,"column":4},"end":{"line":43,"column":27}}]},"7":{"loc":{"start":{"line":46,"column":4},"end":{"line":52,"column":null}},"type":"if","locations":[{"start":{"line":46,"column":4},"end":{"line":52,"column":null}},{"start":{"line":48,"column":11},"end":{"line":52,"column":null}}]},"8":{"loc":{"start":{"line":49,"column":6},"end":{"line":49,"column":76}},"type":"if","locations":[{"start":{"line":49,"column":6},"end":{"line":49,"column":76}}]},"9":{"loc":{"start":{"line":50,"column":6},"end":{"line":50,"column":81}},"type":"if","locations":[{"start":{"line":50,"column":6},"end":{"line":50,"column":81}}]},"10":{"loc":{"start":{"line":65,"column":4},"end":{"line":71,"column":null}},"type":"if","locations":[{"start":{"line":65,"column":4},"end":{"line":71,"column":null}},{"start":{"line":69,"column":11},"end":{"line":71,"column":null}}]},"11":{"loc":{"start":{"line":80,"column":4},"end":{"line":89,"column":null}},"type":"if","locations":[{"start":{"line":80,"column":4},"end":{"line":89,"column":null}},{"start":{"line":84,"column":11},"end":{"line":89,"column":null}}]},"12":{"loc":{"start":{"line":86,"column":6},"end":{"line":88,"column":null}},"type":"if","locations":[{"start":{"line":86,"column":6},"end":{"line":88,"column":null}}]},"13":{"loc":{"start":{"line":90,"column":4},"end":{"line":92,"column":null}},"type":"if","locations":[{"start":{"line":90,"column":4},"end":{"line":92,"column":null}}]},"14":{"loc":{"start":{"line":102,"column":4},"end":{"line":102,"column":21}},"type":"if","locations":[{"start":{"line":102,"column":4},"end":{"line":102,"column":21}}]},"15":{"loc":{"start":{"line":103,"column":4},"end":{"line":103,"column":27}},"type":"if","locations":[{"start":{"line":103,"column":4},"end":{"line":103,"column":27}}]},"16":{"loc":{"start":{"line":104,"column":4},"end":{"line":106,"column":null}},"type":"if","locations":[{"start":{"line":104,"column":4},"end":{"line":106,"column":null}}]},"17":{"loc":{"start":{"line":104,"column":8},"end":{"line":104,"column":196}},"type":"binary-expr","locations":[{"start":{"line":104,"column":8},"end":{"line":104,"column":16}},{"start":{"line":104,"column":68},"end":{"line":104,"column":76}},{"start":{"line":104,"column":128},"end":{"line":104,"column":136}},{"start":{"line":104,"column":188},"end":{"line":104,"column":196}}]},"18":{"loc":{"start":{"line":163,"column":4},"end":{"line":168,"column":null}},"type":"if","locations":[{"start":{"line":163,"column":4},"end":{"line":168,"column":null}},{"start":{"line":166,"column":11},"end":{"line":168,"column":null}}]},"19":{"loc":{"start":{"line":180,"column":4},"end":{"line":184,"column":null}},"type":"if","locations":[{"start":{"line":180,"column":4},"end":{"line":184,"column":null}},{"start":{"line":182,"column":11},"end":{"line":184,"column":null}}]},"20":{"loc":{"start":{"line":194,"column":4},"end":{"line":204,"column":null}},"type":"if","locations":[{"start":{"line":194,"column":4},"end":{"line":204,"column":null}}]},"21":{"loc":{"start":{"line":197,"column":8},"end":{"line":197,"column":34}},"type":"if","locations":[{"start":{"line":197,"column":8},"end":{"line":197,"column":34}}]},"22":{"loc":{"start":{"line":202,"column":15},"end":{"line":202,"column":null}},"type":"cond-expr","locations":[{"start":{"line":202,"column":39},"end":{"line":202,"column":44}},{"start":{"line":202,"column":44},"end":{"line":202,"column":null}}]},"23":{"loc":{"start":{"line":234,"column":6},"end":{"line":237,"column":null}},"type":"if","locations":[{"start":{"line":234,"column":6},"end":{"line":237,"column":null}}]},"24":{"loc":{"start":{"line":241,"column":6},"end":{"line":248,"column":null}},"type":"if","locations":[{"start":{"line":241,"column":6},"end":{"line":248,"column":null}},{"start":{"line":245,"column":13},"end":{"line":248,"column":null}}]},"25":{"loc":{"start":{"line":231,"column":37},"end":{"line":231,"column":null}},"type":"if","locations":[{"start":{"line":231,"column":37},"end":{"line":231,"column":null}}]},"26":{"loc":{"start":{"line":231,"column":37},"end":{"line":231,"column":null}},"type":"binary-expr","locations":[{"start":{"line":231,"column":37},"end":{"line":231,"column":null}},{"start":{"line":231,"column":37},"end":{"line":231,"column":null}}]},"27":{"loc":{"start":{"line":260,"column":43},"end":{"line":260,"column":26}},"type":"cond-expr","locations":[{"start":{"line":260,"column":43},"end":{"line":260,"column":null}},{"start":{"line":260,"column":22},"end":{"line":260,"column":26}}]},"28":{"loc":{"start":{"line":260,"column":43},"end":{"line":260,"column":null}},"type":"binary-expr","locations":[{"start":{"line":260,"column":43},"end":{"line":260,"column":null}},{"start":{"line":260,"column":43},"end":{"line":260,"column":null}}]},"29":{"loc":{"start":{"line":260,"column":43},"end":{"line":260,"column":42}},"type":"cond-expr","locations":[{"start":{"line":260,"column":43},"end":{"line":260,"column":null}},{"start":{"line":260,"column":39},"end":{"line":260,"column":43}}]},"30":{"loc":{"start":{"line":264,"column":20},"end":{"line":264,"column":46}},"type":"binary-expr","locations":[{"start":{"line":264,"column":20},"end":{"line":264,"column":42}},{"start":{"line":264,"column":42},"end":{"line":264,"column":46}}]},"31":{"loc":{"start":{"line":274,"column":6},"end":{"line":278,"column":null}},"type":"if","locations":[{"start":{"line":274,"column":6},"end":{"line":278,"column":null}},{"start":{"line":276,"column":13},"end":{"line":278,"column":null}}]},"32":{"loc":{"start":{"line":288,"column":6},"end":{"line":288,"column":null}},"type":"if","locations":[{"start":{"line":288,"column":6},"end":{"line":288,"column":null}}]},"33":{"loc":{"start":{"line":260,"column":43},"end":{"line":260,"column":null}},"type":"if","locations":[{"start":{"line":260,"column":43},"end":{"line":260,"column":null}}]},"34":{"loc":{"start":{"line":295,"column":20},"end":{"line":295,"column":null}},"type":"cond-expr","locations":[{"start":{"line":295,"column":40},"end":{"line":295,"column":52}},{"start":{"line":295,"column":52},"end":{"line":295,"column":null}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":1,"8":1,"9":1,"10":1,"11":1,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0,"81":0,"82":0,"83":0,"84":0,"85":0,"86":0,"87":0,"88":0,"89":0,"90":0,"91":0,"92":0,"93":0,"94":0,"95":0,"96":0,"97":0,"98":0,"99":0,"100":0,"101":0,"102":0,"103":0,"104":0,"105":0,"106":0,"107":0,"108":0,"109":0,"110":0,"111":0,"112":0,"113":0,"114":0,"115":0,"116":0,"117":0,"118":0,"119":0,"120":0,"121":0,"122":0,"123":0,"124":0,"125":0,"126":0,"127":0,"128":0,"129":0,"130":0,"131":0,"132":0,"133":0,"134":0,"135":0,"136":0,"137":0,"138":0,"139":0,"140":0,"141":0,"142":0,"143":0,"144":0,"145":0,"146":0,"147":0,"148":0,"149":0,"150":0,"151":0,"152":0,"153":0,"154":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0},"b":{"0":[0,0],"1":[0,0],"2":[0,0],"3":[0,0],"4":[0,0],"5":[0,0],"6":[0],"7":[0,0],"8":[0],"9":[0],"10":[0,0],"11":[0,0],"12":[0],"13":[0],"14":[0],"15":[0],"16":[0],"17":[0,0,0,0],"18":[0,0],"19":[0,0],"20":[0],"21":[0],"22":[0,0],"23":[0],"24":[0,0],"25":[0],"26":[0,0],"27":[0,0],"28":[0,0],"29":[0,0],"30":[0,0],"31":[0,0],"32":[0],"33":[0],"34":[0,0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/fact-sync.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/fact-sync.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":14,"column":43},"end":{"line":14,"column":null}},"2":{"start":{"line":15,"column":4},"end":{"line":15,"column":9}},"3":{"start":{"line":16,"column":27},"end":{"line":16,"column":29}},"4":{"start":{"line":17,"column":4},"end":{"line":19,"column":null}},"5":{"start":{"line":18,"column":6},"end":{"line":18,"column":16}},"6":{"start":{"line":20,"column":4},"end":{"line":26,"column":null}},"7":{"start":{"line":21,"column":6},"end":{"line":21,"column":11}},"8":{"start":{"line":22,"column":6},"end":{"line":22,"column":11}},"9":{"start":{"line":24,"column":6},"end":{"line":24,"column":11}},"10":{"start":{"line":25,"column":6},"end":{"line":25,"column":11}},"11":{"start":{"line":28,"column":4},"end":{"line":28,"column":24}},"12":{"start":{"line":28,"column":18},"end":{"line":28,"column":24}},"13":{"start":{"line":30,"column":4},"end":{"line":30,"column":9}},"14":{"start":{"line":31,"column":4},"end":{"line":31,"column":9}},"15":{"start":{"line":32,"column":4},"end":{"line":32,"column":9}},"16":{"start":{"line":33,"column":4},"end":{"line":33,"column":11}},"17":{"start":{"line":37,"column":4},"end":{"line":37,"column":11}},"18":{"start":{"line":41,"column":4},"end":{"line":41,"column":11}},"19":{"start":{"line":51,"column":4},"end":{"line":53,"column":null}},"20":{"start":{"line":52,"column":6},"end":{"line":52,"column":13}},"21":{"start":{"line":54,"column":4},"end":{"line":54,"column":11}},"22":{"start":{"line":75,"column":4},"end":{"line":75,"column":11}},"23":{"start":{"line":85,"column":4},"end":{"line":89,"column":null}},"24":{"start":{"line":86,"column":30},"end":{"line":86,"column":35}},"25":{"start":{"line":87,"column":19},"end":{"line":87,"column":28}},"26":{"start":{"line":88,"column":6},"end":{"line":88,"column":13}},"27":{"start":{"line":63,"column":4},"end":{"line":63,"column":11}},"28":{"start":{"line":93,"column":0},"end":{"line":93,"column":9}},"29":{"start":{"line":94,"column":0},"end":{"line":94,"column":9}}},"fnMap":{"0":{"name":"FactSync","decl":{"start":{"line":14,"column":2},"end":{"line":14,"column":15}},"loc":{"start":{"line":14,"column":43},"end":{"line":34,"column":null}}},"1":{"name":"isConstant","decl":{"start":{"line":36,"column":16},"end":{"line":36,"column":null}},"loc":{"start":{"line":36,"column":16},"end":{"line":38,"column":null}}},"2":{"name":"isDynamic","decl":{"start":{"line":40,"column":15},"end":{"line":40,"column":null}},"loc":{"start":{"line":40,"column":15},"end":{"line":42,"column":null}}},"3":{"name":"calculate","decl":{"start":{"line":50,"column":13},"end":{"line":50,"column":21}},"loc":{"start":{"line":50,"column":30},"end":{"line":55,"column":null}}},"4":{"name":"defaultCacheKeys","decl":{"start":{"line":74,"column":20},"end":{"line":74,"column":24}},"loc":{"start":{"line":74,"column":32},"end":{"line":76,"column":null}}},"5":{"name":"getCacheKey","decl":{"start":{"line":84,"column":15},"end":{"line":84,"column":23}},"loc":{"start":{"line":84,"column":23},"end":{"line":90,"column":null}}},"6":{"name":"hashFromObject","decl":{"start":{"line":62,"column":25},"end":{"line":62,"column":30}},"loc":{"start":{"line":62,"column":30},"end":{"line":64,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":17,"column":4},"end":{"line":19,"column":null}},"type":"if","locations":[{"start":{"line":17,"column":4},"end":{"line":19,"column":null}}]},"1":{"loc":{"start":{"line":20,"column":4},"end":{"line":26,"column":null}},"type":"if","locations":[{"start":{"line":20,"column":4},"end":{"line":26,"column":null}},{"start":{"line":23,"column":11},"end":{"line":26,"column":null}}]},"2":{"loc":{"start":{"line":28,"column":4},"end":{"line":28,"column":24}},"type":"if","locations":[{"start":{"line":28,"column":4},"end":{"line":28,"column":24}}]},"3":{"loc":{"start":{"line":30,"column":29},"end":{"line":30,"column":52}},"type":"binary-expr","locations":[{"start":{"line":30,"column":29},"end":{"line":30,"column":49}},{"start":{"line":30,"column":49},"end":{"line":30,"column":52}}]},"4":{"loc":{"start":{"line":51,"column":4},"end":{"line":53,"column":null}},"type":"if","locations":[{"start":{"line":51,"column":4},"end":{"line":53,"column":null}}]},"5":{"loc":{"start":{"line":85,"column":4},"end":{"line":89,"column":null}},"type":"if","locations":[{"start":{"line":85,"column":4},"end":{"line":89,"column":null}}]}},"s":{"0":1,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":1,"29":1},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0},"b":{"0":[0],"1":[0,0],"2":[0],"3":[0,0],"4":[0],"5":[0]}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/index-sync.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/index-sync.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"5":{"start":{"line":8,"column":0},"end":{"line":8,"column":null}},"6":{"start":{"line":9,"column":0},"end":{"line":9,"column":null}},"7":{"start":{"line":18,"column":2},"end":{"line":18,"column":9}}},"fnMap":{"0":{"name":"engineSync","decl":{"start":{"line":17,"column":9},"end":{"line":17,"column":21}},"loc":{"start":{"line":17,"column":37},"end":{"line":19,"column":null}}}},"branchMap":{},"s":{"0":1,"1":1,"2":1,"3":1,"4":1,"5":1,"6":1,"7":0},"f":{"0":0},"b":{}} +,"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/rule-sync.js": {"path":"/Users/manuelreil/alyne.com/dev/json-rules-engine/src/sync/rule-sync.js","statementMap":{"0":{"start":{"line":3,"column":0},"end":{"line":3,"column":null}},"1":{"start":{"line":4,"column":0},"end":{"line":4,"column":null}},"2":{"start":{"line":5,"column":0},"end":{"line":5,"column":null}},"3":{"start":{"line":6,"column":0},"end":{"line":6,"column":null}},"4":{"start":{"line":7,"column":0},"end":{"line":7,"column":null}},"5":{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},"6":{"start":{"line":23,"column":4},"end":{"line":25,"column":null}},"7":{"start":{"line":24,"column":6},"end":{"line":24,"column":16}},"8":{"start":{"line":26,"column":4},"end":{"line":28,"column":null}},"9":{"start":{"line":27,"column":6},"end":{"line":27,"column":11}},"10":{"start":{"line":29,"column":4},"end":{"line":31,"column":null}},"11":{"start":{"line":30,"column":6},"end":{"line":30,"column":11}},"12":{"start":{"line":32,"column":4},"end":{"line":34,"column":null}},"13":{"start":{"line":33,"column":6},"end":{"line":33,"column":11}},"14":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"15":{"start":{"line":36,"column":6},"end":{"line":36,"column":11}},"16":{"start":{"line":39,"column":22},"end":{"line":39,"column":null}},"17":{"start":{"line":40,"column":4},"end":{"line":40,"column":9}},"18":{"start":{"line":42,"column":19},"end":{"line":42,"column":50}},"19":{"start":{"line":43,"column":4},"end":{"line":43,"column":9}},"20":{"start":{"line":51,"column":4},"end":{"line":51,"column":15}},"21":{"start":{"line":52,"column":4},"end":{"line":52,"column":29}},"22":{"start":{"line":52,"column":23},"end":{"line":52,"column":29}},"23":{"start":{"line":53,"column":4},"end":{"line":53,"column":9}},"24":{"start":{"line":54,"column":4},"end":{"line":54,"column":11}},"25":{"start":{"line":62,"column":4},"end":{"line":64,"column":null}},"26":{"start":{"line":63,"column":6},"end":{"line":63,"column":12}},"27":{"start":{"line":65,"column":4},"end":{"line":65,"column":9}},"28":{"start":{"line":66,"column":4},"end":{"line":66,"column":11}},"29":{"start":{"line":74,"column":4},"end":{"line":83,"column":null}},"30":{"start":{"line":80,"column":6},"end":{"line":80,"column":12}},"31":{"start":{"line":84,"column":4},"end":{"line":84,"column":9}},"32":{"start":{"line":85,"column":4},"end":{"line":85,"column":11}},"33":{"start":{"line":95,"column":4},"end":{"line":95,"column":22}},"34":{"start":{"line":95,"column":16},"end":{"line":95,"column":22}},"35":{"start":{"line":96,"column":4},"end":{"line":100,"column":null}},"36":{"start":{"line":97,"column":6},"end":{"line":97,"column":12}},"37":{"start":{"line":101,"column":4},"end":{"line":101,"column":9}},"38":{"start":{"line":104,"column":4},"end":{"line":104,"column":9}},"39":{"start":{"line":105,"column":4},"end":{"line":105,"column":27}},"40":{"start":{"line":105,"column":22},"end":{"line":105,"column":27}},"41":{"start":{"line":106,"column":4},"end":{"line":106,"column":11}},"42":{"start":{"line":114,"column":4},"end":{"line":114,"column":11}},"43":{"start":{"line":122,"column":4},"end":{"line":122,"column":11}},"44":{"start":{"line":130,"column":4},"end":{"line":130,"column":11}},"45":{"start":{"line":138,"column":4},"end":{"line":138,"column":11}},"46":{"start":{"line":147,"column":4},"end":{"line":147,"column":9}},"47":{"start":{"line":148,"column":4},"end":{"line":148,"column":11}},"48":{"start":{"line":151,"column":28},"end":{"line":151,"column":27}},"49":{"start":{"line":152,"column":18},"end":{"line":152,"column":null}},"50":{"start":{"line":158,"column":4},"end":{"line":160,"column":null}},"51":{"start":{"line":159,"column":6},"end":{"line":159,"column":13}},"52":{"start":{"line":161,"column":4},"end":{"line":161,"column":11}},"53":{"start":{"line":169,"column":36},"end":{"line":169,"column":null}},"54":{"start":{"line":170,"column":21},"end":{"line":170,"column":32}},"55":{"start":{"line":171,"column":21},"end":{"line":171,"column":null}},"56":{"start":{"line":172,"column":6},"end":{"line":175,"column":null}},"57":{"start":{"line":173,"column":21},"end":{"line":173,"column":26}},"58":{"start":{"line":174,"column":8},"end":{"line":174,"column":19}},"59":{"start":{"line":176,"column":6},"end":{"line":176,"column":32}},"60":{"start":{"line":176,"column":27},"end":{"line":176,"column":32}},"61":{"start":{"line":177,"column":6},"end":{"line":177,"column":11}},"62":{"start":{"line":178,"column":6},"end":{"line":178,"column":13}},"63":{"start":{"line":180,"column":4},"end":{"line":180,"column":11}},"64":{"start":{"line":182,"column":8},"end":{"line":182,"column":15}},"65":{"start":{"line":184,"column":11},"end":{"line":184,"column":12}},"66":{"start":{"line":191,"column":21},"end":{"line":191,"column":null}},"67":{"start":{"line":192,"column":23},"end":{"line":192,"column":27}},"68":{"start":{"line":204,"column":30},"end":{"line":228,"column":null}},"69":{"start":{"line":205,"column":6},"end":{"line":227,"column":null}},"70":{"start":{"line":206,"column":8},"end":{"line":206,"column":15}},"71":{"start":{"line":207,"column":13},"end":{"line":227,"column":null}},"72":{"start":{"line":208,"column":30},"end":{"line":208,"column":40}},"73":{"start":{"line":209,"column":12},"end":{"line":209,"column":null}},"74":{"start":{"line":210,"column":8},"end":{"line":216,"column":null}},"75":{"start":{"line":211,"column":10},"end":{"line":211,"column":28}},"76":{"start":{"line":212,"column":15},"end":{"line":216,"column":null}},"77":{"start":{"line":213,"column":10},"end":{"line":213,"column":28}},"78":{"start":{"line":215,"column":10},"end":{"line":215,"column":28}},"79":{"start":{"line":217,"column":23},"end":{"line":217,"column":null}},"80":{"start":{"line":218,"column":8},"end":{"line":218,"column":18}},"81":{"start":{"line":219,"column":8},"end":{"line":219,"column":15}},"82":{"start":{"line":221,"column":33},"end":{"line":221,"column":43}},"83":{"start":{"line":222,"column":23},"end":{"line":222,"column":null}},"84":{"start":{"line":223,"column":8},"end":{"line":223,"column":18}},"85":{"start":{"line":224,"column":8},"end":{"line":224,"column":18}},"86":{"start":{"line":225,"column":8},"end":{"line":225,"column":18}},"87":{"start":{"line":226,"column":8},"end":{"line":226,"column":15}},"88":{"start":{"line":236,"column":31},"end":{"line":242,"column":null}},"89":{"start":{"line":237,"column":6},"end":{"line":237,"column":51}},"90":{"start":{"line":237,"column":38},"end":{"line":237,"column":51}},"91":{"start":{"line":239,"column":31},"end":{"line":239,"column":42}},"92":{"start":{"line":239,"column":46},"end":{"line":239,"column":47}},"93":{"start":{"line":240,"column":6},"end":{"line":240,"column":12}},"94":{"start":{"line":241,"column":6},"end":{"line":241,"column":13}},"95":{"start":{"line":241,"column":43},"end":{"line":241,"column":44}},"96":{"start":{"line":250,"column":29},"end":{"line":271,"column":null}},"97":{"start":{"line":251,"column":6},"end":{"line":253,"column":null}},"98":{"start":{"line":252,"column":8},"end":{"line":252,"column":15}},"99":{"start":{"line":254,"column":6},"end":{"line":256,"column":null}},"100":{"start":{"line":255,"column":8},"end":{"line":255,"column":15}},"101":{"start":{"line":257,"column":26},"end":{"line":257,"column":31}},"102":{"start":{"line":258,"column":19},"end":{"line":258,"column":null}},"103":{"start":{"line":260,"column":6},"end":{"line":269,"column":null}},"104":{"start":{"line":260,"column":19},"end":{"line":260,"column":22}},"105":{"start":{"line":261,"column":20},"end":{"line":261,"column":32}},"106":{"start":{"line":262,"column":8},"end":{"line":268,"column":null}},"107":{"start":{"line":263,"column":10},"end":{"line":263,"column":19}},"108":{"start":{"line":264,"column":10},"end":{"line":264,"column":28}},"109":{"start":{"line":264,"column":22},"end":{"line":264,"column":28}},"110":{"start":{"line":266,"column":10},"end":{"line":266,"column":19}},"111":{"start":{"line":267,"column":10},"end":{"line":267,"column":29}},"112":{"start":{"line":267,"column":23},"end":{"line":267,"column":29}},"113":{"start":{"line":270,"column":6},"end":{"line":270,"column":13}},"114":{"start":{"line":278,"column":16},"end":{"line":280,"column":null}},"115":{"start":{"line":279,"column":6},"end":{"line":279,"column":13}},"116":{"start":{"line":287,"column":16},"end":{"line":289,"column":null}},"117":{"start":{"line":288,"column":6},"end":{"line":288,"column":13}},"118":{"start":{"line":296,"column":16},"end":{"line":298,"column":null}},"119":{"start":{"line":297,"column":6},"end":{"line":297,"column":13}},"120":{"start":{"line":305,"column":20},"end":{"line":321,"column":null}},"121":{"start":{"line":306,"column":24},"end":{"line":306,"column":29}},"122":{"start":{"line":307,"column":6},"end":{"line":320,"column":null}},"123":{"start":{"line":308,"column":8},"end":{"line":315,"column":null}},"124":{"start":{"line":309,"column":10},"end":{"line":309,"column":29}},"125":{"start":{"line":310,"column":10},"end":{"line":310,"column":17}},"126":{"start":{"line":312,"column":10},"end":{"line":312,"column":16}},"127":{"start":{"line":317,"column":8},"end":{"line":317,"column":15}},"128":{"start":{"line":318,"column":8},"end":{"line":318,"column":15}},"129":{"start":{"line":319,"column":8},"end":{"line":319,"column":15}},"130":{"start":{"line":327,"column":26},"end":{"line":336,"column":null}},"131":{"start":{"line":328,"column":6},"end":{"line":328,"column":17}},"132":{"start":{"line":330,"column":6},"end":{"line":332,"column":null}},"133":{"start":{"line":331,"column":8},"end":{"line":331,"column":19}},"134":{"start":{"line":333,"column":20},"end":{"line":333,"column":null}},"135":{"start":{"line":334,"column":6},"end":{"line":334,"column":11}},"136":{"start":{"line":335,"column":6},"end":{"line":335,"column":13}},"137":{"start":{"line":338,"column":4},"end":{"line":350,"column":null}},"138":{"start":{"line":339,"column":21},"end":{"line":339,"column":25}},"139":{"start":{"line":340,"column":6},"end":{"line":340,"column":13}},"140":{"start":{"line":341,"column":11},"end":{"line":350,"column":null}},"141":{"start":{"line":342,"column":21},"end":{"line":342,"column":25}},"142":{"start":{"line":343,"column":6},"end":{"line":343,"column":13}},"143":{"start":{"line":344,"column":11},"end":{"line":350,"column":null}},"144":{"start":{"line":345,"column":21},"end":{"line":345,"column":25}},"145":{"start":{"line":346,"column":6},"end":{"line":346,"column":13}},"146":{"start":{"line":348,"column":21},"end":{"line":348,"column":29}},"147":{"start":{"line":349,"column":6},"end":{"line":349,"column":13}}},"fnMap":{"0":{"name":"RuleSync","decl":{"start":{"line":21,"column":2},"end":{"line":21,"column":15}},"loc":{"start":{"line":21,"column":24},"end":{"line":44,"column":null}}},"1":{"name":"setPriority","decl":{"start":{"line":50,"column":15},"end":{"line":50,"column":25}},"loc":{"start":{"line":50,"column":25},"end":{"line":55,"column":null}}},"2":{"name":"setName","decl":{"start":{"line":61,"column":11},"end":{"line":61,"column":17}},"loc":{"start":{"line":61,"column":17},"end":{"line":67,"column":null}}},"3":{"name":"setConditions","decl":{"start":{"line":73,"column":17},"end":{"line":73,"column":29}},"loc":{"start":{"line":73,"column":29},"end":{"line":86,"column":null}}},"4":{"name":"setEvent","decl":{"start":{"line":94,"column":12},"end":{"line":94,"column":19}},"loc":{"start":{"line":94,"column":19},"end":{"line":107,"column":null}}},"5":{"name":"getEvent","decl":{"start":{"line":113,"column":14},"end":{"line":113,"column":null}},"loc":{"start":{"line":113,"column":14},"end":{"line":115,"column":null}}},"6":{"name":"getPriority","decl":{"start":{"line":121,"column":17},"end":{"line":121,"column":null}},"loc":{"start":{"line":121,"column":17},"end":{"line":123,"column":null}}},"7":{"name":"getConditions","decl":{"start":{"line":129,"column":19},"end":{"line":129,"column":null}},"loc":{"start":{"line":129,"column":19},"end":{"line":131,"column":null}}},"8":{"name":"getEngine","decl":{"start":{"line":137,"column":15},"end":{"line":137,"column":null}},"loc":{"start":{"line":137,"column":15},"end":{"line":139,"column":null}}},"9":{"name":"setEngine","decl":{"start":{"line":146,"column":13},"end":{"line":146,"column":21}},"loc":{"start":{"line":146,"column":21},"end":{"line":149,"column":null}}},"10":{"name":"toJSON","decl":{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},"loc":{"start":{"line":151,"column":28},"end":{"line":162,"column":null}}},"11":{"name":"prioritizeConditions","decl":{"start":{"line":169,"column":24},"end":{"line":169,"column":36}},"loc":{"start":{"line":169,"column":36},"end":{"line":185,"column":null}}},"12":{"name":"(anonymous_20)","decl":{"start":{"line":170,"column":39},"end":{"line":170,"column":40}},"loc":{"start":{"line":170,"column":60},"end":{"line":179,"column":7}}},"13":{"name":"(anonymous_21)","decl":{"start":{"line":181,"column":12},"end":{"line":181,"column":13}},"loc":{"start":{"line":181,"column":22},"end":{"line":183,"column":null}}},"14":{"name":"(anonymous_22)","decl":{"start":{"line":184,"column":11},"end":{"line":184,"column":12}},"loc":{"start":{"line":184,"column":11},"end":{"line":184,"column":12}}},"15":{"name":"evaluate","decl":{"start":{"line":191,"column":12},"end":{"line":191,"column":21}},"loc":{"start":{"line":191,"column":21},"end":{"line":351,"column":null}}},"16":{"name":"evaluateCondition","decl":{"start":{"line":204,"column":10},"end":{"line":204,"column":30}},"loc":{"start":{"line":204,"column":45},"end":{"line":228,"column":null}}},"17":{"name":"evaluateConditions","decl":{"start":{"line":236,"column":10},"end":{"line":236,"column":31}},"loc":{"start":{"line":236,"column":55},"end":{"line":242,"column":null}}},"18":{"name":"(anonymous_26)","decl":{"start":{"line":239,"column":46},"end":{"line":239,"column":47}},"loc":{"start":{"line":239,"column":46},"end":{"line":239,"column":47}}},"19":{"name":"(anonymous_27)","decl":{"start":{"line":241,"column":43},"end":{"line":241,"column":44}},"loc":{"start":{"line":241,"column":43},"end":{"line":241,"column":44}}},"20":{"name":"prioritizeAndRun","decl":{"start":{"line":250,"column":10},"end":{"line":250,"column":29}},"loc":{"start":{"line":250,"column":55},"end":{"line":271,"column":null}}},"21":{"name":"any","decl":{"start":{"line":278,"column":10},"end":{"line":278,"column":16}},"loc":{"start":{"line":278,"column":32},"end":{"line":280,"column":null}}},"22":{"name":"all","decl":{"start":{"line":287,"column":10},"end":{"line":287,"column":16}},"loc":{"start":{"line":287,"column":32},"end":{"line":289,"column":null}}},"23":{"name":"not","decl":{"start":{"line":296,"column":10},"end":{"line":296,"column":16}},"loc":{"start":{"line":296,"column":31},"end":{"line":298,"column":null}}},"24":{"name":"realize","decl":{"start":{"line":305,"column":10},"end":{"line":305,"column":20}},"loc":{"start":{"line":305,"column":44},"end":{"line":321,"column":null}}},"25":{"name":"processResult","decl":{"start":{"line":327,"column":10},"end":{"line":327,"column":26}},"loc":{"start":{"line":327,"column":38},"end":{"line":336,"column":null}}}},"branchMap":{"0":{"loc":{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},"type":"binary-expr","locations":[{"start":{"line":21,"column":24},"end":{"line":21,"column":null}},{"start":{"line":21,"column":24},"end":{"line":21,"column":null}}]},"1":{"loc":{"start":{"line":23,"column":4},"end":{"line":25,"column":null}},"type":"if","locations":[{"start":{"line":23,"column":4},"end":{"line":25,"column":null}}]},"2":{"loc":{"start":{"line":26,"column":4},"end":{"line":28,"column":null}},"type":"if","locations":[{"start":{"line":26,"column":4},"end":{"line":28,"column":null}}]},"3":{"loc":{"start":{"line":26,"column":8},"end":{"line":26,"column":39}},"type":"binary-expr","locations":[{"start":{"line":26,"column":8},"end":{"line":26,"column":19}},{"start":{"line":26,"column":19},"end":{"line":26,"column":39}}]},"4":{"loc":{"start":{"line":29,"column":4},"end":{"line":31,"column":null}},"type":"if","locations":[{"start":{"line":29,"column":4},"end":{"line":31,"column":null}}]},"5":{"loc":{"start":{"line":29,"column":8},"end":{"line":29,"column":38}},"type":"binary-expr","locations":[{"start":{"line":29,"column":8},"end":{"line":29,"column":19}},{"start":{"line":29,"column":19},"end":{"line":29,"column":38}}]},"6":{"loc":{"start":{"line":32,"column":4},"end":{"line":34,"column":null}},"type":"if","locations":[{"start":{"line":32,"column":4},"end":{"line":34,"column":null}}]},"7":{"loc":{"start":{"line":32,"column":8},"end":{"line":32,"column":38}},"type":"binary-expr","locations":[{"start":{"line":32,"column":8},"end":{"line":32,"column":19}},{"start":{"line":32,"column":19},"end":{"line":32,"column":38}}]},"8":{"loc":{"start":{"line":35,"column":4},"end":{"line":37,"column":null}},"type":"if","locations":[{"start":{"line":35,"column":4},"end":{"line":37,"column":null}}]},"9":{"loc":{"start":{"line":35,"column":8},"end":{"line":35,"column":20}},"type":"binary-expr","locations":[{"start":{"line":35,"column":8},"end":{"line":35,"column":20}},{"start":{"line":35,"column":20},"end":{"line":35,"column":36}},{"start":{"line":35,"column":36},"end":{"line":35,"column":57}}]},"10":{"loc":{"start":{"line":39,"column":22},"end":{"line":39,"column":null}},"type":"binary-expr","locations":[{"start":{"line":39,"column":22},"end":{"line":39,"column":33}},{"start":{"line":39,"column":33},"end":{"line":39,"column":54}},{"start":{"line":39,"column":54},"end":{"line":39,"column":null}}]},"11":{"loc":{"start":{"line":42,"column":19},"end":{"line":42,"column":50}},"type":"binary-expr","locations":[{"start":{"line":42,"column":19},"end":{"line":42,"column":30}},{"start":{"line":42,"column":30},"end":{"line":42,"column":48}},{"start":{"line":42,"column":48},"end":{"line":42,"column":50}}]},"12":{"loc":{"start":{"line":52,"column":4},"end":{"line":52,"column":29}},"type":"if","locations":[{"start":{"line":52,"column":4},"end":{"line":52,"column":29}}]},"13":{"loc":{"start":{"line":62,"column":4},"end":{"line":64,"column":null}},"type":"if","locations":[{"start":{"line":62,"column":4},"end":{"line":64,"column":null}}]},"14":{"loc":{"start":{"line":62,"column":8},"end":{"line":62,"column":29}},"type":"binary-expr","locations":[{"start":{"line":62,"column":8},"end":{"line":62,"column":17}},{"start":{"line":62,"column":17},"end":{"line":62,"column":29}}]},"15":{"loc":{"start":{"line":74,"column":4},"end":{"line":83,"column":null}},"type":"if","locations":[{"start":{"line":74,"column":4},"end":{"line":83,"column":null}}]},"16":{"loc":{"start":{"line":75,"column":6},"end":{"line":78,"column":14}},"type":"binary-expr","locations":[{"start":{"line":75,"column":6},"end":{"line":75,"column":14}},{"start":{"line":76,"column":6},"end":{"line":76,"column":14}},{"start":{"line":77,"column":6},"end":{"line":77,"column":14}},{"start":{"line":78,"column":6},"end":{"line":78,"column":14}}]},"17":{"loc":{"start":{"line":95,"column":4},"end":{"line":95,"column":22}},"type":"if","locations":[{"start":{"line":95,"column":4},"end":{"line":95,"column":22}}]},"18":{"loc":{"start":{"line":96,"column":4},"end":{"line":100,"column":null}},"type":"if","locations":[{"start":{"line":96,"column":4},"end":{"line":100,"column":null}}]},"19":{"loc":{"start":{"line":105,"column":4},"end":{"line":105,"column":27}},"type":"if","locations":[{"start":{"line":105,"column":4},"end":{"line":105,"column":27}}]},"20":{"loc":{"start":{"line":151,"column":28},"end":{"line":151,"column":27}},"type":"cond-expr","locations":[{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},{"start":{"line":151,"column":22},"end":{"line":151,"column":28}}]},"21":{"loc":{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},"type":"binary-expr","locations":[{"start":{"line":151,"column":28},"end":{"line":151,"column":null}},{"start":{"line":151,"column":28},"end":{"line":151,"column":null}}]},"22":{"loc":{"start":{"line":158,"column":4},"end":{"line":160,"column":null}},"type":"if","locations":[{"start":{"line":158,"column":4},"end":{"line":160,"column":null}}]},"23":{"loc":{"start":{"line":172,"column":6},"end":{"line":175,"column":null}},"type":"if","locations":[{"start":{"line":172,"column":6},"end":{"line":175,"column":null}}]},"24":{"loc":{"start":{"line":174,"column":20},"end":{"line":174,"column":null}},"type":"binary-expr","locations":[{"start":{"line":174,"column":20},"end":{"line":174,"column":28}},{"start":{"line":174,"column":28},"end":{"line":174,"column":46}},{"start":{"line":174,"column":46},"end":{"line":174,"column":null}}]},"25":{"loc":{"start":{"line":176,"column":6},"end":{"line":176,"column":32}},"type":"if","locations":[{"start":{"line":176,"column":6},"end":{"line":176,"column":32}}]},"26":{"loc":{"start":{"line":182,"column":15},"end":{"line":182,"column":null}},"type":"cond-expr","locations":[{"start":{"line":182,"column":39},"end":{"line":182,"column":44}},{"start":{"line":182,"column":44},"end":{"line":182,"column":null}}]},"27":{"loc":{"start":{"line":205,"column":6},"end":{"line":227,"column":null}},"type":"if","locations":[{"start":{"line":205,"column":6},"end":{"line":227,"column":null}},{"start":{"line":207,"column":13},"end":{"line":227,"column":null}}]},"28":{"loc":{"start":{"line":207,"column":13},"end":{"line":227,"column":null}},"type":"if","locations":[{"start":{"line":207,"column":13},"end":{"line":227,"column":null}},{"start":{"line":220,"column":13},"end":{"line":227,"column":null}}]},"29":{"loc":{"start":{"line":210,"column":8},"end":{"line":216,"column":null}},"type":"if","locations":[{"start":{"line":210,"column":8},"end":{"line":216,"column":null}},{"start":{"line":212,"column":15},"end":{"line":216,"column":null}}]},"30":{"loc":{"start":{"line":212,"column":15},"end":{"line":216,"column":null}},"type":"if","locations":[{"start":{"line":212,"column":15},"end":{"line":216,"column":null}},{"start":{"line":214,"column":15},"end":{"line":216,"column":null}}]},"31":{"loc":{"start":{"line":237,"column":6},"end":{"line":237,"column":51}},"type":"if","locations":[{"start":{"line":237,"column":6},"end":{"line":237,"column":51}}]},"32":{"loc":{"start":{"line":251,"column":6},"end":{"line":253,"column":null}},"type":"if","locations":[{"start":{"line":251,"column":6},"end":{"line":253,"column":null}}]},"33":{"loc":{"start":{"line":254,"column":6},"end":{"line":256,"column":null}},"type":"if","locations":[{"start":{"line":254,"column":6},"end":{"line":256,"column":null}}]},"34":{"loc":{"start":{"line":262,"column":8},"end":{"line":268,"column":null}},"type":"if","locations":[{"start":{"line":262,"column":8},"end":{"line":268,"column":null}},{"start":{"line":265,"column":15},"end":{"line":268,"column":null}}]},"35":{"loc":{"start":{"line":263,"column":19},"end":{"line":263,"column":48}},"type":"binary-expr","locations":[{"start":{"line":263,"column":19},"end":{"line":263,"column":29}},{"start":{"line":263,"column":29},"end":{"line":263,"column":48}}]},"36":{"loc":{"start":{"line":264,"column":10},"end":{"line":264,"column":28}},"type":"if","locations":[{"start":{"line":264,"column":10},"end":{"line":264,"column":28}}]},"37":{"loc":{"start":{"line":266,"column":19},"end":{"line":266,"column":48}},"type":"binary-expr","locations":[{"start":{"line":266,"column":19},"end":{"line":266,"column":29}},{"start":{"line":266,"column":29},"end":{"line":266,"column":48}}]},"38":{"loc":{"start":{"line":267,"column":10},"end":{"line":267,"column":29}},"type":"if","locations":[{"start":{"line":267,"column":10},"end":{"line":267,"column":29}}]},"39":{"loc":{"start":{"line":307,"column":6},"end":{"line":320,"column":null}},"type":"if","locations":[{"start":{"line":307,"column":6},"end":{"line":320,"column":null}},{"start":{"line":316,"column":13},"end":{"line":320,"column":null}}]},"40":{"loc":{"start":{"line":308,"column":8},"end":{"line":315,"column":null}},"type":"if","locations":[{"start":{"line":308,"column":8},"end":{"line":315,"column":null}},{"start":{"line":311,"column":15},"end":{"line":315,"column":null}}]},"41":{"loc":{"start":{"line":330,"column":6},"end":{"line":332,"column":null}},"type":"if","locations":[{"start":{"line":330,"column":6},"end":{"line":332,"column":null}}]},"42":{"loc":{"start":{"line":333,"column":20},"end":{"line":333,"column":null}},"type":"cond-expr","locations":[{"start":{"line":333,"column":29},"end":{"line":333,"column":41}},{"start":{"line":333,"column":41},"end":{"line":333,"column":null}}]},"43":{"loc":{"start":{"line":338,"column":4},"end":{"line":350,"column":null}},"type":"if","locations":[{"start":{"line":338,"column":4},"end":{"line":350,"column":null}},{"start":{"line":341,"column":11},"end":{"line":350,"column":null}}]},"44":{"loc":{"start":{"line":341,"column":11},"end":{"line":350,"column":null}},"type":"if","locations":[{"start":{"line":341,"column":11},"end":{"line":350,"column":null}},{"start":{"line":344,"column":11},"end":{"line":350,"column":null}}]},"45":{"loc":{"start":{"line":344,"column":11},"end":{"line":350,"column":null}},"type":"if","locations":[{"start":{"line":344,"column":11},"end":{"line":350,"column":null}},{"start":{"line":347,"column":11},"end":{"line":350,"column":null}}]}},"s":{"0":1,"1":1,"2":1,"3":1,"4":1,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0,"37":0,"38":0,"39":0,"40":0,"41":0,"42":0,"43":0,"44":0,"45":0,"46":0,"47":0,"48":0,"49":0,"50":0,"51":0,"52":0,"53":0,"54":0,"55":0,"56":0,"57":0,"58":0,"59":0,"60":0,"61":0,"62":0,"63":0,"64":0,"65":0,"66":0,"67":0,"68":0,"69":0,"70":0,"71":0,"72":0,"73":0,"74":0,"75":0,"76":0,"77":0,"78":0,"79":0,"80":0,"81":0,"82":0,"83":0,"84":0,"85":0,"86":0,"87":0,"88":0,"89":0,"90":0,"91":0,"92":0,"93":0,"94":0,"95":0,"96":0,"97":0,"98":0,"99":0,"100":0,"101":0,"102":0,"103":0,"104":0,"105":0,"106":0,"107":0,"108":0,"109":0,"110":0,"111":0,"112":0,"113":0,"114":0,"115":0,"116":0,"117":0,"118":0,"119":0,"120":0,"121":0,"122":0,"123":0,"124":0,"125":0,"126":0,"127":0,"128":0,"129":0,"130":0,"131":0,"132":0,"133":0,"134":0,"135":0,"136":0,"137":0,"138":0,"139":0,"140":0,"141":0,"142":0,"143":0,"144":0,"145":0,"146":0,"147":0},"f":{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0,"13":0,"14":0,"15":0,"16":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":0,"24":0,"25":0},"b":{"0":[0,0],"1":[0],"2":[0],"3":[0,0],"4":[0],"5":[0,0],"6":[0],"7":[0,0],"8":[0],"9":[0,0,0],"10":[0,0,0],"11":[0,0,0],"12":[0],"13":[0],"14":[0,0],"15":[0],"16":[0,0,0,0],"17":[0],"18":[0],"19":[0],"20":[0,0],"21":[0,0],"22":[0],"23":[0],"24":[0,0,0],"25":[0],"26":[0,0],"27":[0,0],"28":[0,0],"29":[0,0],"30":[0,0],"31":[0],"32":[0],"33":[0],"34":[0,0],"35":[0,0],"36":[0],"37":[0,0],"38":[0],"39":[0,0],"40":[0,0],"41":[0],"42":[0,0],"43":[0,0],"44":[0,0],"45":[0,0]}} +} diff --git a/src/optimized/almanac-fast.js b/src/optimized/almanac-fast.js new file mode 100644 index 0000000..4963a9e --- /dev/null +++ b/src/optimized/almanac-fast.js @@ -0,0 +1,189 @@ +'use strict' + +import Fact from '../fact' +import { UndefinedFactError } from '../errors' +import debug from '../debug' +import { JSONPath } from 'jsonpath-plus' + +function defaultPathResolver (value, path) { + return JSONPath({ path, json: value, wrap: false }) +} + +/** + * Optimized fact results lookup with fast-path for cache hits and constants + */ +export default class AlmanacFast { + constructor (options = {}) { + this.factMap = new Map() + this.factResultsCache = new Map() // { cacheKey: actualValue } - no Promise wrapping + this.factPromiseCache = new Map() // { cacheKey: Promise } - only for truly async facts + this.pathCache = new Map() // Pre-compiled JSONPath expressions + this.allowUndefinedFacts = Boolean(options.allowUndefinedFacts) + this.pathResolver = options.pathResolver || defaultPathResolver + this.events = { success: [], failure: [] } + this.ruleResults = [] + } + + addEvent (event, outcome) { + if (!outcome) throw new Error('outcome required: "success" | "failure"]') + this.events[outcome].push(event) + } + + getEvents (outcome = '') { + if (outcome) return this.events[outcome] + return this.events.success.concat(this.events.failure) + } + + addResult (ruleResult) { + this.ruleResults.push(ruleResult) + } + + getResults () { + return this.ruleResults + } + + _getFact (factId) { + return this.factMap.get(factId) + } + + _addConstantFact (fact) { + this.factMap.set(fact.id, fact) + // Store actual value, not Promise + this._setFactValue(fact, {}, fact.value) + } + + /** + * Optimized fact value setting - stores actual values for sync access + */ + _setFactValue (fact, params, value) { + const cacheKey = fact.getCacheKey(params) + if (cacheKey) { + // Check if value is a Promise + if (value && typeof value.then === 'function') { + this.factPromiseCache.set(cacheKey, value) + return value.then(resolvedValue => { + this.factResultsCache.set(cacheKey, resolvedValue) + this.factPromiseCache.delete(cacheKey) + return resolvedValue + }) + } else { + // Direct value storage for sync facts + this.factResultsCache.set(cacheKey, value) + return Promise.resolve(value) + } + } + return Promise.resolve(value) + } + + addFact (id, valueOrMethod, options) { + let factId = id + let fact + if (id instanceof Fact) { + factId = id.id + fact = id + } else { + fact = new Fact(id, valueOrMethod, options) + } + debug('almanac::addFact', { id: factId }) + this.factMap.set(factId, fact) + if (fact.isConstant()) { + this._setFactValue(fact, {}, fact.value) + } + return this + } + + addRuntimeFact (factId, value) { + debug('almanac::addRuntimeFact', { id: factId }) + const fact = new Fact(factId, value) + return this._addConstantFact(fact) + } + + /** + * Optimized fact value resolution with fast-path for cache hits + */ + factValue (factId, params = {}, path = '') { + const fact = this._getFact(factId) + if (fact === undefined) { + if (this.allowUndefinedFacts) { + return Promise.resolve(undefined) + } else { + return Promise.reject(new UndefinedFactError(`Undefined fact: ${factId}`)) + } + } + + let factValuePromise + if (fact.isConstant()) { + // Fast path for constants + const value = fact.calculate(params, this) + factValuePromise = Promise.resolve(value) + } else { + const cacheKey = fact.getCacheKey(params) + + // Fast path for cache hits - return actual value directly + const cachedValue = cacheKey && this.factResultsCache.get(cacheKey) + if (cachedValue !== undefined) { + debug('almanac::factValue cache hit for fact', { id: factId }) + factValuePromise = Promise.resolve(cachedValue) + } else { + // Check if there's a pending Promise for this fact + const pendingPromise = cacheKey && this.factPromiseCache.get(cacheKey) + if (pendingPromise) { + factValuePromise = pendingPromise + } else { + debug('almanac::factValue cache miss, calculating', { id: factId }) + factValuePromise = this._setFactValue(fact, params, fact.calculate(params, this)) + } + } + } + + if (path) { + return this._applyPath(factValuePromise, path) + } + + return factValuePromise + } + + /** + * Optimized path resolution with caching + */ + _applyPath (factValuePromise, path) { + return factValuePromise.then(factValue => { + if (factValue != null && typeof factValue === 'object') { + // Cache compiled path expressions + let compiledPath = this.pathCache.get(path) + if (!compiledPath) { + compiledPath = { path, json: null, wrap: false } + this.pathCache.set(path, compiledPath) + } + + compiledPath.json = factValue + const pathValue = JSONPath(compiledPath) + debug('condition::evaluate extracting object', { property: path, received: pathValue }) + return pathValue + } else { + debug('condition::evaluate could not compute object path of non-object', { path, factValue, type: typeof factValue }) + return factValue + } + }) + } + + /** + * Optimized value resolution - fast path for primitives + */ + getValue (value) { + if (value != null && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, 'fact')) { + return this.factValue(value.fact, value.params, value.path) + } + return Promise.resolve(value) + } + + /** + * Batch resolve multiple fact values efficiently + */ + batchFactValues (requests) { + const promises = requests.map(({ factId, params, path }) => + this.factValue(factId, params, path) + ) + return Promise.all(promises) + } +} diff --git a/src/optimized/condition-fast.js b/src/optimized/condition-fast.js new file mode 100644 index 0000000..9f42bb5 --- /dev/null +++ b/src/optimized/condition-fast.js @@ -0,0 +1,228 @@ +'use strict' + +import debug from '../debug' + +export default class ConditionFast { + constructor (properties) { + if (!properties) throw new Error('Condition: constructor options required') + const booleanOperator = ConditionFast.booleanOperator(properties) + Object.assign(this, properties) + if (booleanOperator) { + const subConditions = properties[booleanOperator] + const subConditionsIsArray = Array.isArray(subConditions) + if (booleanOperator !== 'not' && !subConditionsIsArray) { throw new Error(`"${booleanOperator}" must be an array`) } + if (booleanOperator === 'not' && subConditionsIsArray) { throw new Error(`"${booleanOperator}" cannot be an array`) } + this.operator = booleanOperator + this.priority = parseInt(properties.priority, 10) || 1 + if (subConditionsIsArray) { + this[booleanOperator] = subConditions.map((c) => new ConditionFast(c)) + } else { + this[booleanOperator] = new ConditionFast(subConditions) + } + } else if (!Object.prototype.hasOwnProperty.call(properties, 'condition')) { + if (!Object.prototype.hasOwnProperty.call(properties, 'fact')) { throw new Error('Condition: constructor "fact" property required') } + if (!Object.prototype.hasOwnProperty.call(properties, 'operator')) { throw new Error('Condition: constructor "operator" property required') } + if (!Object.prototype.hasOwnProperty.call(properties, 'value')) { throw new Error('Condition: constructor "value" property required') } + + if (Object.prototype.hasOwnProperty.call(properties, 'priority')) { + properties.priority = parseInt(properties.priority, 10) + } + } + } + + toJSON (stringify = true) { + const props = {} + if (this.priority) { + props.priority = this.priority + } + if (this.name) { + props.name = this.name + } + const oper = ConditionFast.booleanOperator(this) + if (oper) { + if (Array.isArray(this[oper])) { + props[oper] = this[oper].map((c) => c.toJSON(false)) + } else { + props[oper] = this[oper].toJSON(false) + } + } else if (this.isConditionReference()) { + props.condition = this.condition + } else { + props.operator = this.operator + props.value = this.value + props.fact = this.fact + if (this.factResult !== undefined) { + props.factResult = this.factResult + } + if (this.valueResult !== undefined) { + props.valueResult = this.valueResult + } + if (this.result !== undefined) { + props.result = this.result + } + if (this.params) { + props.params = this.params + } + if (this.path) { + props.path = this.path + } + } + if (stringify) { + return JSON.stringify(props) + } + return props + } + + /** + * Optimized condition evaluation with fast-path for constants + */ + evaluate (almanac, operatorMap) { + if (!almanac) return Promise.reject(new Error('almanac required')) + if (!operatorMap) return Promise.reject(new Error('operatorMap required')) + if (this.isBooleanOperator()) { return Promise.reject(new Error('Cannot evaluate() a boolean condition')) } + + const op = operatorMap.get(this.operator) + if (!op) { return Promise.reject(new Error(`Unknown operator: ${this.operator}`)) } + + // Fast path optimization: check if value is a constant (not a fact reference) + const isValueConstant = !(this.value != null && typeof this.value === 'object' && + Object.prototype.hasOwnProperty.call(this.value, 'fact')) + + if (isValueConstant) { + // Fast path: value is constant, only need to resolve fact + return almanac.factValue(this.fact, this.params, this.path) + .then(leftHandSideValue => { + const result = op.evaluate(leftHandSideValue, this.value) + debug('condition::evaluate', { + leftHandSideValue, + operator: this.operator, + rightHandSideValue: this.value, + result + }) + return { + result, + leftHandSideValue, + rightHandSideValue: this.value, + operator: this.operator + } + }) + } else { + // Original path: both fact and value need resolution + return Promise.all([ + almanac.getValue(this.value), + almanac.factValue(this.fact, this.params, this.path) + ]).then(([rightHandSideValue, leftHandSideValue]) => { + const result = op.evaluate(leftHandSideValue, rightHandSideValue) + debug('condition::evaluate', { + leftHandSideValue, + operator: this.operator, + rightHandSideValue, + result + }) + return { + result, + leftHandSideValue, + rightHandSideValue, + operator: this.operator + } + }) + } + } + + /** + * Optimized boolean evaluation with smart short-circuiting + */ + evaluateBooleanCondition (almanac, operatorMap) { + if (!this.isBooleanOperator()) { + return Promise.reject(new Error('evaluateBooleanCondition() can only evaluate boolean conditions')) + } + + const operator = this.booleanOperator() + const conditions = this[operator] + + debug('condition::evaluateBooleanCondition', { operator }) + + if (operator === 'not') { + if (conditions.isBooleanOperator()) { + return conditions.evaluateBooleanCondition(almanac, operatorMap) + .then(result => !result) + } else { + return conditions.evaluate(almanac, operatorMap) + .then(result => !result.result) + } + } + + // Smart short-circuiting for 'any' and 'all' + if (operator === 'any') { + // Short-circuit on first true result + const evaluateNext = (index) => { + if (index >= conditions.length) { + return Promise.resolve(false) + } + + const condition = conditions[index] + const evaluation = condition.isBooleanOperator() + ? condition.evaluateBooleanCondition(almanac, operatorMap) + : condition.evaluate(almanac, operatorMap) + + return evaluation.then(result => { + const isTrue = result === true || (result && result.result === true) + if (isTrue) { + debug('condition::any short-circuit success') + return true + } + return evaluateNext(index + 1) + }) + } + return evaluateNext(0) + } + + if (operator === 'all') { + // Short-circuit on first false result + const evaluateNext = (index) => { + if (index >= conditions.length) { + return Promise.resolve(true) + } + + const condition = conditions[index] + const evaluation = condition.isBooleanOperator() + ? condition.evaluateBooleanCondition(almanac, operatorMap) + : condition.evaluate(almanac, operatorMap) + + return evaluation.then(result => { + const isFalse = result === false || (result && result.result === false) + if (isFalse) { + debug('condition::all short-circuit failure') + return false + } + return evaluateNext(index + 1) + }) + } + return evaluateNext(0) + } + + return Promise.reject(new Error(`Unknown boolean operator: ${operator}`)) + } + + static booleanOperator (condition) { + if (Object.prototype.hasOwnProperty.call(condition, 'any')) { + return 'any' + } else if (Object.prototype.hasOwnProperty.call(condition, 'all')) { + return 'all' + } else if (Object.prototype.hasOwnProperty.call(condition, 'not')) { + return 'not' + } + } + + booleanOperator () { + return ConditionFast.booleanOperator(this) + } + + isBooleanOperator () { + return ConditionFast.booleanOperator(this) !== undefined + } + + isConditionReference () { + return Object.prototype.hasOwnProperty.call(this, 'condition') + } +} diff --git a/src/optimized/engine-fast.js b/src/optimized/engine-fast.js new file mode 100644 index 0000000..2e3d6cd --- /dev/null +++ b/src/optimized/engine-fast.js @@ -0,0 +1,266 @@ +'use strict' + +import Fact from '../fact' +import RuleFast from './rule-fast' +import AlmanacFast from './almanac-fast' +import EventEmitter from 'eventemitter2' +import defaultOperators from '../engine-default-operators' +import defaultDecorators from '../engine-default-operator-decorators' +import debug from '../debug' +import ConditionFast from './condition-fast' +import OperatorMap from '../operator-map' + +export const READY = 'READY' +export const RUNNING = 'RUNNING' +export const FINISHED = 'FINISHED' + +class EngineFast extends EventEmitter { + /** + * Returns a new optimized Engine instance with performance enhancements + * @param {Rule[]} rules - array of rules to initialize with + * @param {Object} options - engine configuration options + */ + constructor (rules = [], options = {}) { + super() + this.rules = [] + this.allowUndefinedFacts = options.allowUndefinedFacts || false + this.allowUndefinedConditions = options.allowUndefinedConditions || false + this.replaceFactsInEventParams = options.replaceFactsInEventParams || false + this.pathResolver = options.pathResolver + this.operators = new OperatorMap() + this.facts = new Map() + this.conditions = new Map() + this.status = READY + rules.map(r => this.addRule(r)) + defaultOperators.map(o => this.addOperator(o)) + defaultDecorators.map(d => this.addOperatorDecorator(d)) + } + + addRule (properties) { + if (!properties) throw new Error('Engine: addRule() requires options') + + let rule + if (properties instanceof RuleFast) { + rule = properties + } else { + if (!Object.prototype.hasOwnProperty.call(properties, 'event')) throw new Error('Engine: addRule() argument requires "event" property') + if (!Object.prototype.hasOwnProperty.call(properties, 'conditions')) throw new Error('Engine: addRule() argument requires "conditions" property') + rule = new RuleFast(properties) + } + rule.setEngine(this) + this.rules.push(rule) + this.prioritizedRules = null + return this + } + + updateRule (rule) { + const ruleIndex = this.rules.findIndex(ruleInEngine => ruleInEngine.name === rule.name) + if (ruleIndex > -1) { + this.rules.splice(ruleIndex, 1) + this.addRule(rule) + this.prioritizedRules = null + } else { + throw new Error('Engine: updateRule() rule not found') + } + } + + removeRule (rule) { + let ruleRemoved = false + if (!(rule instanceof RuleFast)) { + const filteredRules = this.rules.filter(ruleInEngine => ruleInEngine.name !== rule) + ruleRemoved = filteredRules.length !== this.rules.length + this.rules = filteredRules + } else { + const index = this.rules.indexOf(rule) + if (index > -1) { + ruleRemoved = Boolean(this.rules.splice(index, 1).length) + } + } + if (ruleRemoved) { + this.prioritizedRules = null + } + return ruleRemoved + } + + setCondition (name, conditions) { + if (!name) throw new Error('Engine: setCondition() requires name') + if (!conditions) throw new Error('Engine: setCondition() requires conditions') + if (!Object.prototype.hasOwnProperty.call(conditions, 'all') && !Object.prototype.hasOwnProperty.call(conditions, 'any') && !Object.prototype.hasOwnProperty.call(conditions, 'not') && !Object.prototype.hasOwnProperty.call(conditions, 'condition')) { + throw new Error('"conditions" root must contain a single instance of "all", "any", "not", or "condition"') + } + this.conditions.set(name, new ConditionFast(conditions)) + return this + } + + removeCondition (name) { + return this.conditions.delete(name) + } + + addOperator (operatorOrName, cb) { + this.operators.addOperator(operatorOrName, cb) + } + + removeOperator (operatorOrName) { + return this.operators.removeOperator(operatorOrName) + } + + addOperatorDecorator (decoratorOrName, cb) { + this.operators.addOperatorDecorator(decoratorOrName, cb) + } + + removeOperatorDecorator (decoratorOrName) { + return this.operators.removeOperatorDecorator(decoratorOrName) + } + + addFact (id, valueOrMethod, options) { + let factId = id + let fact + if (id instanceof Fact) { + factId = id.id + fact = id + } else { + fact = new Fact(id, valueOrMethod, options) + } + debug('engine::addFact', { id: factId }) + this.facts.set(factId, fact) + return this + } + + removeFact (factOrId) { + let factId + if (!(factOrId instanceof Fact)) { + factId = factOrId + } else { + factId = factOrId.id + } + return this.facts.delete(factId) + } + + prioritizeRules () { + if (!this.prioritizedRules) { + const ruleSets = this.rules.reduce((sets, rule) => { + const priority = rule.priority + if (!sets[priority]) sets[priority] = [] + sets[priority].push(rule) + return sets + }, {}) + this.prioritizedRules = Object.keys(ruleSets).sort((a, b) => { + return Number(a) > Number(b) ? -1 : 1 + }).map((priority) => ruleSets[priority]) + } + return this.prioritizedRules + } + + stop () { + this.status = FINISHED + return this + } + + getFact (factId) { + return this.facts.get(factId) + } + + /** + * Optimized parallel rule evaluation with better async handling + * @param {Rule[]} array of rules to be evaluated + * @return {Promise} resolves when all rules in the array have been evaluated + */ + evaluateRules (ruleArray, almanac) { + return Promise.all(ruleArray.map((rule) => { + if (this.status !== RUNNING) { + debug('engine::run, skipping remaining rules', { status: this.status }) + return Promise.resolve() + } + + return rule.evaluate(almanac).then((ruleResult) => { + debug('engine::run', { ruleResult: ruleResult.result }) + almanac.addResult(ruleResult) + + if (ruleResult.result) { + almanac.addEvent(ruleResult.event, 'success') + return this.emitAsync('success', ruleResult.event, almanac, ruleResult) + .then(() => this.emitAsync(ruleResult.event.type, ruleResult.event.params, almanac, ruleResult)) + } else { + almanac.addEvent(ruleResult.event, 'failure') + return this.emitAsync('failure', ruleResult.event, almanac, ruleResult) + } + }).catch(error => { + debug('engine::evaluateRules error', { error: error.message }) + throw error + }) + })) + } + + /** + * Optimized engine run with better async flow and caching + * @param {Object} runtimeFacts - fact values known at runtime + * @param {Object} runOptions - run options + * @return {Promise} resolves when the engine has completed running + */ + run (runtimeFacts = {}, runOptions = {}) { + debug('engine::run started') + this.status = RUNNING + + // Use optimized almanac + const almanac = runOptions.almanac || new AlmanacFast({ + allowUndefinedFacts: this.allowUndefinedFacts, + pathResolver: this.pathResolver + }) + + // Add engine facts to almanac + this.facts.forEach(fact => { + almanac.addFact(fact) + }) + + // Add runtime facts + for (const factId in runtimeFacts) { + let fact + if (runtimeFacts[factId] instanceof Fact) { + fact = runtimeFacts[factId] + } else { + fact = new Fact(factId, runtimeFacts[factId]) + } + almanac.addFact(fact) + debug('engine::run initialized runtime fact', { id: fact.id, value: fact.value, type: typeof fact.value }) + } + + const orderedSets = this.prioritizeRules() + let cursor = Promise.resolve() + + // Optimized priority set processing with better error handling + return new Promise((resolve, reject) => { + orderedSets.map((set) => { + cursor = cursor.then(() => { + if (this.status !== RUNNING) { + debug('engine::run, stopping due to status change', { status: this.status }) + return Promise.resolve() + } + return this.evaluateRules(set, almanac) + }).catch(reject) + return cursor + }) + + cursor.then(() => { + this.status = FINISHED + debug('engine::run completed') + + const ruleResults = almanac.getResults() + const { results, failureResults } = ruleResults.reduce((hash, ruleResult) => { + const group = ruleResult.result ? 'results' : 'failureResults' + hash[group].push(ruleResult) + return hash + }, { results: [], failureResults: [] }) + + resolve({ + almanac, + results, + failureResults, + events: almanac.getEvents('success'), + failureEvents: almanac.getEvents('failure') + }) + }).catch(reject) + }) + } +} + +export default EngineFast diff --git a/src/optimized/rule-fast.js b/src/optimized/rule-fast.js new file mode 100644 index 0000000..231655b --- /dev/null +++ b/src/optimized/rule-fast.js @@ -0,0 +1,221 @@ +'use strict' + +import ConditionFast from './condition-fast' +import RuleResult from '../rule-result' +import deepClone from 'clone' +import EventEmitter from 'eventemitter2' + +class RuleFast extends EventEmitter { + /** + * returns a new RuleFast instance - optimized for performance + * @param {object,string} options, or json string that can be parsed into options + * @param {integer} options.priority (>1) - higher runs sooner. + * @param {Object} options.event - event to fire when rule evaluates as successful + * @param {string} options.event.type - name of event to emit + * @param {string} options.event.params - parameters to pass to the event listener + * @param {Object} options.conditions - conditions to evaluate when processing this rule + * @param {any} options.name - identifier for a particular rule, particularly valuable in RuleResult output + * @return {RuleFast} instance + */ + constructor (options) { + super() + if (typeof options === 'string') { + options = JSON.parse(options) + } + if (options && options.conditions) { + this.setConditions(options.conditions) + } + if (options && options.onSuccess) { + this.on('success', options.onSuccess) + } + if (options && options.onFailure) { + this.on('failure', options.onFailure) + } + if (options && (options.name || options.name === 0)) { + this.setName(options.name) + } + + const priority = (options && options.priority) || 1 + this.setPriority(priority) + + const event = (options && options.event) || { type: 'unknown' } + this.setEvent(event) + } + + setPriority (priority) { + priority = parseInt(priority, 10) + if (priority <= 0) throw new Error('Priority must be greater than zero') + this.priority = priority + return this + } + + setName (name) { + if (!name && name !== 0) { + throw new Error('Rule "name" must be defined') + } + this.name = name + return this + } + + setConditions (conditions) { + if ( + !Object.prototype.hasOwnProperty.call(conditions, 'all') && + !Object.prototype.hasOwnProperty.call(conditions, 'any') && + !Object.prototype.hasOwnProperty.call(conditions, 'not') && + !Object.prototype.hasOwnProperty.call(conditions, 'condition') + ) { + throw new Error( + '"conditions" root must contain a single instance of "all", "any", "not", or "condition"' + ) + } + this.conditions = new ConditionFast(conditions) + return this + } + + setEvent (event) { + if (!event) throw new Error('Rule: setEvent() requires event object') + if (!Object.prototype.hasOwnProperty.call(event, 'type')) { + throw new Error( + 'Rule: setEvent() requires event object with "type" property' + ) + } + this.ruleEvent = { + type: event.type + } + this.event = this.ruleEvent + if (event.params) this.ruleEvent.params = event.params + return this + } + + getEvent () { + return this.ruleEvent + } + + getPriority () { + return this.priority + } + + getConditions () { + return this.conditions + } + + getEngine () { + return this.engine + } + + setEngine (engine) { + this.engine = engine + return this + } + + toJSON (stringify = true) { + const props = { + conditions: this.conditions.toJSON(false), + priority: this.priority, + event: this.ruleEvent, + name: this.name + } + if (stringify) { + return JSON.stringify(props) + } + return props + } + + prioritizeConditions (conditions) { + const factSets = conditions.reduce((sets, condition) => { + let priority = condition.priority + if (!priority) { + const fact = this.engine.getFact(condition.fact) + priority = (fact && fact.priority) || 1 + } + if (!sets[priority]) sets[priority] = [] + sets[priority].push(condition) + return sets + }, {}) + return Object.keys(factSets) + .sort((a, b) => { + return Number(a) > Number(b) ? -1 : 1 + }) + .map((priority) => factSets[priority]) + } + + /** + * Optimized rule evaluation using smart short-circuiting + * @return {Promise(RuleResult)} rule evaluation result + */ + evaluate (almanac) { + const ruleResult = new RuleResult( + this.conditions, + this.ruleEvent, + this.priority, + this.name + ) + + /** + * Optimized condition evaluation with built-in short-circuiting + */ + const evaluateCondition = (condition) => { + if (condition.isConditionReference()) { + return realize(condition) + } else if (condition.isBooleanOperator()) { + // Use optimized boolean evaluation with short-circuiting + return condition.evaluateBooleanCondition(almanac, this.engine.operators) + .then(result => { + condition.result = result + return result + }) + } else { + return condition.evaluate(almanac, this.engine.operators) + .then(evaluationResult => { + const passes = evaluationResult.result + condition.factResult = evaluationResult.leftHandSideValue + condition.valueResult = evaluationResult.rightHandSideValue + condition.result = passes + return passes + }) + } + } + + /** + * Dereferences the condition reference and then evaluates it. + */ + const realize = (conditionReference) => { + const condition = this.engine.conditions.get(conditionReference.condition) + if (!condition) { + if (this.engine.allowUndefinedConditions) { + conditionReference.result = false + return Promise.resolve(false) + } else { + return Promise.reject(new Error( + `No condition ${conditionReference.condition} exists` + )) + } + } else { + delete conditionReference.condition + Object.assign(conditionReference, deepClone(condition)) + return evaluateCondition(conditionReference) + } + } + + /** + * Process rule result and emit events + */ + const processResult = (result) => { + ruleResult.setResult(result) + let processEvent = Promise.resolve() + if (this.engine.replaceFactsInEventParams) { + processEvent = ruleResult.resolveEventParams(almanac) + } + const event = result ? 'success' : 'failure' + return processEvent + .then(() => this.emitAsync(event, ruleResult.event, almanac, ruleResult)) + .then(() => ruleResult) + } + + // Leverage ConditionFast's built-in boolean evaluation with short-circuiting + return evaluateCondition(this.conditions) + .then(result => processResult(result)) + } +} + +export default RuleFast diff --git a/test/optimized/engine-fast-all.test.js b/test/optimized/engine-fast-all.test.js new file mode 100644 index 0000000..044609c --- /dev/null +++ b/test/optimized/engine-fast-all.test.js @@ -0,0 +1,111 @@ +'use strict' + +import sinon from 'sinon' +import { EngineFast } from '../../src/index' + +async function factSenior (params, engine) { + return 65 +} + +async function factChild (params, engine) { + return 10 +} + +async function factAdult (params, engine) { + return 30 +} + +describe('EngineFast: "all" conditions', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + + describe('supports a single "all" condition', () => { + const event = { + type: 'ageTrigger', + params: { + demographic: 'under50' + } + } + const conditions = { + all: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }] + } + let eventSpy + beforeEach(() => { + eventSpy = sandbox.spy() + const rule = factories.rule({ conditions, event }) + engine = new EngineFast() + engine.addRule(rule) + engine.on('success', eventSpy) + }) + + it('emits when the condition is met', async () => { + engine.addFact('age', factChild) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + it('does not emit when the condition fails', () => { + engine.addFact('age', factSenior) + engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) + + describe('supports "any" with multiple conditions', () => { + const conditions = { + all: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }, { + fact: 'age', + operator: 'greaterThan', + value: 21 + }] + } + const event = { + type: 'ageTrigger', + params: { + demographic: 'adult' + } + } + let eventSpy + beforeEach(() => { + eventSpy = sandbox.spy() + const rule = factories.rule({ conditions, event }) + engine = new EngineFast() + engine.addRule(rule) + engine.on('success', eventSpy) + }) + + it('emits an event when every condition is met', async () => { + engine.addFact('age', factAdult) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + describe('a condition fails', () => { + it('does not emit when the first condition fails', async () => { + engine.addFact('age', factChild) + await engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + + it('does not emit when the second condition', async () => { + engine.addFact('age', factSenior) + await engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) + }) +}) diff --git a/test/optimized/engine-fast-any.test.js b/test/optimized/engine-fast-any.test.js new file mode 100644 index 0000000..a379ba7 --- /dev/null +++ b/test/optimized/engine-fast-any.test.js @@ -0,0 +1,107 @@ +'use strict' + +import sinon from 'sinon' +import { EngineFast } from '../../src/index' + +describe('EngineFast: "any" conditions', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + + describe('supports a single "any" condition', () => { + const event = { + type: 'ageTrigger', + params: { + demographic: 'under50' + } + } + const conditions = { + any: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }] + } + let eventSpy + let ageSpy + beforeEach(() => { + eventSpy = sandbox.spy() + ageSpy = sandbox.stub() + const rule = factories.rule({ conditions, event }) + engine = new EngineFast() + engine.addRule(rule) + engine.addFact('age', ageSpy) + engine.on('success', eventSpy) + }) + + it('emits when the condition is met', async () => { + ageSpy.returns(10) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + it('does not emit when the condition fails', () => { + ageSpy.returns(75) + engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) + + describe('supports "any" with multiple conditions', () => { + const conditions = { + any: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }, { + fact: 'segment', + operator: 'equal', + value: 'european' + }] + } + const event = { + type: 'ageTrigger', + params: { + demographic: 'under50' + } + } + let eventSpy + let ageSpy + let segmentSpy + beforeEach(() => { + eventSpy = sandbox.spy() + ageSpy = sandbox.stub() + segmentSpy = sandbox.stub() + const rule = factories.rule({ conditions, event }) + engine = new EngineFast() + engine.addRule(rule) + engine.addFact('segment', segmentSpy) + engine.addFact('age', ageSpy) + engine.on('success', eventSpy) + }) + + it('emits an event when any condition is met', async () => { + segmentSpy.returns('north-american') + ageSpy.returns(25) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + + segmentSpy.returns('european') + ageSpy.returns(100) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + it('does not emit when all conditions fail', async () => { + segmentSpy.returns('north-american') + ageSpy.returns(100) + await engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) +}) diff --git a/test/optimized/engine-fast-comprehensive.test.js b/test/optimized/engine-fast-comprehensive.test.js new file mode 100644 index 0000000..c5e25f4 --- /dev/null +++ b/test/optimized/engine-fast-comprehensive.test.js @@ -0,0 +1,202 @@ +'use strict' + +import sinon from 'sinon' +import { EngineFast, Rule } from '../../src/index' + +describe('EngineFast: comprehensive coverage', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + beforeEach(() => { + engine = new EngineFast() + }) + + describe('setCondition()', () => { + it('throws error when name is missing', () => { + expect(() => { + engine.setCondition() + }).to.throw(/Engine: setCondition\(\) requires name/) + }) + + it('throws error when conditions are missing', () => { + expect(() => { + engine.setCondition('test') + }).to.throw(/Engine: setCondition\(\) requires conditions/) + }) + + it('throws error for invalid root conditions', () => { + expect(() => { + engine.setCondition('test', { invalid: true }) + }).to.throw(/"conditions" root must contain a single instance of "all", "any", "not", or "condition"/) + }) + + it('successfully sets a valid condition', () => { + const conditions = { all: [{ fact: 'age', operator: 'greaterThan', value: 18 }] } + const result = engine.setCondition('adult', conditions) + expect(result).to.equal(engine) + expect(engine.conditions.has('adult')).to.be.true() + }) + }) + + describe('removeCondition()', () => { + it('removes existing condition', () => { + const conditions = { all: [{ fact: 'age', operator: 'greaterThan', value: 18 }] } + engine.setCondition('adult', conditions) + expect(engine.conditions.has('adult')).to.be.true() + + const result = engine.removeCondition('adult') + expect(result).to.be.true() + expect(engine.conditions.has('adult')).to.be.false() + }) + + it('returns false for non-existing condition', () => { + const result = engine.removeCondition('nonexistent') + expect(result).to.be.false() + }) + }) + + describe('addOperatorDecorator()', () => { + it('adds operator decorator', () => { + engine.addOperatorDecorator('some', (operator) => { + return operator + }) + expect(engine.operators.decorators.has('some')).to.be.true() + }) + }) + + describe('removeOperatorDecorator()', () => { + it('removes operator decorator', () => { + engine.addOperatorDecorator('some', (operator) => { + return operator + }) + expect(engine.operators.decorators.has('some')).to.be.true() + + const result = engine.removeOperatorDecorator('some') + expect(result).to.be.true() + expect(engine.operators.decorators.has('some')).to.be.false() + }) + }) + + describe('getFact()', () => { + it('retrieves existing fact', () => { + engine.addFact('testFact', 42) + const fact = engine.getFact('testFact') + expect(fact).to.exist() + expect(fact.value).to.equal(42) + }) + + it('returns undefined for non-existing fact', () => { + const fact = engine.getFact('nonexistent') + expect(fact).to.be.undefined() + }) + }) + + describe('prioritizeRules()', () => { + it('prioritizes rules by priority value', () => { + const rule1 = new Rule(factories.rule({ priority: 10 })) + const rule2 = new Rule(factories.rule({ priority: 5 })) + const rule3 = new Rule(factories.rule({ priority: 10 })) + + engine.addRule(rule1) + engine.addRule(rule2) + engine.addRule(rule3) + + const prioritized = engine.prioritizeRules() + expect(prioritized.length).to.equal(2) // Two priority groups + expect(prioritized[0].length).to.equal(2) // Two rules with priority 10 + expect(prioritized[1].length).to.equal(1) // One rule with priority 5 + }) + + it('caches prioritized rules', () => { + const rule1 = new Rule(factories.rule({ priority: 10 })) + engine.addRule(rule1) + + const firstCall = engine.prioritizeRules() + const secondCall = engine.prioritizeRules() + expect(firstCall).to.equal(secondCall) // Same reference + }) + }) + + describe('rule priority handling', () => { + it('handles rules with different priorities', async () => { + const rule1 = new Rule(factories.rule({ priority: 1, event: { type: 'low' } })) + const rule2 = new Rule(factories.rule({ priority: 10, event: { type: 'high' } })) + + engine.addRule(rule1) + engine.addRule(rule2) + engine.addFact('age', 25) + engine.addFact('pointBalance', 2000) + + const results = await engine.run() + expect(results.events.length).to.equal(2) + }) + + it('handles stop() during execution', () => { + const rule = new Rule(factories.rule()) + engine.addRule(rule) + engine.addFact('age', 25) + engine.addFact('pointBalance', 2000) + + // Stop the engine + engine.stop() + expect(engine.status).to.equal('FINISHED') + }) + }) + + describe('error handling', () => { + it('handles rule evaluation errors gracefully', async () => { + const badRule = new Rule({ + conditions: { all: [{ fact: 'age', operator: 'invalidOperator', value: 18 }] }, + event: { type: 'test' } + }) + engine.addRule(badRule) + engine.addFact('age', 25) + + const errorSpy = sandbox.spy() + engine.on('failure', errorSpy) + + try { + await engine.run() + } catch (error) { + // Expected to catch error + } + }) + }) + + describe('allowUndefinedFacts option', () => { + it('throws when undefined fact encountered and option is false', async () => { + const rule = new Rule({ + conditions: { all: [{ fact: 'nonexistent', operator: 'equal', value: 'test' }] }, + event: { type: 'test' } + }) + engine.addRule(rule) + + try { + await engine.run() + expect.fail('Should have thrown an error') + } catch (error) { + expect(error.message).to.include('Undefined fact') + } + }) + + it('treats undefined facts as falsey when option is true', async () => { + engine = new EngineFast([], { allowUndefinedFacts: true }) + const rule = new Rule({ + conditions: { all: [{ fact: 'nonexistent', operator: 'equal', value: undefined }] }, + event: { type: 'test' } + }) + engine.addRule(rule) + + const eventSpy = sandbox.spy() + engine.on('success', eventSpy) + + const result = await engine.run() + expect(result.events.length).to.equal(1) + }) + }) +}) diff --git a/test/optimized/engine-fast-run.test.js b/test/optimized/engine-fast-run.test.js new file mode 100644 index 0000000..5d1166c --- /dev/null +++ b/test/optimized/engine-fast-run.test.js @@ -0,0 +1,136 @@ +'use strict' + +import { EngineFast } from '../../src/index' +import AlmanacFast from '../../src/optimized/almanac-fast' +import sinon from 'sinon' + +describe('EngineFast: run', () => { + let engine, rule, rule2 + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + + const condition21 = { + any: [{ + fact: 'age', + operator: 'greaterThanInclusive', + value: 21 + }] + } + const condition75 = { + any: [{ + fact: 'age', + operator: 'greaterThanInclusive', + value: 75 + }] + } + let eventSpy + + beforeEach(() => { + eventSpy = sandbox.spy() + engine = new EngineFast() + rule = factories.rule({ conditions: condition21, event: { type: 'generic1' } }) + engine.addRule(rule) + rule2 = factories.rule({ conditions: condition75, event: { type: 'generic2' } }) + engine.addRule(rule2) + engine.on('success', eventSpy) + }) + + describe('independent runs', () => { + it('treats each run() independently', async () => { + await Promise.all([50, 10, 12, 30, 14, 15, 25].map((age) => engine.run({ age }))) + expect(eventSpy).to.have.been.calledThrice() + }) + + it('allows runtime facts to override engine facts for a single run()', async () => { + engine.addFact('age', 30) + + await engine.run({ age: 85 }) // override 'age' with runtime fact + expect(eventSpy).to.have.been.calledTwice() + + sandbox.reset() + await engine.run() // no runtime fact; revert to age: 30 + expect(eventSpy).to.have.been.calledOnce() + + sandbox.reset() + await engine.run({ age: 2 }) // override 'age' with runtime fact + expect(eventSpy.callCount).to.equal(0) + }) + }) + + describe('returns', () => { + it('activated events', async () => { + const { events, failureEvents } = await engine.run({ age: 30 }) + expect(events.length).to.equal(1) + expect(events).to.deep.include(rule.event) + expect(failureEvents.length).to.equal(1) + expect(failureEvents).to.deep.include(rule2.event) + }) + + it('multiple activated events', () => { + return engine.run({ age: 90 }).then(results => { + expect(results.events.length).to.equal(2) + expect(results.events).to.deep.include(rule.event) + expect(results.events).to.deep.include(rule2.event) + }) + }) + + it('does not include unactived triggers', () => { + return engine.run({ age: 10 }).then(results => { + expect(results.events.length).to.equal(0) + }) + }) + + it('includes the almanac', () => { + return engine.run({ age: 10 }).then(results => { + expect(results.almanac).to.be.an.instanceOf(AlmanacFast) + return results.almanac.factValue('age') + }).then(ageFact => expect(ageFact).to.equal(10)) + }) + }) + + describe('facts updated during run', () => { + beforeEach(() => { + engine.on('success', (event, almanac, ruleResult) => { + // Assign unique runtime facts per event + almanac.addRuntimeFact(`runtime-fact-${event.type}`, ruleResult.conditions.any[0].value) + }) + }) + + it('returns an almanac with runtime facts added', () => { + return engine.run({ age: 90 }).then(results => { + return Promise.all([ + results.almanac.factValue('runtime-fact-generic1'), + results.almanac.factValue('runtime-fact-generic2') + ]) + }).then(promiseValues => { + expect(promiseValues[0]).to.equal(21) + expect(promiseValues[1]).to.equal(75) + }) + }) + }) + + describe('custom alamanc', () => { + class CapitalAlmanac extends AlmanacFast { + factValue (factId, params, path) { + return super.factValue(factId, params, path).then(value => { + if (typeof value === 'string') { + return value.toUpperCase() + } + return value + }) + } + } + + it('returns the capitalized value when using the CapitalAlamanc', () => { + return engine.run({ greeting: 'hello', age: 30 }, { almanac: new CapitalAlmanac() }).then((results) => { + const fact = results.almanac.factValue('greeting') + return expect(fact).to.eventually.equal('HELLO') + }) + }) + }) +}) diff --git a/test/optimized/engine-fast.test.js b/test/optimized/engine-fast.test.js new file mode 100644 index 0000000..c276194 --- /dev/null +++ b/test/optimized/engine-fast.test.js @@ -0,0 +1,333 @@ +'use strict' + +import sinon from 'sinon' +import { EngineFast, Fact, Rule, Operator } from '../../src/index' +import defaultOperators from '../../src/engine-default-operators' + +describe('EngineFast', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + beforeEach(() => { + engine = new EngineFast() + }) + + it('has methods for managing facts and rules, and running itself', () => { + expect(engine).to.have.property('addRule') + expect(engine).to.have.property('removeRule') + expect(engine).to.have.property('addOperator') + expect(engine).to.have.property('removeOperator') + expect(engine).to.have.property('addFact') + expect(engine).to.have.property('removeFact') + expect(engine).to.have.property('run') + expect(engine).to.have.property('stop') + }) + + describe('constructor', () => { + it('initializes with the default state', () => { + expect(engine.status).to.equal('READY') + expect(engine.rules.length).to.equal(0) + defaultOperators.forEach(op => { + expect(engine.operators.get(op.name)).to.be.an.instanceof(Operator) + }) + }) + + it('can be initialized with rules', () => { + const rules = [ + factories.rule(), + factories.rule(), + factories.rule() + ] + engine = new EngineFast(rules) + expect(engine.rules.length).to.equal(rules.length) + }) + }) + + describe('stop()', () => { + it('changes the status to "FINISHED"', () => { + expect(engine.stop().status).to.equal('FINISHED') + }) + }) + + describe('addRule()', () => { + describe('rule instance', () => { + it('adds the rule', () => { + const rule = new Rule(factories.rule()) + expect(engine.rules.length).to.equal(0) + engine.addRule(rule) + expect(engine.rules.length).to.equal(1) + // EngineFast converts Rule to RuleFast internally + expect(engine.rules[0]).to.be.an('object') + expect(engine.rules[0].event).to.eql(rule.event) + }) + }) + + describe('required fields', () => { + it('.conditions', () => { + const rule = factories.rule() + delete rule.conditions + expect(() => { + engine.addRule(rule) + }).to.throw(/Engine: addRule\(\) argument requires "conditions" property/) + }) + + it('.event', () => { + const rule = factories.rule() + delete rule.event + expect(() => { + engine.addRule(rule) + }).to.throw(/Engine: addRule\(\) argument requires "event" property/) + }) + }) + }) + + describe('updateRule()', () => { + it('updates rule', () => { + let rule1 = new Rule(factories.rule({ name: 'rule1' })) + let rule2 = new Rule(factories.rule({ name: 'rule2' })) + engine.addRule(rule1) + engine.addRule(rule2) + expect(engine.rules[0].conditions.all.length).to.equal(2) + expect(engine.rules[1].conditions.all.length).to.equal(2) + + rule1.conditions = { all: [] } + engine.updateRule(rule1) + + rule1 = engine.rules.find(rule => rule.name === 'rule1') + rule2 = engine.rules.find(rule => rule.name === 'rule2') + expect(rule1.conditions.all.length).to.equal(0) + expect(rule2.conditions.all.length).to.equal(2) + }) + + it('should throw error if rule not found', () => { + const rule1 = new Rule(factories.rule({ name: 'rule1' })) + engine.addRule(rule1) + const rule2 = new Rule(factories.rule({ name: 'rule2' })) + expect(() => { + engine.updateRule(rule2) + }).to.throw(/Engine: updateRule\(\) rule not found/) + }) + }) + + describe('removeRule()', () => { + function setup () { + const rule1 = new Rule(factories.rule({ name: 'rule1' })) + const rule2 = new Rule(factories.rule({ name: 'rule2' })) + engine.addRule(rule1) + engine.addRule(rule2) + engine.prioritizeRules() + + // Return the converted RuleFast instances from the engine + return [engine.rules[0], engine.rules[1]] + } + context('remove by rule.name', () => { + it('removes a single rule', () => { + const [rule1] = setup() + expect(engine.rules.length).to.equal(2) + + const isRemoved = engine.removeRule(rule1.name) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(1) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('removes multiple rules with the same name', () => { + const [rule1] = setup() + const rule3 = new Rule(factories.rule({ name: rule1.name })) + engine.addRule(rule3) + expect(engine.rules.length).to.equal(3) + + const isRemoved = engine.removeRule(rule1.name) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(1) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('returns false when rule cannot be found', () => { + setup() + expect(engine.rules.length).to.equal(2) + + const isRemoved = engine.removeRule('not-found-name') + + expect(isRemoved).to.be.false() + expect(engine.rules.length).to.equal(2) + expect(engine.prioritizedRules).to.not.equal(null) + }) + }) + context('remove by rule object', () => { + it('removes a single rule', () => { + const [rule1] = setup() + expect(engine.rules.length).to.equal(2) + + const isRemoved = engine.removeRule(rule1) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(1) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('removes a single rule, even if two have the same name', () => { + const [rule1] = setup() + const rule3 = new Rule(factories.rule({ name: rule1.name })) + engine.addRule(rule3) + expect(engine.rules.length).to.equal(3) + + const isRemoved = engine.removeRule(rule1) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(2) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('returns false when rule cannot be found', () => { + setup() + expect(engine.rules.length).to.equal(2) + + const rule3 = new Rule(factories.rule({ name: 'rule3' })) + const isRemoved = engine.removeRule(rule3) + + expect(isRemoved).to.be.false() + expect(engine.rules.length).to.equal(2) + expect(engine.prioritizedRules).to.not.equal(null) + }) + }) + }) + + describe('addOperator()', () => { + it('adds the operator', () => { + engine.addOperator('startsWithLetter', (factValue, jsonValue) => { + return factValue[0] === jsonValue + }) + expect(engine.operators.get('startsWithLetter')).to.exist() + expect(engine.operators.get('startsWithLetter')).to.be.an.instanceof(Operator) + }) + + it('accepts an operator instance', () => { + const op = new Operator('my-operator', _ => true) + engine.addOperator(op) + expect(engine.operators.get('my-operator')).to.equal(op) + }) + }) + + describe('removeOperator()', () => { + it('removes the operator', () => { + engine.addOperator('startsWithLetter', (factValue, jsonValue) => { + return factValue[0] === jsonValue + }) + expect(engine.operators.get('startsWithLetter')).to.be.an.instanceof(Operator) + engine.removeOperator('startsWithLetter') + expect(engine.operators.get('startsWithLetter')).to.be.null() + }) + + it('can only remove added operators', () => { + const isRemoved = engine.removeOperator('nonExisting') + expect(isRemoved).to.equal(false) + }) + }) + + describe('addFact()', () => { + const FACT_NAME = 'FACT_NAME' + const FACT_VALUE = 'FACT_VALUE' + + function assertFact (engine) { + expect(engine.facts.size).to.equal(1) + expect(engine.facts.has(FACT_NAME)).to.be.true() + } + + it('allows a constant fact', () => { + engine.addFact(FACT_NAME, FACT_VALUE) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).value).to.equal(FACT_VALUE) + }) + + it('allows options to be passed', () => { + const options = { cache: false } + engine.addFact(FACT_NAME, FACT_VALUE, options) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).value).to.equal(FACT_VALUE) + expect(engine.facts.get(FACT_NAME).options).to.eql(options) + }) + + it('allows a lamba fact with no options', () => { + engine.addFact(FACT_NAME, async (params, engine) => { + return FACT_VALUE + }) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).value).to.be.undefined() + }) + + it('allows a lamba fact with options', () => { + const options = { cache: false } + engine.addFact(FACT_NAME, async (params, engine) => { + return FACT_VALUE + }, options) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).options).to.eql(options) + expect(engine.facts.get(FACT_NAME).value).to.be.undefined() + }) + + it('allows a fact instance', () => { + const options = { cache: false } + const fact = new Fact(FACT_NAME, 50, options) + engine.addFact(fact) + assertFact(engine) + expect(engine.facts.get(FACT_NAME)).to.exist() + expect(engine.facts.get(FACT_NAME).options).to.eql(options) + }) + }) + + describe('removeFact()', () => { + it('removes a Fact', () => { + expect(engine.facts.size).to.equal(0) + const fact = new Fact('newFact', 50, { cache: false }) + engine.addFact(fact) + expect(engine.facts.size).to.equal(1) + engine.removeFact('newFact') + expect(engine.facts.size).to.equal(0) + }) + + it('can only remove added facts', () => { + expect(engine.facts.size).to.equal(0) + const isRemoved = engine.removeFact('newFact') + expect(isRemoved).to.equal(false) + }) + }) + + describe('run()', () => { + beforeEach(() => { + const conditions = { + all: [{ + fact: 'age', + operator: 'greaterThanInclusive', + value: 18 + }] + } + const event = { type: 'generic' } + const rule = factories.rule({ conditions, event }) + engine.addRule(rule) + engine.addFact('age', 20) + }) + + it('changes the status to "RUNNING"', () => { + const eventSpy = sandbox.spy() + engine.on('success', (event, almanac) => { + eventSpy() + expect(engine.status).to.equal('RUNNING') + }) + return engine.run() + }) + + it('changes status to FINISHED once complete', async () => { + expect(engine.status).to.equal('READY') + await engine.run() + expect(engine.status).to.equal('FINISHED') + }) + }) +}) From 9c4b9fa5bc95c0311434239213f31b77410a456c Mon Sep 17 00:00:00 2001 From: Manuel Reil Date: Sun, 17 Aug 2025 12:48:58 +0200 Subject: [PATCH 5/7] Adds ultra mode --- .claude/settings.local.json | 4 +- benchmark/benchmark-fast-vs-ultra.js | 114 ++++++ benchmark/benchmark-ultra-vs-original.js | 101 ++++++ benchmark/benchmark-ultra.js | 100 ++++++ src/json-rules-engine.js | 25 +- src/optimized/almanac-ultra.js | 221 ++++++++++++ src/optimized/condition-ultra.js | 238 +++++++++++++ src/optimized/debug-fast.js | 22 ++ src/optimized/engine-ultra.js | 300 ++++++++++++++++ src/optimized/perf-utils.js | 35 ++ src/optimized/rule-ultra.js | 148 ++++++++ test/optimized/engine-ultra-all.test.js | 111 ++++++ test/optimized/engine-ultra-any.test.js | 107 ++++++ .../engine-ultra-comprehensive.test.js | 202 +++++++++++ test/optimized/engine-ultra-run.test.js | 136 +++++++ test/optimized/engine-ultra.test.js | 333 ++++++++++++++++++ 16 files changed, 2189 insertions(+), 8 deletions(-) create mode 100644 benchmark/benchmark-fast-vs-ultra.js create mode 100644 benchmark/benchmark-ultra-vs-original.js create mode 100644 benchmark/benchmark-ultra.js create mode 100644 src/optimized/almanac-ultra.js create mode 100644 src/optimized/condition-ultra.js create mode 100644 src/optimized/debug-fast.js create mode 100644 src/optimized/engine-ultra.js create mode 100644 src/optimized/perf-utils.js create mode 100644 src/optimized/rule-ultra.js create mode 100644 test/optimized/engine-ultra-all.test.js create mode 100644 test/optimized/engine-ultra-any.test.js create mode 100644 test/optimized/engine-ultra-comprehensive.test.js create mode 100644 test/optimized/engine-ultra-run.test.js create mode 100644 test/optimized/engine-ultra.test.js diff --git a/.claude/settings.local.json b/.claude/settings.local.json index 11e53a9..85b20eb 100644 --- a/.claude/settings.local.json +++ b/.claude/settings.local.json @@ -6,7 +6,9 @@ "Bash(npm run benchmark:quick:*)", "Bash(npm run benchmark:*)", "Bash(npm test)", - "Bash(npm run lint:*)" + "Bash(npm run lint:*)", + "Bash(cp:*)", + "Bash(git checkout:*)" ] }, "enableAllProjectMcpServers": false diff --git a/benchmark/benchmark-fast-vs-ultra.js b/benchmark/benchmark-fast-vs-ultra.js new file mode 100644 index 0000000..68a6d04 --- /dev/null +++ b/benchmark/benchmark-fast-vs-ultra.js @@ -0,0 +1,114 @@ +const { EngineFast, EngineUltra } = require('../dist/index') +const { performance } = require('perf_hooks') +const rules = require('./rules') + +async function benchmarkEngine (EngineClass, engineName, numEvents = 1000, numRules = 30) { + console.log(`\n=== ${engineName} Benchmark ===`) + + // Generate test events first + const events = [] + for (let i = 0; i < numEvents; i++) { + events.push({ + record: { + review: { + maturityValue: Math.floor(Math.random() * 5) + 1, + isComplete: Math.random() > 0.3, + score: Math.floor(Math.random() * 100), + riskLevel: ['low', 'medium', 'high'][Math.floor(Math.random() * 3)] + }, + company: { + size: ['small', 'medium', 'large'][Math.floor(Math.random() * 3)], + industry: ['tech', 'finance', 'healthcare'][Math.floor(Math.random() * 3)] + } + }, + metadata: { + timestamp: Date.now(), + source: 'webhook' + } + }) + } + + // Create engine with rules + const engine = new EngineClass() + for (let i = 0; i < numRules; i++) { + engine.addRule(rules[i]) + } + + // Add static facts that most rules will use + engine.addFact('type', 'com.alyne.objects.updated') + engine.addFact('eventType', 'com.alyne.objects.updated') + engine.addFact('data', (params, almanac) => events[0]) // Use first event as data + engine.addFact('companyId', 'company-123') + engine.addFact('userId', 'user-456') + + console.log(`Engine setup: ${numRules} rules loaded`) + + // Warm up JIT + for (let i = 0; i < 10; i++) { + await engine.run(events[0]) + } + + // Actual benchmark - run multiple times for better accuracy + const runs = 3 + let totalDuration = 0 + + for (let run = 0; run < runs; run++) { + const startTime = performance.now() + + for (let i = 0; i < numEvents; i++) { + await engine.run(events[i]) + } + + const endTime = performance.now() + totalDuration += (endTime - startTime) + } + + const avgDuration = totalDuration / runs + const eventsPerSecond = Math.round((numEvents * 1000) / avgDuration) + + console.log(`Processed ${numEvents} events in ${avgDuration.toFixed(2)}ms (avg of ${runs} runs)`) + console.log(`Throughput: ${eventsPerSecond} events/second`) + + return { duration: avgDuration, eventsPerSecond, engineName } +} + +async function runComparison () { + console.log('Performance Comparison: EngineFast vs EngineUltra') + console.log('='.repeat(60)) + + const workloads = [ + { events: 100, rules: 10, name: 'Small' }, + { events: 500, rules: 20, name: 'Medium' }, + { events: 1000, rules: 30, name: 'Large' }, + { events: 2000, rules: 30, name: 'Extra Large' } + ] + + for (const workload of workloads) { + console.log(`\nšŸ” ${workload.name} Workload: ${workload.events} events, ${workload.rules} rules`) + + const [fastResult, ultraResult] = await Promise.all([ + benchmarkEngine(EngineFast, 'EngineFast', workload.events, workload.rules), + benchmarkEngine(EngineUltra, 'EngineUltra', workload.events, workload.rules) + ]) + + const improvement = ((ultraResult.eventsPerSecond - fastResult.eventsPerSecond) / fastResult.eventsPerSecond * 100).toFixed(2) + const speedupFactor = (ultraResult.eventsPerSecond / fastResult.eventsPerSecond).toFixed(2) + + console.log('\nšŸ“Š Performance Results:') + console.log(`EngineFast: ${fastResult.eventsPerSecond} events/sec`) + console.log(`EngineUltra: ${ultraResult.eventsPerSecond} events/sec`) + console.log(`Improvement: +${improvement}% (${speedupFactor}x faster)`) + + if (improvement > 0) { + console.log('āœ… EngineUltra is faster') + } else { + console.log('āš ļø EngineFast is faster') + } + } +} + +if (require.main === module) { + runComparison().catch(console.error) +} + +module.exports = { benchmarkEngine, runComparison } diff --git a/benchmark/benchmark-ultra-vs-original.js b/benchmark/benchmark-ultra-vs-original.js new file mode 100644 index 0000000..d78e06d --- /dev/null +++ b/benchmark/benchmark-ultra-vs-original.js @@ -0,0 +1,101 @@ +const { Engine, EngineUltra } = require('../dist/index') +const { performance } = require('perf_hooks') +const rules = require('./rules') + +async function benchmarkEngine (EngineClass, engineName, numEvents = 1000, numRules = 30) { + console.log(`\n=== ${engineName} Benchmark ===`) + + // Generate test events first + const events = [] + for (let i = 0; i < numEvents; i++) { + events.push({ + record: { + review: { + maturityValue: Math.floor(Math.random() * 5) + 1, + isComplete: Math.random() > 0.3, + score: Math.floor(Math.random() * 100), + riskLevel: ['low', 'medium', 'high'][Math.floor(Math.random() * 3)] + }, + company: { + size: ['small', 'medium', 'large'][Math.floor(Math.random() * 3)], + industry: ['tech', 'finance', 'healthcare'][Math.floor(Math.random() * 3)] + } + }, + metadata: { + timestamp: Date.now(), + source: 'webhook' + } + }) + } + + // Create engine with rules + const engine = new EngineClass() + for (let i = 0; i < numRules; i++) { + engine.addRule(rules[i]) + } + + // Add static facts that most rules will use + engine.addFact('type', 'com.alyne.objects.updated') + engine.addFact('eventType', 'com.alyne.objects.updated') + engine.addFact('data', (params, almanac) => events[0]) // Use first event as data + engine.addFact('companyId', 'company-123') + engine.addFact('userId', 'user-456') + + console.log(`Engine setup: ${numRules} rules loaded`) + + // Warm up JIT + for (let i = 0; i < 10; i++) { + await engine.run(events[0]) + } + + // Actual benchmark + const startTime = performance.now() + + for (let i = 0; i < numEvents; i++) { + await engine.run(events[i]) + } + + const endTime = performance.now() + const duration = endTime - startTime + const eventsPerSecond = Math.round((numEvents * 1000) / duration) + + console.log(`Processed ${numEvents} events in ${duration.toFixed(2)}ms`) + console.log(`Throughput: ${eventsPerSecond} events/second`) + + return { duration, eventsPerSecond, engineName } +} + +async function runComparison () { + console.log('Performance Comparison: EngineUltra vs Original Engine') + console.log('='.repeat(60)) + + const workloads = [ + { events: 100, rules: 10, name: 'Small' }, + { events: 500, rules: 20, name: 'Medium' }, + { events: 1000, rules: 30, name: 'Large' }, + { events: 2000, rules: 30, name: 'Extra Large' } + ] + + for (const workload of workloads) { + console.log(`\nšŸ” ${workload.name} Workload: ${workload.events} events, ${workload.rules} rules`) + + const [originalResult, ultraResult] = await Promise.all([ + benchmarkEngine(Engine, 'Engine (Original)', workload.events, workload.rules), + benchmarkEngine(EngineUltra, 'EngineUltra', workload.events, workload.rules) + ]) + + const improvement = ((ultraResult.eventsPerSecond - originalResult.eventsPerSecond) / originalResult.eventsPerSecond * 100).toFixed(2) + const speedupFactor = (ultraResult.eventsPerSecond / originalResult.eventsPerSecond).toFixed(2) + + console.log('\nšŸ“Š Performance Results:') + console.log(`Original: ${originalResult.eventsPerSecond} events/sec`) + console.log(`Ultra: ${ultraResult.eventsPerSecond} events/sec`) + console.log(`Improvement: +${improvement}% (${speedupFactor}x faster)`) + } +} + +if (require.main === module) { + runComparison().catch(console.error) +} + +module.exports = { benchmarkEngine, runComparison } diff --git a/benchmark/benchmark-ultra.js b/benchmark/benchmark-ultra.js new file mode 100644 index 0000000..2b5221f --- /dev/null +++ b/benchmark/benchmark-ultra.js @@ -0,0 +1,100 @@ +const { Engine, EngineFast, EngineUltra } = require('../dist/index') +const { performance } = require('perf_hooks') +const rules = require('./rules') + +async function benchmarkEngine (EngineClass, engineName, numEvents = 1000, numRules = 30) { + console.log(`\n=== ${engineName} Benchmark ===`) + + // Generate test events first + const events = [] + for (let i = 0; i < numEvents; i++) { + events.push({ + record: { + review: { + maturityValue: Math.floor(Math.random() * 5) + 1, + isComplete: Math.random() > 0.3, + score: Math.floor(Math.random() * 100), + riskLevel: ['low', 'medium', 'high'][Math.floor(Math.random() * 3)] + }, + company: { + size: ['small', 'medium', 'large'][Math.floor(Math.random() * 3)], + industry: ['tech', 'finance', 'healthcare'][Math.floor(Math.random() * 3)] + } + }, + metadata: { + timestamp: Date.now(), + source: 'webhook' + } + }) + } + + // Create engine with rules + const engine = new EngineClass() + for (let i = 0; i < numRules; i++) { + engine.addRule(rules[i]) + } + + // Add static facts that most rules will use + engine.addFact('type', 'com.alyne.objects.updated') + engine.addFact('eventType', 'com.alyne.objects.updated') + engine.addFact('data', (params, almanac) => events[0]) // Use first event as data + engine.addFact('companyId', 'company-123') + engine.addFact('userId', 'user-456') + + console.log(`Engine setup: ${numRules} rules loaded`) + + // Warm up JIT + for (let i = 0; i < 10; i++) { + await engine.run(events[0]) + } + + // Actual benchmark + const startTime = performance.now() + + for (let i = 0; i < numEvents; i++) { + await engine.run(events[i]) + } + + const endTime = performance.now() + const duration = endTime - startTime + const eventsPerSecond = Math.round((numEvents * 1000) / duration) + + console.log(`Processed ${numEvents} events in ${duration.toFixed(2)}ms`) + console.log(`Throughput: ${eventsPerSecond} events/second`) + + return { duration, eventsPerSecond, engineName } +} + +async function runComparison () { + console.log('Performance Comparison: Debug Overhead Elimination') + console.log('='.repeat(60)) + + const smallWorkload = { events: 100, rules: 10 } + const mediumWorkload = { events: 500, rules: 20 } + const largeWorkload = { events: 1000, rules: 30 } + + for (const { events, rules } of [smallWorkload, mediumWorkload, largeWorkload]) { + console.log(`\nšŸ” Workload: ${events} events, ${rules} rules`) + + const [originalResult, fastResult, ultraResult] = await Promise.all([ + benchmarkEngine(Engine, 'Engine (Original)', events, rules), + benchmarkEngine(EngineFast, 'EngineFast', events, rules), + benchmarkEngine(EngineUltra, 'EngineUltra', events, rules) + ]) + + const fastImprovement = ((fastResult.eventsPerSecond - originalResult.eventsPerSecond) / originalResult.eventsPerSecond * 100).toFixed(2) + const ultraImprovement = ((ultraResult.eventsPerSecond - originalResult.eventsPerSecond) / originalResult.eventsPerSecond * 100).toFixed(2) + const ultraVsFast = ((ultraResult.eventsPerSecond - fastResult.eventsPerSecond) / fastResult.eventsPerSecond * 100).toFixed(2) + + console.log('\nšŸ“Š Performance Improvements:') + console.log(`EngineFast vs Original: +${fastImprovement}%`) + console.log(`EngineUltra vs Original: +${ultraImprovement}%`) + console.log(`EngineUltra vs EngineFast: +${ultraVsFast}%`) + } +} + +if (require.main === module) { + runComparison().catch(console.error) +} + +module.exports = { benchmarkEngine, runComparison } diff --git a/src/json-rules-engine.js b/src/json-rules-engine.js index 6eb93ba..0bdb74d 100644 --- a/src/json-rules-engine.js +++ b/src/json-rules-engine.js @@ -12,19 +12,30 @@ import RuleSync from './sync/rule-sync' import AlmanacSync from './sync/almanac-sync' import ConditionSync from './sync/condition-sync' -export { - Fact, - Rule, - Operator, - Engine, - Almanac, +// Import optimized variants +import EngineFast from './optimized/engine-fast' +import AlmanacFast from './optimized/almanac-fast' +import EngineUltra from './optimized/engine-ultra' +import AlmanacUltra from './optimized/almanac-ultra' + +export { + Fact, + Rule, + Operator, + Engine, + Almanac, OperatorDecorator, // Sync variants EngineSync, FactSync, RuleSync, AlmanacSync, - ConditionSync + ConditionSync, + // Optimized variants + EngineFast, + AlmanacFast, + EngineUltra, + AlmanacUltra } export default function (rules, options) { diff --git a/src/optimized/almanac-ultra.js b/src/optimized/almanac-ultra.js new file mode 100644 index 0000000..96fcc37 --- /dev/null +++ b/src/optimized/almanac-ultra.js @@ -0,0 +1,221 @@ +'use strict' + +import Fact from '../fact' +import { debug, debugEnabled } from './debug-fast' +import { isObject, isFactReference } from './perf-utils' + +/** + * Ultra-optimized Almanac with maximum performance enhancements + */ +export default class AlmanacUltra { + constructor (options = {}) { + this.factMap = options.facts || new Map() + this.runtimeFactMap = new Map() + + // Separate caches for sync vs async facts to avoid Promise wrapping overhead + this.factResultsCache = new Map() // { cacheKey: actualValue } - no Promise wrapping + this.factPromiseCache = new Map() // { cacheKey: Promise } - only for truly async facts + + // Pre-compiled JSONPath cache + this.pathCache = new Map() + + this.allowUndefinedFacts = options.allowUndefinedFacts + this.pathResolver = options.pathResolver + this.events = [] + } + + _setFactValue (fact, params, value) { + // Optimized cache key generation + let cacheKey + if (params && Object.keys(params).length > 0) { + cacheKey = fact.id + JSON.stringify(params) + } else { + cacheKey = fact.id + } + + // Cache actual values, not Promises, for better performance + this.factResultsCache.set(cacheKey, value) + + if (fact.options.cache === false) { + // Remove from cache immediately if caching disabled + this.factResultsCache.delete(cacheKey) + this.factPromiseCache.delete(cacheKey) + } + + return Promise.resolve(value) + } + + _addConstantFact (fact) { + this.factMap.set(fact.id, fact) + return this + } + + addFact (factOrId, valueOrMethod, options) { + let factId, fact + if (factOrId instanceof Fact) { + factId = factOrId.id + fact = factOrId + } else { + factId = factOrId + fact = new Fact(factId, valueOrMethod, options) + } + + if (debugEnabled) { + debug('almanac::addFact', { id: factId }) + } + return this._addConstantFact(fact) + } + + addRuntimeFact (factId, factValueOrMethod) { + let fact + if (factValueOrMethod instanceof Fact) { + fact = factValueOrMethod + } else { + fact = new Fact(factId, factValueOrMethod) + } + + if (debugEnabled) { + debug('almanac::addRuntimeFact', { id: factId }) + } + this.runtimeFactMap.set(factId, fact) + return this + } + + _getFact (factId) { + return this.runtimeFactMap.get(factId) || this.factMap.get(factId) + } + + /** + * Ultra-optimized fact value resolution with smart caching + */ + factValue (factId, params, path) { + const fact = this._getFact(factId) + if (!fact) { + if (this.allowUndefinedFacts) { + return Promise.resolve(undefined) + } + return Promise.reject(new Error(`Undefined fact: ${factId}`)) + } + + // Optimized cache key - avoid JSON.stringify when possible + let cacheKey + if (params && Object.keys(params).length > 0) { + cacheKey = factId + JSON.stringify(params) + } else { + cacheKey = factId + } + + // Check sync cache first (fastest path) + if (this.factResultsCache.has(cacheKey)) { + if (debugEnabled) { + debug('almanac::factValue cache hit for fact', { id: factId }) + } + const cachedValue = this.factResultsCache.get(cacheKey) + return this._applyPath(cachedValue, path) + } + + // Check if we have a pending Promise for this fact + if (this.factPromiseCache.has(cacheKey)) { + return this.factPromiseCache.get(cacheKey).then(value => this._applyPath(value, path)) + } + + if (debugEnabled) { + debug('almanac::factValue cache miss, calculating', { id: factId }) + } + + // Determine if fact is constant or dynamic + if (fact.isConstant()) { + // Sync path - cache immediately and return + this.factResultsCache.set(cacheKey, fact.value) + return this._applyPath(fact.value, path) + } + + // Dynamic fact path - create and cache Promise + const promise = Promise.resolve(fact.calculate(params, this)) + .then(value => { + // Move from Promise cache to value cache + this.factPromiseCache.delete(cacheKey) + this.factResultsCache.set(cacheKey, value) + return value + }) + + this.factPromiseCache.set(cacheKey, promise) + return promise.then(value => this._applyPath(value, path)) + } + + /** + * Ultra-optimized path application with pre-compiled JSONPath + */ + _applyPath (factValue, path) { + if (!path || !isObject(factValue)) { + return Promise.resolve(factValue) + } + + // Use custom path resolver if available + if (this.pathResolver) { + const pathValue = this.pathResolver(factValue, path) + if (debugEnabled) { + debug('condition::evaluate extracting object', { property: path, received: pathValue }) + } + return Promise.resolve(pathValue) + } + + // Fast JSONPath with caching + let compiledPath = this.pathCache.get(path) + if (!compiledPath) { + const JSONPath = require('jsonpath-plus').JSONPath + compiledPath = JSONPath.toPathArray(path) + this.pathCache.set(path, compiledPath) + } + + try { + const pathValue = this._fastJSONPath(factValue, compiledPath) + if (debugEnabled) { + debug('condition::evaluate extracting object', { property: path, received: pathValue }) + } + return Promise.resolve(pathValue) + } catch (err) { + if (debugEnabled) { + debug('condition::evaluate could not compute object path of non-object', { path, factValue, type: typeof factValue }) + } + return Promise.resolve(undefined) + } + } + + /** + * Fast JSONPath implementation for common cases + */ + _fastJSONPath (obj, pathArray) { + let current = obj + const pathLength = pathArray.length + + for (let i = 0; i < pathLength; i++) { + if (current == null) return undefined + current = current[pathArray[i]] + } + + return current + } + + /** + * Ultra-optimized value resolution + */ + getValue (value) { + if (!isFactReference(value)) { + return Promise.resolve(value) + } + return this.factValue(value.fact, value.params, value.path) + } + + getEvent (eventName) { + return this.events.filter(event => { + if (eventName) return event.type === eventName + return true + }) + } + + addEvent (event, outcome = 'success') { + this.events.push({ ...event, outcome }) + return this + } +} diff --git a/src/optimized/condition-ultra.js b/src/optimized/condition-ultra.js new file mode 100644 index 0000000..c4631b8 --- /dev/null +++ b/src/optimized/condition-ultra.js @@ -0,0 +1,238 @@ +'use strict' + +import { debug, debugEnabled } from './debug-fast' + +export default class ConditionUltra { + constructor (properties) { + if (!properties) throw new Error('Condition: constructor options required') + const booleanOperator = ConditionUltra.booleanOperator(properties) + Object.assign(this, properties) + if (booleanOperator) { + const subConditions = properties[booleanOperator] + const subConditionsIsArray = Array.isArray(subConditions) + if (booleanOperator !== 'not' && !subConditionsIsArray) { throw new Error(`"${booleanOperator}" must be an array`) } + if (booleanOperator === 'not' && subConditionsIsArray) { throw new Error(`"${booleanOperator}" cannot be an array`) } + this.operator = booleanOperator + this.priority = parseInt(properties.priority, 10) || 1 + if (subConditionsIsArray) { + this[booleanOperator] = subConditions.map((c) => new ConditionUltra(c)) + } else { + this[booleanOperator] = new ConditionUltra(subConditions) + } + } else if (!Object.prototype.hasOwnProperty.call(properties, 'condition')) { + if (!Object.prototype.hasOwnProperty.call(properties, 'fact')) { throw new Error('Condition: constructor "fact" property required') } + if (!Object.prototype.hasOwnProperty.call(properties, 'operator')) { throw new Error('Condition: constructor "operator" property required') } + if (!Object.prototype.hasOwnProperty.call(properties, 'value')) { throw new Error('Condition: constructor "value" property required') } + + if (Object.prototype.hasOwnProperty.call(properties, 'priority')) { + properties.priority = parseInt(properties.priority, 10) + } + } + } + + toJSON (stringify = true) { + const props = {} + if (this.priority) { + props.priority = this.priority + } + if (this.name) { + props.name = this.name + } + const oper = ConditionUltra.booleanOperator(this) + if (oper) { + if (Array.isArray(this[oper])) { + props[oper] = this[oper].map((c) => c.toJSON(false)) + } else { + props[oper] = this[oper].toJSON(false) + } + } else if (this.isConditionReference()) { + props.condition = this.condition + } else { + props.operator = this.operator + props.value = this.value + props.fact = this.fact + if (this.factResult !== undefined) { + props.factResult = this.factResult + } + if (this.valueResult !== undefined) { + props.valueResult = this.valueResult + } + if (this.result !== undefined) { + props.result = this.result + } + if (this.params) { + props.params = this.params + } + if (this.path) { + props.path = this.path + } + } + if (stringify) { + return JSON.stringify(props) + } + return props + } + + /** + * Ultra-optimized condition evaluation with no debug overhead in production + */ + evaluate (almanac, operatorMap) { + if (!almanac) return Promise.reject(new Error('almanac required')) + if (!operatorMap) return Promise.reject(new Error('operatorMap required')) + if (this.isBooleanOperator()) { return Promise.reject(new Error('Cannot evaluate() a boolean condition')) } + + const op = operatorMap.get(this.operator) + if (!op) { return Promise.reject(new Error(`Unknown operator: ${this.operator}`)) } + + // Fast path optimization: check if value is a constant (not a fact reference) + const isValueConstant = !(this.value != null && typeof this.value === 'object' && + Object.prototype.hasOwnProperty.call(this.value, 'fact')) + + if (isValueConstant) { + // Fast path: value is constant, only need to resolve fact + return almanac.factValue(this.fact, this.params, this.path) + .then(leftHandSideValue => { + const result = op.evaluate(leftHandSideValue, this.value) + if (debugEnabled) { + debug('condition::evaluate', { + leftHandSideValue, + operator: this.operator, + rightHandSideValue: this.value, + result + }) + } + return { + result, + leftHandSideValue, + rightHandSideValue: this.value, + operator: this.operator + } + }) + } else { + // Original path: both fact and value need resolution + return Promise.all([ + almanac.getValue(this.value), + almanac.factValue(this.fact, this.params, this.path) + ]).then(([rightHandSideValue, leftHandSideValue]) => { + const result = op.evaluate(leftHandSideValue, rightHandSideValue) + if (debugEnabled) { + debug('condition::evaluate', { + leftHandSideValue, + operator: this.operator, + rightHandSideValue, + result + }) + } + return { + result, + leftHandSideValue, + rightHandSideValue, + operator: this.operator + } + }) + } + } + + /** + * Ultra-optimized boolean evaluation with smart short-circuiting and no debug overhead + */ + evaluateBooleanCondition (almanac, operatorMap) { + if (!this.isBooleanOperator()) { + return Promise.reject(new Error('evaluateBooleanCondition() can only evaluate boolean conditions')) + } + + const operator = this.booleanOperator() + const conditions = this[operator] + + if (debugEnabled) { + debug('condition::evaluateBooleanCondition', { operator }) + } + + if (operator === 'not') { + if (conditions.isBooleanOperator()) { + return conditions.evaluateBooleanCondition(almanac, operatorMap) + .then(result => !result) + } else { + return conditions.evaluate(almanac, operatorMap) + .then(result => !result.result) + } + } + + // Smart short-circuiting for 'any' and 'all' + if (operator === 'any') { + // Short-circuit on first true result + const evaluateNext = (index) => { + if (index >= conditions.length) { + return Promise.resolve(false) + } + + const condition = conditions[index] + const evaluation = condition.isBooleanOperator() + ? condition.evaluateBooleanCondition(almanac, operatorMap) + : condition.evaluate(almanac, operatorMap) + + return evaluation.then(result => { + const isTrue = result === true || (result && result.result === true) + if (isTrue) { + if (debugEnabled) { + debug('condition::any short-circuit success') + } + return true + } + return evaluateNext(index + 1) + }) + } + return evaluateNext(0) + } + + if (operator === 'all') { + // Short-circuit on first false result + const evaluateNext = (index) => { + if (index >= conditions.length) { + return Promise.resolve(true) + } + + const condition = conditions[index] + const evaluation = condition.isBooleanOperator() + ? condition.evaluateBooleanCondition(almanac, operatorMap) + : condition.evaluate(almanac, operatorMap) + + return evaluation.then(result => { + const isFalse = result === false || (result && result.result === false) + if (isFalse) { + if (debugEnabled) { + debug('condition::all short-circuit failure') + } + return false + } + return evaluateNext(index + 1) + }) + } + return evaluateNext(0) + } + + return Promise.reject(new Error(`Unknown boolean operator: ${operator}`)) + } + + static booleanOperator (condition) { + if (Object.prototype.hasOwnProperty.call(condition, 'any')) { + return 'any' + } else if (Object.prototype.hasOwnProperty.call(condition, 'all')) { + return 'all' + } else if (Object.prototype.hasOwnProperty.call(condition, 'not')) { + return 'not' + } + } + + booleanOperator () { + return ConditionUltra.booleanOperator(this) + } + + isBooleanOperator () { + return ConditionUltra.booleanOperator(this) !== undefined + } + + isConditionReference () { + return Object.prototype.hasOwnProperty.call(this, 'condition') + } +} diff --git a/src/optimized/debug-fast.js b/src/optimized/debug-fast.js new file mode 100644 index 0000000..a7b8594 --- /dev/null +++ b/src/optimized/debug-fast.js @@ -0,0 +1,22 @@ +function createDebug () { + try { + if ((typeof process !== 'undefined' && process.env && process.env.DEBUG && process.env.DEBUG.match(/json-rules-engine/)) || + (typeof window !== 'undefined' && window.localStorage && window.localStorage.debug && window.localStorage.debug.match(/json-rules-engine/))) { + return { + debug: console.debug.bind(console), + enabled: true + } + } + } catch (ex) { + // Do nothing + } + return { + debug: () => {}, + enabled: false + } +} + +const debugInfo = createDebug() +export const debug = debugInfo.debug +export const debugEnabled = debugInfo.enabled +export default debug diff --git a/src/optimized/engine-ultra.js b/src/optimized/engine-ultra.js new file mode 100644 index 0000000..e3b8c84 --- /dev/null +++ b/src/optimized/engine-ultra.js @@ -0,0 +1,300 @@ +'use strict' + +import Fact from '../fact' +import RuleUltra from './rule-ultra' +import AlmanacUltra from './almanac-ultra' +import EventEmitter from 'eventemitter2' +import defaultOperators from '../engine-default-operators' +import defaultDecorators from '../engine-default-operator-decorators' +import { debug, debugEnabled } from './debug-fast' +import ConditionUltra from './condition-ultra' +import OperatorMap from '../operator-map' +import { hasProp, EVENT_PROP, CONDITIONS_PROP } from './perf-utils' + +export const READY = 'READY' +export const RUNNING = 'RUNNING' +export const FINISHED = 'FINISHED' + +class EngineUltra extends EventEmitter { + /** + * Returns a new ultra-optimized Engine instance with maximum performance + * @param {Rule[]} rules - array of rules to initialize with + * @param {Object} options - engine configuration options + */ + constructor (rules = [], options = {}) { + super() + this.rules = [] + this.allowUndefinedFacts = options.allowUndefinedFacts || false + this.allowUndefinedConditions = options.allowUndefinedConditions || false + this.replaceFactsInEventParams = options.replaceFactsInEventParams || false + this.pathResolver = options.pathResolver + this.operators = new OperatorMap() + this.facts = new Map() + this.conditions = new Map() + this.status = READY + this.prioritizedRules = null + + // Initialize without function calls in hot path + const rulesLength = rules.length + for (let i = 0; i < rulesLength; i++) { + this.addRule(rules[i]) + } + + // Batch operator/decorator setup + const operatorsLength = defaultOperators.length + for (let i = 0; i < operatorsLength; i++) { + this.addOperator(defaultOperators[i]) + } + + const decoratorsLength = defaultDecorators.length + for (let i = 0; i < decoratorsLength; i++) { + this.addOperatorDecorator(defaultDecorators[i]) + } + } + + addRule (properties) { + if (!properties) throw new Error('Engine: addRule() requires options') + + let rule + if (properties instanceof RuleUltra) { + rule = properties + } else { + if (!hasProp(properties, EVENT_PROP)) throw new Error('Engine: addRule() argument requires "event" property') + if (!hasProp(properties, CONDITIONS_PROP)) throw new Error('Engine: addRule() argument requires "conditions" property') + rule = new RuleUltra(properties) + } + rule.setEngine(this) + this.rules.push(rule) + this.prioritizedRules = null + return this + } + + updateRule (rule) { + const index = this.rules.findIndex(ruleInEngine => ruleInEngine.name === rule.name) + if (index > -1) { + this.rules.splice(index, 1) + this.addRule(rule) + this.prioritizedRules = null + } else { + throw new Error('Engine: updateRule() rule not found') + } + } + + removeRule (rule) { + let ruleRemoved = false + if (!(rule instanceof RuleUltra)) { + const originalLength = this.rules.length + this.rules = this.rules.filter(ruleInEngine => ruleInEngine.name !== rule) + ruleRemoved = this.rules.length !== originalLength + } else { + const index = this.rules.indexOf(rule) + if (index > -1) { + ruleRemoved = Boolean(this.rules.splice(index, 1).length) + } + } + if (ruleRemoved) { + this.prioritizedRules = null + } + return ruleRemoved + } + + setCondition (name, conditions) { + if (!name) throw new Error('Engine: setCondition() requires name') + if (!conditions) throw new Error('Engine: setCondition() requires conditions') + if (!hasProp(conditions, 'all') && !hasProp(conditions, 'any') && !hasProp(conditions, 'not') && !hasProp(conditions, 'condition')) { + throw new Error('"conditions" root must contain a single instance of "all", "any", "not", or "condition"') + } + this.conditions.set(name, new ConditionUltra(conditions)) + return this + } + + removeCondition (name) { + return this.conditions.delete(name) + } + + addOperator (operatorOrName, cb) { + this.operators.addOperator(operatorOrName, cb) + } + + removeOperator (operatorOrName) { + return this.operators.removeOperator(operatorOrName) + } + + addOperatorDecorator (decoratorOrName, cb) { + this.operators.addOperatorDecorator(decoratorOrName, cb) + } + + removeOperatorDecorator (decoratorOrName) { + return this.operators.removeOperatorDecorator(decoratorOrName) + } + + addFact (id, valueOrMethod, options) { + let factId = id + let fact + if (id instanceof Fact) { + factId = id.id + fact = id + } else { + fact = new Fact(factId, valueOrMethod, options) + } + if (debugEnabled) { + debug('engine::addFact', { id: factId }) + } + this.facts.set(factId, fact) + return this + } + + removeFact (factOrId) { + let factId + if (factOrId instanceof Fact) { + factId = factOrId.id + } else { + factId = factOrId + } + return this.facts.delete(factId) + } + + getFact (factId) { + return this.facts.get(factId) + } + + /** + * Ultra-optimized rule prioritization with minimal object creation + */ + prioritizeRules () { + if (!this.prioritizedRules) { + const ruleSets = {} + const rulesLength = this.rules.length + + // Single pass through rules + for (let i = 0; i < rulesLength; i++) { + const rule = this.rules[i] + const priority = rule.priority + if (!ruleSets[priority]) ruleSets[priority] = [] + ruleSets[priority].push(rule) + } + + // Sort priorities without intermediate array creation + const priorities = Object.keys(ruleSets) + priorities.sort((a, b) => Number(b) - Number(a)) // Descending order + + this.prioritizedRules = new Array(priorities.length) + for (let i = 0; i < priorities.length; i++) { + this.prioritizedRules[i] = ruleSets[priorities[i]] + } + } + return this.prioritizedRules + } + + stop () { + this.status = FINISHED + return this + } + + /** + * Ultra-optimized rule evaluation with minimal Promise overhead + */ + evaluateRules (ruleArray, almanac) { + const ruleArrayLength = ruleArray.length + const promises = new Array(ruleArrayLength) + + for (let i = 0; i < ruleArrayLength; i++) { + const rule = ruleArray[i] + if (this.status !== RUNNING) { + if (debugEnabled) { + debug('engine::run, skipping remaining rules', { status: this.status }) + } + promises[i] = Promise.resolve() + } else { + promises[i] = rule.evaluate(almanac).then((ruleResult) => { + if (debugEnabled) { + debug('engine::run', { ruleResult: ruleResult.result }) + } + return ruleResult + }).catch((error) => { + if (debugEnabled) { + debug('engine::evaluateRules error', { error: error.message }) + } + throw error + }) + } + } + + return Promise.all(promises) + } + + /** + * Ultra-optimized main run method with minimal overhead + */ + run (runtimeFacts = {}, runOptions = {}) { + if (debugEnabled) { + debug('engine::run started') + } + this.status = RUNNING + + const almanac = runOptions.almanac || new AlmanacUltra({ + facts: this.facts, + pathResolver: this.pathResolver, + allowUndefinedFacts: this.allowUndefinedFacts + }) + + // Fast runtime fact setup + const runtimeFactKeys = Object.keys(runtimeFacts) + const runtimeFactsLength = runtimeFactKeys.length + for (let i = 0; i < runtimeFactsLength; i++) { + const factId = runtimeFactKeys[i] + const fact = new Fact(factId, runtimeFacts[factId]) + if (debugEnabled) { + debug('engine::run initialized runtime fact', { id: fact.id, value: fact.value, type: typeof fact.value }) + } + almanac.addRuntimeFact(fact.id, fact) + } + + // Ultra-optimized rule execution + const prioritizedRules = this.prioritizeRules() + const executeRuleSets = (index) => { + if (index >= prioritizedRules.length || this.status !== RUNNING) { + if (debugEnabled) { + debug('engine::run, stopping due to status change', { status: this.status }) + } + return Promise.resolve([]) + } + + return this.evaluateRules(prioritizedRules[index], almanac).then(ruleResults => { + return executeRuleSets(index + 1).then(nextResults => { + return ruleResults.concat(nextResults) + }) + }) + } + + return executeRuleSets(0).then(ruleResults => { + this.status = FINISHED + if (debugEnabled) { + debug('engine::run completed') + } + + // Fast result compilation + const events = [] + const failureEvents = [] + const ruleResultsLength = ruleResults.length + + for (let i = 0; i < ruleResultsLength; i++) { + const ruleResult = ruleResults[i] + if (ruleResult && ruleResult.result) { + events.push(ruleResult.event) + } else if (ruleResult && !ruleResult.result) { + failureEvents.push(ruleResult.event) + } + } + + return { + events, + failureEvents, + almanac, + results: ruleResults + } + }) + } +} + +export default EngineUltra diff --git a/src/optimized/perf-utils.js b/src/optimized/perf-utils.js new file mode 100644 index 0000000..91bdc22 --- /dev/null +++ b/src/optimized/perf-utils.js @@ -0,0 +1,35 @@ +'use strict' + +// Pre-compiled performance helpers to avoid repeated operations + +// Cache for hasOwnProperty to avoid prototype lookup +const hasOwnProp = Object.prototype.hasOwnProperty + +// Optimized hasOwnProperty check +export const hasProp = (obj, prop) => hasOwnProp.call(obj, prop) + +// Fast object type check +export const isObject = (value) => value != null && typeof value === 'object' + +// Fast fact reference check - checks if value is a fact reference object +export const isFactReference = (value) => isObject(value) && hasProp(value, 'fact') + +// Fast shallow clone for simple objects (faster than deepClone for rule results) +export const shallowClone = (obj) => { + if (!isObject(obj)) return obj + if (Array.isArray(obj)) return obj.slice() + return Object.assign({}, obj) +} + +// Pre-compile common property names for faster access +export const FACT_PROP = 'fact' +export const OPERATOR_PROP = 'operator' +export const VALUE_PROP = 'value' +export const CONDITIONS_PROP = 'conditions' +export const EVENT_PROP = 'event' +export const PRIORITY_PROP = 'priority' +export const NAME_PROP = 'name' +export const CONDITION_PROP = 'condition' +export const ALL_PROP = 'all' +export const ANY_PROP = 'any' +export const NOT_PROP = 'not' diff --git a/src/optimized/rule-ultra.js b/src/optimized/rule-ultra.js new file mode 100644 index 0000000..abd5642 --- /dev/null +++ b/src/optimized/rule-ultra.js @@ -0,0 +1,148 @@ +'use strict' + +import ConditionUltra from './condition-ultra' +import RuleResult from '../rule-result' +import EventEmitter from 'eventemitter2' +import { debugEnabled, debug } from './debug-fast' +import { hasProp, PRIORITY_PROP } from './perf-utils' + +class RuleUltra extends EventEmitter { + /** + * Ultra-optimized Rule with minimal debug overhead + * @param {object} properties - rule properties + */ + constructor (properties = {}) { + super() + if (typeof properties === 'string') { + properties = JSON.parse(properties) + } + + Object.assign(this, properties) + this.priority = this.priority || 1 + this.conditions = new ConditionUltra(this.conditions) + this.engine = null + + if (hasProp(properties, PRIORITY_PROP)) { + this.setPriority(properties.priority) + } + } + + setConditions (conditions) { + if (!conditions) throw new Error('Rule: setConditions() requires conditions') + this.conditions = new ConditionUltra(conditions) + return this + } + + setEvent (event) { + if (!event) throw new Error('Rule: setEvent() requires event object') + if (!hasProp(event, 'type')) throw new Error('Rule: setEvent() requires event object with "type" property') + this.event = event + return this + } + + setPriority (priority) { + priority = parseInt(priority, 10) + if (priority <= 0) throw new Error('Rule: setPriority() priority must be greater than zero') + this.priority = priority + return this + } + + setName (name) { + if (name === '') { + throw new Error('Rule: setName() cannot be blank') + } + this.name = name + return this + } + + getName () { + return this.name + } + + getConditions () { + return this.conditions + } + + getEvent () { + return this.event + } + + getPriority () { + return this.priority + } + + setEngine (engine) { + this.engine = engine + return this + } + + toJSON (stringify = true) { + const props = { + conditions: this.conditions.toJSON(false), + priority: this.priority, + event: this.event + } + if (this.name) { + props.name = this.name + } + if (this.onSuccess) { + props.onSuccess = this.onSuccess + } + if (this.onFailure) { + props.onFailure = this.onFailure + } + if (stringify) { + return JSON.stringify(props) + } + return props + } + + /** + * Ultra-optimized rule evaluation + */ + evaluate (almanac) { + const evaluationPromise = this.conditions.isBooleanOperator() + ? this.conditions.evaluateBooleanCondition(almanac, this.engine.operators) + : this.conditions.evaluate(almanac, this.engine.operators) + .then(conditionResult => conditionResult.result) + + return evaluationPromise.then(ruleResult => { + const ruleResultObj = new RuleResult(this.conditions, this.event, this.priority, this.name) + ruleResultObj.result = ruleResult + + if (ruleResult) { + this._processSuccess(ruleResultObj, almanac) + } else { + this._processFailure(ruleResultObj, almanac) + } + + return ruleResultObj + }) + } + + _processSuccess (ruleResult, almanac) { + almanac.addEvent(ruleResult.event, 'success') + if (debugEnabled) { + debug('rule::fact-result', ruleResult.event) + } + this.emit('success', ruleResult.event, almanac, ruleResult) + this.engine.emit('success', ruleResult.event, almanac, ruleResult) + if (this.onSuccess) { + this.onSuccess(ruleResult.event, almanac, ruleResult) + } + } + + _processFailure (ruleResult, almanac) { + almanac.addEvent(ruleResult.event, 'failure') + if (debugEnabled) { + debug('rule::fact-result', ruleResult.event) + } + this.emit('failure', ruleResult.event, almanac, ruleResult) + this.engine.emit('failure', ruleResult.event, almanac, ruleResult) + if (this.onFailure) { + this.onFailure(ruleResult.event, almanac, ruleResult) + } + } +} + +export default RuleUltra diff --git a/test/optimized/engine-ultra-all.test.js b/test/optimized/engine-ultra-all.test.js new file mode 100644 index 0000000..789f8a3 --- /dev/null +++ b/test/optimized/engine-ultra-all.test.js @@ -0,0 +1,111 @@ +'use strict' + +import sinon from 'sinon' +import { EngineUltra } from '../../src/index' + +async function factSenior (params, engine) { + return 65 +} + +async function factChild (params, engine) { + return 10 +} + +async function factAdult (params, engine) { + return 30 +} + +describe('EngineUltra: "all" conditions', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + + describe('supports a single "all" condition', () => { + const event = { + type: 'ageTrigger', + params: { + demographic: 'under50' + } + } + const conditions = { + all: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }] + } + let eventSpy + beforeEach(() => { + eventSpy = sandbox.spy() + const rule = factories.rule({ conditions, event }) + engine = new EngineUltra() + engine.addRule(rule) + engine.on('success', eventSpy) + }) + + it('emits when the condition is met', async () => { + engine.addFact('age', factChild) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + it('does not emit when the condition fails', () => { + engine.addFact('age', factSenior) + engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) + + describe('supports "any" with multiple conditions', () => { + const conditions = { + all: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }, { + fact: 'age', + operator: 'greaterThan', + value: 21 + }] + } + const event = { + type: 'ageTrigger', + params: { + demographic: 'adult' + } + } + let eventSpy + beforeEach(() => { + eventSpy = sandbox.spy() + const rule = factories.rule({ conditions, event }) + engine = new EngineUltra() + engine.addRule(rule) + engine.on('success', eventSpy) + }) + + it('emits an event when every condition is met', async () => { + engine.addFact('age', factAdult) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + describe('a condition fails', () => { + it('does not emit when the first condition fails', async () => { + engine.addFact('age', factChild) + await engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + + it('does not emit when the second condition', async () => { + engine.addFact('age', factSenior) + await engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) + }) +}) diff --git a/test/optimized/engine-ultra-any.test.js b/test/optimized/engine-ultra-any.test.js new file mode 100644 index 0000000..bc25075 --- /dev/null +++ b/test/optimized/engine-ultra-any.test.js @@ -0,0 +1,107 @@ +'use strict' + +import sinon from 'sinon' +import { EngineUltra } from '../../src/index' + +describe('EngineUltra: "any" conditions', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + + describe('supports a single "any" condition', () => { + const event = { + type: 'ageTrigger', + params: { + demographic: 'under50' + } + } + const conditions = { + any: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }] + } + let eventSpy + let ageSpy + beforeEach(() => { + eventSpy = sandbox.spy() + ageSpy = sandbox.stub() + const rule = factories.rule({ conditions, event }) + engine = new EngineUltra() + engine.addRule(rule) + engine.addFact('age', ageSpy) + engine.on('success', eventSpy) + }) + + it('emits when the condition is met', async () => { + ageSpy.returns(10) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + it('does not emit when the condition fails', () => { + ageSpy.returns(75) + engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) + + describe('supports "any" with multiple conditions', () => { + const conditions = { + any: [{ + fact: 'age', + operator: 'lessThan', + value: 50 + }, { + fact: 'segment', + operator: 'equal', + value: 'european' + }] + } + const event = { + type: 'ageTrigger', + params: { + demographic: 'under50' + } + } + let eventSpy + let ageSpy + let segmentSpy + beforeEach(() => { + eventSpy = sandbox.spy() + ageSpy = sandbox.stub() + segmentSpy = sandbox.stub() + const rule = factories.rule({ conditions, event }) + engine = new EngineUltra() + engine.addRule(rule) + engine.addFact('segment', segmentSpy) + engine.addFact('age', ageSpy) + engine.on('success', eventSpy) + }) + + it('emits an event when any condition is met', async () => { + segmentSpy.returns('north-american') + ageSpy.returns(25) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + + segmentSpy.returns('european') + ageSpy.returns(100) + await engine.run() + expect(eventSpy).to.have.been.calledWith(event) + }) + + it('does not emit when all conditions fail', async () => { + segmentSpy.returns('north-american') + ageSpy.returns(100) + await engine.run() + expect(eventSpy).to.not.have.been.calledWith(event) + }) + }) +}) diff --git a/test/optimized/engine-ultra-comprehensive.test.js b/test/optimized/engine-ultra-comprehensive.test.js new file mode 100644 index 0000000..94764e9 --- /dev/null +++ b/test/optimized/engine-ultra-comprehensive.test.js @@ -0,0 +1,202 @@ +'use strict' + +import sinon from 'sinon' +import { EngineUltra, Rule } from '../../src/index' + +describe('EngineUltra: comprehensive coverage', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + beforeEach(() => { + engine = new EngineUltra() + }) + + describe('setCondition()', () => { + it('throws error when name is missing', () => { + expect(() => { + engine.setCondition() + }).to.throw(/Engine: setCondition\(\) requires name/) + }) + + it('throws error when conditions are missing', () => { + expect(() => { + engine.setCondition('test') + }).to.throw(/Engine: setCondition\(\) requires conditions/) + }) + + it('throws error for invalid root conditions', () => { + expect(() => { + engine.setCondition('test', { invalid: true }) + }).to.throw(/"conditions" root must contain a single instance of "all", "any", "not", or "condition"/) + }) + + it('successfully sets a valid condition', () => { + const conditions = { all: [{ fact: 'age', operator: 'greaterThan', value: 18 }] } + const result = engine.setCondition('adult', conditions) + expect(result).to.equal(engine) + expect(engine.conditions.has('adult')).to.be.true() + }) + }) + + describe('removeCondition()', () => { + it('removes existing condition', () => { + const conditions = { all: [{ fact: 'age', operator: 'greaterThan', value: 18 }] } + engine.setCondition('adult', conditions) + expect(engine.conditions.has('adult')).to.be.true() + + const result = engine.removeCondition('adult') + expect(result).to.be.true() + expect(engine.conditions.has('adult')).to.be.false() + }) + + it('returns false for non-existing condition', () => { + const result = engine.removeCondition('nonexistent') + expect(result).to.be.false() + }) + }) + + describe('addOperatorDecorator()', () => { + it('adds operator decorator', () => { + engine.addOperatorDecorator('some', (operator) => { + return operator + }) + expect(engine.operators.decorators.has('some')).to.be.true() + }) + }) + + describe('removeOperatorDecorator()', () => { + it('removes operator decorator', () => { + engine.addOperatorDecorator('some', (operator) => { + return operator + }) + expect(engine.operators.decorators.has('some')).to.be.true() + + const result = engine.removeOperatorDecorator('some') + expect(result).to.be.true() + expect(engine.operators.decorators.has('some')).to.be.false() + }) + }) + + describe('getFact()', () => { + it('retrieves existing fact', () => { + engine.addFact('testFact', 42) + const fact = engine.getFact('testFact') + expect(fact).to.exist() + expect(fact.value).to.equal(42) + }) + + it('returns undefined for non-existing fact', () => { + const fact = engine.getFact('nonexistent') + expect(fact).to.be.undefined() + }) + }) + + describe('prioritizeRules()', () => { + it('prioritizes rules by priority value', () => { + const rule1 = new Rule(factories.rule({ priority: 10 })) + const rule2 = new Rule(factories.rule({ priority: 5 })) + const rule3 = new Rule(factories.rule({ priority: 10 })) + + engine.addRule(rule1) + engine.addRule(rule2) + engine.addRule(rule3) + + const prioritized = engine.prioritizeRules() + expect(prioritized.length).to.equal(2) // Two priority groups + expect(prioritized[0].length).to.equal(2) // Two rules with priority 10 + expect(prioritized[1].length).to.equal(1) // One rule with priority 5 + }) + + it('caches prioritized rules', () => { + const rule1 = new Rule(factories.rule({ priority: 10 })) + engine.addRule(rule1) + + const firstCall = engine.prioritizeRules() + const secondCall = engine.prioritizeRules() + expect(firstCall).to.equal(secondCall) // Same reference + }) + }) + + describe('rule priority handling', () => { + it('handles rules with different priorities', async () => { + const rule1 = new Rule(factories.rule({ priority: 1, event: { type: 'low' } })) + const rule2 = new Rule(factories.rule({ priority: 10, event: { type: 'high' } })) + + engine.addRule(rule1) + engine.addRule(rule2) + engine.addFact('age', 25) + engine.addFact('pointBalance', 2000) + + const results = await engine.run() + expect(results.events.length).to.equal(2) + }) + + it('handles stop() during execution', () => { + const rule = new Rule(factories.rule()) + engine.addRule(rule) + engine.addFact('age', 25) + engine.addFact('pointBalance', 2000) + + // Stop the engine + engine.stop() + expect(engine.status).to.equal('FINISHED') + }) + }) + + describe('error handling', () => { + it('handles rule evaluation errors gracefully', async () => { + const badRule = new Rule({ + conditions: { all: [{ fact: 'age', operator: 'invalidOperator', value: 18 }] }, + event: { type: 'test' } + }) + engine.addRule(badRule) + engine.addFact('age', 25) + + const errorSpy = sandbox.spy() + engine.on('failure', errorSpy) + + try { + await engine.run() + } catch (error) { + // Expected to catch error + } + }) + }) + + describe('allowUndefinedFacts option', () => { + it('throws when undefined fact encountered and option is false', async () => { + const rule = new Rule({ + conditions: { all: [{ fact: 'nonexistent', operator: 'equal', value: 'test' }] }, + event: { type: 'test' } + }) + engine.addRule(rule) + + try { + await engine.run() + expect.fail('Should have thrown an error') + } catch (error) { + expect(error.message).to.include('Undefined fact') + } + }) + + it('treats undefined facts as falsey when option is true', async () => { + engine = new EngineUltra([], { allowUndefinedFacts: true }) + const rule = new Rule({ + conditions: { all: [{ fact: 'nonexistent', operator: 'equal', value: undefined }] }, + event: { type: 'test' } + }) + engine.addRule(rule) + + const eventSpy = sandbox.spy() + engine.on('success', eventSpy) + + const result = await engine.run() + expect(result.events.length).to.equal(1) + }) + }) +}) diff --git a/test/optimized/engine-ultra-run.test.js b/test/optimized/engine-ultra-run.test.js new file mode 100644 index 0000000..953bd9d --- /dev/null +++ b/test/optimized/engine-ultra-run.test.js @@ -0,0 +1,136 @@ +'use strict' + +import { EngineUltra } from '../../src/index' +import AlmanacUltra from '../../src/optimized/almanac-ultra' +import sinon from 'sinon' + +describe('EngineUltra: run', () => { + let engine, rule, rule2 + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + + const condition21 = { + any: [{ + fact: 'age', + operator: 'greaterThanInclusive', + value: 21 + }] + } + const condition75 = { + any: [{ + fact: 'age', + operator: 'greaterThanInclusive', + value: 75 + }] + } + let eventSpy + + beforeEach(() => { + eventSpy = sandbox.spy() + engine = new EngineUltra() + rule = factories.rule({ conditions: condition21, event: { type: 'generic1' } }) + engine.addRule(rule) + rule2 = factories.rule({ conditions: condition75, event: { type: 'generic2' } }) + engine.addRule(rule2) + engine.on('success', eventSpy) + }) + + describe('independent runs', () => { + it('treats each run() independently', async () => { + await Promise.all([50, 10, 12, 30, 14, 15, 25].map((age) => engine.run({ age }))) + expect(eventSpy).to.have.been.calledThrice() + }) + + it('allows runtime facts to override engine facts for a single run()', async () => { + engine.addFact('age', 30) + + await engine.run({ age: 85 }) // override 'age' with runtime fact + expect(eventSpy).to.have.been.calledTwice() + + sandbox.reset() + await engine.run() // no runtime fact; revert to age: 30 + expect(eventSpy).to.have.been.calledOnce() + + sandbox.reset() + await engine.run({ age: 2 }) // override 'age' with runtime fact + expect(eventSpy.callCount).to.equal(0) + }) + }) + + describe('returns', () => { + it('activated events', async () => { + const { events, failureEvents } = await engine.run({ age: 30 }) + expect(events.length).to.equal(1) + expect(events).to.deep.include(rule.event) + expect(failureEvents.length).to.equal(1) + expect(failureEvents).to.deep.include(rule2.event) + }) + + it('multiple activated events', () => { + return engine.run({ age: 90 }).then(results => { + expect(results.events.length).to.equal(2) + expect(results.events).to.deep.include(rule.event) + expect(results.events).to.deep.include(rule2.event) + }) + }) + + it('does not include unactived triggers', () => { + return engine.run({ age: 10 }).then(results => { + expect(results.events.length).to.equal(0) + }) + }) + + it('includes the almanac', () => { + return engine.run({ age: 10 }).then(results => { + expect(results.almanac).to.be.an.instanceOf(AlmanacUltra) + return results.almanac.factValue('age') + }).then(ageFact => expect(ageFact).to.equal(10)) + }) + }) + + describe('facts updated during run', () => { + beforeEach(() => { + engine.on('success', (event, almanac, ruleResult) => { + // Assign unique runtime facts per event + almanac.addRuntimeFact(`runtime-fact-${event.type}`, ruleResult.conditions.any[0].value) + }) + }) + + it('returns an almanac with runtime facts added', () => { + return engine.run({ age: 90 }).then(results => { + return Promise.all([ + results.almanac.factValue('runtime-fact-generic1'), + results.almanac.factValue('runtime-fact-generic2') + ]) + }).then(promiseValues => { + expect(promiseValues[0]).to.equal(21) + expect(promiseValues[1]).to.equal(75) + }) + }) + }) + + describe('custom alamanc', () => { + class CapitalAlmanac extends AlmanacUltra { + factValue (factId, params, path) { + return super.factValue(factId, params, path).then(value => { + if (typeof value === 'string') { + return value.toUpperCase() + } + return value + }) + } + } + + it('returns the capitalized value when using the CapitalAlamanc', () => { + return engine.run({ greeting: 'hello', age: 30 }, { almanac: new CapitalAlmanac() }).then((results) => { + const fact = results.almanac.factValue('greeting') + return expect(fact).to.eventually.equal('HELLO') + }) + }) + }) +}) diff --git a/test/optimized/engine-ultra.test.js b/test/optimized/engine-ultra.test.js new file mode 100644 index 0000000..c276194 --- /dev/null +++ b/test/optimized/engine-ultra.test.js @@ -0,0 +1,333 @@ +'use strict' + +import sinon from 'sinon' +import { EngineFast, Fact, Rule, Operator } from '../../src/index' +import defaultOperators from '../../src/engine-default-operators' + +describe('EngineFast', () => { + let engine + let sandbox + before(() => { + sandbox = sinon.createSandbox() + }) + afterEach(() => { + sandbox.restore() + }) + beforeEach(() => { + engine = new EngineFast() + }) + + it('has methods for managing facts and rules, and running itself', () => { + expect(engine).to.have.property('addRule') + expect(engine).to.have.property('removeRule') + expect(engine).to.have.property('addOperator') + expect(engine).to.have.property('removeOperator') + expect(engine).to.have.property('addFact') + expect(engine).to.have.property('removeFact') + expect(engine).to.have.property('run') + expect(engine).to.have.property('stop') + }) + + describe('constructor', () => { + it('initializes with the default state', () => { + expect(engine.status).to.equal('READY') + expect(engine.rules.length).to.equal(0) + defaultOperators.forEach(op => { + expect(engine.operators.get(op.name)).to.be.an.instanceof(Operator) + }) + }) + + it('can be initialized with rules', () => { + const rules = [ + factories.rule(), + factories.rule(), + factories.rule() + ] + engine = new EngineFast(rules) + expect(engine.rules.length).to.equal(rules.length) + }) + }) + + describe('stop()', () => { + it('changes the status to "FINISHED"', () => { + expect(engine.stop().status).to.equal('FINISHED') + }) + }) + + describe('addRule()', () => { + describe('rule instance', () => { + it('adds the rule', () => { + const rule = new Rule(factories.rule()) + expect(engine.rules.length).to.equal(0) + engine.addRule(rule) + expect(engine.rules.length).to.equal(1) + // EngineFast converts Rule to RuleFast internally + expect(engine.rules[0]).to.be.an('object') + expect(engine.rules[0].event).to.eql(rule.event) + }) + }) + + describe('required fields', () => { + it('.conditions', () => { + const rule = factories.rule() + delete rule.conditions + expect(() => { + engine.addRule(rule) + }).to.throw(/Engine: addRule\(\) argument requires "conditions" property/) + }) + + it('.event', () => { + const rule = factories.rule() + delete rule.event + expect(() => { + engine.addRule(rule) + }).to.throw(/Engine: addRule\(\) argument requires "event" property/) + }) + }) + }) + + describe('updateRule()', () => { + it('updates rule', () => { + let rule1 = new Rule(factories.rule({ name: 'rule1' })) + let rule2 = new Rule(factories.rule({ name: 'rule2' })) + engine.addRule(rule1) + engine.addRule(rule2) + expect(engine.rules[0].conditions.all.length).to.equal(2) + expect(engine.rules[1].conditions.all.length).to.equal(2) + + rule1.conditions = { all: [] } + engine.updateRule(rule1) + + rule1 = engine.rules.find(rule => rule.name === 'rule1') + rule2 = engine.rules.find(rule => rule.name === 'rule2') + expect(rule1.conditions.all.length).to.equal(0) + expect(rule2.conditions.all.length).to.equal(2) + }) + + it('should throw error if rule not found', () => { + const rule1 = new Rule(factories.rule({ name: 'rule1' })) + engine.addRule(rule1) + const rule2 = new Rule(factories.rule({ name: 'rule2' })) + expect(() => { + engine.updateRule(rule2) + }).to.throw(/Engine: updateRule\(\) rule not found/) + }) + }) + + describe('removeRule()', () => { + function setup () { + const rule1 = new Rule(factories.rule({ name: 'rule1' })) + const rule2 = new Rule(factories.rule({ name: 'rule2' })) + engine.addRule(rule1) + engine.addRule(rule2) + engine.prioritizeRules() + + // Return the converted RuleFast instances from the engine + return [engine.rules[0], engine.rules[1]] + } + context('remove by rule.name', () => { + it('removes a single rule', () => { + const [rule1] = setup() + expect(engine.rules.length).to.equal(2) + + const isRemoved = engine.removeRule(rule1.name) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(1) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('removes multiple rules with the same name', () => { + const [rule1] = setup() + const rule3 = new Rule(factories.rule({ name: rule1.name })) + engine.addRule(rule3) + expect(engine.rules.length).to.equal(3) + + const isRemoved = engine.removeRule(rule1.name) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(1) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('returns false when rule cannot be found', () => { + setup() + expect(engine.rules.length).to.equal(2) + + const isRemoved = engine.removeRule('not-found-name') + + expect(isRemoved).to.be.false() + expect(engine.rules.length).to.equal(2) + expect(engine.prioritizedRules).to.not.equal(null) + }) + }) + context('remove by rule object', () => { + it('removes a single rule', () => { + const [rule1] = setup() + expect(engine.rules.length).to.equal(2) + + const isRemoved = engine.removeRule(rule1) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(1) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('removes a single rule, even if two have the same name', () => { + const [rule1] = setup() + const rule3 = new Rule(factories.rule({ name: rule1.name })) + engine.addRule(rule3) + expect(engine.rules.length).to.equal(3) + + const isRemoved = engine.removeRule(rule1) + + expect(isRemoved).to.be.true() + expect(engine.rules.length).to.equal(2) + expect(engine.prioritizedRules).to.equal(null) + }) + + it('returns false when rule cannot be found', () => { + setup() + expect(engine.rules.length).to.equal(2) + + const rule3 = new Rule(factories.rule({ name: 'rule3' })) + const isRemoved = engine.removeRule(rule3) + + expect(isRemoved).to.be.false() + expect(engine.rules.length).to.equal(2) + expect(engine.prioritizedRules).to.not.equal(null) + }) + }) + }) + + describe('addOperator()', () => { + it('adds the operator', () => { + engine.addOperator('startsWithLetter', (factValue, jsonValue) => { + return factValue[0] === jsonValue + }) + expect(engine.operators.get('startsWithLetter')).to.exist() + expect(engine.operators.get('startsWithLetter')).to.be.an.instanceof(Operator) + }) + + it('accepts an operator instance', () => { + const op = new Operator('my-operator', _ => true) + engine.addOperator(op) + expect(engine.operators.get('my-operator')).to.equal(op) + }) + }) + + describe('removeOperator()', () => { + it('removes the operator', () => { + engine.addOperator('startsWithLetter', (factValue, jsonValue) => { + return factValue[0] === jsonValue + }) + expect(engine.operators.get('startsWithLetter')).to.be.an.instanceof(Operator) + engine.removeOperator('startsWithLetter') + expect(engine.operators.get('startsWithLetter')).to.be.null() + }) + + it('can only remove added operators', () => { + const isRemoved = engine.removeOperator('nonExisting') + expect(isRemoved).to.equal(false) + }) + }) + + describe('addFact()', () => { + const FACT_NAME = 'FACT_NAME' + const FACT_VALUE = 'FACT_VALUE' + + function assertFact (engine) { + expect(engine.facts.size).to.equal(1) + expect(engine.facts.has(FACT_NAME)).to.be.true() + } + + it('allows a constant fact', () => { + engine.addFact(FACT_NAME, FACT_VALUE) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).value).to.equal(FACT_VALUE) + }) + + it('allows options to be passed', () => { + const options = { cache: false } + engine.addFact(FACT_NAME, FACT_VALUE, options) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).value).to.equal(FACT_VALUE) + expect(engine.facts.get(FACT_NAME).options).to.eql(options) + }) + + it('allows a lamba fact with no options', () => { + engine.addFact(FACT_NAME, async (params, engine) => { + return FACT_VALUE + }) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).value).to.be.undefined() + }) + + it('allows a lamba fact with options', () => { + const options = { cache: false } + engine.addFact(FACT_NAME, async (params, engine) => { + return FACT_VALUE + }, options) + assertFact(engine) + expect(engine.facts.get(FACT_NAME).options).to.eql(options) + expect(engine.facts.get(FACT_NAME).value).to.be.undefined() + }) + + it('allows a fact instance', () => { + const options = { cache: false } + const fact = new Fact(FACT_NAME, 50, options) + engine.addFact(fact) + assertFact(engine) + expect(engine.facts.get(FACT_NAME)).to.exist() + expect(engine.facts.get(FACT_NAME).options).to.eql(options) + }) + }) + + describe('removeFact()', () => { + it('removes a Fact', () => { + expect(engine.facts.size).to.equal(0) + const fact = new Fact('newFact', 50, { cache: false }) + engine.addFact(fact) + expect(engine.facts.size).to.equal(1) + engine.removeFact('newFact') + expect(engine.facts.size).to.equal(0) + }) + + it('can only remove added facts', () => { + expect(engine.facts.size).to.equal(0) + const isRemoved = engine.removeFact('newFact') + expect(isRemoved).to.equal(false) + }) + }) + + describe('run()', () => { + beforeEach(() => { + const conditions = { + all: [{ + fact: 'age', + operator: 'greaterThanInclusive', + value: 18 + }] + } + const event = { type: 'generic' } + const rule = factories.rule({ conditions, event }) + engine.addRule(rule) + engine.addFact('age', 20) + }) + + it('changes the status to "RUNNING"', () => { + const eventSpy = sandbox.spy() + engine.on('success', (event, almanac) => { + eventSpy() + expect(engine.status).to.equal('RUNNING') + }) + return engine.run() + }) + + it('changes status to FINISHED once complete', async () => { + expect(engine.status).to.equal('READY') + await engine.run() + expect(engine.status).to.equal('FINISHED') + }) + }) +}) From 1f0bd486bcd7440988fd686085e6a83f34022f1e Mon Sep 17 00:00:00 2001 From: Manuel Reil Date: Sun, 17 Aug 2025 12:57:39 +0200 Subject: [PATCH 6/7] Adds benchmark:compare:all --- package.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index df06bff..df3608b 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,8 @@ "benchmark:quick": "node --expose-gc benchmark/benchmark.js --events 100 --rules 10 --runs 3", "benchmark:full": "node --expose-gc benchmark/benchmark.js --events 10000 --rules 30 --runs 10", "benchmark:compare": "node --expose-gc benchmark/benchmark-comparison.js", - "benchmark:compare:quick": "node --expose-gc benchmark/benchmark-comparison.js --events 100 --rules 10 --runs 3" + "benchmark:compare:quick": "node --expose-gc benchmark/benchmark-comparison.js --events 100 --rules 10 --runs 3", + "benchmark:compare:all": "node --expose-gc benchmark/benchmark-fast-vs-ultra.js" }, "repository": { "type": "git", From 9aea16be75eff4af6c4db97dd3789abaf128e967 Mon Sep 17 00:00:00 2001 From: Manuel Reil Date: Sun, 17 Aug 2025 13:11:01 +0200 Subject: [PATCH 7/7] Cleans up benchmark folder --- benchmark/benchmark-optimized.js | 107 ----------------------- benchmark/benchmark-ultra-vs-original.js | 101 --------------------- benchmark/benchmark-ultra.js | 100 --------------------- 3 files changed, 308 deletions(-) delete mode 100644 benchmark/benchmark-optimized.js delete mode 100644 benchmark/benchmark-ultra-vs-original.js delete mode 100644 benchmark/benchmark-ultra.js diff --git a/benchmark/benchmark-optimized.js b/benchmark/benchmark-optimized.js deleted file mode 100644 index adfe106..0000000 --- a/benchmark/benchmark-optimized.js +++ /dev/null @@ -1,107 +0,0 @@ -const { Engine, EngineFast } = require('../dist/index') -const { performance } = require('perf_hooks') -const rules = require('./rules') - -async function benchmarkEngine (EngineClass, engineName, numEvents = 1000, numRules = 30) { - console.log(`\n=== ${engineName} Benchmark ===`) - - // Create engine with rules - const engine = new EngineClass() - rules.slice(0, numRules).forEach(rule => engine.addRule(rule)) - - // Generate test events - const { generateEvents } = require('./events') - const events = generateEvents(require('./events').baseEvents, numEvents) - - // Warm-up run with proper fact structure - await engine.run(events[0]) - - // Benchmark run - const startTime = performance.now() - let totalSuccessEvents = 0 - let totalFailureEvents = 0 - - for (const event of events) { - // Pass the event as facts to the engine - const result = await engine.run(event) - totalSuccessEvents += result.events.length - totalFailureEvents += result.failureEvents.length - } - - const endTime = performance.now() - const duration = endTime - startTime - const eventsPerSecond = Math.round(numEvents / (duration / 1000)) - - console.log(`Events processed: ${numEvents}`) - console.log(`Rules per event: ${numRules}`) - console.log(`Total time: ${Math.round(duration)}ms`) - console.log(`Events/second: ${eventsPerSecond}`) - console.log(`Success events: ${totalSuccessEvents}`) - console.log(`Failure events: ${totalFailureEvents}`) - console.log(`Avg time per event: ${Math.round(duration / numEvents * 100) / 100}ms`) - - return { - engineName, - numEvents, - numRules, - duration, - eventsPerSecond, - totalSuccessEvents, - totalFailureEvents, - avgTimePerEvent: duration / numEvents - } -} - -async function runComparison () { - console.log('Performance Comparison: Original vs Optimized Async Engine') - console.log('==========================================================') - - const results = [] - - // Test small workload - console.log('\n--- Small Workload Test (100 events, 10 rules) ---') - results.push(await benchmarkEngine(Engine, 'Original Engine', 100, 10)) - results.push(await benchmarkEngine(EngineFast, 'Optimized Engine (EngineFast)', 100, 10)) - - // Test medium workload - console.log('\n--- Medium Workload Test (500 events, 20 rules) ---') - results.push(await benchmarkEngine(Engine, 'Original Engine', 500, 20)) - results.push(await benchmarkEngine(EngineFast, 'Optimized Engine (EngineFast)', 500, 20)) - - // Test large workload - console.log('\n--- Large Workload Test (1000 events, 30 rules) ---') - results.push(await benchmarkEngine(Engine, 'Original Engine', 1000, 30)) - results.push(await benchmarkEngine(EngineFast, 'Optimized Engine (EngineFast)', 1000, 30)) - - // Performance comparison summary - console.log('\n\n=== PERFORMANCE COMPARISON SUMMARY ===') - - for (let i = 0; i < results.length; i += 2) { - const original = results[i] - const optimized = results[i + 1] - const improvement = ((original.duration - optimized.duration) / original.duration) * 100 - const throughputImprovement = ((optimized.eventsPerSecond - original.eventsPerSecond) / original.eventsPerSecond) * 100 - - console.log(`\n${original.numEvents} events, ${original.numRules} rules:`) - console.log(` Original: ${Math.round(original.duration)}ms (${original.eventsPerSecond} events/sec)`) - console.log(` Optimized: ${Math.round(optimized.duration)}ms (${optimized.eventsPerSecond} events/sec)`) - console.log(` Performance: ${improvement > 0 ? '+' : ''}${Math.round(improvement * 100) / 100}% ${improvement > 0 ? 'faster' : 'slower'}`) - console.log(` Throughput: ${throughputImprovement > 0 ? '+' : ''}${Math.round(throughputImprovement * 100) / 100}% ${throughputImprovement > 0 ? 'better' : 'worse'}`) - } - - // Overall assessment - const totalOriginalTime = results.filter((_, i) => i % 2 === 0).reduce((sum, r) => sum + r.duration, 0) - const totalOptimizedTime = results.filter((_, i) => i % 2 === 1).reduce((sum, r) => sum + r.duration, 0) - const overallImprovement = ((totalOriginalTime - totalOptimizedTime) / totalOriginalTime) * 100 - - console.log('\n=== OVERALL PERFORMANCE ===') - console.log(`Total Original Time: ${Math.round(totalOriginalTime)}ms`) - console.log(`Total Optimized Time: ${Math.round(totalOptimizedTime)}ms`) - console.log(`Overall Improvement: ${overallImprovement > 0 ? '+' : ''}${Math.round(overallImprovement * 100) / 100}% ${overallImprovement > 0 ? 'faster' : 'slower'}`) -} - -if (require.main === module) { - runComparison().catch(console.error) -} - -module.exports = { benchmarkEngine, runComparison } diff --git a/benchmark/benchmark-ultra-vs-original.js b/benchmark/benchmark-ultra-vs-original.js deleted file mode 100644 index d78e06d..0000000 --- a/benchmark/benchmark-ultra-vs-original.js +++ /dev/null @@ -1,101 +0,0 @@ -const { Engine, EngineUltra } = require('../dist/index') -const { performance } = require('perf_hooks') -const rules = require('./rules') - -async function benchmarkEngine (EngineClass, engineName, numEvents = 1000, numRules = 30) { - console.log(`\n=== ${engineName} Benchmark ===`) - - // Generate test events first - const events = [] - for (let i = 0; i < numEvents; i++) { - events.push({ - record: { - review: { - maturityValue: Math.floor(Math.random() * 5) + 1, - isComplete: Math.random() > 0.3, - score: Math.floor(Math.random() * 100), - riskLevel: ['low', 'medium', 'high'][Math.floor(Math.random() * 3)] - }, - company: { - size: ['small', 'medium', 'large'][Math.floor(Math.random() * 3)], - industry: ['tech', 'finance', 'healthcare'][Math.floor(Math.random() * 3)] - } - }, - metadata: { - timestamp: Date.now(), - source: 'webhook' - } - }) - } - - // Create engine with rules - const engine = new EngineClass() - for (let i = 0; i < numRules; i++) { - engine.addRule(rules[i]) - } - - // Add static facts that most rules will use - engine.addFact('type', 'com.alyne.objects.updated') - engine.addFact('eventType', 'com.alyne.objects.updated') - engine.addFact('data', (params, almanac) => events[0]) // Use first event as data - engine.addFact('companyId', 'company-123') - engine.addFact('userId', 'user-456') - - console.log(`Engine setup: ${numRules} rules loaded`) - - // Warm up JIT - for (let i = 0; i < 10; i++) { - await engine.run(events[0]) - } - - // Actual benchmark - const startTime = performance.now() - - for (let i = 0; i < numEvents; i++) { - await engine.run(events[i]) - } - - const endTime = performance.now() - const duration = endTime - startTime - const eventsPerSecond = Math.round((numEvents * 1000) / duration) - - console.log(`Processed ${numEvents} events in ${duration.toFixed(2)}ms`) - console.log(`Throughput: ${eventsPerSecond} events/second`) - - return { duration, eventsPerSecond, engineName } -} - -async function runComparison () { - console.log('Performance Comparison: EngineUltra vs Original Engine') - console.log('='.repeat(60)) - - const workloads = [ - { events: 100, rules: 10, name: 'Small' }, - { events: 500, rules: 20, name: 'Medium' }, - { events: 1000, rules: 30, name: 'Large' }, - { events: 2000, rules: 30, name: 'Extra Large' } - ] - - for (const workload of workloads) { - console.log(`\nšŸ” ${workload.name} Workload: ${workload.events} events, ${workload.rules} rules`) - - const [originalResult, ultraResult] = await Promise.all([ - benchmarkEngine(Engine, 'Engine (Original)', workload.events, workload.rules), - benchmarkEngine(EngineUltra, 'EngineUltra', workload.events, workload.rules) - ]) - - const improvement = ((ultraResult.eventsPerSecond - originalResult.eventsPerSecond) / originalResult.eventsPerSecond * 100).toFixed(2) - const speedupFactor = (ultraResult.eventsPerSecond / originalResult.eventsPerSecond).toFixed(2) - - console.log('\nšŸ“Š Performance Results:') - console.log(`Original: ${originalResult.eventsPerSecond} events/sec`) - console.log(`Ultra: ${ultraResult.eventsPerSecond} events/sec`) - console.log(`Improvement: +${improvement}% (${speedupFactor}x faster)`) - } -} - -if (require.main === module) { - runComparison().catch(console.error) -} - -module.exports = { benchmarkEngine, runComparison } diff --git a/benchmark/benchmark-ultra.js b/benchmark/benchmark-ultra.js deleted file mode 100644 index 2b5221f..0000000 --- a/benchmark/benchmark-ultra.js +++ /dev/null @@ -1,100 +0,0 @@ -const { Engine, EngineFast, EngineUltra } = require('../dist/index') -const { performance } = require('perf_hooks') -const rules = require('./rules') - -async function benchmarkEngine (EngineClass, engineName, numEvents = 1000, numRules = 30) { - console.log(`\n=== ${engineName} Benchmark ===`) - - // Generate test events first - const events = [] - for (let i = 0; i < numEvents; i++) { - events.push({ - record: { - review: { - maturityValue: Math.floor(Math.random() * 5) + 1, - isComplete: Math.random() > 0.3, - score: Math.floor(Math.random() * 100), - riskLevel: ['low', 'medium', 'high'][Math.floor(Math.random() * 3)] - }, - company: { - size: ['small', 'medium', 'large'][Math.floor(Math.random() * 3)], - industry: ['tech', 'finance', 'healthcare'][Math.floor(Math.random() * 3)] - } - }, - metadata: { - timestamp: Date.now(), - source: 'webhook' - } - }) - } - - // Create engine with rules - const engine = new EngineClass() - for (let i = 0; i < numRules; i++) { - engine.addRule(rules[i]) - } - - // Add static facts that most rules will use - engine.addFact('type', 'com.alyne.objects.updated') - engine.addFact('eventType', 'com.alyne.objects.updated') - engine.addFact('data', (params, almanac) => events[0]) // Use first event as data - engine.addFact('companyId', 'company-123') - engine.addFact('userId', 'user-456') - - console.log(`Engine setup: ${numRules} rules loaded`) - - // Warm up JIT - for (let i = 0; i < 10; i++) { - await engine.run(events[0]) - } - - // Actual benchmark - const startTime = performance.now() - - for (let i = 0; i < numEvents; i++) { - await engine.run(events[i]) - } - - const endTime = performance.now() - const duration = endTime - startTime - const eventsPerSecond = Math.round((numEvents * 1000) / duration) - - console.log(`Processed ${numEvents} events in ${duration.toFixed(2)}ms`) - console.log(`Throughput: ${eventsPerSecond} events/second`) - - return { duration, eventsPerSecond, engineName } -} - -async function runComparison () { - console.log('Performance Comparison: Debug Overhead Elimination') - console.log('='.repeat(60)) - - const smallWorkload = { events: 100, rules: 10 } - const mediumWorkload = { events: 500, rules: 20 } - const largeWorkload = { events: 1000, rules: 30 } - - for (const { events, rules } of [smallWorkload, mediumWorkload, largeWorkload]) { - console.log(`\nšŸ” Workload: ${events} events, ${rules} rules`) - - const [originalResult, fastResult, ultraResult] = await Promise.all([ - benchmarkEngine(Engine, 'Engine (Original)', events, rules), - benchmarkEngine(EngineFast, 'EngineFast', events, rules), - benchmarkEngine(EngineUltra, 'EngineUltra', events, rules) - ]) - - const fastImprovement = ((fastResult.eventsPerSecond - originalResult.eventsPerSecond) / originalResult.eventsPerSecond * 100).toFixed(2) - const ultraImprovement = ((ultraResult.eventsPerSecond - originalResult.eventsPerSecond) / originalResult.eventsPerSecond * 100).toFixed(2) - const ultraVsFast = ((ultraResult.eventsPerSecond - fastResult.eventsPerSecond) / fastResult.eventsPerSecond * 100).toFixed(2) - - console.log('\nšŸ“Š Performance Improvements:') - console.log(`EngineFast vs Original: +${fastImprovement}%`) - console.log(`EngineUltra vs Original: +${ultraImprovement}%`) - console.log(`EngineUltra vs EngineFast: +${ultraVsFast}%`) - } -} - -if (require.main === module) { - runComparison().catch(console.error) -} - -module.exports = { benchmarkEngine, runComparison }