nuxeo-development-framework 5.6.4 → 5.6.5

package/esm2015/lib/shared/directives/fluid-height.directive.js

@@ -0,0 +1,115 @@
+import { Directive, Input, NgModule } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export class FluidHeightDirective {
+    constructor(renderer, elementRef, ngZone) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.ngZone = ngZone;
+        this.minHeight = 0;
+        this.topOffset = 0;
+        this.subtractItems = [];
+        this.decrease = 0;
+        this.delay = 200;
+        this.cssVar = '--ndf-fluid-height';
+        this.calculate = true;
+        this._inlineStyle = false;
+        this._domElement = this.elementRef.nativeElement;
+        this._resizeListener = () => this.onResize();
+        this.ngZone.runOutsideAngular(() => {
+            window.addEventListener('resize', this._resizeListener);
+        });
+    }
+    get inlineStyle() {
+        return this._inlineStyle;
+    }
+    set inlineStyle(value) {
+        this._inlineStyle = coerceBooleanProperty(value);
+    }
+    ngAfterViewInit() {
+        this.scheduleSetHeight();
+    }
+    scheduleSetHeight(delay = this.delay) {
+        setTimeout(() => this.setHeight(), delay);
+    }
+    onResize() {
+        if (this._animationId) {
+            cancelAnimationFrame(this._animationId);
+        }
+        this._animationId = requestAnimationFrame(() => this.setHeight());
+    }
+    setHeight() {
+        if (!this.calculate) {
+            return;
+        }
+        const windowHeight = window.innerHeight;
+        const topOffset = this.topOffset || this._calcTopOffset();
+        let height = windowHeight - topOffset;
+        this.subtractItems.forEach((selector) => {
+            height -= this._getSelectorHeight(selector);
+        });
+        height = Math.max(height - this.decrease, this.minHeight);
+        if (this.inlineStyle) {
+            this.renderer.setStyle(this._domElement, 'height', `${height}px`);
+        }
+        else {
+            this.renderer.setAttribute(this._domElement, 'style', `${this.cssVar} : ${height}px`);
+        }
+    }
+    _getSelectorHeight(selector) {
+        const element = document.querySelector(selector);
+        return element ? element.clientHeight : 0;
+    }
+    _calcTopOffset() {
+        try {
+            const rect = this._domElement.getBoundingClientRect();
+            const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+            return rect.top + scrollTop;
+        }
+        catch (_a) {
+            return 0;
+        }
+    }
+    ngOnDestroy() {
+        window.removeEventListener('resize', this._resizeListener);
+    }
+}
+FluidHeightDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FluidHeightDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+FluidHeightDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FluidHeightDirective, selector: "[ndfFluidHeight]", inputs: { minHeight: "minHeight", topOffset: ["ndfFluidHeight", "topOffset"], subtractItems: "subtractItems", decrease: "decrease", delay: "delay", cssVar: "cssVar", calculate: "calculate", inlineStyle: "inlineStyle" }, exportAs: ["ndfFluidHeight"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FluidHeightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ndfFluidHeight]',
+                    exportAs: 'ndfFluidHeight'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { minHeight: [{
+                type: Input
+            }], topOffset: [{
+                type: Input,
+                args: ['ndfFluidHeight']
+            }], subtractItems: [{
+                type: Input
+            }], decrease: [{
+                type: Input
+            }], delay: [{
+                type: Input
+            }], cssVar: [{
+                type: Input
+            }], calculate: [{
+                type: Input
+            }], inlineStyle: [{
+                type: Input
+            }] } });
+export class FluidHeightModule {
+}
+FluidHeightModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FluidHeightModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FluidHeightModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FluidHeightModule, declarations: [FluidHeightDirective], exports: [FluidHeightDirective] });
+FluidHeightModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FluidHeightModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FluidHeightModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [FluidHeightDirective],
+                    exports: [FluidHeightDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fluid-height.directive.js","sourceRoot":"","sources":["../../../../../../projects/nuxeo-development-framework/src/lib/shared/directives/fluid-height.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, ElementRef, Input, NgModule, NgZone, OnDestroy, Renderer2 } from '@angular/core';\r\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\r\n\r\n@Directive({\r\n\tselector: '[ndfFluidHeight]',\r\n\texportAs: 'ndfFluidHeight'\r\n})\r\nexport class FluidHeightDirective implements AfterViewInit, OnDestroy {\r\n\t@Input() minHeight = 0;\r\n\t@Input('ndfFluidHeight') topOffset = 0;\r\n\t@Input() subtractItems: string[] = [];\r\n\t@Input() decrease = 0;\r\n\t@Input() delay = 200;\r\n\t@Input() cssVar = '--ndf-fluid-height';\r\n\t@Input() calculate = true;\r\n\r\n\tprivate _inlineStyle = false;\r\n\t@Input()\r\n\tget inlineStyle(): boolean {\r\n\t\treturn this._inlineStyle;\r\n\t}\r\n\r\n\tset inlineStyle(value: boolean) {\r\n\t\tthis._inlineStyle = coerceBooleanProperty(value);\r\n\t}\r\n\r\n\tprivate _domElement: HTMLElement;\r\n\tprivate _animationId?: number;\r\n\tprivate _resizeListener: () => void;\r\n\r\n\tconstructor(\r\n\t\tprivate renderer: Renderer2,\r\n\t\tprivate elementRef: ElementRef,\r\n\t\tprivate ngZone: NgZone\r\n\t) {\r\n\t\tthis._domElement = this.elementRef.nativeElement as HTMLElement;\r\n\r\n\t\tthis._resizeListener = () => this.onResize();\r\n\r\n\t\tthis.ngZone.runOutsideAngular(() => {\r\n\t\t\twindow.addEventListener('resize', this._resizeListener);\r\n\t\t});\r\n\t}\r\n\r\n\tngAfterViewInit(): void {\r\n\t\tthis.scheduleSetHeight();\r\n\t}\r\n\r\n\tscheduleSetHeight(delay: number = this.delay): void {\r\n\t\tsetTimeout(() => this.setHeight(), delay);\r\n\t}\r\n\r\n\tprivate onResize(): void {\r\n\t\tif (this._animationId) {\r\n\t\t\tcancelAnimationFrame(this._animationId);\r\n\t\t}\r\n\t\tthis._animationId = requestAnimationFrame(() => this.setHeight());\r\n\t}\r\n\r\n\tprivate setHeight(): void {\r\n\t\tif (!this.calculate) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst windowHeight = window.innerHeight;\r\n\t\tconst topOffset = this.topOffset || this._calcTopOffset();\r\n\t\tlet height = windowHeight - topOffset;\r\n\r\n\t\tthis.subtractItems.forEach((selector) => {\r\n\t\t\theight -= this._getSelectorHeight(selector);\r\n\t\t});\r\n\r\n\t\theight = Math.max(height - this.decrease, this.minHeight);\r\n\r\n\t\tif (this.inlineStyle) {\r\n\t\t\tthis.renderer.setStyle(this._domElement, 'height', `${height}px`);\r\n\t\t} else {\r\n\t\t\tthis.renderer.setAttribute(this._domElement, 'style', `${this.cssVar} : ${height}px`);\r\n\t\t}\r\n\t}\r\n\r\n\tprivate _getSelectorHeight(selector: string): number {\r\n\t\tconst element = document.querySelector(selector) as HTMLElement | null;\r\n\t\treturn element ? element.clientHeight : 0;\r\n\t}\r\n\r\n\tprivate _calcTopOffset(): number {\r\n\t\ttry {\r\n\t\t\tconst rect = this._domElement.getBoundingClientRect();\r\n\t\t\tconst scrollTop = window.pageYOffset || document.documentElement.scrollTop;\r\n\t\t\treturn rect.top + scrollTop;\r\n\t\t} catch {\r\n\t\t\treturn 0;\r\n\t\t}\r\n\t}\r\n\r\n\tstatic ngAcceptInputType_inlineStyle: BooleanInput;\r\n\r\n\tngOnDestroy(): void {\r\n\t\twindow.removeEventListener('resize', this._resizeListener);\r\n\t}\r\n}\r\n\r\n@NgModule({\r\n\tdeclarations: [FluidHeightDirective],\r\n\texports: [FluidHeightDirective]\r\n})\r\nexport class FluidHeightModule {}\r\n"]}

package/esm2015/lib/shared/directives/index.js

@@ -0,0 +1,4 @@
+export * from './fluid-height.directive';
+export * from './element-height.directive';
+export * from './copy-to-clipboard.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9zaGFyZWQvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmx1aWQtaGVpZ2h0LmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZWxlbWVudC1oZWlnaHQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9jb3B5LXRvLWNsaXBib2FyZC5kaXJlY3RpdmUnO1xyXG4iXX0=

package/esm2015/lib/shared/evaluator/evaluator.js

@@ -0,0 +1,318 @@
+import _, { get, keys, set, trim, values } from 'lodash';
+import stringHash from 'string-hash';
+/**
+ * Creates a secure context for function evaluation that prevents access to the window object.
+ * @returns {Record<string, any>} A secure context object with safe properties.
+ */
+function createSecureContext() {
+    // Create a secure context with only safe properties
+    return {
+        // Add any safe globals here that should be accessible
+        console: {
+            log: console.log,
+            warn: console.warn,
+            error: console.error
+        },
+        // Add other safe objects/functions as needed
+        Math,
+        Date,
+        Number,
+        String,
+        Boolean,
+        Array,
+        Object,
+        JSON,
+        // Prevent access to window
+        window: undefined,
+        self: undefined,
+        globalThis: undefined,
+        _: _ // Include lodash if needed, but ensure it's used safely
+    };
+}
+/**
+ * A utility class for evaluating expressions, interpolating strings, and working with templates.
+ * This class provides static methods for dynamic evaluation of code, string interpolation,
+ * and template processing with caching capabilities.
+ */
+export class Evaluator {
+    /**
+     * Creates a function from a string or returns the function if already provided.
+     * Uses a secure context to prevent access to the window object by default.
+     * @param {string|Function} func - The function or string to convert to a function.
+     * @param {...any} params - The parameters to pass to the function.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the evaluation.
+     * @returns {Function} - The resulting function.
+     */
+    static evaluator(func, ...params) {
+        // Extract options if the last parameter is an options object
+        let options = {};
+        if (params.length > 0 &&
+            params[params.length - 1] &&
+            typeof params[params.length - 1] === 'object' &&
+            'securityMode' in params[params.length - 1]) {
+            options = params.pop();
+        }
+        if (typeof func === 'function') {
+            return func;
+        }
+        if (typeof params[0] === 'object') {
+            params = keys(params[0]);
+        }
+        // Check if we should use secure mode (default) or unsafe mode
+        const securityMode = options.securityMode || 'secure';
+        if (securityMode === 'unsafe') {
+            // In unsafe mode, create a function with access to all globals
+            return new Function(...params, func);
+        }
+        const sandbox = createSecureContext();
+        const sandboxKeys = Object.keys(sandbox);
+        const sandboxAssignments = sandboxKeys.map((key) => `const ${key} = sandbox.${key};`).join('');
+        const wrapper = new Function(...params, 'sandbox', `${sandboxAssignments}${func}`);
+        return (...args) => wrapper(...args, sandbox);
+    }
+    /**
+     * Replaces template expressions in a string with values from data.
+     * Supports function calls within templates and fallback values using || syntax.
+     * By default, ensures evaluation happens in a secure context to prevent access to window object.
+     * @param {string} rawTemplate - The template string containing expressions to interpolate.
+     * @param {Record<string, any>} data - The data object containing values to use for interpolation.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the interpolation process.
+     * @returns {string} - The interpolated string with all expressions replaced with actual values.
+     */
+    static interpolateString(rawTemplate, data, options = {}) {
+        if (!rawTemplate) {
+            return '';
+        }
+        if (typeof rawTemplate !== 'string') {
+            return rawTemplate.toString();
+        }
+        // Check if we should use secure mode (default) or unsafe mode
+        const securityMode = options.securityMode || 'secure';
+        // Create a secure data object if needed
+        const secureData = securityMode === 'unsafe'
+            ? data
+            : Object.assign(Object.assign(Object.assign({}, createSecureContext()), data), { 
+                // Ensure these remain undefined
+                window: undefined, self: undefined, globalThis: undefined });
+        return rawTemplate.replace(/({{\s*(.*?)\s*}})/g, (match, $1, expression) => {
+            if (expression.indexOf('(') !== -1) {
+                return expression.replace(/([^(]+)\(([^)]+)\s*\);?/, (_, fnName, argsStr) => {
+                    fnName = trim(fnName);
+                    const func = get(secureData, fnName);
+                    if (func) {
+                        if (argsStr) {
+                            const args = argsStr.split(',').map((arg) => {
+                                const trimmed = trim(arg);
+                                if (/^['"]/.test(trimmed))
+                                    return trimmed.slice(1, -1);
+                                return get(secureData, trimmed);
+                            });
+                            return Evaluator.evaluate(func, args, '', false, secureData, options);
+                        }
+                        return Evaluator.evaluate(func, [], '', false, secureData, options);
+                    }
+                    return '';
+                });
+            }
+            else {
+                let dataPath = expression;
+                if (expression.indexOf('?') !== -1) {
+                    dataPath = expression.replace(/\?\./g, '.');
+                }
+                const parts = dataPath.split('||').map((item) => item.trim());
+                let value = '';
+                let path = '';
+                for (let i = 0; i < parts.length; i++) {
+                    path = parts[i];
+                    if (_.has(secureData, path)) {
+                        value = _.get(secureData, path);
+                        break;
+                    }
+                }
+                if (options.data) {
+                    set(options.data, path, value);
+                }
+                return value;
+            }
+        });
+    }
+    /**
+     * Performs an evaluation using the evaluation context of this component.
+     * By default, ensures evaluation happens in a secure context to prevent access to window object.
+     * @param {string|Function|object} func - The function or string to evaluate.
+     * @param {object} args - The arguments to pass to the evaluation.
+     * @param {string} ret - The name of the variable within the evaluation context to return.
+     * @param {boolean} interpolate - Determines if it should replace all {{ }} token references with actual data.
+     * @param {object} context -   - The evaluation context.
+     * @param {EvaluatorOptions } options - The options to pass to the evaluation.
+     * @returns {*} - The result of the evaluation.
+     */
+    static evaluate(func, args = {}, ret = 'show', interpolate = false, context = {}, options = {}) {
+        let returnVal = null;
+        const field = args.field ? args.field : { key: 'unknown' };
+        const fieldKey = field.key;
+        if (typeof func === 'string') {
+            if (ret) {
+                func = `var ${ret};${func};return ${ret}`;
+            }
+            if (interpolate) {
+                func = Evaluator.interpolate(func, args, options);
+            }
+            try {
+                // Pass the security mode option to the evaluator
+                const evaluatorOptions = { securityMode: options.securityMode || 'secure' };
+                func = Evaluator.evaluator(func, args, context, evaluatorOptions);
+                args = Array.isArray(args) ? args : values(args);
+            }
+            catch (err) {
+                console.warn(`An error occured within the custom function for ${fieldKey}`, err);
+                returnVal = null;
+                func = false;
+            }
+        }
+        if (typeof func === 'function') {
+            try {
+                returnVal = Evaluator.execute(func, args, context, options);
+            }
+            catch (err) {
+                returnVal = null;
+                console.warn(`An error occured within custom function for ${fieldKey}`, err);
+            }
+        }
+        else if (func) {
+            console.warn(`Unknown function type for ${fieldKey}`);
+        }
+        return returnVal;
+    }
+    /**
+     * Executes a function with provided arguments and context.
+     * By default, ensures execution happens in a secure context to prevent access to window object.
+     * @param {Function} func - The function to execute.
+     * @param {any[]|Record<string, any>} args - The arguments to pass to the function, either as an array or object.
+     * @param {Record<string, any>} [context={}] - The context (this) to use when executing the function.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the execution.
+     * @returns {any} - The result of the function execution.
+     */
+    static execute(func, args, context = {}, options = {}) {
+        // Check if we should use secure mode (default) or unsafe mode
+        const securityMode = options.securityMode || 'secure';
+        if (securityMode === 'unsafe') {
+            // In unsafe mode, execute with the original context
+            return Array.isArray(args) ? func.apply(context, args) : func.call(context, args);
+        }
+        else {
+            // In secure mode, create a secure context by merging the provided context with our secure context
+            const secureContext = Object.assign(Object.assign(Object.assign({}, createSecureContext()), context), { 
+                // Ensure these remain undefined even if they were in the provided context
+                window: undefined, self: undefined, globalThis: undefined });
+            // Execute the function with the secure context
+            return Array.isArray(args) ? func.apply(secureContext, args) : func.call(secureContext, args);
+        }
+    }
+    /**
+     * Creates a template function from a string with caching for performance.
+     * By default, ensures the template function executes in a secure context.
+     * @param {string} template - The template string to compile into a function.
+     * @param {string} [hash] - Optional hash to use as cache key. If not provided, a hash will be generated from the template.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the template.
+     * @returns {Function|undefined} - The compiled template function, or undefined if compilation fails.
+     */
+    static template(template, hash, options = {}) {
+        hash = hash || stringHash(template).toString();
+        // If hash contains options object, extract it
+        if (typeof hash === 'object' && 'securityMode' in hash) {
+            options = hash;
+            hash = stringHash(template).toString();
+        }
+        // Check if we have a cached version
+        const cacheKey = hash + (options.securityMode || 'secure');
+        if (Evaluator.cache[cacheKey]) {
+            return Evaluator.cache[cacheKey];
+        }
+        try {
+            template = template.replace(/ctx\./g, '');
+            // Create the template function using lodash
+            const templateFunc = _.template(template, Evaluator.templateSettings);
+            // Check if we should use secure mode (default) or unsafe mode
+            const securityMode = options.securityMode || 'secure';
+            if (securityMode === 'unsafe') {
+                // In unsafe mode, return the original template function
+                return (Evaluator.cache[cacheKey] = templateFunc);
+            }
+            else {
+                // In secure mode, wrap the template function to ensure it runs in a secure context
+                const secureTemplateFunc = (data) => {
+                    // Create a secure context for the template
+                    const secureData = Object.assign(Object.assign(Object.assign({}, createSecureContext()), data), { 
+                        // Ensure these remain undefined
+                        window: undefined, self: undefined, globalThis: undefined });
+                    return templateFunc(secureData);
+                };
+                // Cache and return the secure template function
+                return (Evaluator.cache[cacheKey] = secureTemplateFunc);
+            }
+        }
+        catch (err) {
+            console.warn('Error while processing template', err, template);
+            return undefined;
+        }
+    }
+    /**
+     * Interpolates a template with data, handling both function templates and string templates.
+     * By default, ensures interpolation happens in a secure context to prevent access to window object.
+     * @param {string|Function} rawTemplate - The template to interpolate, either as a string or a function.
+     * @param {Record<string, any>} data - The data object to use for interpolation.
+     * @param {EvaluatorOptions} options - Options for the interpolation process.
+     * @returns {string|any} - The result of the interpolation, typically a string but could be any type depending on the template.
+     */
+    static interpolate(rawTemplate, data, options = {}) {
+        if (typeof rawTemplate === 'function') {
+            try {
+                // If the template is a function, execute it with the data
+                // We can't directly secure a provided function, but we can use execute
+                // to run it in a secure context if needed
+                if (options.securityMode !== 'unsafe') {
+                    const secureData = Object.assign(Object.assign(Object.assign({}, createSecureContext()), data), { window: undefined, self: undefined, globalThis: undefined });
+                    return rawTemplate(secureData);
+                }
+                else {
+                    return rawTemplate(data);
+                }
+            }
+            catch (err) {
+                console.warn('Error interpolating template', err, data);
+                return err.message;
+            }
+        }
+        rawTemplate = String(rawTemplate);
+        // Pass the security mode option to the template method
+        const template = Evaluator.template(rawTemplate, undefined, options);
+        if (typeof template === 'function') {
+            try {
+                return template(data);
+            }
+            catch (err) {
+                console.warn('Error interpolating template', err, rawTemplate, data);
+                return err.message;
+            }
+        }
+        return template;
+    }
+}
+/**
+ * Cache for storing compiled template functions to improve performance.
+ * Keys are string hashes of the template, values are the compiled functions.
+ */
+Evaluator.cache = {};
+/**
+ * Settings for template processing, defining regex patterns for different template operations.
+ * - interpolate: Pattern for variable interpolation ({{ variable }})
+ * - evaluate: Pattern for code evaluation ({% code %})
+ * - escape: Pattern for HTML escaping ({{{ variable }}})
+ */
+Evaluator.templateSettings = {
+    interpolate: /{{([\s\S]+?)}}/g,
+    evaluate: /\{%([\s\S]+?)%\}/g,
+    escape: /\{\{\{([\s\S]+?)\}\}\}/g
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../../../../projects/nuxeo-development-framework/src/lib/shared/evaluator/evaluator.ts"],"names":[],"mappings":"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","sourcesContent":["import _, { get, keys, set, trim, values } from 'lodash';\r\nimport stringHash from 'string-hash';\r\n\r\nimport { EvaluatorOptions, TemplateSettings } from './types';\r\n\r\n/**\r\n * Creates a secure context for function evaluation that prevents access to the window object.\r\n * @returns {Record<string, any>} A secure context object with safe properties.\r\n */\r\nfunction createSecureContext(): Record<string, any> {\r\n\t// Create a secure context with only safe properties\r\n\treturn {\r\n\t\t// Add any safe globals here that should be accessible\r\n\t\tconsole: {\r\n\t\t\tlog: console.log,\r\n\t\t\twarn: console.warn,\r\n\t\t\terror: console.error\r\n\t\t},\r\n\t\t// Add other safe objects/functions as needed\r\n\t\tMath,\r\n\t\tDate,\r\n\t\tNumber,\r\n\t\tString,\r\n\t\tBoolean,\r\n\t\tArray,\r\n\t\tObject,\r\n\t\tJSON,\r\n\t\t// Prevent access to window\r\n\t\twindow: undefined,\r\n\t\tself: undefined,\r\n\t\tglobalThis: undefined,\r\n\t\t_: _ // Include lodash if needed, but ensure it's used safely\r\n\t};\r\n}\r\n\r\n/**\r\n * A utility class for evaluating expressions, interpolating strings, and working with templates.\r\n * This class provides static methods for dynamic evaluation of code, string interpolation,\r\n * and template processing with caching capabilities.\r\n */\r\nexport class Evaluator {\r\n\t/**\r\n\t * Cache for storing compiled template functions to improve performance.\r\n\t * Keys are string hashes of the template, values are the compiled functions.\r\n\t */\r\n\tstatic cache: Record<string, Function> = {};\r\n\r\n\t/**\r\n\t * Settings for template processing, defining regex patterns for different template operations.\r\n\t * - interpolate: Pattern for variable interpolation ({{ variable }})\r\n\t * - evaluate: Pattern for code evaluation ({% code %})\r\n\t * - escape: Pattern for HTML escaping ({{{ variable }}})\r\n\t */\r\n\tstatic templateSettings: TemplateSettings = {\r\n\t\tinterpolate: /{{([\\s\\S]+?)}}/g,\r\n\t\tevaluate: /\\{%([\\s\\S]+?)%\\}/g,\r\n\t\tescape: /\\{\\{\\{([\\s\\S]+?)\\}\\}\\}/g\r\n\t};\r\n\r\n\t/**\r\n\t * Creates a function from a string or returns the function if already provided.\r\n\t * Uses a secure context to prevent access to the window object by default.\r\n\t * @param {string|Function} func - The function or string to convert to a function.\r\n\t * @param {...any} params - The parameters to pass to the function.\r\n\t * @param {EvaluatorOptions} [options={}] - Optional configuration for the evaluation.\r\n\t * @returns {Function} - The resulting function.\r\n\t */\r\n\tstatic evaluator(func: string | Function, ...params: any[]): Function {\r\n\t\t// Extract options if the last parameter is an options object\r\n\t\tlet options: EvaluatorOptions = {};\r\n\t\tif (\r\n\t\t\tparams.length > 0 &&\r\n\t\t\tparams[params.length - 1] &&\r\n\t\t\ttypeof params[params.length - 1] === 'object' &&\r\n\t\t\t'securityMode' in params[params.length - 1]\r\n\t\t) {\r\n\t\t\toptions = params.pop() as EvaluatorOptions;\r\n\t\t}\r\n\r\n\t\tif (typeof func === 'function') {\r\n\t\t\treturn func;\r\n\t\t}\r\n\r\n\t\tif (typeof params[0] === 'object') {\r\n\t\t\tparams = keys(params[0]);\r\n\t\t}\r\n\r\n\t\t// Check if we should use secure mode (default) or unsafe mode\r\n\t\tconst securityMode = options.securityMode || 'secure';\r\n\r\n\t\tif (securityMode === 'unsafe') {\r\n\t\t\t// In unsafe mode, create a function with access to all globals\r\n\t\t\treturn new Function(...params, func as string);\r\n\t\t}\r\n\t\tconst sandbox = createSecureContext();\r\n\t\tconst sandboxKeys = Object.keys(sandbox);\r\n\t\tconst sandboxAssignments = sandboxKeys.map((key) => `const ${key} = sandbox.${key};`).join('');\r\n\r\n\t\tconst wrapper = new Function(...params, 'sandbox', `${sandboxAssignments}${func as string}`);\r\n\r\n\t\treturn (...args: any[]) => wrapper(...args, sandbox);\r\n\t}\r\n\r\n\t/**\r\n\t * Replaces template expressions in a string with values from data.\r\n\t * Supports function calls within templates and fallback values using || syntax.\r\n\t * By default, ensures evaluation happens in a secure context to prevent access to window object.\r\n\t * @param {string} rawTemplate - The template string containing expressions to interpolate.\r\n\t * @param {Record<string, any>} data - The data object containing values to use for interpolation.\r\n\t * @param {EvaluatorOptions} [options={}] - Optional configuration for the interpolation process.\r\n\t * @returns {string} - The interpolated string with all expressions replaced with actual values.\r\n\t */\r\n\tstatic interpolateString(rawTemplate: string, data: Record<string, any>, options: EvaluatorOptions = {}): string {\r\n\t\tif (!rawTemplate) {\r\n\t\t\treturn '';\r\n\t\t}\r\n\t\tif (typeof rawTemplate !== 'string') {\r\n\t\t\treturn (rawTemplate as any).toString();\r\n\t\t}\r\n\r\n\t\t// Check if we should use secure mode (default) or unsafe mode\r\n\t\tconst securityMode = options.securityMode || 'secure';\r\n\r\n\t\t// Create a secure data object if needed\r\n\t\tconst secureData =\r\n\t\t\tsecurityMode === 'unsafe'\r\n\t\t\t\t? data\r\n\t\t\t\t: {\r\n\t\t\t\t\t\t...createSecureContext(),\r\n\t\t\t\t\t\t...data,\r\n\t\t\t\t\t\t// Ensure these remain undefined\r\n\t\t\t\t\t\twindow: undefined,\r\n\t\t\t\t\t\tself: undefined,\r\n\t\t\t\t\t\tglobalThis: undefined\r\n\t\t\t\t\t};\r\n\r\n\t\treturn rawTemplate.replace(/({{\\s*(.*?)\\s*}})/g, (match: string, $1: string, expression: string) => {\r\n\t\t\tif (expression.indexOf('(') !== -1) {\r\n\t\t\t\treturn expression.replace(/([^(]+)\\(([^)]+)\\s*\\);?/, (_: string, fnName: string, argsStr: string) => {\r\n\t\t\t\t\tfnName = trim(fnName);\r\n\t\t\t\t\tconst func = get(secureData, fnName);\r\n\r\n\t\t\t\t\tif (func) {\r\n\t\t\t\t\t\tif (argsStr) {\r\n\t\t\t\t\t\t\tconst args = argsStr.split(',').map((arg: string) => {\r\n\t\t\t\t\t\t\t\tconst trimmed = trim(arg);\r\n\t\t\t\t\t\t\t\tif (/^['\"]/.test(trimmed)) return trimmed.slice(1, -1);\r\n\t\t\t\t\t\t\t\treturn get(secureData, trimmed);\r\n\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\treturn Evaluator.evaluate(func, args, '', false, secureData, options);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\treturn Evaluator.evaluate(func, [], '', false, secureData, options);\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn '';\r\n\t\t\t\t});\r\n\t\t\t} else {\r\n\t\t\t\tlet dataPath = expression;\r\n\t\t\t\tif (expression.indexOf('?') !== -1) {\r\n\t\t\t\t\tdataPath = expression.replace(/\\?\\./g, '.');\r\n\t\t\t\t}\r\n\t\t\t\tconst parts = dataPath.split('||').map((item: string) => item.trim());\r\n\t\t\t\tlet value = '';\r\n\t\t\t\tlet path = '';\r\n\t\t\t\tfor (let i = 0; i < parts.length; i++) {\r\n\t\t\t\t\tpath = parts[i];\r\n\t\t\t\t\tif (_.has(secureData, path)) {\r\n\t\t\t\t\t\tvalue = _.get(secureData, path);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tif (options.data) {\r\n\t\t\t\t\tset(options.data, path, value);\r\n\t\t\t\t}\r\n\t\t\t\treturn value;\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Performs an evaluation using the evaluation context of this component.\r\n\t * By default, ensures evaluation happens in a secure context to prevent access to window object.\r\n\t * @param {string|Function|object} func - The function or string to evaluate.\r\n\t * @param {object} args - The arguments to pass to the evaluation.\r\n\t * @param {string} ret - The name of the variable within the evaluation context to return.\r\n\t * @param {boolean} interpolate - Determines if it should replace all {{ }} token references with actual data.\r\n\t * @param {object} context -   - The evaluation context.\r\n\t * @param {EvaluatorOptions } options - The options to pass to the evaluation.\r\n\t * @returns {*} - The result of the evaluation.\r\n\t */\r\n\tstatic evaluate(\r\n\t\tfunc: any,\r\n\t\targs: Record<string, any> = {},\r\n\t\tret: string = 'show',\r\n\t\tinterpolate: boolean = false,\r\n\t\tcontext: Record<string, any> = {},\r\n\t\toptions: EvaluatorOptions = {}\r\n\t): any {\r\n\t\tlet returnVal = null;\r\n\r\n\t\tconst field = args.field ? args.field : { key: 'unknown' };\r\n\t\tconst fieldKey = field.key;\r\n\r\n\t\tif (typeof func === 'string') {\r\n\t\t\tif (ret) {\r\n\t\t\t\tfunc = `var ${ret};${func};return ${ret}`;\r\n\t\t\t}\r\n\r\n\t\t\tif (interpolate) {\r\n\t\t\t\tfunc = Evaluator.interpolate(func, args, options);\r\n\t\t\t}\r\n\r\n\t\t\ttry {\r\n\t\t\t\t// Pass the security mode option to the evaluator\r\n\t\t\t\tconst evaluatorOptions = { securityMode: options.securityMode || 'secure' };\r\n\t\t\t\tfunc = Evaluator.evaluator(func, args, context, evaluatorOptions);\r\n\t\t\t\targs = Array.isArray(args) ? args : values(args);\r\n\t\t\t} catch (err) {\r\n\t\t\t\tconsole.warn(`An error occured within the custom function for ${fieldKey}`, err);\r\n\t\t\t\treturnVal = null;\r\n\t\t\t\tfunc = false;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (typeof func === 'function') {\r\n\t\t\ttry {\r\n\t\t\t\treturnVal = Evaluator.execute(func, args, context, options);\r\n\t\t\t} catch (err) {\r\n\t\t\t\treturnVal = null;\r\n\t\t\t\tconsole.warn(`An error occured within custom function for ${fieldKey}`, err);\r\n\t\t\t}\r\n\t\t} else if (func) {\r\n\t\t\tconsole.warn(`Unknown function type for ${fieldKey}`);\r\n\t\t}\r\n\t\treturn returnVal;\r\n\t}\r\n\r\n\t/**\r\n\t * Executes a function with provided arguments and context.\r\n\t * By default, ensures execution happens in a secure context to prevent access to window object.\r\n\t * @param {Function} func - The function to execute.\r\n\t * @param {any[]|Record<string, any>} args - The arguments to pass to the function, either as an array or object.\r\n\t * @param {Record<string, any>} [context={}] - The context (this) to use when executing the function.\r\n\t * @param {EvaluatorOptions} [options={}] - Optional configuration for the execution.\r\n\t * @returns {any} - The result of the function execution.\r\n\t */\r\n\tstatic execute(\r\n\t\tfunc: Function,\r\n\t\targs: any[] | Record<string, any>,\r\n\t\tcontext: Record<string, any> = {},\r\n\t\toptions: EvaluatorOptions = {}\r\n\t): any {\r\n\t\t// Check if we should use secure mode (default) or unsafe mode\r\n\t\tconst securityMode = options.securityMode || 'secure';\r\n\r\n\t\tif (securityMode === 'unsafe') {\r\n\t\t\t// In unsafe mode, execute with the original context\r\n\t\t\treturn Array.isArray(args) ? func.apply(context, args) : func.call(context, args);\r\n\t\t} else {\r\n\t\t\t// In secure mode, create a secure context by merging the provided context with our secure context\r\n\t\t\tconst secureContext = {\r\n\t\t\t\t...createSecureContext(),\r\n\t\t\t\t...context,\r\n\t\t\t\t// Ensure these remain undefined even if they were in the provided context\r\n\t\t\t\twindow: undefined,\r\n\t\t\t\tself: undefined,\r\n\t\t\t\tglobalThis: undefined\r\n\t\t\t};\r\n\r\n\t\t\t// Execute the function with the secure context\r\n\t\t\treturn Array.isArray(args) ? func.apply(secureContext, args) : func.call(secureContext, args);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Creates a template function from a string with caching for performance.\r\n\t * By default, ensures the template function executes in a secure context.\r\n\t * @param {string} template - The template string to compile into a function.\r\n\t * @param {string} [hash] - Optional hash to use as cache key. If not provided, a hash will be generated from the template.\r\n\t * @param {EvaluatorOptions} [options={}] - Optional configuration for the template.\r\n\t * @returns {Function|undefined} - The compiled template function, or undefined if compilation fails.\r\n\t */\r\n\tstatic template(template: string, hash?: string, options: EvaluatorOptions = {}): Function | undefined {\r\n\t\thash = hash || stringHash(template).toString();\r\n\r\n\t\t// If hash contains options object, extract it\r\n\t\tif (typeof hash === 'object' && 'securityMode' in hash) {\r\n\t\t\toptions = hash as unknown as EvaluatorOptions;\r\n\t\t\thash = stringHash(template).toString();\r\n\t\t}\r\n\r\n\t\t// Check if we have a cached version\r\n\t\tconst cacheKey = hash + (options.securityMode || 'secure');\r\n\t\tif (Evaluator.cache[cacheKey]) {\r\n\t\t\treturn Evaluator.cache[cacheKey];\r\n\t\t}\r\n\r\n\t\ttry {\r\n\t\t\ttemplate = template.replace(/ctx\\./g, '');\r\n\r\n\t\t\t// Create the template function using lodash\r\n\t\t\tconst templateFunc = _.template(template, Evaluator.templateSettings);\r\n\r\n\t\t\t// Check if we should use secure mode (default) or unsafe mode\r\n\t\t\tconst securityMode = options.securityMode || 'secure';\r\n\r\n\t\t\tif (securityMode === 'unsafe') {\r\n\t\t\t\t// In unsafe mode, return the original template function\r\n\t\t\t\treturn (Evaluator.cache[cacheKey] = templateFunc);\r\n\t\t\t} else {\r\n\t\t\t\t// In secure mode, wrap the template function to ensure it runs in a secure context\r\n\t\t\t\tconst secureTemplateFunc = (data: any) => {\r\n\t\t\t\t\t// Create a secure context for the template\r\n\t\t\t\t\tconst secureData = {\r\n\t\t\t\t\t\t...createSecureContext(),\r\n\t\t\t\t\t\t...data,\r\n\t\t\t\t\t\t// Ensure these remain undefined\r\n\t\t\t\t\t\twindow: undefined,\r\n\t\t\t\t\t\tself: undefined,\r\n\t\t\t\t\t\tglobalThis: undefined\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\treturn templateFunc(secureData);\r\n\t\t\t\t};\r\n\r\n\t\t\t\t// Cache and return the secure template function\r\n\t\t\t\treturn (Evaluator.cache[cacheKey] = secureTemplateFunc);\r\n\t\t\t}\r\n\t\t} catch (err) {\r\n\t\t\tconsole.warn('Error while processing template', err, template);\r\n\t\t\treturn undefined;\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Interpolates a template with data, handling both function templates and string templates.\r\n\t * By default, ensures interpolation happens in a secure context to prevent access to window object.\r\n\t * @param {string|Function} rawTemplate - The template to interpolate, either as a string or a function.\r\n\t * @param {Record<string, any>} data - The data object to use for interpolation.\r\n\t * @param {EvaluatorOptions} options - Options for the interpolation process.\r\n\t * @returns {string|any} - The result of the interpolation, typically a string but could be any type depending on the template.\r\n\t */\r\n\tstatic interpolate(\r\n\t\trawTemplate: string | Function,\r\n\t\tdata: Record<string, any>,\r\n\t\toptions: EvaluatorOptions = {}\r\n\t): string | any {\r\n\t\tif (typeof rawTemplate === 'function') {\r\n\t\t\ttry {\r\n\t\t\t\t// If the template is a function, execute it with the data\r\n\t\t\t\t// We can't directly secure a provided function, but we can use execute\r\n\t\t\t\t// to run it in a secure context if needed\r\n\t\t\t\tif (options.securityMode !== 'unsafe') {\r\n\t\t\t\t\tconst secureData = {\r\n\t\t\t\t\t\t...createSecureContext(),\r\n\t\t\t\t\t\t...data,\r\n\t\t\t\t\t\twindow: undefined,\r\n\t\t\t\t\t\tself: undefined,\r\n\t\t\t\t\t\tglobalThis: undefined\r\n\t\t\t\t\t};\r\n\t\t\t\t\treturn rawTemplate(secureData);\r\n\t\t\t\t} else {\r\n\t\t\t\t\treturn rawTemplate(data);\r\n\t\t\t\t}\r\n\t\t\t} catch (err) {\r\n\t\t\t\tconsole.warn('Error interpolating template', err, data);\r\n\t\t\t\treturn (err as Error).message;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\trawTemplate = String(rawTemplate);\r\n\t\t// Pass the security mode option to the template method\r\n\t\tconst template = Evaluator.template(rawTemplate, undefined, options);\r\n\r\n\t\tif (typeof template === 'function') {\r\n\t\t\ttry {\r\n\t\t\t\treturn template(data);\r\n\t\t\t} catch (err) {\r\n\t\t\t\tconsole.warn('Error interpolating template', err, rawTemplate, data);\r\n\t\t\t\treturn (err as Error).message;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn template;\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/shared/evaluator/index.js

@@ -0,0 +1,3 @@
+export * from './evaluator';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9zaGFyZWQvZXZhbHVhdG9yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsU0FBUyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldmFsdWF0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJ1xyXG4iXX0=

package/esm2015/lib/shared/evaluator/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9zaGFyZWQvZXZhbHVhdG9yL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBFdmFsdWF0b3JPcHRpb25zID0ge1xyXG5cdGRhdGE/OiBSZWNvcmQ8c3RyaW5nLCBhbnk+O1xyXG5cdC8qKlxyXG5cdCAqIENvbnRyb2xzIHRoZSBzZWN1cml0eSBsZXZlbCBvZiBldmFsdWF0aW9uLlxyXG5cdCAqIC0gJ3NlY3VyZScgKGRlZmF1bHQpOiBQcmV2ZW50cyBhY2Nlc3MgdG8gd2luZG93IG9iamVjdCBhbmQgb3RoZXIgZ2xvYmFsIG9iamVjdHNcclxuXHQgKiAtICd1bnNhZmUnOiBBbGxvd3MgYWNjZXNzIHRvIGFsbCBnbG9iYWwgb2JqZWN0cyAodXNlIHdpdGggY2F1dGlvbilcclxuXHQgKi9cclxuXHRzZWN1cml0eU1vZGU/OiAnc2VjdXJlJyB8ICd1bnNhZmUnO1xyXG59O1xyXG5cclxuZXhwb3J0IHR5cGUgVGVtcGxhdGVTZXR0aW5ncyA9IHtcclxuXHRpbnRlcnBvbGF0ZTogUmVnRXhwO1xyXG5cdGV2YWx1YXRlOiBSZWdFeHA7XHJcblx0ZXNjYXBlOiBSZWdFeHA7XHJcbn07XHJcblxyXG5leHBvcnQgdHlwZSBJbnRlcnBvbGF0ZVN0cmluZyA9IGAke3N0cmluZ317eyR7c3RyaW5nIHwgbnVtYmVyfX19JHtzdHJpbmd9YDtcclxuXHJcbmV4cG9ydCB0eXBlIEV2YWx1YXRlZFN0cmluZzxWQVIgZXh0ZW5kcyBzdHJpbmcgPSAnc2hvdyc+ID0gYCR7c3RyaW5nfSR7VkFSfSR7V2hpdGVzcGFjZX09JHtXaGl0ZXNwYWNlfSR7c3RyaW5nfWA7XHJcblxyXG50eXBlIFdoaXRlc3BhY2UgPSAnJyB8ICcgJyB8IGAke2FueX1gO1xyXG4iXX0=

package/esm2015/lib/shared/index.js

@@ -0,0 +1,8 @@
+export * from './directives';
+export * from './services';
+export * from './components';
+export * from './models';
+export * from './libraryShared.module';
+export * from './evaluator';
+export * from './constants';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9zaGFyZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLGFBQWEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL21vZGVscyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGlicmFyeVNoYXJlZC5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2V2YWx1YXRvcidcclxuZXhwb3J0ICogZnJvbSAnLi9jb25zdGFudHMnXHJcbiJdfQ==