@hotmeshio/hotmesh 0.0.1

package/build/services/logger/index.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from 'winston';
+import { ILogger } from '../../types/logger';
+declare class LoggerService implements ILogger {
+    private appId;
+    private instanceId;
+    private name;
+    private logLevel;
+    private logger;
+    constructor(appId?: string, instanceId?: string, name?: string, logLevel?: string, customLogger?: Logger);
+    private createDefaultLogger;
+    info(message: string, ...meta: any[]): void;
+    error(message: string, ...meta: any[]): void;
+    warn(message: string, ...meta: any[]): void;
+    debug(message: string, ...meta: any[]): void;
+    tagify(obj: Record<string, unknown>): string;
+}
+export { LoggerService, ILogger };

package/build/services/logger/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = void 0;
+const winston_1 = require("winston");
+class LoggerService {
+    constructor(appId = 'appId', instanceId = 'instanceId', name = 'name', logLevel = 'info', customLogger) {
+        this.appId = appId;
+        this.instanceId = instanceId;
+        this.name = name;
+        this.logLevel = logLevel;
+        this.logger = customLogger || this.createDefaultLogger();
+    }
+    createDefaultLogger() {
+        return (0, winston_1.createLogger)({
+            level: this.logLevel,
+            format: winston_1.format.combine(winston_1.format.colorize(), winston_1.format.timestamp(), winston_1.format.printf((info) => {
+                const { timestamp, level, message } = info;
+                // Extract the object from the `info` object's `Symbol(splat)` field
+                const symbols = Object.getOwnPropertySymbols(info);
+                const splatSymbol = symbols.find(symbol => symbol.toString() === 'Symbol(splat)');
+                let splatData = {};
+                if (splatSymbol) {
+                    splatData = info[splatSymbol][0] || {};
+                }
+                // Pass it to the `tagify` method
+                const tags = this.tagify(splatData);
+                return `${timestamp} [${level}] [${this.name || this.appId}:${this.instanceId}] ${message} ${tags}`;
+            })),
+            transports: [new winston_1.transports.Console()],
+        });
+    }
+    info(message, ...meta) {
+        this.logger.info(message, ...meta);
+    }
+    error(message, ...meta) {
+        this.logger.error(message, ...meta);
+    }
+    warn(message, ...meta) {
+        this.logger.warn(message, ...meta);
+    }
+    debug(message, ...meta) {
+        this.logger.debug(message, ...meta);
+    }
+    tagify(obj) {
+        if (!obj) {
+            return '';
+        }
+        const tags = [];
+        try {
+            Object.entries(obj).forEach(([key, val]) => {
+                let value = val;
+                if (typeof val === 'function') {
+                    val = val();
+                }
+                if (val instanceof Date) {
+                    value = val.toISOString();
+                }
+                else if (typeof val === 'object' && val !== null) {
+                    value = JSON.stringify(val);
+                }
+                else {
+                    value = value ? value.toString() : value;
+                }
+                tags.push(`${key}:${value}`);
+            });
+        }
+        catch (err) {
+            this.error('tagify-error', err);
+        }
+        return tags.join(' ');
+    }
+}
+exports.LoggerService = LoggerService;

package/build/services/mapper/index.d.ts

@@ -0,0 +1,24 @@
+import { JobState } from "../../types/job";
+import { TransitionRule } from "../../types/transition";
+import { StreamCode } from "../../types";
+declare class MapperService {
+    private rules;
+    private data;
+    constructor(rules: Record<string, unknown>, data: JobState);
+    mapRules(): Record<string, unknown>;
+    private traverseRules;
+    /**
+     * resolve a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
+     * @param value
+     * @returns
+     */
+    private pipe;
+    /**
+     * resolve a simple mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
+     * @param value
+     * @returns
+     */
+    private resolve;
+    static evaluate(transitionRule: TransitionRule | boolean, context: JobState, code: StreamCode): boolean;
+}
+export { MapperService };

package/build/services/mapper/index.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapperService = void 0;
+const pipe_1 = require("../pipe");
+class MapperService {
+    constructor(rules, data) {
+        this.rules = rules;
+        this.data = data;
+    }
+    mapRules() {
+        return this.traverseRules(this.rules);
+    }
+    traverseRules(rules) {
+        if (typeof rules === 'object' && '@pipe' in rules) {
+            return this.pipe(rules['@pipe']);
+        }
+        if (typeof rules === 'object' && rules !== null) {
+            const mappedRules = {};
+            for (const key in rules) {
+                if (Object.prototype.hasOwnProperty.call(rules, key)) {
+                    mappedRules[key] = this.traverseRules(rules[key]);
+                }
+            }
+            return mappedRules;
+        }
+        else {
+            return this.resolve(rules);
+        }
+    }
+    /**
+     * resolve a pipe expression of the form: { @pipe: [["{data.foo.bar}", 2, false, "hello world"]] }
+     * @param value
+     * @returns
+     */
+    pipe(value) {
+        const pipe = new pipe_1.Pipe(value, this.data);
+        return pipe.process();
+    }
+    /**
+     * resolve a simple mapping expression in the form: "{data.foo.bar}" or 2 or false or "hello world"
+     * @param value
+     * @returns
+     */
+    resolve(value) {
+        const pipe = new pipe_1.Pipe([[value]], this.data);
+        return pipe.process();
+    }
+    static evaluate(transitionRule, context, code) {
+        if (typeof transitionRule === 'boolean') {
+            return transitionRule;
+        }
+        if (code.toString() === (transitionRule.code || 200).toString()) {
+            const orGate = transitionRule.gate === 'or';
+            let allAreTrue = true;
+            let someAreTrue = false;
+            transitionRule.match.forEach(({ expected, actual }) => {
+                if ((orGate && !someAreTrue) || (!orGate && allAreTrue)) {
+                    const result = pipe_1.Pipe.resolve(actual, context) === expected;
+                    if (orGate && result) {
+                        someAreTrue = true;
+                    }
+                    else if (!orGate && !result) {
+                        allAreTrue = false;
+                    }
+                }
+            });
+            return orGate ? someAreTrue : allAreTrue;
+        }
+        return false;
+    }
+}
+exports.MapperService = MapperService;

package/build/services/pipe/functions/array.d.ts

@@ -0,0 +1,24 @@
+declare class ArrayHandler {
+    get(array: any[], index: number): any;
+    concat(array1: any[], array2: any[]): any[];
+    every(array: any[], callback: (value: any, index: number, array: any[]) => boolean): boolean;
+    filter(array: any[], callback: (value: any, index: number, array: any[]) => boolean): any[];
+    find(array: any[], callback: (value: any, index: number, array: any[]) => boolean): any;
+    findIndex(array: any[], callback: (value: any, index: number, array: any[]) => boolean): number;
+    forEach(array: any[], callback: (value: any, index: number, array: any[]) => void): void;
+    indexOf(array: any[], searchElement: any, fromIndex?: number): number;
+    join(array: any[], separator: string): string;
+    lastIndexOf(array: any[], searchElement: any, fromIndex?: number): number;
+    map(array: any[], callback: (value: any, index: number, array: any[]) => any): any[];
+    pop(array: any[]): any;
+    push(array: any[], ...items: any[]): number;
+    reduce(array: any[], callback: (accumulator: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any;
+    reverse(array: any[]): any[];
+    shift(array: any[]): any;
+    slice(array: any[], start?: number, end?: number): any[];
+    some(array: any[], callback: (value: any, index: number, array: any[]) => boolean): boolean;
+    sort(array: any[], compareFunction?: (a: any, b: any) => number): any[];
+    splice(array: any[], start: number, deleteCount?: number, ...items: any[]): any[];
+    unshift(array: any[], ...items: any[]): number;
+}
+export { ArrayHandler };

package/build/services/pipe/functions/array.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayHandler = void 0;
+class ArrayHandler {
+    get(array, index) {
+        return array[index];
+    }
+    concat(array1, array2) {
+        return array1.concat(array2);
+    }
+    every(array, callback) {
+        return array.every(callback);
+    }
+    filter(array, callback) {
+        return array.filter(callback);
+    }
+    find(array, callback) {
+        return array.find(callback);
+    }
+    findIndex(array, callback) {
+        return array.findIndex(callback);
+    }
+    forEach(array, callback) {
+        array.forEach(callback);
+    }
+    indexOf(array, searchElement, fromIndex) {
+        return array.indexOf(searchElement, fromIndex);
+    }
+    join(array, separator) {
+        return array.join(separator);
+    }
+    lastIndexOf(array, searchElement, fromIndex) {
+        return array.lastIndexOf(searchElement, fromIndex);
+    }
+    map(array, callback) {
+        return array.map(callback);
+    }
+    pop(array) {
+        return array.pop();
+    }
+    push(array, ...items) {
+        return array.push(...items);
+    }
+    reduce(array, callback, initialValue) {
+        return array.reduce(callback, initialValue);
+    }
+    reverse(array) {
+        return array.reverse();
+    }
+    shift(array) {
+        return array.shift();
+    }
+    slice(array, start, end) {
+        return array.slice(start, end);
+    }
+    some(array, callback) {
+        return array.some(callback);
+    }
+    sort(array, compareFunction) {
+        return array.sort(compareFunction);
+    }
+    splice(array, start, deleteCount, ...items) {
+        return array.splice(start, deleteCount, ...items);
+    }
+    unshift(array, ...items) {
+        return array.unshift(...items);
+    }
+}
+exports.ArrayHandler = ArrayHandler;

package/build/services/pipe/functions/bitwise.d.ts

@@ -0,0 +1,9 @@
+declare class BitwiseHandler {
+    and(a: number, b: number): number;
+    or(a: number, b: number): number;
+    xor(a: number, b: number): number;
+    leftShift(a: number, b: number): number;
+    rightShift(a: number, b: number): number;
+    unsignedRightShift(a: number, b: number): number;
+}
+export { BitwiseHandler };

package/build/services/pipe/functions/bitwise.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitwiseHandler = void 0;
+class BitwiseHandler {
+    and(a, b) {
+        return a & b;
+    }
+    or(a, b) {
+        return a | b;
+    }
+    xor(a, b) {
+        return a ^ b;
+    }
+    leftShift(a, b) {
+        return a << b;
+    }
+    rightShift(a, b) {
+        return a >> b;
+    }
+    unsignedRightShift(a, b) {
+        return a >>> b;
+    }
+}
+exports.BitwiseHandler = BitwiseHandler;

package/build/services/pipe/functions/conditional.d.ts

@@ -0,0 +1,10 @@
+declare class ConditionalHandler {
+    ternary(condition: boolean, valueIfTrue: any, valueIfFalse: any): any;
+    equality(value1: any, value2: any): boolean;
+    strict_equality(value1: any, value2: any): boolean;
+    greater_than(value1: number, value2: number): boolean;
+    less_than(value1: number, value2: number): boolean;
+    greater_than_or_equal(value1: number, value2: number): boolean;
+    less_than_or_equal(value1: number, value2: number): boolean;
+}
+export { ConditionalHandler };

package/build/services/pipe/functions/conditional.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalHandler = void 0;
+class ConditionalHandler {
+    ternary(condition, valueIfTrue, valueIfFalse) {
+        return condition ? valueIfTrue : valueIfFalse;
+    }
+    equality(value1, value2) {
+        return value1 == value2;
+    }
+    strict_equality(value1, value2) {
+        return value1 === value2;
+    }
+    greater_than(value1, value2) {
+        return value1 > value2;
+    }
+    less_than(value1, value2) {
+        return value1 < value2;
+    }
+    greater_than_or_equal(value1, value2) {
+        return value1 >= value2;
+    }
+    less_than_or_equal(value1, value2) {
+        return value1 <= value2;
+    }
+}
+exports.ConditionalHandler = ConditionalHandler;

package/build/services/pipe/functions/date.d.ts

@@ -0,0 +1,57 @@
+type DateInput = Date | string | number;
+declare class DateHandler {
+    /**
+     * It is so common in mapping operations to use a string (ISO) date as input. This helper
+     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
+     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
+     * @param input
+     * @returns
+     */
+    static getDateInstance(input: DateInput): Date;
+    fromISOString(isoString: string): Date;
+    now(): number;
+    parse(dateString: string): number;
+    getDate(date: DateInput): number;
+    getDay(date: DateInput): number;
+    getFullYear(date: DateInput): number;
+    getHours(date: DateInput): number;
+    getMilliseconds(date: DateInput): number;
+    getMinutes(date: DateInput): number;
+    getMonth(date: DateInput): number;
+    getSeconds(date: DateInput): number;
+    getTime(date: DateInput): number;
+    getTimezoneOffset(date: DateInput): number;
+    getUTCDate(date: DateInput): number;
+    getUTCDay(date: DateInput): number;
+    getUTCFullYear(date: DateInput): number;
+    getUTCHours(date: DateInput): number;
+    getUTCMilliseconds(date: DateInput): number;
+    getUTCMinutes(date: DateInput): number;
+    getUTCMonth(date: DateInput): number;
+    getUTCSeconds(date: DateInput): number;
+    setMilliseconds(date: DateInput, ms: number): number;
+    setMinutes(date: DateInput, minutes: number, seconds?: number, ms?: number): number;
+    setMonth(date: DateInput, month: number, day?: number): number;
+    setSeconds(date: DateInput, seconds: number, ms?: number): number;
+    setTime(date: DateInput, time: number): number;
+    setUTCDate(date: DateInput, day: number): number;
+    setUTCFullYear(date: DateInput, year: number, month?: number, day?: number): number;
+    setUTCHours(date: DateInput, hours: number, minutes?: number, seconds?: number, ms?: number): number;
+    setUTCMilliseconds(date: DateInput, ms: number): number;
+    setUTCMinutes(date: DateInput, minutes: number, seconds?: number, ms?: number): number;
+    setUTCMonth(date: DateInput, month: number, day?: number): number;
+    setUTCSeconds(date: DateInput, seconds: number, ms?: number): number;
+    setDate(date: DateInput, day: number): number;
+    setFullYear(date: DateInput, year: number, month?: number, day?: number): number;
+    setHours(date: DateInput, hours: number, minutes?: number, seconds?: number, ms?: number): number;
+    toDateString(date: DateInput): string;
+    toISOString(date: DateInput): string;
+    toJSON(date: DateInput): string;
+    toLocaleDateString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+    toLocaleString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+    toLocaleTimeString(date: DateInput, locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+    toString(date: DateInput): string;
+    UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
+    valueOf(date: DateInput): number;
+}
+export { DateHandler };

package/build/services/pipe/functions/date.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateHandler = void 0;
+class DateHandler {
+    /**
+     * It is so common in mapping operations to use a string (ISO) date as input. This helper
+     * method allows for a more-concise mapping ruleset by avoiding date initialization boilerplate
+     * code and instead handles the ISO, Milliseconds, and ECMAScript Date input types.
+     * @param input
+     * @returns
+     */
+    static getDateInstance(input) {
+        const ISO_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?$/;
+        if (typeof input === 'string') {
+            if (ISO_REGEX.test(input)) {
+                return new Date(input);
+            }
+            const milliseconds = parseInt(input, 10);
+            if (!isNaN(milliseconds)) {
+                return new Date(milliseconds);
+            }
+        }
+        else if (input instanceof Date) {
+            return input;
+        }
+        else if (typeof input === 'number') {
+            return new Date(input);
+        }
+        throw new Error("Invalid date format");
+    }
+    fromISOString(isoString) {
+        return new Date(isoString);
+    }
+    now() {
+        return Date.now();
+    }
+    parse(dateString) {
+        return Date.parse(dateString);
+    }
+    getDate(date) {
+        return DateHandler.getDateInstance(date).getDate();
+    }
+    getDay(date) {
+        return DateHandler.getDateInstance(date).getDay();
+    }
+    getFullYear(date) {
+        return DateHandler.getDateInstance(date).getFullYear();
+    }
+    getHours(date) {
+        return DateHandler.getDateInstance(date).getHours();
+    }
+    getMilliseconds(date) {
+        return DateHandler.getDateInstance(date).getMilliseconds();
+    }
+    getMinutes(date) {
+        return DateHandler.getDateInstance(date).getMinutes();
+    }
+    getMonth(date) {
+        return DateHandler.getDateInstance(date).getMonth();
+    }
+    getSeconds(date) {
+        return DateHandler.getDateInstance(date).getSeconds();
+    }
+    getTime(date) {
+        return DateHandler.getDateInstance(date).getTime();
+    }
+    getTimezoneOffset(date) {
+        return DateHandler.getDateInstance(date).getTimezoneOffset();
+    }
+    getUTCDate(date) {
+        return DateHandler.getDateInstance(date).getUTCDate();
+    }
+    getUTCDay(date) {
+        return DateHandler.getDateInstance(date).getUTCDay();
+    }
+    getUTCFullYear(date) {
+        return DateHandler.getDateInstance(date).getUTCFullYear();
+    }
+    getUTCHours(date) {
+        return DateHandler.getDateInstance(date).getUTCHours();
+    }
+    getUTCMilliseconds(date) {
+        return DateHandler.getDateInstance(date).getUTCMilliseconds();
+    }
+    getUTCMinutes(date) {
+        return DateHandler.getDateInstance(date).getUTCMinutes();
+    }
+    getUTCMonth(date) {
+        return DateHandler.getDateInstance(date).getUTCMonth();
+    }
+    getUTCSeconds(date) {
+        return DateHandler.getDateInstance(date).getUTCSeconds();
+    }
+    setMilliseconds(date, ms) {
+        return DateHandler.getDateInstance(date).setMilliseconds(ms);
+    }
+    setMinutes(date, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setMinutes(minutes, seconds, ms);
+    }
+    setMonth(date, month, day) {
+        return DateHandler.getDateInstance(date).setMonth(month, day);
+    }
+    setSeconds(date, seconds, ms) {
+        return DateHandler.getDateInstance(date).setSeconds(seconds, ms);
+    }
+    setTime(date, time) {
+        return DateHandler.getDateInstance(date).setTime(time);
+    }
+    setUTCDate(date, day) {
+        return DateHandler.getDateInstance(date).setUTCDate(day);
+    }
+    setUTCFullYear(date, year, month, day) {
+        return DateHandler.getDateInstance(date).setUTCFullYear(year, month, day);
+    }
+    setUTCHours(date, hours, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setUTCHours(hours, minutes, seconds, ms);
+    }
+    setUTCMilliseconds(date, ms) {
+        return DateHandler.getDateInstance(date).setUTCMilliseconds(ms);
+    }
+    setUTCMinutes(date, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setUTCMinutes(minutes, seconds, ms);
+    }
+    setUTCMonth(date, month, day) {
+        return DateHandler.getDateInstance(date).setUTCMonth(month, day);
+    }
+    setUTCSeconds(date, seconds, ms) {
+        return DateHandler.getDateInstance(date).setUTCSeconds(seconds, ms);
+    }
+    setDate(date, day) {
+        return DateHandler.getDateInstance(date).setDate(day);
+    }
+    setFullYear(date, year, month, day) {
+        return DateHandler.getDateInstance(date).setFullYear(year, month, day);
+    }
+    setHours(date, hours, minutes, seconds, ms) {
+        return DateHandler.getDateInstance(date).setHours(hours, minutes, seconds, ms);
+    }
+    toDateString(date) {
+        return DateHandler.getDateInstance(date).toDateString();
+    }
+    toISOString(date) {
+        return DateHandler.getDateInstance(date).toISOString();
+    }
+    toJSON(date) {
+        return DateHandler.getDateInstance(date).toJSON();
+    }
+    toLocaleDateString(date, locales, options) {
+        return DateHandler.getDateInstance(date).toLocaleDateString(locales, options);
+    }
+    toLocaleString(date, locales, options) {
+        return DateHandler.getDateInstance(date).toLocaleString(locales, options);
+    }
+    toLocaleTimeString(date, locales, options) {
+        return DateHandler.getDateInstance(date).toLocaleTimeString(locales, options);
+    }
+    toString(date) {
+        return DateHandler.getDateInstance(date).toString();
+    }
+    UTC(year, month, date, hours, minutes, seconds, ms) {
+        return Date.UTC(year, month, date, hours, minutes, seconds, ms);
+    }
+    valueOf(date) {
+        return DateHandler.getDateInstance(date).valueOf();
+    }
+}
+exports.DateHandler = DateHandler;

package/build/services/pipe/functions/index.d.ts

@@ -0,0 +1,25 @@
+import { ArrayHandler } from './array';
+import { BitwiseHandler } from './bitwise';
+import { ConditionalHandler } from './conditional';
+import { DateHandler } from './date';
+import { JsonHandler } from './json';
+import { MathHandler } from './math';
+import { NumberHandler } from './number';
+import { ObjectHandler } from './object';
+import { StringHandler } from './string';
+import { SymbolHandler } from './symbol';
+import { UnaryHandler } from './unary';
+declare const _default: {
+    array: ArrayHandler;
+    bitwise: BitwiseHandler;
+    conditional: ConditionalHandler;
+    date: DateHandler;
+    json: JsonHandler;
+    math: MathHandler;
+    number: NumberHandler;
+    object: ObjectHandler;
+    string: StringHandler;
+    symbol: SymbolHandler;
+    unary: UnaryHandler;
+};
+export default _default;

package/build/services/pipe/functions/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const array_1 = require("./array");
+const bitwise_1 = require("./bitwise");
+const conditional_1 = require("./conditional");
+const date_1 = require("./date");
+const json_1 = require("./json");
+const math_1 = require("./math");
+const number_1 = require("./number");
+const object_1 = require("./object");
+const string_1 = require("./string");
+const symbol_1 = require("./symbol");
+const unary_1 = require("./unary");
+exports.default = {
+    array: new array_1.ArrayHandler(),
+    bitwise: new bitwise_1.BitwiseHandler(),
+    conditional: new conditional_1.ConditionalHandler(),
+    date: new date_1.DateHandler(),
+    json: new json_1.JsonHandler(),
+    math: new math_1.MathHandler(),
+    number: new number_1.NumberHandler(),
+    object: new object_1.ObjectHandler(),
+    string: new string_1.StringHandler(),
+    symbol: new symbol_1.SymbolHandler(),
+    unary: new unary_1.UnaryHandler(),
+};

package/build/services/pipe/functions/json.d.ts

@@ -0,0 +1,5 @@
+declare class JsonHandler {
+    stringify(value: any, replacer?: (this: any, key: string, value: any) => any | (number | string)[] | null, space?: string | number): string;
+    parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
+}
+export { JsonHandler };

package/build/services/pipe/functions/json.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonHandler = void 0;
+class JsonHandler {
+    stringify(value, replacer, space) {
+        return JSON.stringify(value, replacer, space);
+    }
+    parse(text, reviver) {
+        return JSON.parse(text, reviver);
+    }
+}
+exports.JsonHandler = JsonHandler;