@researchdatabox/redbox-core 0.0.0-bootstrap.0

package/dist/services/DomSanitizerService.d.ts

@@ -0,0 +1,105 @@
+import { Services as coreServices } from '../CoreService';
+export declare namespace Services {
+    /**
+     * SVG and DOM sanitization service using DOMPurify.
+     *
+     * This service provides secure sanitization of SVG and other DOM content using
+     * configurable DOMPurify profiles defined in config/dompurify.js.
+     *
+     * Security Approach & OWASP References:
+     * ======================================
+     * This service implements defense-in-depth sanitization following OWASP recommendations:
+     *
+     * 1. **DOMPurify Library** (OWASP Recommended):
+     *    - Uses DOMPurify, an OWASP-recommended DOM sanitization library
+     *    - Reference: https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html#html-sanitization
+     *    - DOMPurify GitHub: https://github.com/cure53/DOMPurify
+     *    - Actively maintained with regular security audits
+     *
+     * 2. **Multi-Layer Validation** (Defense in Depth):
+     *    - Pre-sanitization validation: Size limits, structural checks, dangerous pattern detection
+     *    - DOMPurify sanitization: Main sanitization pass with configurable profiles
+     *    - Post-sanitization validation: Final security checks for remaining dangerous patterns
+     *    - Reference: https://owasp.org/www-community/Defense_in_Depth
+     *
+     * 3. **SVG-Specific Threats Addressed**:
+     *    - Script injection via <script> tags, event handlers (onclick, onload, etc.)
+     *    - JavaScript/VBScript protocols in href/xlink:href attributes
+     *    - Data URLs that could contain malicious payloads
+     *    - Foreign object elements allowing arbitrary HTML injection
+     *    - CDATA sections and processing instructions
+     *    - External resource references (http/https URLs)
+     *    - Reference: https://owasp.org/www-community/attacks/Billion_laughs_attack
+     *    - Reference: https://owasp.org/www-community/attacks/Cross-site_Scripting_(XSS)
+     *
+     * 4. **Protocol Validation**:
+     *    - Blocks dangerous protocols: javascript:, vbscript:, data:, file:, etc.
+     *    - Blocks external references to prevent privacy leaks and SSRF
+     *    - Reference: https://cheatsheetseries.owasp.org/cheatsheets/AJAX_Security_Cheat_Sheet.html
+     *
+     * 5. **Content Security Policy (CSP) Compatible**:
+     *    - Sanitized content is safe for use with strict CSP
+     *    - No inline scripts or event handlers in output
+     *    - Reference: https://cheatsheetseries.owasp.org/cheatsheets/Content_Security_Policy_Cheat_Sheet.html
+     *
+     * 6. **Size & Complexity Limits**:
+     *    - Prevents billion laughs attacks and resource exhaustion
+     *    - Configurable maximum size limits
+     *    - Nesting depth validation
+     *
+     * Available profiles:
+     * - 'svg': Strict SVG sanitization for user-uploaded SVG files
+     * - 'html': General HTML content sanitization for rich text
+     * - 'minimal': Light sanitization for trusted content
+     *
+     * Usage:
+     * - sanitize(svg): Sanitizes SVG content with full validation and error reporting
+     * - sanitizeWithProfile(content, profile): Generic sanitization with any profile
+     *
+     * Security Notes:
+     * - Always validate sanitization results before rendering
+     * - Review errors array for blocked threats
+     * - Consider additional application-specific validation
+     * - Keep DOMPurify updated for latest security patches
+     */
+    class DomSanitizer extends coreServices.Core.Service {
+        constructor();
+        getMaxBytes(): number;
+        /**
+         * Generic DOM sanitization method that can use any configured profile.
+         * @param content - The content to sanitize
+         * @param profileName - The DOMPurify profile to use
+         * @returns Sanitized content
+         */
+        sanitizeWithProfile(content: string, profileName?: string): string;
+        /**
+         * Get DOMPurify configuration for the specified profile.
+         * @param profileName - The configuration profile to use (defaults to 'svg')
+         */
+        private getDOMPurifyConfig;
+        /**
+         * Validate href/xlink:href attributes to ensure they are safe.
+         */
+        private validateHrefAttributes;
+        /**
+         * Sanitize an SVG string using DOMPurify.
+         * Returns object with safety status, sanitized markup, and errors/warnings.
+         */
+        sanitize(svg: string): {
+            safe: boolean;
+            sanitized: string;
+            errors: string[];
+            warnings: string[];
+            info: {
+                originalBytes: number;
+                sanitizedBytes: number;
+            };
+        };
+        private inspectSvgStructure;
+    }
+}
+export default Services;
+declare global {
+    let DomSanitizerService: Services.DomSanitizer;
+}
+//# sourceMappingURL=DomSanitizerService.d.ts.map

package/dist/services/DomSanitizerService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomSanitizerService.d.ts","sourceRoot":"","sources":["../../src/services/DomSanitizerService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AA+K1D,yBAAiB,QAAQ,CAAC;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DG;IACH,MAAa,YAAa,SAAQ,YAAY,CAAC,IAAI,CAAC,OAAO;;QAOzD,WAAW,IAAI,MAAM;QAIrB;;;;;WAKG;QACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,GAAE,MAAe,GAAG,MAAM;QAe1E;;;WAGG;QACH,OAAO,CAAC,kBAAkB;QAuB1B;;WAEG;QACH,OAAO,CAAC,sBAAsB;QAmD9B;;;WAGG;QACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG;YACrB,IAAI,EAAE,OAAO,CAAC;YACd,SAAS,EAAE,MAAM,CAAC;YAClB,MAAM,EAAE,MAAM,EAAE,CAAC;YACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;YACnB,IAAI,EAAE;gBAAE,aAAa,EAAE,MAAM,CAAC;gBAAC,cAAc,EAAE,MAAM,CAAA;aAAE,CAAC;SACzD;QA+MD,OAAO,CAAC,mBAAmB;KA8B5B;CAGF;AAGD,eAAe,QAAQ,CAAC;AAGxB,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,mBAAmB,EAAE,QAAQ,CAAC,YAAY,CAAC;CAChD"}

package/dist/services/DomSanitizerService.js

@@ -0,0 +1,506 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const PopulateExportedMethods_decorator_1 = require("../decorator/PopulateExportedMethods.decorator");
+const CoreService_1 = require("../CoreService");
+const domPurify = require("dompurify");
+const buffer_1 = require("buffer");
+const jsdom_1 = require("jsdom");
+const isDomPurifyInstance = (candidate) => {
+    if (!candidate || (typeof candidate !== 'object' && typeof candidate !== 'function')) {
+        return false;
+    }
+    const record = candidate;
+    return typeof record.sanitize === 'function'
+        && typeof record.addHook === 'function'
+        && typeof record.removeHook === 'function';
+};
+const isSanitizerNode = (candidate) => {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const record = candidate;
+    return typeof record.remove === 'function'
+        && typeof record.removeAttribute === 'function'
+        && typeof record.getAttribute === 'function';
+};
+const isDomPurifyConfig = (candidate) => {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const record = candidate;
+    return typeof record.profiles === 'object' && record.profiles !== null;
+};
+const getWindow = () => {
+    const globalCache = globalThis;
+    const globalWindow = globalCache.window;
+    if (globalWindow && typeof globalWindow.document !== 'undefined') {
+        return globalWindow;
+    }
+    const cacheKey = '__domSanitizerWindow';
+    if (!globalCache[cacheKey]) {
+        const { window } = new jsdom_1.JSDOM('', { pretendToBeVisual: true });
+        globalCache[cacheKey] = window;
+    }
+    return globalCache[cacheKey];
+};
+const instantiateDomPurify = (factoryModule) => {
+    if (!factoryModule) {
+        return null;
+    }
+    const windowRef = getWindow();
+    const tryGet = (candidate) => (isDomPurifyInstance(candidate) ? candidate : null);
+    const moduleRecord = (typeof factoryModule === 'object' || typeof factoryModule === 'function')
+        ? factoryModule
+        : null;
+    const candidates = [
+        () => tryGet(factoryModule),
+        () => tryGet(moduleRecord?.default),
+        () => tryGet(moduleRecord?.DOMPurify),
+        () => {
+            const createDOMPurify = moduleRecord?.createDOMPurify;
+            if (typeof createDOMPurify === 'function') {
+                return tryGet(createDOMPurify(windowRef));
+            }
+            return null;
+        },
+        () => {
+            if (typeof factoryModule === 'function') {
+                return tryGet(factoryModule(windowRef));
+            }
+            return null;
+        },
+        () => {
+            const defaultExport = moduleRecord?.default;
+            if (typeof defaultExport === 'function') {
+                return tryGet(defaultExport(windowRef));
+            }
+            return null;
+        }
+    ];
+    for (const resolver of candidates) {
+        try {
+            const instance = resolver();
+            if (instance) {
+                return instance;
+            }
+        }
+        catch (error) {
+            sails?.log?.silly?.('DomSanitizerService:: DOMPurify instantiation attempt failed', error);
+        }
+    }
+    return null;
+};
+const initialiseDOMPurify = () => {
+    const instanceFromDomPurify = instantiateDomPurify(domPurify);
+    if (instanceFromDomPurify) {
+        return instanceFromDomPurify;
+    }
+    throw new Error('DomSanitizerService: Failed to initialise DOMPurify with hook support');
+};
+const DOMPurify = initialiseDOMPurify();
+globalThis.DOMPurify = DOMPurify;
+const createDOMPurifyForCall = () => {
+    const windowRef = getWindow();
+    const moduleRecord = (typeof domPurify === 'object' || typeof domPurify === 'function')
+        ? domPurify
+        : null;
+    const createDOMPurify = (typeof moduleRecord?.createDOMPurify === 'function' && moduleRecord.createDOMPurify)
+        || (typeof domPurify === 'function' && domPurify)
+        || (typeof moduleRecord?.default === 'function' && moduleRecord.default)
+        || null;
+    if (typeof createDOMPurify === 'function') {
+        try {
+            const instance = createDOMPurify(windowRef);
+            if (isDomPurifyInstance(instance)) {
+                return instance;
+            }
+        }
+        catch (error) {
+            sails?.log?.silly?.('DomSanitizerService:: per-call DOMPurify creation failed, falling back', error);
+        }
+    }
+    const fallback = instantiateDomPurify(domPurify);
+    if (fallback) {
+        return fallback;
+    }
+    throw new Error('DomSanitizerService: Failed to initialise DOMPurify instance for sanitize call');
+};
+var Services;
+(function (Services) {
+    /**
+     * SVG and DOM sanitization service using DOMPurify.
+     *
+     * This service provides secure sanitization of SVG and other DOM content using
+     * configurable DOMPurify profiles defined in config/dompurify.js.
+     *
+     * Security Approach & OWASP References:
+     * ======================================
+     * This service implements defense-in-depth sanitization following OWASP recommendations:
+     *
+     * 1. **DOMPurify Library** (OWASP Recommended):
+     *    - Uses DOMPurify, an OWASP-recommended DOM sanitization library
+     *    - Reference: https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html#html-sanitization
+     *    - DOMPurify GitHub: https://github.com/cure53/DOMPurify
+     *    - Actively maintained with regular security audits
+     *
+     * 2. **Multi-Layer Validation** (Defense in Depth):
+     *    - Pre-sanitization validation: Size limits, structural checks, dangerous pattern detection
+     *    - DOMPurify sanitization: Main sanitization pass with configurable profiles
+     *    - Post-sanitization validation: Final security checks for remaining dangerous patterns
+     *    - Reference: https://owasp.org/www-community/Defense_in_Depth
+     *
+     * 3. **SVG-Specific Threats Addressed**:
+     *    - Script injection via <script> tags, event handlers (onclick, onload, etc.)
+     *    - JavaScript/VBScript protocols in href/xlink:href attributes
+     *    - Data URLs that could contain malicious payloads
+     *    - Foreign object elements allowing arbitrary HTML injection
+     *    - CDATA sections and processing instructions
+     *    - External resource references (http/https URLs)
+     *    - Reference: https://owasp.org/www-community/attacks/Billion_laughs_attack
+     *    - Reference: https://owasp.org/www-community/attacks/Cross-site_Scripting_(XSS)
+     *
+     * 4. **Protocol Validation**:
+     *    - Blocks dangerous protocols: javascript:, vbscript:, data:, file:, etc.
+     *    - Blocks external references to prevent privacy leaks and SSRF
+     *    - Reference: https://cheatsheetseries.owasp.org/cheatsheets/AJAX_Security_Cheat_Sheet.html
+     *
+     * 5. **Content Security Policy (CSP) Compatible**:
+     *    - Sanitized content is safe for use with strict CSP
+     *    - No inline scripts or event handlers in output
+     *    - Reference: https://cheatsheetseries.owasp.org/cheatsheets/Content_Security_Policy_Cheat_Sheet.html
+     *
+     * 6. **Size & Complexity Limits**:
+     *    - Prevents billion laughs attacks and resource exhaustion
+     *    - Configurable maximum size limits
+     *    - Nesting depth validation
+     *
+     * Available profiles:
+     * - 'svg': Strict SVG sanitization for user-uploaded SVG files
+     * - 'html': General HTML content sanitization for rich text
+     * - 'minimal': Light sanitization for trusted content
+     *
+     * Usage:
+     * - sanitize(svg): Sanitizes SVG content with full validation and error reporting
+     * - sanitizeWithProfile(content, profile): Generic sanitization with any profile
+     *
+     * Security Notes:
+     * - Always validate sanitization results before rendering
+     * - Review errors array for blocked threats
+     * - Consider additional application-specific validation
+     * - Keep DOMPurify updated for latest security patches
+     */
+    class DomSanitizer extends CoreService_1.Services.Core.Service {
+        constructor() {
+            super();
+            this.logHeader = "DomSanitizerService::";
+        }
+        getMaxBytes() {
+            return _.get(sails.config, 'record.form.svgMaxBytes', 1048576); // 1MB default
+        }
+        /**
+         * Generic DOM sanitization method that can use any configured profile.
+         * @param content - The content to sanitize
+         * @param profileName - The DOMPurify profile to use
+         * @returns Sanitized content
+         */
+        sanitizeWithProfile(content, profileName = 'html') {
+            if (!_.isString(content)) {
+                throw new Error('Content must be a string');
+            }
+            try {
+                const config = this.getDOMPurifyConfig(profileName);
+                const sanitized = DOMPurify.sanitize(content, config);
+                return String(sanitized);
+            }
+            catch (error) {
+                sails.log.error(`DomSanitizerService: Error sanitizing content with profile '${profileName}':`, error);
+                throw error;
+            }
+        }
+        /**
+         * Get DOMPurify configuration for the specified profile.
+         * @param profileName - The configuration profile to use (defaults to 'svg')
+         */
+        getDOMPurifyConfig(profileName = 'svg') {
+            const rawConfig = _.get(sails.config, 'dompurify', {});
+            const dompurifyConfig = isDomPurifyConfig(rawConfig)
+                ? rawConfig
+                : { profiles: {}, defaultProfile: 'svg', hooks: {}, globalSettings: {} };
+            const profiles = dompurifyConfig.profiles || {};
+            const globalSettings = dompurifyConfig.globalSettings || {};
+            // Get the requested profile or fall back to default
+            const profile = profiles[profileName] || profiles[dompurifyConfig.defaultProfile] || profiles.svg;
+            if (!profile) {
+                sails.log.error(`DomSanitizerService: DOMPurify profile '${profileName}' not found and no fallback available`);
+                throw new Error(`DOMPurify configuration profile '${profileName}' not found`);
+            }
+            // Merge profile settings with global settings
+            return {
+                ...globalSettings,
+                ...profile
+            };
+        }
+        /**
+         * Validate href/xlink:href attributes to ensure they are safe.
+         */
+        validateHrefAttributes(svg) {
+            const errors = [];
+            // Check for dangerous protocols in href attributes
+            const dangerousProtocols = [
+                'javascript:', 'vbscript:', 'data:', 'file:', 'ftp:', 'ftps:',
+                'chrome:', 'resource:', 'moz-extension:', 'chrome-extension:',
+                'ms-appx:', 'ms-appx-web:', 'about:', 'blob:', 'filesystem:'
+            ];
+            // Check for external references (http/https/protocol-relative)
+            const externalProtocols = ['http:', 'https:', '//'];
+            // Match href attributes with both quoted and unquoted values
+            // Group 1: quoted value (single or double quotes)
+            // Group 2: unquoted value (non-whitespace, non->)
+            const hrefPattern = /(?:href|xlink:href)\s*=\s*(?:["']([^"']*)["']|([^\s>]+))/gi;
+            let match;
+            while ((match = hrefPattern.exec(svg)) !== null) {
+                // Use whichever capture group matched (quoted = group 1, unquoted = group 2)
+                const url = (match[1] !== undefined ? match[1] : match[2]).toLowerCase().trim();
+                // Check for dangerous protocols
+                for (const protocol of dangerousProtocols) {
+                    if (url.startsWith(protocol)) {
+                        if (protocol === 'javascript:') {
+                            errors.push('javascript-protocol');
+                        }
+                        else if (protocol === 'vbscript:') {
+                            errors.push('vbscript-protocol');
+                        }
+                        else if (protocol === 'data:') {
+                            errors.push('data-url-embed');
+                        }
+                        else {
+                            errors.push('dangerous-protocol');
+                        }
+                        break;
+                    }
+                }
+                // Check for external references
+                for (const protocol of externalProtocols) {
+                    if (url.startsWith(protocol)) {
+                        errors.push('external-ref');
+                        break;
+                    }
+                }
+            }
+            return { valid: errors.length === 0, errors };
+        }
+        /**
+         * Sanitize an SVG string using DOMPurify.
+         * Returns object with safety status, sanitized markup, and errors/warnings.
+         */
+        sanitize(svg) {
+            const errors = [];
+            const warnings = [];
+            // Enhanced input validation
+            if (!_.isString(svg)) {
+                errors.push('not-a-string');
+                return { safe: false, sanitized: '', errors, warnings, info: { originalBytes: 0, sanitizedBytes: 0 } };
+            }
+            // Check for null bytes and other control characters
+            const containsControlCharacters = Array.from(svg).some((char) => {
+                const code = char.charCodeAt(0);
+                return (code >= 0 && code <= 8)
+                    || code === 11
+                    || code === 12
+                    || (code >= 14 && code <= 31)
+                    || code === 127;
+            });
+            if (containsControlCharacters) {
+                errors.push('contains-control-characters');
+            }
+            const originalBytes = buffer_1.Buffer.byteLength(svg, 'utf8');
+            const max = this.getMaxBytes();
+            if (originalBytes > max || svg.length > max) {
+                if (originalBytes > max) {
+                    errors.push('too-large');
+                }
+                if (svg.length > max) {
+                    errors.push('string-too-long');
+                }
+                return { safe: false, sanitized: '', errors, warnings, info: { originalBytes, sanitizedBytes: 0 } };
+            }
+            // Basic structural check
+            if (!/<svg[\s>]/i.test(svg)) {
+                errors.push('missing-svg-root');
+            }
+            // Check for excessive nesting and element count (resource exhaustion protection)
+            const svgStructure = this.inspectSvgStructure(svg);
+            if (svgStructure.maxDepth > 1000) {
+                errors.push('excessive-nesting');
+            }
+            if (svgStructure.totalElements > 100000) {
+                errors.push('excessive-elements');
+            }
+            // Check for suspicious CDATA sections
+            if (/<!\[CDATA\[/i.test(svg)) {
+                errors.push('cdata-section');
+            }
+            // Check for processing instructions
+            if (/<\?\w+/i.test(svg)) {
+                warnings.push('processing-instructions');
+            }
+            // Pre-validation: Check for dangerous patterns before sanitization
+            const hrefValidation = this.validateHrefAttributes(svg);
+            if (!hrefValidation.valid) {
+                // Filter out 'external-ref' as it will be caught by hooks
+                errors.push(...hrefValidation.errors.filter(e => e !== 'external-ref'));
+            }
+            // Check for script elements
+            if (/<script[\s>]/i.test(svg)) {
+                errors.push('script-element');
+            }
+            // Check for foreign object elements
+            if (/<foreignObject[\s>]/i.test(svg)) {
+                errors.push('foreign-object');
+            }
+            try {
+                // Use DOMPurify to sanitize the SVG
+                const config = this.getDOMPurifyConfig();
+                const beforeSanitizeElementsHook = (node) => {
+                    if (!isSanitizerNode(node)) {
+                        return;
+                    }
+                    if (node.tagName && /^(script|iframe|embed|object|applet)$/i.test(node.tagName)) {
+                        node.remove();
+                    }
+                };
+                const beforeSanitizeAttributesHook = (node) => {
+                    if (!isSanitizerNode(node)) {
+                        return;
+                    }
+                    if (node.attributes) {
+                        const attrs = Array.from(node.attributes);
+                        attrs.forEach((attr) => {
+                            if (attr.name.toLowerCase().startsWith('on')) {
+                                node.removeAttribute(attr.name);
+                                warnings.push('event-handlers-removed');
+                            }
+                        });
+                    }
+                    const href = node.getAttribute('href') || node.getAttribute('xlink:href');
+                    if (!href) {
+                        return;
+                    }
+                    const lowerHref = href.toLowerCase().trim();
+                    const dangerousProtocols = [
+                        'javascript:', 'vbscript:', 'data:', 'file:', 'chrome:',
+                        'resource:', 'moz-extension:', 'chrome-extension:', 'ms-appx:',
+                        'about:', 'blob:', 'filesystem:'
+                    ];
+                    const externalProtocols = ['http:', 'https:', '//'];
+                    let shouldRemove = false;
+                    for (const protocol of dangerousProtocols) {
+                        if (lowerHref.startsWith(protocol)) {
+                            shouldRemove = true;
+                            break;
+                        }
+                    }
+                    if (!shouldRemove) {
+                        for (const protocol of externalProtocols) {
+                            if (lowerHref.startsWith(protocol)) {
+                                shouldRemove = true;
+                                errors.push('external-ref');
+                                break;
+                            }
+                        }
+                    }
+                    if (shouldRemove) {
+                        node.removeAttribute('href');
+                        node.removeAttribute('xlink:href');
+                    }
+                };
+                const domPurifyForCall = createDOMPurifyForCall();
+                domPurifyForCall.addHook('beforeSanitizeElements', beforeSanitizeElementsHook);
+                domPurifyForCall.addHook('beforeSanitizeAttributes', beforeSanitizeAttributesHook);
+                let sanitized;
+                try {
+                    sanitized = domPurifyForCall.sanitize(svg, config);
+                }
+                finally {
+                    domPurifyForCall.removeHook('beforeSanitizeAttributes');
+                    domPurifyForCall.removeHook('beforeSanitizeElements');
+                }
+                // Post-sanitization validation
+                // Convert TrustedHTML to string for further processing
+                let working = String(sanitized);
+                // Final security checks for any remaining dangerous patterns
+                const dangerousPatterns = [
+                    { pattern: /javascript\s*:/gi, error: 'javascript-protocol-found' },
+                    { pattern: /vbscript\s*:/gi, error: 'vbscript-protocol-found' },
+                    // Block all data URLs - they can be used to embed malicious content
+                    // Pattern matches "data:" followed by any content (MIME type, encoding, data)
+                    // Examples blocked: data:text/html, data:image/svg+xml, data:application/javascript, etc.
+                    { pattern: /data\s*:[^,\s]*[,\s]/gi, error: 'unsafe-data-url-found' },
+                    { pattern: /<script[\s>]/gi, error: 'script-element-found' },
+                    { pattern: /<\/script\s*>/gi, error: 'script-closing-tag-found' },
+                    { pattern: /on\w+\s*=/gi, error: 'event-handler-found' }
+                ];
+                dangerousPatterns.forEach(check => {
+                    if (check.pattern.test(working)) {
+                        errors.push(check.error);
+                        // Remove the dangerous content
+                        working = working.replace(check.pattern, '');
+                    }
+                });
+                // Collapse excessive whitespace
+                working = working.replace(/\s{2,}/g, ' ').trim();
+                const sanitizedBytes = buffer_1.Buffer.byteLength(working, 'utf8');
+                const safe = errors.length === 0;
+                return {
+                    safe,
+                    sanitized: working,
+                    errors,
+                    warnings,
+                    info: { originalBytes, sanitizedBytes }
+                };
+            }
+            catch (error) {
+                // Handle any DOMPurify errors
+                errors.push('sanitization-error');
+                sails.log.error('SVG sanitization error:', error);
+                return {
+                    safe: false,
+                    sanitized: '',
+                    errors,
+                    warnings,
+                    info: { originalBytes, sanitizedBytes: 0 }
+                };
+            }
+        }
+        inspectSvgStructure(svg) {
+            const tagRegex = /<\s*(\/)?\s*([a-zA-Z][\w:.-]*)([^>]*)>/g;
+            let depth = 0;
+            let maxDepth = 0;
+            let totalElements = 0;
+            let match;
+            while ((match = tagRegex.exec(svg)) !== null) {
+                const isClosingTag = Boolean(match[1]);
+                const trailingSegment = match[3] ?? '';
+                const isSelfClosingTag = /\/\s*$/.test(trailingSegment);
+                if (isClosingTag) {
+                    depth = Math.max(0, depth - 1);
+                    continue;
+                }
+                totalElements += 1;
+                depth += 1;
+                if (depth > maxDepth) {
+                    maxDepth = depth;
+                }
+                if (isSelfClosingTag) {
+                    depth = Math.max(0, depth - 1);
+                }
+            }
+            return { maxDepth, totalElements };
+        }
+    }
+    Services.DomSanitizer = DomSanitizer;
+})(Services || (exports.Services = Services = {}));
+exports.default = Services;
+(0, PopulateExportedMethods_decorator_1.PopulateExportedMethods)(Services.DomSanitizer);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DomSanitizerService.js","sourceRoot":"","sources":["../../src/services/DomSanitizerService.ts"],"names":[],"mappings":"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"}