@grnsft/if 0.1.8 → 0.2.0

package/build/models/time-sync.js

@@ -1,91 +1,138 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeSyncModel = void 0;
-const moment = require("moment");
-const moment_range_1 = require("moment-range");
-const config_1 = require("../config");
+exports.TimeSync = void 0;
+const types_1 = require("node:util/types");
+const luxon_1 = require("luxon");
+const zod_1 = require("zod");
+const parameterize_1 = require("../lib/parameterize");
 const errors_1 = require("../util/errors");
-const units_dealer_1 = require("../util/units-dealer");
-const momentRange = (0, moment_range_1.extendMoment)(moment);
+const config_1 = require("../config");
+const validations_1 = require("../util/validations");
 const { InputValidationError } = errors_1.ERRORS;
-const { INVALID_TIME_NORMALIZATION, INVALID_TIME_INTERVAL, INVALID_OBSERVATION_OVERLAP, } = config_1.STRINGS;
-class TimeSyncModel {
-    constructor() {
-        this.interval = 1;
-        /**
-         * Calculates minimal factor.
-         */
-        this.convertPerInterval = (value, duration) => value / duration;
-        /**
-         * Normalize time per given second.
-         */
-        this.normalizeTimePerSecond = (currentRoundMoment, i) => {
-            const thisMoment = moment(currentRoundMoment).milliseconds(0);
-            return thisMoment.add(i, 'second');
+const { INVALID_TIME_NORMALIZATION, INVALID_OBSERVATION_OVERLAP, AVOIDING_PADDING_BY_EDGES, } = config_1.STRINGS;
+const TimeSync = (globalConfig) => {
+    const metadata = {
+        kind: 'execute',
+    };
+    /**
+     * Take input array and return time-synchronized input array.
+     */
+    const execute = (inputs) => {
+        const validatedConfig = validateGlobalConfig();
+        const timeParams = {
+            startTime: luxon_1.DateTime.fromISO(validatedConfig['start-time']),
+            endTime: luxon_1.DateTime.fromISO(validatedConfig['end-time']),
+            interval: validatedConfig.interval,
+            allowPadding: validatedConfig['allow-padding'],
         };
-        /**
-         * Iterates over given inputs frame, meanwhile checking if aggregation method is `sum`, then calculates it.
-         * For methods is `avg` and `none` calculating average of the frame.
-         */
-        this.resampleInputFrame = (inputsInTimeslot) => {
-            return inputsInTimeslot.reduce((acc, input, index, inputs) => {
-                const metrics = Object.keys(input);
-                metrics.forEach(metric => {
-                    const method = this.dealer.askToGiveMethodFor(metric);
-                    acc[metric] = acc[metric] ?? 0;
-                    if (metric === 'timestamp') {
-                        acc[metric] = inputs[0][metric];
-                        return;
-                    }
-                    if (method === 'sum') {
-                        acc[metric] += input[metric];
-                        return;
-                    }
-                    /** divide each metric by the timeslot length, so that their sum yields the timeslot average.*/
-                    if (index === inputsInTimeslot.length - 1) {
-                        acc[metric] /= inputsInTimeslot.length;
-                        return;
-                    }
-                    acc[metric] += input[metric];
+        const pad = checkForPadding(inputs, timeParams);
+        validatePadding(pad, timeParams);
+        const paddedInputs = padInputs(inputs, pad, timeParams);
+        const flattenInputs = paddedInputs.reduce((acc, input, index) => {
+            const safeInput = Object.assign({}, input, validateInput(input, index));
+            const currentMoment = parseDate(safeInput.timestamp);
+            /** Checks if not the first input, then check consistency with previous ones. */
+            if (index > 0) {
+                const previousInput = paddedInputs[index - 1];
+                const previousInputTimestamp = parseDate(previousInput.timestamp);
+                /** Checks for timestamps overlap. */
+                if (parseDate(previousInput.timestamp).plus({
+                    seconds: previousInput.duration,
+                }) > currentMoment) {
+                    throw new InputValidationError(INVALID_OBSERVATION_OVERLAP);
+                }
+                const compareableTime = previousInputTimestamp.plus({
+                    seconds: previousInput.duration,
                 });
-                return acc;
-            }, {});
-        };
-    }
+                const timelineGapSize = currentMoment
+                    .diff(compareableTime)
+                    .as('seconds');
+                /** Checks if there is gap in timeline. */
+                if (timelineGapSize > 1) {
+                    acc.push(...getZeroishInputPerSecondBetweenRange(compareableTime, currentMoment, safeInput));
+                }
+            }
+            /** Break down current observation. */
+            for (let i = 0; i < safeInput.duration; i++) {
+                const normalizedInput = breakDownInput(safeInput, i);
+                acc.push(normalizedInput);
+            }
+            return trimInputsByGlobalTimeline(acc, timeParams);
+        }, []);
+        const sortedInputs = flattenInputs.sort((a, b) => parseDate(a.timestamp).diff(parseDate(b.timestamp)).as('seconds'));
+        return resampleInputs(sortedInputs, timeParams);
+    };
+    const parseDate = (date) => {
+        if (!date)
+            return luxon_1.DateTime.invalid('Invalid date');
+        // dates are passed to time-sync.ts both in ISO 8601 format
+        // and as a Date object (from the deserialization of a YAML file)
+        // if the YAML parser fails to identify as a date, it passes as a string
+        if ((0, types_1.isDate)(date)) {
+            return luxon_1.DateTime.fromJSDate(date);
+        }
+        if (typeof date === 'string') {
+            return luxon_1.DateTime.fromISO(date);
+        }
+        throw new InputValidationError(`Unexpected date datatype: ${typeof date}: ${date}`);
+    };
     /**
-     * Setups basic configuration.
+     * Validates input parameters.
      */
-    async configure(params) {
-        this.startTime = params['start-time'];
-        this.endTime = params['end-time'];
-        this.interval = params.interval;
-        this.dealer = await (0, units_dealer_1.UnitsDealer)();
-        return this;
-    }
+    const validateInput = (input, index) => {
+        const schema = zod_1.z.object({
+            timestamp: zod_1.z
+                .string({
+                required_error: `required in input[${index}]`,
+            })
+                .datetime({
+                message: `invalid datetime in input[${index}]`,
+            })
+                .or(zod_1.z.date()),
+            duration: zod_1.z.number(),
+        });
+        return (0, validations_1.validate)(schema, input);
+    };
     /**
-     * Validates `startTime`, `endTime` and `interval` params.
+     * Validates global config parameters.
      */
-    validateParams() {
-        if (!this.startTime || !this.endTime) {
-            throw new InputValidationError(INVALID_TIME_NORMALIZATION);
-        }
-        if (this.startTime > this.endTime) {
+    const validateGlobalConfig = () => {
+        if (globalConfig === undefined) {
             throw new InputValidationError(INVALID_TIME_NORMALIZATION);
         }
-        if (!this.interval) {
-            throw new InputValidationError(INVALID_TIME_INTERVAL);
-        }
-    }
+        const schema = zod_1.z
+            .object({
+            'start-time': zod_1.z.string().datetime(),
+            'end-time': zod_1.z.string().datetime(),
+            interval: zod_1.z.number(),
+            'allow-padding': zod_1.z.boolean(),
+        })
+            .refine(data => data['start-time'] < data['end-time'], {
+            message: '`start-time` should be lower than `end-time`',
+        });
+        return (0, validations_1.validate)(schema, globalConfig);
+    };
+    /**
+     * Calculates minimal factor.
+     */
+    const convertPerInterval = (value, duration) => value / duration;
     /**
-     * Barkes down input per minimal time unit.
+     * Normalize time per given second.
      */
-    breakDownInput(input, i) {
+    const normalizeTimePerSecond = (currentRoundMoment, i) => {
+        const thisMoment = parseDate(currentRoundMoment).startOf('second');
+        return thisMoment.plus({ seconds: i });
+    };
+    /**
+     * Breaks down input per minimal time unit.
+     */
+    const breakDownInput = (input, i) => {
         const inputKeys = Object.keys(input);
         return inputKeys.reduce((acc, key) => {
-            const method = this.dealer.askToGiveMethodFor(key);
+            const method = parameterize_1.parameterize.getAggregationMethod(key);
             if (key === 'timestamp') {
-                const perSecond = this.normalizeTimePerSecond(input.timestamp, i);
-                acc[key] = moment(perSecond).milliseconds(0).toISOString();
+                const perSecond = normalizeTimePerSecond(input.timestamp, i);
+                acc[key] = perSecond.toUTC().toISO() ?? '';
                 return acc;
             }
             /** @todo use user defined resolution later */
@@ -95,19 +142,19 @@ class TimeSyncModel {
             }
             acc[key] =
                 method === 'sum'
-                    ? this.convertPerInterval(input[key], input['duration'])
+                    ? convertPerInterval(input[key], input['duration'])
                     : input[key];
             return acc;
         }, {});
-    }
+    };
     /**
      * Populates object to fill the gaps in observational timeline using zeroish values.
      */
-    fillWithZeroishInput(input, missingTimestamp) {
+    const fillWithZeroishInput = (input, missingTimestamp) => {
         const metrics = Object.keys(input);
         return metrics.reduce((acc, metric) => {
             if (metric === 'timestamp') {
-                acc[metric] = moment(missingTimestamp).milliseconds(0).toISOString();
+                acc[metric] = missingTimestamp.startOf('second').toUTC().toISO() ?? '';
                 return acc;
             }
             /** @todo later will be changed to user defined interval */
@@ -119,117 +166,139 @@ class TimeSyncModel {
                 acc[metric] = acc['duration'];
                 return acc;
             }
-            const method = this.dealer.askToGiveMethodFor(metric);
-            acc[metric] = method === 'avg' || method === 'sum' ? 0 : input[metric];
+            const method = parameterize_1.parameterize.getAggregationMethod(metric);
+            if (method === 'avg' || method === 'sum') {
+                acc[metric] = 0;
+                return acc;
+            }
+            acc[metric] = input[metric];
             return acc;
         }, {});
-    }
+    };
+    /**
+     * Checks if `error on padding` is enabled and padding is needed. If so, then throws error.
+     */
+    const validatePadding = (pad, params) => {
+        const { start, end } = pad;
+        const isPaddingNeeded = start || end;
+        if (!params.allowPadding && isPaddingNeeded) {
+            throw new InputValidationError(AVOIDING_PADDING_BY_EDGES(start, end));
+        }
+    };
     /**
      * Checks if padding is needed either at start of the timeline or the end and returns status.
      */
-    checkForPadding(inputs) {
-        const startDiffInSeconds = moment(inputs[0].timestamp).diff(moment(this.startTime)) / 1000;
+    const checkForPadding = (inputs, params) => {
+        const startDiffInSeconds = parseDate(inputs[0].timestamp)
+            .diff(params.startTime)
+            .as('seconds');
         const lastInput = inputs[inputs.length - 1];
-        const endDiffInSeconds = moment(lastInput.timestamp)
-            .add(lastInput.duration, 'seconds')
-            .diff(moment(this.endTime)) / 1000;
+        const endDiffInSeconds = parseDate(lastInput.timestamp)
+            .plus({ second: lastInput.duration })
+            .diff(params.endTime)
+            .as('seconds');
         return {
             start: startDiffInSeconds > 0,
             end: endDiffInSeconds < 0,
         };
-    }
+    };
+    /**
+     * Iterates over given inputs frame, meanwhile checking if aggregation method is `sum`, then calculates it.
+     * For methods is `avg` and `none` calculating average of the frame.
+     */
+    const resampleInputFrame = (inputsInTimeslot) => {
+        return inputsInTimeslot.reduce((acc, input, index, inputs) => {
+            const metrics = Object.keys(input);
+            metrics.forEach(metric => {
+                const method = parameterize_1.parameterize.getAggregationMethod(metric);
+                acc[metric] = acc[metric] ?? 0;
+                if (metric === 'timestamp') {
+                    acc[metric] = inputs[0][metric];
+                    return;
+                }
+                if (method === 'sum') {
+                    acc[metric] += input[metric];
+                    return;
+                }
+                if (method === 'none') {
+                    acc[metric] = input[metric];
+                    return;
+                }
+                /**
+                 * If timeslot contains records more than one, then divide each metric by the timeslot length,
+                 *  so that their sum yields the timeslot average.
+                 */
+                if (inputsInTimeslot.length > 1 &&
+                    index === inputsInTimeslot.length - 1) {
+                    acc[metric] /= inputsInTimeslot.length;
+                    return;
+                }
+                acc[metric] += input[metric];
+            });
+            return acc;
+        }, {});
+    };
     /**
      * Takes each array frame with interval length, then aggregating them together as from units.yaml file.
      */
-    resampleInputs(inputs) {
+    const resampleInputs = (inputs, params) => {
         return inputs.reduce((acc, _input, index, inputs) => {
-            const frameStart = index * this.interval;
-            const frameEnd = (index + 1) * this.interval;
+            const frameStart = index * params.interval;
+            const frameEnd = (index + 1) * params.interval;
             const inputsFrame = inputs.slice(frameStart, frameEnd);
-            const resampledInput = this.resampleInputFrame(inputsFrame);
+            const resampledInput = resampleInputFrame(inputsFrame);
             /** Checks if resampled input is not empty, then includes in result. */
             if (Object.keys(resampledInput).length > 0) {
                 acc.push(resampledInput);
             }
             return acc;
         }, []);
-    }
+    };
     /**
      * Pads zeroish inputs from the beginning or at the end of the inputs if needed.
      */
-    padInputs(inputs, pad) {
+    const padInputs = (inputs, pad, params) => {
         const { start, end } = pad;
         const paddedFromBeginning = [];
         if (start) {
-            const dateRange = momentRange.range(moment(this.startTime), moment(inputs[0].timestamp).subtract(1, 'second'));
-            /** Checks if converting to value of is needed. */
-            for (const second of dateRange.by('second')) {
-                paddedFromBeginning.push(this.fillWithZeroishInput(inputs[0], second.valueOf()));
-            }
+            paddedFromBeginning.push(...getZeroishInputPerSecondBetweenRange(params.startTime, parseDate(inputs[0].timestamp), inputs[0]));
         }
         const paddedArray = paddedFromBeginning.concat(inputs);
         if (end) {
             const lastInput = inputs[inputs.length - 1];
-            const dateRange = momentRange.range(moment(lastInput.timestamp).add(lastInput.duration, 'seconds'), moment(this.endTime));
-            for (const second of dateRange.by('second')) {
-                paddedArray.push(this.fillWithZeroishInput(lastInput, second.valueOf()));
-            }
+            const lastInputEnd = parseDate(lastInput.timestamp).plus({
+                seconds: lastInput.duration,
+            });
+            paddedArray.push(...getZeroishInputPerSecondBetweenRange(lastInputEnd, params.endTime.plus({ seconds: 1 }), lastInput));
         }
         return paddedArray;
-    }
+    };
+    const getZeroishInputPerSecondBetweenRange = (startDate, endDate, templateInput) => {
+        const array = [];
+        const dateRange = luxon_1.Interval.fromDateTimes(startDate, endDate);
+        for (const interval of dateRange.splitBy({ second: 1 })) {
+            array.push(fillWithZeroishInput(templateInput, 
+            // as far as I can tell, start will never be null
+            // because if we pass an invalid start/endDate to
+            // Interval, we get a zero length array as the range
+            interval.start || luxon_1.DateTime.invalid('not expected - start is null')));
+        }
+        return array;
+    };
     /*
      * Checks if input's timestamp is included in global specified period then leaves it, otherwise.
      */
-    trimInputsByGlobalTimeline(inputs) {
+    const trimInputsByGlobalTimeline = (inputs, params) => {
         return inputs.reduce((acc, item) => {
             const { timestamp } = item;
-            if (moment(timestamp).isSameOrAfter(moment(this.startTime)) &&
-                moment(timestamp).isSameOrBefore(moment(this.endTime))) {
+            if (parseDate(timestamp) >= params.startTime &&
+                parseDate(timestamp) <= params.endTime) {
                 acc.push(item);
             }
             return acc;
         }, []);
-    }
-    /**
-     * Normalizes provided time window according to time configuration.
-     */
-    async execute(inputs) {
-        this.validateParams();
-        const pad = this.checkForPadding(inputs);
-        const paddedInputs = this.padInputs(inputs, pad);
-        const flattenInputs = paddedInputs.reduce((acc, input, index) => {
-            const currentMoment = moment(input.timestamp);
-            /** Checks if not the first input, then check consistency with previous ones. */
-            if (index > 0) {
-                const previousInput = paddedInputs[index - 1];
-                const previousInputTimestamp = moment(previousInput.timestamp);
-                /** Checks for timestamps overlap. */
-                if (moment(previousInput.timestamp)
-                    .add(previousInput.duration, 'seconds')
-                    .isAfter(currentMoment)) {
-                    throw new InputValidationError(INVALID_OBSERVATION_OVERLAP);
-                }
-                const compareableTime = previousInputTimestamp.add(previousInput.duration, 'second');
-                const timelineGapSize = currentMoment.diff(compareableTime, 'second');
-                //console.log(currentMoment, timelineGapSize)
-                /** Checks if there is gap in timeline. */
-                if (timelineGapSize > 1) {
-                    for (let missingTimestamp = compareableTime.valueOf(); missingTimestamp <= currentMoment.valueOf() - 1000; missingTimestamp += 1000) {
-                        const filledGap = this.fillWithZeroishInput(input, missingTimestamp);
-                        acc.push(filledGap);
-                    }
-                }
-            }
-            /** Break down current observation. */
-            for (let i = 0; i < input.duration; i++) {
-                const normalizedInput = this.breakDownInput(input, i);
-                acc.push(normalizedInput);
-            }
-            return this.trimInputsByGlobalTimeline(acc);
-        }, []);
-        const sortedInputs = flattenInputs.sort((a, b) => moment(a.timestamp).diff(moment(b.timestamp)));
-        return this.resampleInputs(sortedInputs);
-    }
-}
-exports.TimeSyncModel = TimeSyncModel;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-sync.js","sourceRoot":"","sources":["../../src/models/time-sync.ts"],"names":[],"mappings":"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","sourcesContent":["import moment = require('moment');\nimport {extendMoment} from 'moment-range';\n\nimport {STRINGS} from '../config';\n\nimport {ERRORS} from '../util/errors';\nimport {UnitsDealer} from '../util/units-dealer';\n\nimport {ModelParams, ModelPluginInterface} from '../types/model-interface';\nimport {PaddingReceipt, TimeNormalizerConfig} from '../types/time-sync';\nimport {UnitsDealerUsage} from '../types/units-dealer';\nimport {UnitKeyName} from '../types/units';\n\nconst momentRange = extendMoment(moment);\n\nconst {InputValidationError} = ERRORS;\n\nconst {\n  INVALID_TIME_NORMALIZATION,\n  INVALID_TIME_INTERVAL,\n  INVALID_OBSERVATION_OVERLAP,\n} = STRINGS;\n\nexport class TimeSyncModel implements ModelPluginInterface {\n  startTime: string | undefined;\n  endTime: string | undefined;\n  dealer!: UnitsDealerUsage;\n  interval = 1;\n\n  /**\n   * Setups basic configuration.\n   */\n  async configure(params: TimeNormalizerConfig): Promise<ModelPluginInterface> {\n    this.startTime = params['start-time'];\n    this.endTime = params['end-time'];\n    this.interval = params.interval;\n    this.dealer = await UnitsDealer();\n\n    return this;\n  }\n\n  /**\n   * Validates `startTime`, `endTime` and `interval` params.\n   */\n  private validateParams() {\n    if (!this.startTime || !this.endTime) {\n      throw new InputValidationError(INVALID_TIME_NORMALIZATION);\n    }\n\n    if (this.startTime > this.endTime) {\n      throw new InputValidationError(INVALID_TIME_NORMALIZATION);\n    }\n\n    if (!this.interval) {\n      throw new InputValidationError(INVALID_TIME_INTERVAL);\n    }\n  }\n\n  /**\n   * Calculates minimal factor.\n   */\n  private convertPerInterval = (value: number, duration: number) =>\n    value / duration;\n\n  /**\n   * Normalize time per given second.\n   */\n  private normalizeTimePerSecond = (currentRoundMoment: string, i: number) => {\n    const thisMoment = moment(currentRoundMoment).milliseconds(0);\n\n    return thisMoment.add(i, 'second');\n  };\n\n  /**\n   * Barkes down input per minimal time unit.\n   */\n  private breakDownInput(input: ModelParams, i: number) {\n    const inputKeys = Object.keys(input) as UnitKeyName[];\n\n    return inputKeys.reduce((acc, key) => {\n      const method = this.dealer.askToGiveMethodFor(key);\n\n      if (key === 'timestamp') {\n        const perSecond = this.normalizeTimePerSecond(input.timestamp, i);\n        acc[key] = moment(perSecond).milliseconds(0).toISOString();\n\n        return acc;\n      }\n\n      /** @todo use user defined resolution later */\n      if (key === 'duration') {\n        acc[key] = 1;\n\n        return acc;\n      }\n\n      acc[key] =\n        method === 'sum'\n          ? this.convertPerInterval(input[key], input['duration'])\n          : input[key];\n\n      return acc;\n    }, {} as ModelParams);\n  }\n\n  /**\n   * Populates object to fill the gaps in observational timeline using zeroish values.\n   */\n  private fillWithZeroishInput(input: ModelParams, missingTimestamp: number) {\n    const metrics = Object.keys(input) as UnitKeyName[];\n\n    return metrics.reduce((acc, metric) => {\n      if (metric === 'timestamp') {\n        acc[metric] = moment(missingTimestamp).milliseconds(0).toISOString();\n\n        return acc;\n      }\n\n      /** @todo later will be changed to user defined interval */\n      if (metric === 'duration') {\n        acc[metric] = 1;\n\n        return acc;\n      }\n\n      if (metric === 'time-reserved') {\n        acc[metric] = acc['duration'];\n\n        return acc;\n      }\n\n      const method = this.dealer.askToGiveMethodFor(metric);\n      acc[metric] = method === 'avg' || method === 'sum' ? 0 : input[metric];\n\n      return acc;\n    }, {} as ModelParams);\n  }\n\n  /**\n   * Checks if padding is needed either at start of the timeline or the end and returns status.\n   */\n  private checkForPadding(inputs: ModelParams[]): PaddingReceipt {\n    const startDiffInSeconds =\n      moment(inputs[0].timestamp).diff(moment(this.startTime)) / 1000;\n\n    const lastInput = inputs[inputs.length - 1];\n    const endDiffInSeconds =\n      moment(lastInput.timestamp)\n        .add(lastInput.duration, 'seconds')\n        .diff(moment(this.endTime)) / 1000;\n\n    return {\n      start: startDiffInSeconds > 0,\n      end: endDiffInSeconds < 0,\n    };\n  }\n\n  /**\n   * Iterates over given inputs frame, meanwhile checking if aggregation method is `sum`, then calculates it.\n   * For methods is `avg` and `none` calculating average of the frame.\n   */\n  private resampleInputFrame = (inputsInTimeslot: ModelParams[]) => {\n    return inputsInTimeslot.reduce((acc, input, index, inputs) => {\n      const metrics = Object.keys(input) as UnitKeyName[];\n\n      metrics.forEach(metric => {\n        const method = this.dealer.askToGiveMethodFor(metric);\n        acc[metric] = acc[metric] ?? 0;\n\n        if (metric === 'timestamp') {\n          acc[metric] = inputs[0][metric];\n\n          return;\n        }\n\n        if (method === 'sum') {\n          acc[metric] += input[metric];\n\n          return;\n        }\n\n        /** divide each metric by the timeslot length, so that their sum yields the timeslot average.*/\n        if (index === inputsInTimeslot.length - 1) {\n          acc[metric] /= inputsInTimeslot.length;\n\n          return;\n        }\n\n        acc[metric] += input[metric];\n      });\n\n      return acc;\n    }, {} as ModelParams);\n  };\n\n  /**\n   * Takes each array frame with interval length, then aggregating them together as from units.yaml file.\n   */\n  private resampleInputs(inputs: ModelParams[]) {\n    return inputs.reduce((acc, _input, index, inputs) => {\n      const frameStart = index * this.interval;\n      const frameEnd = (index + 1) * this.interval;\n      const inputsFrame = inputs.slice(frameStart, frameEnd);\n\n      const resampledInput = this.resampleInputFrame(inputsFrame);\n\n      /** Checks if resampled input is not empty, then includes in result. */\n      if (Object.keys(resampledInput).length > 0) {\n        acc.push(resampledInput);\n      }\n\n      return acc;\n    }, [] as ModelParams[]);\n  }\n\n  /**\n   * Pads zeroish inputs from the beginning or at the end of the inputs if needed.\n   */\n  private padInputs(inputs: ModelParams[], pad: PaddingReceipt): ModelParams[] {\n    const {start, end} = pad;\n    const paddedFromBeginning = [];\n\n    if (start) {\n      const dateRange = momentRange.range(\n        moment(this.startTime),\n        moment(inputs[0].timestamp).subtract(1, 'second')\n      );\n\n      /** Checks if converting to value of is needed. */\n      for (const second of dateRange.by('second')) {\n        paddedFromBeginning.push(\n          this.fillWithZeroishInput(inputs[0], second.valueOf())\n        );\n      }\n    }\n\n    const paddedArray = paddedFromBeginning.concat(inputs);\n\n    if (end) {\n      const lastInput = inputs[inputs.length - 1];\n      const dateRange = momentRange.range(\n        moment(lastInput.timestamp).add(lastInput.duration, 'seconds'),\n        moment(this.endTime)\n      );\n\n      for (const second of dateRange.by('second')) {\n        paddedArray.push(\n          this.fillWithZeroishInput(lastInput, second.valueOf())\n        );\n      }\n    }\n\n    return paddedArray;\n  }\n\n  /*\n   * Checks if input's timestamp is included in global specified period then leaves it, otherwise.\n   */\n  private trimInputsByGlobalTimeline(inputs: ModelParams[]): ModelParams[] {\n    return inputs.reduce((acc, item) => {\n      const {timestamp} = item;\n\n      if (\n        moment(timestamp).isSameOrAfter(moment(this.startTime)) &&\n        moment(timestamp).isSameOrBefore(moment(this.endTime))\n      ) {\n        acc.push(item);\n      }\n\n      return acc;\n    }, [] as ModelParams[]);\n  }\n\n  /**\n   * Normalizes provided time window according to time configuration.\n   */\n  async execute(inputs: ModelParams[]): Promise<ModelParams[]> {\n    this.validateParams();\n\n    const pad = this.checkForPadding(inputs);\n    const paddedInputs = this.padInputs(inputs, pad);\n\n    const flattenInputs = paddedInputs.reduce((acc, input, index) => {\n      const currentMoment = moment(input.timestamp);\n\n      /** Checks if not the first input, then check consistency with previous ones. */\n      if (index > 0) {\n        const previousInput = paddedInputs[index - 1];\n        const previousInputTimestamp = moment(previousInput.timestamp);\n\n        /** Checks for timestamps overlap. */\n        if (\n          moment(previousInput.timestamp)\n            .add(previousInput.duration, 'seconds')\n            .isAfter(currentMoment)\n        ) {\n          throw new InputValidationError(INVALID_OBSERVATION_OVERLAP);\n        }\n\n        const compareableTime = previousInputTimestamp.add(\n          previousInput.duration,\n          'second'\n        );\n\n        const timelineGapSize = currentMoment.diff(compareableTime, 'second');\n        //console.log(currentMoment, timelineGapSize)\n        /** Checks if there is gap in timeline. */\n        if (timelineGapSize > 1) {\n          for (\n            let missingTimestamp = compareableTime.valueOf();\n            missingTimestamp <= currentMoment.valueOf() - 1000;\n            missingTimestamp += 1000\n          ) {\n            const filledGap = this.fillWithZeroishInput(\n              input,\n              missingTimestamp\n            );\n\n            acc.push(filledGap);\n          }\n        }\n      }\n\n      /** Break down current observation. */\n      for (let i = 0; i < input.duration; i++) {\n        const normalizedInput = this.breakDownInput(input, i);\n\n        acc.push(normalizedInput);\n      }\n\n      return this.trimInputsByGlobalTimeline(acc);\n    }, [] as ModelParams[]);\n\n    const sortedInputs = flattenInputs.sort((a, b) =>\n      moment(a.timestamp).diff(moment(b.timestamp))\n    );\n\n    return this.resampleInputs(sortedInputs);\n  }\n}\n"]}
+    };
+    return { metadata, execute };
+};
+exports.TimeSync = TimeSync;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-sync.js","sourceRoot":"","sources":["../../src/models/time-sync.ts"],"names":[],"mappings":"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","sourcesContent":["import {isDate} from 'node:util/types';\nimport {DateTime, DateTimeMaybeValid, Interval} from 'luxon';\nimport {z} from 'zod';\n\nimport {parameterize} from '../lib/parameterize';\n\nimport {ERRORS} from '../util/errors';\n\nimport {STRINGS} from '../config';\n\nimport {PluginParams} from '../types/interface';\nimport {\n  PaddingReceipt,\n  TimeNormalizerConfig,\n  TimeParams,\n} from '../types/time-sync';\nimport {PluginInterface} from '../types/interface';\nimport {validate} from '../util/validations';\n\nconst {InputValidationError} = ERRORS;\n\nconst {\n  INVALID_TIME_NORMALIZATION,\n  INVALID_OBSERVATION_OVERLAP,\n  AVOIDING_PADDING_BY_EDGES,\n} = STRINGS;\n\nexport const TimeSync = (\n  globalConfig: TimeNormalizerConfig\n): PluginInterface => {\n  const metadata = {\n    kind: 'execute',\n  };\n\n  /**\n   * Take input array and return time-synchronized input array.\n   */\n  const execute = (inputs: PluginParams[]): PluginParams[] => {\n    const validatedConfig = validateGlobalConfig();\n    const timeParams = {\n      startTime: DateTime.fromISO(validatedConfig['start-time']),\n      endTime: DateTime.fromISO(validatedConfig['end-time']),\n      interval: validatedConfig.interval,\n      allowPadding: validatedConfig['allow-padding'],\n    };\n\n    const pad = checkForPadding(inputs, timeParams);\n    validatePadding(pad, timeParams);\n\n    const paddedInputs = padInputs(inputs, pad, timeParams);\n\n    const flattenInputs = paddedInputs.reduce(\n      (acc: PluginParams[], input, index) => {\n        const safeInput = Object.assign({}, input, validateInput(input, index));\n        const currentMoment = parseDate(safeInput.timestamp);\n\n        /** Checks if not the first input, then check consistency with previous ones. */\n        if (index > 0) {\n          const previousInput = paddedInputs[index - 1];\n          const previousInputTimestamp = parseDate(previousInput.timestamp);\n\n          /** Checks for timestamps overlap. */\n          if (\n            parseDate(previousInput.timestamp).plus({\n              seconds: previousInput.duration,\n            }) > currentMoment\n          ) {\n            throw new InputValidationError(INVALID_OBSERVATION_OVERLAP);\n          }\n\n          const compareableTime = previousInputTimestamp.plus({\n            seconds: previousInput.duration,\n          });\n\n          const timelineGapSize = currentMoment\n            .diff(compareableTime)\n            .as('seconds');\n\n          /** Checks if there is gap in timeline. */\n          if (timelineGapSize > 1) {\n            acc.push(\n              ...getZeroishInputPerSecondBetweenRange(\n                compareableTime,\n                currentMoment,\n                safeInput\n              )\n            );\n          }\n        }\n        /** Break down current observation. */\n        for (let i = 0; i < safeInput.duration; i++) {\n          const normalizedInput = breakDownInput(safeInput, i);\n\n          acc.push(normalizedInput);\n        }\n\n        return trimInputsByGlobalTimeline(acc, timeParams);\n      },\n      [] as PluginParams[]\n    );\n\n    const sortedInputs = flattenInputs.sort((a, b) =>\n      parseDate(a.timestamp).diff(parseDate(b.timestamp)).as('seconds')\n    );\n\n    return resampleInputs(sortedInputs, timeParams) as PluginParams[];\n  };\n\n  const parseDate = (date: Date | string) => {\n    if (!date) return DateTime.invalid('Invalid date');\n    // dates are passed to time-sync.ts both in ISO 8601 format\n    // and as a Date object (from the deserialization of a YAML file)\n    // if the YAML parser fails to identify as a date, it passes as a string\n    if (isDate(date)) {\n      return DateTime.fromJSDate(date);\n    }\n    if (typeof date === 'string') {\n      return DateTime.fromISO(date);\n    }\n    throw new InputValidationError(\n      `Unexpected date datatype: ${typeof date}: ${date}`\n    );\n  };\n\n  /**\n   * Validates input parameters.\n   */\n  const validateInput = (input: PluginParams, index: number) => {\n    const schema = z.object({\n      timestamp: z\n        .string({\n          required_error: `required in input[${index}]`,\n        })\n        .datetime({\n          message: `invalid datetime in input[${index}]`,\n        })\n        .or(z.date()),\n      duration: z.number(),\n    });\n\n    return validate<z.infer<typeof schema>>(schema, input);\n  };\n\n  /**\n   * Validates global config parameters.\n   */\n  const validateGlobalConfig = () => {\n    if (globalConfig === undefined) {\n      throw new InputValidationError(INVALID_TIME_NORMALIZATION);\n    }\n\n    const schema = z\n      .object({\n        'start-time': z.string().datetime(),\n        'end-time': z.string().datetime(),\n        interval: z.number(),\n        'allow-padding': z.boolean(),\n      })\n      .refine(data => data['start-time'] < data['end-time'], {\n        message: '`start-time` should be lower than `end-time`',\n      });\n\n    return validate<z.infer<typeof schema>>(schema, globalConfig);\n  };\n\n  /**\n   * Calculates minimal factor.\n   */\n  const convertPerInterval = (value: number, duration: number) =>\n    value / duration;\n\n  /**\n   * Normalize time per given second.\n   */\n  const normalizeTimePerSecond = (\n    currentRoundMoment: Date | string,\n    i: number\n  ) => {\n    const thisMoment = parseDate(currentRoundMoment).startOf('second');\n    return thisMoment.plus({seconds: i});\n  };\n  /**\n   * Breaks down input per minimal time unit.\n   */\n  const breakDownInput = (input: PluginParams, i: number) => {\n    const inputKeys = Object.keys(input);\n\n    return inputKeys.reduce((acc, key) => {\n      const method = parameterize.getAggregationMethod(key);\n\n      if (key === 'timestamp') {\n        const perSecond = normalizeTimePerSecond(input.timestamp, i);\n        acc[key] = perSecond.toUTC().toISO() ?? '';\n\n        return acc;\n      }\n\n      /** @todo use user defined resolution later */\n      if (key === 'duration') {\n        acc[key] = 1;\n\n        return acc;\n      }\n\n      acc[key] =\n        method === 'sum'\n          ? convertPerInterval(input[key], input['duration'])\n          : input[key];\n\n      return acc;\n    }, {} as PluginParams);\n  };\n\n  /**\n   * Populates object to fill the gaps in observational timeline using zeroish values.\n   */\n  const fillWithZeroishInput = (\n    input: PluginParams,\n    missingTimestamp: DateTimeMaybeValid\n  ) => {\n    const metrics = Object.keys(input);\n\n    return metrics.reduce((acc, metric) => {\n      if (metric === 'timestamp') {\n        acc[metric] = missingTimestamp.startOf('second').toUTC().toISO() ?? '';\n\n        return acc;\n      }\n\n      /** @todo later will be changed to user defined interval */\n      if (metric === 'duration') {\n        acc[metric] = 1;\n\n        return acc;\n      }\n\n      if (metric === 'time-reserved') {\n        acc[metric] = acc['duration'];\n\n        return acc;\n      }\n\n      const method = parameterize.getAggregationMethod(metric);\n\n      if (method === 'avg' || method === 'sum') {\n        acc[metric] = 0;\n\n        return acc;\n      }\n\n      acc[metric] = input[metric];\n\n      return acc;\n    }, {} as PluginParams);\n  };\n\n  /**\n   * Checks if `error on padding` is enabled and padding is needed. If so, then throws error.\n   */\n  const validatePadding = (pad: PaddingReceipt, params: TimeParams): void => {\n    const {start, end} = pad;\n    const isPaddingNeeded = start || end;\n    if (!params.allowPadding && isPaddingNeeded) {\n      throw new InputValidationError(AVOIDING_PADDING_BY_EDGES(start, end));\n    }\n  };\n\n  /**\n   * Checks if padding is needed either at start of the timeline or the end and returns status.\n   */\n  const checkForPadding = (\n    inputs: PluginParams[],\n    params: TimeParams\n  ): PaddingReceipt => {\n    const startDiffInSeconds = parseDate(inputs[0].timestamp)\n      .diff(params.startTime)\n      .as('seconds');\n\n    const lastInput = inputs[inputs.length - 1];\n\n    const endDiffInSeconds = parseDate(lastInput.timestamp)\n      .plus({second: lastInput.duration})\n      .diff(params.endTime)\n      .as('seconds');\n\n    return {\n      start: startDiffInSeconds > 0,\n      end: endDiffInSeconds < 0,\n    };\n  };\n\n  /**\n   * Iterates over given inputs frame, meanwhile checking if aggregation method is `sum`, then calculates it.\n   * For methods is `avg` and `none` calculating average of the frame.\n   */\n  const resampleInputFrame = (inputsInTimeslot: PluginParams[]) => {\n    return inputsInTimeslot.reduce((acc, input, index, inputs) => {\n      const metrics = Object.keys(input);\n\n      metrics.forEach(metric => {\n        const method = parameterize.getAggregationMethod(metric);\n        acc[metric] = acc[metric] ?? 0;\n\n        if (metric === 'timestamp') {\n          acc[metric] = inputs[0][metric];\n\n          return;\n        }\n\n        if (method === 'sum') {\n          acc[metric] += input[metric];\n\n          return;\n        }\n\n        if (method === 'none') {\n          acc[metric] = input[metric];\n\n          return;\n        }\n\n        /**\n         * If timeslot contains records more than one, then divide each metric by the timeslot length,\n         *  so that their sum yields the timeslot average.\n         */\n        if (\n          inputsInTimeslot.length > 1 &&\n          index === inputsInTimeslot.length - 1\n        ) {\n          acc[metric] /= inputsInTimeslot.length;\n\n          return;\n        }\n\n        acc[metric] += input[metric];\n      });\n\n      return acc;\n    }, {} as PluginParams);\n  };\n\n  /**\n   * Takes each array frame with interval length, then aggregating them together as from units.yaml file.\n   */\n  const resampleInputs = (inputs: PluginParams[], params: TimeParams) => {\n    return inputs.reduce((acc: PluginParams[], _input, index, inputs) => {\n      const frameStart = index * params.interval;\n      const frameEnd = (index + 1) * params.interval;\n      const inputsFrame = inputs.slice(frameStart, frameEnd);\n\n      const resampledInput = resampleInputFrame(inputsFrame);\n\n      /** Checks if resampled input is not empty, then includes in result. */\n      if (Object.keys(resampledInput).length > 0) {\n        acc.push(resampledInput);\n      }\n\n      return acc;\n    }, [] as PluginParams[]);\n  };\n\n  /**\n   * Pads zeroish inputs from the beginning or at the end of the inputs if needed.\n   */\n  const padInputs = (\n    inputs: PluginParams[],\n    pad: PaddingReceipt,\n    params: TimeParams\n  ): PluginParams[] => {\n    const {start, end} = pad;\n    const paddedFromBeginning = [];\n\n    if (start) {\n      paddedFromBeginning.push(\n        ...getZeroishInputPerSecondBetweenRange(\n          params.startTime,\n          parseDate(inputs[0].timestamp),\n          inputs[0]\n        )\n      );\n    }\n\n    const paddedArray = paddedFromBeginning.concat(inputs);\n\n    if (end) {\n      const lastInput = inputs[inputs.length - 1];\n      const lastInputEnd = parseDate(lastInput.timestamp).plus({\n        seconds: lastInput.duration,\n      });\n      paddedArray.push(\n        ...getZeroishInputPerSecondBetweenRange(\n          lastInputEnd,\n          params.endTime.plus({seconds: 1}),\n          lastInput\n        )\n      );\n    }\n    return paddedArray;\n  };\n\n  const getZeroishInputPerSecondBetweenRange = (\n    startDate: DateTimeMaybeValid,\n    endDate: DateTimeMaybeValid,\n    templateInput: PluginParams\n  ) => {\n    const array: PluginParams[] = [];\n    const dateRange = Interval.fromDateTimes(startDate, endDate);\n    for (const interval of dateRange.splitBy({second: 1})) {\n      array.push(\n        fillWithZeroishInput(\n          templateInput,\n          // as far as I can tell, start will never be null\n          // because if we pass an invalid start/endDate to\n          // Interval, we get a zero length array as the range\n          interval.start || DateTime.invalid('not expected - start is null')\n        )\n      );\n    }\n    return array;\n  };\n\n  /*\n   * Checks if input's timestamp is included in global specified period then leaves it, otherwise.\n   */\n  const trimInputsByGlobalTimeline = (\n    inputs: PluginParams[],\n    params: TimeParams\n  ): PluginParams[] => {\n    return inputs.reduce((acc: PluginParams[], item) => {\n      const {timestamp} = item;\n\n      if (\n        parseDate(timestamp) >= params.startTime &&\n        parseDate(timestamp) <= params.endTime\n      ) {\n        acc.push(item);\n      }\n\n      return acc;\n    }, [] as PluginParams[]);\n  };\n\n  return {metadata, execute};\n};\n"]}

package/build/types/aggregation.d.ts

@@ -0,0 +1,3 @@
+export type AggregationResult = Record<string, number>;
+export declare const AGGREGATION_METHODS: readonly ["horizontal", "vertical", "both"];
+export type AggregationMethodsNames = (typeof AGGREGATION_METHODS)[number];

package/build/types/aggregation.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGGREGATION_METHODS = void 0;
+exports.AGGREGATION_METHODS = ['horizontal', 'vertical', 'both'];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdncmVnYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvYWdncmVnYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRWEsUUFBQSxtQkFBbUIsR0FBRyxDQUFDLFlBQVksRUFBRSxVQUFVLEVBQUUsTUFBTSxDQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBBZ2dyZWdhdGlvblJlc3VsdCA9IFJlY29yZDxzdHJpbmcsIG51bWJlcj47XG5cbmV4cG9ydCBjb25zdCBBR0dSRUdBVElPTl9NRVRIT0RTID0gWydob3Jpem9udGFsJywgJ3ZlcnRpY2FsJywgJ2JvdGgnXSBhcyBjb25zdDtcblxuZXhwb3J0IHR5cGUgQWdncmVnYXRpb25NZXRob2RzTmFtZXMgPSAodHlwZW9mIEFHR1JFR0FUSU9OX01FVEhPRFMpW251bWJlcl07XG4iXX0=

package/build/types/compute.d.ts

@@ -0,0 +1,25 @@
+import { PluginsStorage } from './initialize';
+import { PluginParams } from './interface';
+import { Context } from './manifest';
+export type NodeConfig = {
+    [key: string]: Record<string, any>;
+};
+export type Params = {
+    plugins: PluginsStorage;
+    context: Context;
+    pipeline?: string[];
+    config?: NodeConfig;
+    defaults?: PluginParams;
+};
+export type Node = {
+    children?: any;
+    pipeline?: string[];
+    config?: NodeConfig;
+    defaults?: PluginParams;
+    inputs?: PluginParams[];
+    outputs?: PluginParams[];
+};
+export type ComputeParams = {
+    context: Context;
+    plugins: PluginsStorage;
+};

package/build/types/compute.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcHV0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9jb21wdXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1BsdWdpbnNTdG9yYWdlfSBmcm9tICcuL2luaXRpYWxpemUnO1xuaW1wb3J0IHtQbHVnaW5QYXJhbXN9IGZyb20gJy4vaW50ZXJmYWNlJztcbmltcG9ydCB7Q29udGV4dH0gZnJvbSAnLi9tYW5pZmVzdCc7XG5cbmV4cG9ydCB0eXBlIE5vZGVDb25maWcgPSB7XG4gIFtrZXk6IHN0cmluZ106IFJlY29yZDxzdHJpbmcsIGFueT47XG59O1xuXG5leHBvcnQgdHlwZSBQYXJhbXMgPSB7XG4gIHBsdWdpbnM6IFBsdWdpbnNTdG9yYWdlO1xuICBjb250ZXh0OiBDb250ZXh0O1xuICBwaXBlbGluZT86IHN0cmluZ1tdO1xuICBjb25maWc/OiBOb2RlQ29uZmlnO1xuICBkZWZhdWx0cz86IFBsdWdpblBhcmFtcztcbn07XG5cbmV4cG9ydCB0eXBlIE5vZGUgPSB7XG4gIGNoaWxkcmVuPzogYW55O1xuICBwaXBlbGluZT86IHN0cmluZ1tdO1xuICBjb25maWc/OiBOb2RlQ29uZmlnO1xuICBkZWZhdWx0cz86IFBsdWdpblBhcmFtcztcbiAgaW5wdXRzPzogUGx1Z2luUGFyYW1zW107XG4gIG91dHB1dHM/OiBQbHVnaW5QYXJhbXNbXTtcbn07XG5cbmV4cG9ydCB0eXBlIENvbXB1dGVQYXJhbXMgPSB7XG4gIGNvbnRleHQ6IENvbnRleHQ7XG4gIHBsdWdpbnM6IFBsdWdpbnNTdG9yYWdlO1xufTtcbiJdfQ==

package/build/types/exhaust-plugin-interface.d.ts

@@ -0,0 +1,7 @@
+import { Context } from './manifest';
+export interface ExhaustPluginInterface {
+    /**
+     * Execute exhaust based on `context` and `tree`, produce output to a file in `outputPath`.
+     */
+    execute(tree: any, context: Context, outputPath?: string): void;
+}

package/build/types/exhaust-plugin-interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhoYXVzdC1wbHVnaW4taW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL2V4aGF1c3QtcGx1Z2luLWludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb250ZXh0fSBmcm9tICcuL21hbmlmZXN0JztcblxuZXhwb3J0IGludGVyZmFjZSBFeGhhdXN0UGx1Z2luSW50ZXJmYWNlIHtcbiAgLyoqXG4gICAqIEV4ZWN1dGUgZXhoYXVzdCBiYXNlZCBvbiBgY29udGV4dGAgYW5kIGB0cmVlYCwgcHJvZHVjZSBvdXRwdXQgdG8gYSBmaWxlIGluIGBvdXRwdXRQYXRoYC5cbiAgICovXG4gIGV4ZWN1dGUodHJlZTogYW55LCBjb250ZXh0OiBDb250ZXh0LCBvdXRwdXRQYXRoPzogc3RyaW5nKTogdm9pZDtcbn1cbiJdfQ==

package/build/types/group-by.d.ts

@@ -0,0 +1,3 @@
+export type GroupByConfig = {
+    group: string[];
+};

package/build/types/group-by.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JvdXAtYnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvZ3JvdXAtYnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEdyb3VwQnlDb25maWcgPSB7XG4gIGdyb3VwOiBzdHJpbmdbXTtcbn07XG4iXX0=