content-security-toolkit 1.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Iker Laforga
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# Content Security Toolkit
+
+A comprehensive toolkit for implementing content security measures in web applications.
+
+## Features
+
+- Prevent keyboard shortcuts (Ctrl+P, Ctrl+S, etc.)
+- Disable context menu (right-click)
+- Block printing attempts
+- Add watermarks to content
+- Works across desktop and mobile browsers
+- Highly configurable and extensible
+
+## Installation
+
+```bash
+npm install content-security-toolkit
+# or
+yarn add content-security-toolkit
+
+
+Content Security Toolkit is a comprehensive JavaScript/TypeScript library designed to protect sensitive web content from unauthorized copying, extraction, and distribution. It implements multiple layers of protection strategies that work together to safeguard digital content while maintaining a good user experience for legitimate users.
+
+Unlike traditional DRM (Digital Rights Management) systems that often require specialized software or hardware, Content Security Toolkit operates entirely within the browser environment, making it lightweight, easy to implement, and compatible with standard web applications.
+
+## Core Architecture
+
+The library is built on a modular, strategy-based architecture:
+
+- **ContentProtector**: The main class that orchestrates all protection strategies
+- **ProtectionStrategy**: The interface implemented by all protection mechanisms
+- **Strategy Implementations**: Individual protection mechanisms that can be enabled/disabled independently
+
+
+This architecture allows for flexible configuration and easy extension with new protection strategies.
+
+## Available Protection Strategies
+
+### 1. Keyboard Shortcut Protection (KeyboardStrategy)
+
+**Purpose**: Prevents users from using keyboard shortcuts to copy, save, print, or otherwise extract content.
+
+**Implementation Details**:
+
+- Intercepts key combinations like Ctrl+C, Ctrl+P, Ctrl+S, Ctrl+Shift+I
+- Configurable to block specific shortcuts
+- Provides custom event handlers for blocked shortcuts
+
+
+### 2. Context Menu Protection (ContextMenuStrategy)
+
+**Purpose**: Prevents users from accessing the browser's context menu (right-click menu) to copy content or view page source.
+
+**Implementation Details**:
+
+- Intercepts the contextmenu event on specified elements
+- Can be applied to the entire document or specific elements
+- Supports custom handler for context menu attempts
+
+
+### 3. Print Protection (PrintStrategy)
+
+**Purpose**: Prevents users from printing the page or using the browser's print functionality.
+
+**Implementation Details**:
+
+- Intercepts print events (window.print, Ctrl+P)
+- Optionally displays a custom message when print is attempted
+- Can be configured to allow printing but with watermarks
+
+
+### 4. Selection Protection (SelectionStrategy)
+
+**Purpose**: Prevents users from selecting and copying text content.
+
+**Implementation Details**:
+
+- Disables text selection via CSS and JavaScript
+- Intercepts selection events
+- Can be applied to specific elements or the entire document
+- Supports custom handler for selection attempts
+
+
+### 5. Watermark Protection (WatermarkStrategy)
+
+**Purpose**: Adds visible watermarks to the content to discourage unauthorized sharing and identify the source.
+
+**Implementation Details**:
+
+- Creates a grid of semi-transparent watermarks across the content
+- Supports customization of text, opacity, density, and positioning
+- Includes user identification (userId) to trace leaked content
+- **Observer Mechanism**: Implements a MutationObserver to detect when watermarks are removed from the DOM and automatically regenerates them
+- Watermarks are positioned in a way that makes them difficult to remove without affecting the content
+
+
+### 6. DevTools Protection (DevToolsStrategy)
+
+**Purpose**: Detects and responds to attempts to open browser developer tools, which could be used to inspect and modify the page.
+
+**Implementation Details**:
+
+- Uses multiple detection techniques (window.devtools, console timing, resize detection)
+- Provides callbacks when DevTools are opened or closed
+- Can be configured to take specific actions when DevTools are detected
+
+
+### 7. Screenshot Protection (ScreenshotStrategy)
+
+**Purpose**: Detects and responds to screenshot attempts.
+
+**Implementation Details**:
+
+- Monitors clipboard events and screen capture APIs
+- Blurs content or displays warning message during screenshot attempts
+- Provides callbacks when screenshot attempts are detected
+- Uses visual tricks to make screenshots less useful (temporary content blurring)
+
+
+## Technical Deep Dive
+
+### Watermark Observer Mechanism
+
+The watermark protection includes a sophisticated observer system that ensures watermarks remain present even if they're removed from the DOM.
+This observer continuously monitors the DOM for any attempts to remove watermark elements and immediately regenerates them when such attempts are detected.
+
+### DevTools Detection Techniques
+
+The DevTools protection strategy employs multiple detection methods to identify when developer tools are opened:
+
+1. **Console Timing Difference**: Measures the execution time difference between regular code and code that triggers debugger features
+2. **Window Size Monitoring**: Detects the window size changes that occur when DevTools are opened
+3. **Feature Detection**: Checks for the presence of DevTools-specific objects and properties
+4. **Debugger Statement Handling**: Uses strategic debugger statements that behave differently when DevTools are open
+
+
+### Screenshot Detection
+
+The screenshot protection uses several techniques to detect and respond to screenshot attempts:
+
+1. **Clipboard Event Monitoring**: Detects copy events that might indicate a screenshot
+2. **Visual Feedback**: Can temporarily blur content or display a warning when screenshot attempts are detected
+3. **Screen Capture API Interception**: Monitors and responds to browser screen capture API calls
+
+
+## Known Limitations and Issues
+
+While Content Security Toolkit provides robust protection, it's important to understand its limitations:
+
+1. **Client-Side Only**: As a JavaScript library, all protections run in the browser and can potentially be circumvented by determined users with technical knowledge.
+2. **No Server-Side Validation**: The library doesn't include server-side components to validate content access or enforce permissions beyond the browser.
+3. **Browser Compatibility**: Some protection strategies rely on modern browser APIs and may not work in older browsers.
+4. **Mobile Limitations**: Some protections (particularly DevTools detection) are less effective on mobile devices.
+5. **Accessibility Impact**: Content protection measures can interfere with accessibility tools. Care should be taken to ensure content remains accessible to users with disabilities.
+6. **Performance Considerations**: Extensive protection, particularly watermarking with high density, can impact page performance.
+7. **Hardware Screenshots**: The library cannot prevent screenshots taken using physical cameras or external hardware.
+8. **Browser Extensions**: Some browser extensions might interfere with or bypass certain protection mechanisms.
+
+Unlike DRM systems that encrypt content and control playback through specialized software, Content Security Toolkit focuses on preventing common extraction methods while maintaining compatibility with standard web browsers. It's designed as a deterrent rather than an unbreakable protection system.
+
+## Best Practices for Implementation
+
+For optimal protection, consider these implementation guidelines:
+
+1. **Layer Multiple Strategies**: Enable multiple protection mechanisms for defense in depth
+2. **Custom Handlers**: Implement custom handlers to log protection events and take appropriate actions
+3. **User Education**: Inform users about content protection and acceptable use policies
+4. **Selective Protection**: Apply protection only to sensitive content to minimize performance impact
+5. **Regular Updates**: Keep the library updated to benefit from security improvements
+6. **Complementary Measures**: Combine with server-side protections and legal terms of use
+7. **Accessibility Considerations**: Test with accessibility tools and provide alternative access methods for legitimate users with special needs

package/dist/config/default-extensions-config.json

@@ -0,0 +1,103 @@
+{
+    "extensions": {
+        "evernote-web-clipper": {
+            "name": "Evernote Web Clipper",
+            "description": "Clips web content to Evernote",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".evernote-clipper", "#evernoteClipper", "#evernoteClipperToolsMain"],
+                "jsSignatures": ["EvernoteClipper", "ENClipper"]
+            }
+        },
+        "onenote-clipper": {
+            "name": "OneNote Web Clipper",
+            "description": "Clips web content to OneNote",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".onenote-clipper", "#oneNoteClipper", "#oneNoteWebClipper"],
+                "jsSignatures": ["OneNoteClipper", "OneNoteWebClipper"]
+            }
+        },
+        "notion-web-clipper": {
+            "name": "Notion Web Clipper",
+            "description": "Clips web content to Notion",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".notion-clipper", "#notionClipper"],
+                "jsSignatures": ["notionClientAPI"]
+            }
+        },
+        "pocket": {
+            "name": "Pocket",
+            "description": "Saves content for later reading",
+            "risk": "medium",
+            "detectionMethods": {
+                "domSelectors": [".pocket-button", "#pocket-button-container"],
+                "jsSignatures": ["Pocket", "PocketButtonManager"]
+            }
+        },
+        "instapaper": {
+            "name": "Instapaper",
+            "description": "Saves content for later reading",
+            "risk": "medium",
+            "detectionMethods": {
+                "domSelectors": [".instapaper-button", "#instapaper-button"],
+                "jsSignatures": ["Instapaper"]
+            }
+        },
+        "readwise": {
+            "name": "Readwise",
+            "description": "Saves highlights and annotations",
+            "risk": "medium",
+            "detectionMethods": {
+                "domSelectors": [".readwise-button", "#readwise-highlights"],
+                "jsSignatures": ["readwiseAPI", "readwiseHighlighter"]
+            }
+        },
+        "singlefile": {
+            "name": "SingleFile",
+            "description": "Saves complete web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".singlefile-button", "#singlefile-ui"],
+                "jsSignatures": ["singlefile", "SingleFile"]
+            }
+        },
+        "save-page-we": {
+            "name": "Save Page WE",
+            "description": "Saves complete web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".save-page-we"],
+                "jsSignatures": ["savePageWE"]
+            }
+        },
+        "fireshot": {
+            "name": "Fireshot",
+            "description": "Takes screenshots of web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".fireshot-ui", "#fireshot-container"],
+                "jsSignatures": ["FireShot", "FSCapture"]
+            }
+        },
+        "gofullpage": {
+            "name": "GoFullPage",
+            "description": "Takes full page screenshots",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".gofullpage-ui"],
+                "jsSignatures": ["GoFullPage", "FullPageScreenshot"]
+            }
+        },
+        "web-scraper": {
+            "name": "Web Scraper",
+            "description": "Extracts data from web pages",
+            "risk": "high",
+            "detectionMethods": {
+                "domSelectors": [".web-scraper-selection", "#web-scraper-selector-overlay"],
+                "jsSignatures": ["WebScraper", "SelectorGraph"]
+            }
+        }
+    }
+}

package/dist/core/ContentProtector.d.ts

@@ -0,0 +1,63 @@
+import type { ContentProtectionOptions, ProtectionStrategy } from "../types";
+/**
+ * Main class for protecting content from copying, screenshotting, and other extraction methods
+ * Coordinates multiple protection strategies and manages their lifecycle
+ */
+export declare class ContentProtector {
+    private options;
+    private strategies;
+    private isActive;
+    private overlayManager;
+    private protectedContentManager;
+    private mediator;
+    private handlerRegistry;
+    private logger;
+    /**
+     * Create a new ContentProtector instance
+     * @param options Configuration options for content protection
+     */
+    constructor(options?: ContentProtectionOptions);
+    /**
+     * Initialize protection strategies based on configuration options
+     * Creates strategy instances and adds them to the strategies map
+     */
+    private initializeStrategies;
+    /**
+     * Apply all protection strategies
+     * Activates each strategy to protect content
+     */
+    protect(): void;
+    /**
+     * Remove all protection strategies
+     * Deactivates each strategy and cleans up resources
+     */
+    unprotect(): void;
+    /**
+     * Update protection options
+     * Removes existing protection, updates options, and reapplies if needed
+     * @param options New options to apply
+     */
+    updateOptions(options: Partial<ContentProtectionOptions>): void;
+    /**
+     * Check if protection is currently active
+     * @returns True if protection is active
+     */
+    isProtected(): boolean;
+    /**
+     * Get a specific strategy by name
+     * @param name Strategy name
+     * @returns The strategy instance or undefined if not found
+     */
+    getStrategy(name: string): ProtectionStrategy | undefined;
+    /**
+     * Check if a specific strategy is active
+     * @param name Strategy name
+     * @returns True if the strategy exists
+     */
+    hasStrategy(name: string): boolean;
+    /**
+     * Clean up and dispose of all resources
+     * Removes protection and cleans up global managers
+     */
+    dispose(): void;
+}

package/dist/core/ContentProtector.js

@@ -0,0 +1,279 @@
+import { KeyboardStrategy, PrintStrategy, ContextMenuStrategy, WatermarkStrategy, SelectionStrategy, DevToolsStrategy, ScreenshotStrategy, BrowserExtensionDetectionStrategy, FrameEmbeddingProtectionStrategy, } from "../strategies";
+import { SecurityOverlayManager } from "../utils/securityOverlayManager";
+import { intervalManager } from "../utils/intervalManager";
+import { eventManager } from "../utils/eventManager";
+import { ContentProtectionMediator } from "./mediator/ContentProtectionMediator";
+import { HandlerRegistry } from "./mediator/handlers/eventHandlerRegistry";
+import { ProtectedContentManager } from "../utils/protectedContentManager";
+import { SimpleLoggingService } from "../utils/logging/simple/SimpleLoggingService";
+/**
+ * Main class for protecting content from copying, screenshotting, and other extraction methods
+ * Coordinates multiple protection strategies and manages their lifecycle
+ */
+export class ContentProtector {
+    /**
+     * Create a new ContentProtector instance
+     * @param options Configuration options for content protection
+     */
+    constructor(options = {}) {
+        this.strategies = new Map();
+        this.isActive = false;
+        // Define default options
+        const defaults = {
+            preventKeyboardShortcuts: true,
+            preventContextMenu: true,
+            preventPrinting: true,
+            preventSelection: true,
+            preventScreenshots: true,
+            enableWatermark: false,
+            preventDevTools: false,
+            preventExtensions: false,
+            preventEmbedding: false,
+            debugMode: false,
+        };
+        // Merge defaults with provided options
+        this.options = {
+            ...defaults,
+            ...options,
+        };
+        // Initialize logger
+        this.logger = new SimpleLoggingService("ContentProtector", this.options.debugMode);
+        // Normalize and set targetElement if not provided
+        const resolveTargetElement = (t) => {
+            if (typeof document === "undefined")
+                return null;
+            // Already an element
+            if (t instanceof HTMLElement)
+                return t;
+            // CSS selector string
+            if (typeof t === "string") {
+                try {
+                    const el = document.querySelector(t);
+                    return el instanceof HTMLElement ? el : null;
+                }
+                catch {
+                    return null;
+                }
+            }
+            // Vue 3 ref ({ value: HTMLElement }) or Vue component ($el) or DOM-like node
+            if (t && typeof t === "object") {
+                const maybe = t;
+                if (maybe.value instanceof HTMLElement)
+                    return maybe.value;
+                if (maybe.$el instanceof HTMLElement)
+                    return maybe.$el;
+                if (maybe.nodeType === 1 && typeof maybe.nodeName === "string")
+                    return t;
+            }
+            return null;
+        };
+        // Normalize provided targetElement, or default to document.body
+        const normalizedTarget = resolveTargetElement(this.options.targetElement);
+        if (normalizedTarget) {
+            this.options.targetElement = normalizedTarget;
+        }
+        else if (!this.options.targetElement && typeof document !== "undefined") {
+            this.options.targetElement = document.body;
+        }
+        else {
+            // If user provided something invalid, clear it to avoid passing non-DOM objects to strategies
+            if (this.options.targetElement) {
+                this.logger = new SimpleLoggingService("ContentProtector", this.options.debugMode);
+                this.logger.warn("Provided targetElement is not a DOM element - falling back to document.body if available");
+                if (typeof document !== "undefined")
+                    this.options.targetElement = document.body;
+                else
+                    this.options.targetElement = undefined;
+            }
+        }
+        // Initialize the mediator
+        this.mediator = new ContentProtectionMediator(this.options.debugMode);
+        // Initialize the handler registry
+        this.handlerRegistry = new HandlerRegistry(this.mediator, this.options.debugMode);
+        // Initialize overlay manager
+        this.overlayManager = new SecurityOverlayManager(this.options.debugMode);
+        this.overlayManager.setMediator(this.mediator);
+        // Initialize protected content manager
+        this.protectedContentManager = new ProtectedContentManager(this.options.targetElement, this.options.debugMode);
+        this.protectedContentManager.setMediator(this.mediator);
+        // Wire content visibility callbacks from customHandlers (useful for Vue re-mounting)
+        if (this.options.customHandlers) {
+            this.protectedContentManager.setContentCallbacks(this.options.customHandlers.onContentHidden, this.options.customHandlers.onContentRestored);
+        }
+        // Configure debug mode for managers
+        if (this.options.debugMode) {
+            this.logger.log("Initialized with options", this.options);
+            // Enable debug mode for the event manager
+            eventManager.setDebugMode(true);
+            // Enable debug mode for the interval manager
+            //intervalManager.setDebugMode(true);
+        }
+        this.initializeStrategies();
+    }
+    /**
+     * Initialize protection strategies based on configuration options
+     * Creates strategy instances and adds them to the strategies map
+     */
+    initializeStrategies() {
+        const { debugMode, targetElement, customHandlers } = this.options;
+        // Initialize strategies based on options
+        if (this.options.preventKeyboardShortcuts) {
+            this.strategies.set("keyboard", new KeyboardStrategy(customHandlers?.onKeyboardShortcutBlocked, debugMode));
+        }
+        if (this.options.preventContextMenu) {
+            this.strategies.set("contextMenu", new ContextMenuStrategy(this.options.contextMenuOptions, targetElement, customHandlers?.onContextMenuAttempt, debugMode));
+        }
+        if (this.options.preventPrinting) {
+            this.strategies.set("print", new PrintStrategy(customHandlers?.onPrintAttempt, debugMode));
+        }
+        if (this.options.preventSelection) {
+            this.strategies.set("selection", new SelectionStrategy(targetElement, customHandlers?.onSelectionAttempt, debugMode));
+        }
+        if (this.options.enableWatermark && this.options.watermarkOptions) {
+            this.strategies.set("watermark", new WatermarkStrategy(this.options.watermarkOptions, targetElement, debugMode));
+        }
+        if (this.options.preventDevTools) {
+            const devToolsStrategy = new DevToolsStrategy(this.options.devToolsOptions, targetElement, customHandlers?.onDevToolsOpen, debugMode);
+            devToolsStrategy.setMediator(this.mediator);
+            this.strategies.set("devTools", devToolsStrategy);
+        }
+        if (this.options.preventScreenshots) {
+            const screenshotStrategy = new ScreenshotStrategy(this.options.screenshotOptions, targetElement, customHandlers?.onScreenshotAttempt, debugMode);
+            screenshotStrategy.setMediator(this.mediator);
+            this.strategies.set("screenshot", screenshotStrategy);
+        }
+        if (this.options.preventExtensions) {
+            const extensionStrategy = new BrowserExtensionDetectionStrategy(this.options.extensionOptions, targetElement, customHandlers?.onExtensionDetected, debugMode);
+            extensionStrategy.setMediator(this.mediator);
+            this.strategies.set("extension", extensionStrategy);
+        }
+        if (this.options.preventEmbedding) {
+            const frameStrategy = new FrameEmbeddingProtectionStrategy(this.options.frameEmbeddingOptions, targetElement, customHandlers?.onFrameEmbeddingDetected, debugMode);
+            frameStrategy.setMediator(this.mediator);
+            this.strategies.set("iFrame", frameStrategy);
+        }
+        this.logger.log("Initialized strategies", Array.from(this.strategies.keys()));
+    }
+    /**
+     * Apply all protection strategies
+     * Activates each strategy to protect content
+     */
+    protect() {
+        if (this.isActive) {
+            this.logger.log("Already protected, skipping");
+            return;
+        }
+        this.logger.log("Applying protection strategies");
+        // Apply each strategy
+        for (const [name, strategy] of this.strategies.entries()) {
+            try {
+                this.logger.log(`Applying strategy "${name}"`);
+                strategy.apply();
+            }
+            catch (error) {
+                this.logger.error(`Error applying strategy "${name}":`, error);
+            }
+        }
+        this.isActive = true;
+        this.logger.log("All protection strategies applied successfully");
+    }
+    /**
+     * Remove all protection strategies
+     * Deactivates each strategy and cleans up resources
+     */
+    unprotect() {
+        if (!this.isActive) {
+            this.logger.log("Not protected, skipping");
+            return;
+        }
+        this.logger.log("Removing protection strategies");
+        // Create a copy of the strategy entries to avoid modification during iteration
+        const entries = Array.from(this.strategies.entries());
+        // Remove each strategy and track failures
+        let successCount = 0;
+        let failCount = 0;
+        for (const [name, strategy] of entries) {
+            try {
+                this.logger.log(`Removing strategy "${name}"`);
+                if (strategy.isApplied()) {
+                    strategy.remove();
+                    successCount++;
+                }
+            }
+            catch (error) {
+                failCount++;
+                this.logger.error(`Error removing strategy "${name}":`, error);
+            }
+        }
+        // Clear all strategies regardless of removal success
+        this.strategies.clear();
+        this.isActive = false;
+        this.logger.log(`Protection removed (${successCount} successful, ${failCount} failed)`);
+    }
+    /**
+     * Update protection options
+     * Removes existing protection, updates options, and reapplies if needed
+     * @param options New options to apply
+     */
+    updateOptions(options) {
+        this.logger.log("Updating options", options);
+        // Store the current state
+        const wasActive = this.isActive;
+        // Remove existing protections
+        this.unprotect();
+        // Update options
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+        // Update debug mode for managers and logger
+        if (options.debugMode !== undefined) {
+            this.logger.setDebugMode(options.debugMode);
+            eventManager.setDebugMode(options.debugMode);
+            //intervalManager.setDebugMode(options.debugMode);
+            this.overlayManager.setDebugMode(options.debugMode);
+        }
+        this.logger.log("New options after update", this.options);
+        // Reinitialize strategies
+        this.strategies.clear();
+        this.initializeStrategies();
+        // Reapply protection if it was active before
+        if (wasActive) {
+            this.logger.log("Reapplying protection after options update");
+            this.protect();
+        }
+    }
+    /**
+     * Check if protection is currently active
+     * @returns True if protection is active
+     */
+    isProtected() {
+        return this.isActive;
+    }
+    /**
+     * Get a specific strategy by name
+     * @param name Strategy name
+     * @returns The strategy instance or undefined if not found
+     */
+    getStrategy(name) {
+        return this.strategies.get(name);
+    }
+    /**
+     * Check if a specific strategy is active
+     * @param name Strategy name
+     * @returns True if the strategy exists
+     */
+    hasStrategy(name) {
+        return this.strategies.has(name);
+    }
+    /**
+     * Clean up and dispose of all resources
+     * Removes protection and cleans up global managers
+     */
+    dispose() {
+        this.unprotect();
+        // Dispose interval manager
+        intervalManager.dispose();
+        this.logger.log("Disposed all resources");
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1 @@
+export { ContentProtector } from './ContentProtector';

package/dist/core/index.js

@@ -0,0 +1,2 @@
+// BARREL FILE
+export { ContentProtector } from './ContentProtector';