@qrvey/utils 1.15.0-9 → 1.16.0-0

package/dist/elements/interfaces/IVemCore.js

@@ -0,0 +1 @@
+import { VemPositionType, } from "./IVemPosition";

package/dist/elements/interfaces/IVemPosition.d.ts

@@ -0,0 +1,44 @@
+export interface VemSizeFixed {
+    width: number;
+    height: number;
+}
+export interface VemSizeResponsive {
+    colSpan: number;
+    rowSpan: number;
+}
+export interface VemPositionFixed extends VemSizeFixed {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface VemPositionResponsive extends VemSizeResponsive {
+    colStart: number;
+    rowStart: number;
+}
+export type VemPosition = VemPositionFixed | VemPositionResponsive;
+export interface VemPositionMap {
+    [VemPositionType.FIXED]: VemPositionFixed;
+    [VemPositionType.RESPONSIVE]: VemPositionResponsive;
+}
+export declare enum VemPositionType {
+    FIXED = "fixed",
+    RESPONSIVE = "responsive"
+}
+interface VemPositionBase<TPosition extends VemPosition> {
+    desktop: TPosition;
+    tablet?: TPosition;
+    mobile?: TPosition;
+}
+export type VemPositionConfigFixed = VemPositionBase<VemPositionFixed>;
+export type VemPositionConfigResponsive = VemPositionBase<VemPositionResponsive>;
+export type VemPositionConfig = VemPositionConfigFixed | VemPositionConfigResponsive;
+export interface VemPositionConfigMap {
+    [VemPositionType.FIXED]: VemPositionConfigFixed;
+    [VemPositionType.RESPONSIVE]: VemPositionConfigResponsive;
+}
+export type VemSize = VemSizeFixed | VemSizeResponsive;
+export interface VemSizeConfig {
+    [VemPositionType.FIXED]: VemSizeFixed;
+    [VemPositionType.RESPONSIVE]: VemSizeResponsive;
+}
+export {};

package/dist/elements/interfaces/IVemPosition.js

@@ -0,0 +1,5 @@
+export var VemPositionType;
+(function (VemPositionType) {
+    VemPositionType["FIXED"] = "fixed";
+    VemPositionType["RESPONSIVE"] = "responsive";
+})(VemPositionType || (VemPositionType = {}));

package/dist/elements/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ICanvasGrid";
+export * from "./IFixedPosition";
+export * from "./IVemCore";
+export * from "./IVemPosition";

package/dist/elements/interfaces/index.js

@@ -0,0 +1,4 @@
+export * from "./ICanvasGrid";
+export * from "./IFixedPosition";
+export * from "./IVemCore";
+export * from "./IVemPosition";

package/dist/elements/utils/element.d.ts

@@ -0,0 +1,4 @@
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { Vem } from "../interfaces/IVemCore";
+import { VemPositionType } from "../interfaces/IVemPosition";
+export declare const copyDesktopPositionToDevice: (elements: Vem[], newCanvasDevice: CanvasDevice, canvasType: VemPositionType) => Vem[];

package/dist/elements/utils/element.js

@@ -0,0 +1,24 @@
+import { setElementPosition } from "./position";
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { VemPositionType, } from "../interfaces/IVemPosition";
+export const copyDesktopPositionToDevice = (elements, newCanvasDevice, canvasType) => {
+    const defaultPositionMap = {
+        [VemPositionType.FIXED]: {
+            x: 0,
+            y: 0,
+        },
+        [VemPositionType.RESPONSIVE]: {
+            colStart: 1,
+            rowStart: 1,
+        },
+    };
+    return elements.map((element) => {
+        var _a;
+        if (!((_a = element.position[canvasType]) === null || _a === void 0 ? void 0 : _a[newCanvasDevice])) {
+            const desktopViewPosition = element.position[canvasType][CanvasDevice.DESKTOP];
+            const newDevicePosition = Object.assign(Object.assign(Object.assign({}, desktopViewPosition), defaultPositionMap[canvasType]), { preCalculated: true });
+            return setElementPosition(element, canvasType, newCanvasDevice, newDevicePosition);
+        }
+        return element;
+    });
+};

package/dist/elements/utils/fixed.position.d.ts

@@ -0,0 +1,12 @@
+import { CanvasDevice, VemFixed, VemPositionFixed } from "../interfaces";
+export declare const hasOverflow: (element: VemFixed, device: CanvasDevice, resolution: number, canvasHeight?: number) => boolean;
+export declare const hasOverlap: (element: VemFixed, elements: VemFixed[], device: CanvasDevice) => number;
+export declare const itemXOverflow: (item: VemFixed, device: CanvasDevice, resolution: number) => boolean;
+export declare const itemYOverflow: (item: VemFixed, device: CanvasDevice, canvasHeight: number) => boolean;
+export declare const checkFixedGridItemsOverlap: (item: VemPositionFixed, itemToCompare: VemPositionFixed) => boolean;
+export declare const dxGetFixedGridItemDevice: (element: VemFixed, device: CanvasDevice) => VemPositionFixed;
+export declare const dxGetFixedGridItemX: (element: VemFixed, device: CanvasDevice, allowNegative?: boolean) => number;
+export declare const dxGetFixedGridItemY: (element: VemFixed, device: CanvasDevice, allowNegative?: boolean) => number;
+export declare const dxGetFixedGridItemZ: (element: VemFixed, device: CanvasDevice) => number;
+export declare const dxGetFixedGridItemHeight: (element: VemFixed, device: CanvasDevice) => number;
+export declare const dxGetFixedGridItemWidth: (element: VemFixed, device: CanvasDevice) => number;

package/dist/elements/utils/fixed.position.js

@@ -0,0 +1,72 @@
+export const hasOverflow = (element, device, resolution, canvasHeight) => {
+    const hasXOverflow = itemXOverflow(element, device, resolution);
+    const hasYOverflow = canvasHeight
+        ? itemYOverflow(element, device, canvasHeight)
+        : false;
+    return hasXOverflow || hasYOverflow;
+};
+export const hasOverlap = (element, elements, device) => {
+    const elementPosition = element.position.fixed[device];
+    if (!elementPosition)
+        return;
+    const overlappingElements = elements.filter((cElement) => checkFixedGridItemsOverlap(elementPosition, cElement.position.fixed[device]));
+    return overlappingElements.length;
+};
+export const itemXOverflow = (item, device, resolution) => {
+    const fixedPosition = item.position.fixed;
+    return (!!fixedPosition[device] &&
+        fixedPosition[device].x + fixedPosition[device].width > resolution);
+};
+export const itemYOverflow = (item, device, canvasHeight) => {
+    const fixedPosition = item.position.fixed;
+    return (!!fixedPosition[device] &&
+        fixedPosition[device].y + fixedPosition[device].height > canvasHeight);
+};
+export const checkFixedGridItemsOverlap = (item, itemToCompare) => {
+    return !(item.x + item.width < itemToCompare.x ||
+        item.x > itemToCompare.x + itemToCompare.width ||
+        item.y + item.height < itemToCompare.y ||
+        item.y > itemToCompare.y + itemToCompare.height);
+};
+export const dxGetFixedGridItemDevice = (element, device) => {
+    return {
+        x: dxGetFixedGridItemX(element, device),
+        y: dxGetFixedGridItemY(element, device),
+        z: dxGetFixedGridItemZ(element, device),
+        height: dxGetFixedGridItemHeight(element, device),
+        width: dxGetFixedGridItemWidth(element, device),
+    };
+};
+export const dxGetFixedGridItemX = (element, device, allowNegative = false) => {
+    var _a;
+    const position = element.position.fixed[device];
+    const itemX = (_a = position === null || position === void 0 ? void 0 : position.x) !== null && _a !== void 0 ? _a : 0;
+    if (!allowNegative) {
+        return itemX >= 0 ? itemX : 0;
+    }
+    return itemX;
+};
+export const dxGetFixedGridItemY = (element, device, allowNegative = false) => {
+    var _a;
+    const position = element.position.fixed[device];
+    const itemY = (_a = position === null || position === void 0 ? void 0 : position.y) !== null && _a !== void 0 ? _a : 0;
+    if (!allowNegative) {
+        return itemY >= 0 ? itemY : 0;
+    }
+    return itemY;
+};
+export const dxGetFixedGridItemZ = (element, device) => {
+    var _a;
+    const position = element.position.fixed[device];
+    return (_a = position === null || position === void 0 ? void 0 : position.z) !== null && _a !== void 0 ? _a : 1;
+};
+export const dxGetFixedGridItemHeight = (element, device) => {
+    var _a;
+    const position = element.position.fixed[device];
+    return (_a = position === null || position === void 0 ? void 0 : position.height) !== null && _a !== void 0 ? _a : 400;
+};
+export const dxGetFixedGridItemWidth = (element, device) => {
+    var _a;
+    const position = element.position.fixed[device];
+    return (_a = position === null || position === void 0 ? void 0 : position.width) !== null && _a !== void 0 ? _a : 400;
+};

package/dist/elements/utils/general.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compares two objects based on their `distance` property and determines their relative order.
+ * @param a - An object with a `distance` property (number).
+ * @param b - Another object with a `distance` property (number).
+ * @param a.distance
+ * @param b.distance
+ * @returns - A negative number if `a` has a smaller distance than `b`,
+ *            a positive number if `a` has a larger distance than `b`,
+ *            or 0 if both have equal distances.
+ */
+export declare const sortByDistanceFunction: (a: {
+    distance: number;
+}, b: {
+    distance: number;
+}) => 0 | 1 | -1;

package/dist/elements/utils/general.js

@@ -0,0 +1,16 @@
+/**
+ * Compares two objects based on their `distance` property and determines their relative order.
+ * @param a - An object with a `distance` property (number).
+ * @param b - Another object with a `distance` property (number).
+ * @param a.distance
+ * @param b.distance
+ * @returns - A negative number if `a` has a smaller distance than `b`,
+ *            a positive number if `a` has a larger distance than `b`,
+ *            or 0 if both have equal distances.
+ */
+export const sortByDistanceFunction = (a, b) => {
+    if (a.distance === b.distance) {
+        return 0;
+    }
+    return a.distance < b.distance ? -1 : 1;
+};

package/dist/elements/utils/overlap.d.ts

@@ -0,0 +1,63 @@
+interface OverlapNode {
+    startX: number;
+    endX: number;
+    startY: number;
+    endY: number;
+    maxEndX: number;
+    maxEndY: number;
+    left?: OverlapNode;
+    right?: OverlapNode;
+}
+/**
+ *
+ */
+export declare class OverlapIntervalTree {
+    root?: OverlapNode;
+    /**
+     *
+     */
+    constructor();
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    insert(startX: number, endX: number, startY: number, endY: number): void;
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _initNode;
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _insert;
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    overlaps(startX: number, endX: number, startY: number, endY: number): boolean;
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    private _overlaps;
+}
+export {};

package/dist/elements/utils/overlap.js

@@ -0,0 +1,95 @@
+/**
+ *
+ */
+export class OverlapIntervalTree {
+    /**
+     *
+     */
+    constructor() {
+        this.root = undefined;
+    }
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    insert(startX, endX, startY, endY) {
+        this.root = this._insert(this.root, startX, endX, startY, endY);
+    }
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    _initNode(startX, endX, startY, endY) {
+        return {
+            startX,
+            endX,
+            startY,
+            endY,
+            maxEndX: endX,
+            maxEndY: endY,
+            left: undefined,
+            right: undefined,
+        };
+    }
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    _insert(node, startX, endX, startY, endY) {
+        if (node === undefined) {
+            return this._initNode(startX, endX, startY, endY);
+        }
+        if (startY < node.startY) {
+            node.left = this._insert(node.left, startX, endX, startY, endY);
+        }
+        else {
+            node.right = this._insert(node.right, startX, endX, startY, endY);
+        }
+        node.maxEndX = Math.max(node.maxEndX, endX);
+        node.maxEndY = Math.max(node.maxEndY, endY);
+        return node;
+    }
+    /**
+     *
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    overlaps(startX, endX, startY, endY) {
+        return this._overlaps(this.root, startX, endX, startY, endY);
+    }
+    /**
+     *
+     * @param node
+     * @param startX
+     * @param endX
+     * @param startY
+     * @param endY
+     */
+    _overlaps(node, startX, endX, startY, endY) {
+        if (node === undefined) {
+            return false;
+        }
+        if (startX <= node.endX &&
+            endX >= node.startX &&
+            startY <= node.endY &&
+            endY >= node.startY) {
+            return true;
+        }
+        if (node.left !== undefined && node.left.maxEndY >= startY) {
+            return this._overlaps(node.left, startX, endX, startY, endY);
+        }
+        return this._overlaps(node.right, startX, endX, startY, endY);
+    }
+}

package/dist/elements/utils/position.d.ts

@@ -0,0 +1,4 @@
+import { CanvasDevice } from "../interfaces/ICanvasGrid";
+import { Vem } from "../interfaces/IVemCore";
+import { VemPosition, VemPositionType } from "../interfaces/IVemPosition";
+export declare const setElementPosition: <T extends VemPositionType = VemPositionType>(baseElement: Vem<unknown, T>, type: T, device: CanvasDevice, position: VemPosition) => Vem<unknown, T>;

package/dist/elements/utils/position.js

@@ -0,0 +1 @@
+export const setElementPosition = (baseElement, type, device, position) => (Object.assign(Object.assign({}, baseElement), { position: Object.assign(Object.assign({}, baseElement.position), { [type]: Object.assign(Object.assign({}, baseElement.position[type]), { [device]: position }) }) }));

package/dist/filters/adapters/FDToLogic.js

@@ -34,7 +34,8 @@ function getLogicBodyFromFD21(filterData) {
                 filters = filters.concat(expressions);
             });
         }
-        logics.push(Object.assign(Object.assign({}, logic), { filters }));
+        if (!isEmpty(filters))
+            logics.push(Object.assign(Object.assign({}, logic), { filters }));
         return logics;
     }, []);
 }

package/dist/filters/helpers/backend/buildExpression.js

@@ -13,6 +13,7 @@ export function buildExpression(filter) {
     const expression = {
         groupValue: getBackendGroupValue(filter),
         questionid: filter.column.id,
+        qrveyid: filter.column.qrveyid,
         questionType: filter.column.type,
         property: getBackendProperty(filter),
         validationType: getBackendValidator(filter),

package/dist/filters/helpers/backend/buildFilters.d.ts

@@ -1,3 +1,8 @@
 import { IFBFilter } from "../../interfaces/backend/IFBFilter";
 import { IFSFilter } from "../../interfaces/common/IFSFilter";
+/**
+ *
+ * @param filters
+ * @param groupColumns
+ */
 export declare function buildFilters(filters: IFSFilter[], groupColumns?: boolean): IFBFilter[];

package/dist/filters/helpers/backend/buildFilters.js

@@ -1,7 +1,12 @@
+import { buildExpression } from "./buildExpression";
 import { isEmpty } from "../../../general/mix/isEmpty";
 import { _hasProperty } from "../../../general/object/hasProperty";
 import { FILTER_OPERATOR } from "../../constants/common/FILTER_OPERATOR";
-import { buildExpression } from "./buildExpression";
+/**
+ *
+ * @param filters
+ * @param groupColumns
+ */
 export function buildFilters(filters, groupColumns = false) {
     const expression = numericExpression(filters, groupColumns);
     const orOperators = expression.split("+");
@@ -25,6 +30,8 @@ export function buildFilters(filters, groupColumns = false) {
         return getColumnExpressions(group, getFilter);
     })
         .filter(Boolean);
+    if (isEmpty(expressions))
+        return [];
     if (orOperators.length > 1) {
         return [
             {
@@ -38,6 +45,11 @@ export function buildFilters(filters, groupColumns = false) {
     }
     return [{ operator: FILTER_OPERATOR.AND, expressions }];
 }
+/**
+ *
+ * @param group
+ * @param getFilter
+ */
 function getColumnExpressions(group, getFilter) {
     const columnOrOperators = group.split("/");
     if (columnOrOperators.length > 1) {
@@ -50,12 +62,22 @@ function getColumnExpressions(group, getFilter) {
     }
     return getFilter(group);
 }
+/**
+ *
+ * @param operator
+ * @param priority
+ */
 function logicToNumeric(operator, priority = false) {
     if (operator === FILTER_OPERATOR.AND) {
         return "*";
     }
     return priority ? "/" : "+";
 }
+/**
+ *
+ * @param filters
+ * @param groupColumns
+ */
 function numericExpression(filters, groupColumns = false) {
     let expression = "";
     filters.forEach((item, index) => {

package/dist/filters/helpers/backend/getBackendValues.js

@@ -1,5 +1,6 @@
 import { COLUMN } from "../../../columns/constants/COLUMN";
 import { flattenDeep } from "../../../general/array/flattenDeep";
+import { isEmpty } from "../../../general/mix/isEmpty";
 import { FILTER_VALIDATOR } from "../../constants/common/FILTER_VALIDATOR";
 import { FILTER_VALIDATOR_INFO } from "../../constants/common/FILTER_VALIDATOR_INFO";
 import { isRankingFilter } from "../common/isRankingFilter";
@@ -82,7 +83,9 @@ function getNullValues(values, filter) {
     return addValue ? [FILTER_VALIDATOR_INFO[filter.validator].label] : [];
 }
 function getInValues(values) {
-    return values.map((value) => getValue(value, value)).filter(Boolean);
+    return values
+        .map((value) => (Object.assign(Object.assign({}, getValue(value, value)), { anchor: isEmpty(value.anchor) ? undefined : value.anchor })))
+        .filter(Boolean);
 }
 function getValue(objectValue, value) {
     return objectValue.enabled ? value : undefined;

package/dist/filters/helpers/getAvailableScopesIDsByConfig.js

@@ -12,5 +12,6 @@ export function getAvailableScopesIDsByConfig(config = {}) {
         tabid: getAttribute(config, "tab_id") || config.tabid,
         pageid: getAttribute(config, "page_id") || config.pageid,
         defaultid: getAttribute(config, "default_id") || config.defaultid,
+        panelid: getAttribute(config, "panel_id") || config.panelid,
     };
 }

package/dist/filters/interfaces/backend/IFBExpression.js

@@ -3,4 +3,3 @@ export {};
 //
 // formulaType?: string;
 // linkid?: string;
-// qrveyid?: string;

package/dist/general/array/getUniqueSimpleArray.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get unique vaues from an Array of primitive JS types
+ * @param arr Array of primitive types
+ * @returns the new array with unique items
+ */
+export declare function getUniqueSimpleArray<T = unknown>(arr: T[]): T[];

package/dist/general/array/getUniqueSimpleArray.js

@@ -0,0 +1,10 @@
+/**
+ * Get unique vaues from an Array of primitive JS types
+ * @param arr Array of primitive types
+ * @returns the new array with unique items
+ */
+export function getUniqueSimpleArray(arr) {
+    if (!Array.isArray(arr))
+        return arr;
+    return Array.from(new Set(arr));
+}

package/dist/general/array/index.d.ts

@@ -5,6 +5,7 @@ export * from "./getArrayByProperty";
 export * from "./filterNestedTree";
 export * from "./getFirstIndexFromArray";
 export * from "./getUniqueArray";
+export * from "./getUniqueSimpleArray";
 export * from "./howManyByParam";
 export * from "./getLastIndexFromArray";
 export * from "./intersectObjectArrays";

package/dist/general/array/index.js

@@ -5,6 +5,7 @@ export * from "./getArrayByProperty";
 export * from "./filterNestedTree";
 export * from "./getFirstIndexFromArray";
 export * from "./getUniqueArray";
+export * from "./getUniqueSimpleArray";
 export * from "./howManyByParam";
 export * from "./getLastIndexFromArray";
 export * from "./intersectObjectArrays";

package/dist/general/string/index.d.ts

@@ -2,3 +2,7 @@ export * from "./capitalize";
 export * from "./padLeadingZeros";
 export * from "./parseUrl";
 export * from "./camelize";
+export * from "./secureHTML";
+export * from "./strategies/XSSSanitizer";
+export * from "./strategies/XSSEstrictedSanitizer";
+export * from "./urlValidator";

package/dist/general/string/index.js

@@ -2,3 +2,7 @@ export * from "./capitalize";
 export * from "./padLeadingZeros";
 export * from "./parseUrl";
 export * from "./camelize";
+export * from "./secureHTML";
+export * from "./strategies/XSSSanitizer";
+export * from "./strategies/XSSEstrictedSanitizer";
+export * from "./urlValidator";

package/dist/general/string/secureHTML.d.ts

@@ -0,0 +1,8 @@
+import { SanitizerStrategy } from "../../interfaces/SatinizerStrategy";
+/**
+ * Sanitizes HTML using the provided strategy.
+ * @param {string} html - HTML to sanitize.
+ * @param {SanitizerStrategy} sanitizer - Sanitization strategy.
+ * @returns {string} - Sanitized HTML.
+ */
+export declare const secureHTML: (html: string, sanitizer: SanitizerStrategy) => string;

package/dist/general/string/secureHTML.js

@@ -0,0 +1,9 @@
+/**
+ * Sanitizes HTML using the provided strategy.
+ * @param {string} html - HTML to sanitize.
+ * @param {SanitizerStrategy} sanitizer - Sanitization strategy.
+ * @returns {string} - Sanitized HTML.
+ */
+export const secureHTML = (html, sanitizer) => {
+    return sanitizer.sanitize(html);
+};

package/dist/general/string/strategies/XSSEstrictedSanitizer.d.ts

@@ -0,0 +1,8 @@
+import { IFilterXSSOptions } from "xss";
+import { SanitizerStrategy } from "../../../interfaces/SatinizerStrategy";
+export declare class XSSEstrictedSanitizer implements SanitizerStrategy {
+    private attributesBlackList;
+    private options;
+    constructor(options?: IFilterXSSOptions, attributesBlackList?: string[]);
+    sanitize(html: string): string;
+}

package/dist/general/string/strategies/XSSEstrictedSanitizer.js

@@ -0,0 +1,19 @@
+import { filterXSS } from "xss";
+export class XSSEstrictedSanitizer {
+    constructor(options, attributesBlackList = []) {
+        this.attributesBlackList = attributesBlackList;
+        this.options = Object.assign({ css: false, onIgnoreTagAttr: (_tag, name, value) => {
+                if (this.attributesBlackList.includes(name)) {
+                    return ""; // Elimina el atributo si está en la lista negra
+                }
+                return `${name}="${value}"`; // Mantiene el atributo si no está en la lista negra
+            }, onIgnoreTag: (tag, _html, _options) => {
+                if (["script", "iframe"].includes(tag)) {
+                    return ""; // Elimina los <script>
+                }
+            }, escapeHtml: (str) => str }, options);
+    }
+    sanitize(html) {
+        return filterXSS(html, this.options);
+    }
+}

package/dist/general/string/strategies/XSSSanitizer.d.ts

@@ -0,0 +1,8 @@
+import { IFilterXSSOptions } from "xss";
+import { SanitizerStrategy } from "../../../interfaces/SatinizerStrategy";
+export declare class XSSSanitizer implements SanitizerStrategy {
+    private attributesBlackList;
+    private options;
+    constructor(options?: IFilterXSSOptions, attributesBlackList?: string[]);
+    sanitize(html: string): string;
+}

package/dist/general/string/strategies/XSSSanitizer.js

@@ -0,0 +1,15 @@
+import { filterXSS } from "xss";
+export class XSSSanitizer {
+    constructor(options, attributesBlackList = []) {
+        this.attributesBlackList = attributesBlackList;
+        this.options = Object.assign({ css: false, onIgnoreTagAttr: (tag, name, value) => {
+                if (!this.attributesBlackList.includes(name)) {
+                    return `${name}="${value}"`;
+                }
+                return "";
+            } }, options);
+    }
+    sanitize(html) {
+        return filterXSS(html, this.options);
+    }
+}

package/dist/general/string/urlValidator.d.ts

@@ -0,0 +1,10 @@
+export declare class URLValidator {
+    private validDomains;
+    private validProtocols;
+    constructor(domains?: string[], protocols?: string[]);
+    setValidDomains(domains?: string[]): this;
+    setValidProtocols(protocols?: string[]): this;
+    validate(url: string): boolean;
+    private isValidProtocol;
+    private isValidDomain;
+}