@akashjs/runtime 0.2.6 → 0.2.7

package/dist/query-state.d.ts

@@ -0,0 +1,82 @@
+import { S as Signal } from './signals-DionyGGY.js';
+
+/**
+ * URL-synced reactive state.
+ *
+ * Automatically sync signal values to URL query parameters.
+ * Users can share links, use browser back/forward, and state
+ * persists across page reloads — all with zero boilerplate.
+ *
+ * ```ts
+ * const search = useQueryState('q', '');
+ * const page = useQueryState('page', 1);
+ * const tags = useQueryState('tags', ['js']);
+ *
+ * search.set('akashjs'); // URL → ?q=akashjs&page=1&tags=js
+ * // User hits back → signals update automatically
+ * ```
+ */
+
+interface QueryStateOptions<T> {
+    /** Custom serializer (default: auto-detect from type) */
+    serialize?: (value: T) => string;
+    /** Custom deserializer (default: auto-detect from type) */
+    deserialize?: (raw: string) => T;
+    /** Whether to push or replace history entry (default: 'replace') */
+    history?: 'push' | 'replace';
+    /** Debounce URL updates in ms (default: 0) */
+    debounce?: number;
+    /** Remove param from URL when value equals default */
+    removeDefault?: boolean;
+}
+/**
+ * Create a signal synced to a URL query parameter.
+ *
+ * ```ts
+ * const search = useQueryState('q', '');
+ * search();            // reads from URL or default
+ * search.set('hello'); // updates URL to ?q=hello
+ * ```
+ */
+declare function useQueryState<T>(key: string, defaultValue: T, options?: QueryStateOptions<T>): Signal<T>;
+type QueryStateSchema = Record<string, {
+    default: unknown;
+    serialize?: (value: any) => string;
+    deserialize?: (raw: string) => any;
+}>;
+type QueryStates<T extends QueryStateSchema> = {
+    [K in keyof T]: Signal<T[K]['default']>;
+};
+/**
+ * Create multiple URL-synced signals at once.
+ * All updates within a batch result in a single URL change.
+ *
+ * ```ts
+ * const { q, page, sort } = useQueryStates({
+ *   q: { default: '' },
+ *   page: { default: 1 },
+ *   sort: { default: 'name' },
+ * });
+ * ```
+ */
+declare function useQueryStates<T extends QueryStateSchema>(schema: T, options?: {
+    history?: 'push' | 'replace';
+}): QueryStates<T>;
+/**
+ * Remove all query state params from the URL.
+ */
+declare function clearQueryState(): void;
+/**
+ * Get all current query params as a plain object.
+ */
+declare function getQueryParams(): Record<string, string>;
+/**
+ * Cleanup: remove a specific query state binding.
+ */
+declare function removeQueryState(key: string): void;
+/**
+ * Cleanup all query state bindings (useful for testing).
+ */
+declare function resetQueryState(): void;
+
+export { type QueryStateOptions, clearQueryState, getQueryParams, removeQueryState, resetQueryState, useQueryState, useQueryStates };

package/dist/query-state.js

@@ -0,0 +1,2 @@
+export{c as clearQueryState,d as getQueryParams,e as removeQueryState,f as resetQueryState,a as useQueryState,b as useQueryStates}from'./chunk-F6VSSM2P.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=query-state.js.map
+//# sourceMappingURL=query-state.js.map

package/dist/query-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"query-state.js"}

package/dist/reconcile.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkAQQQVDBQ_cjs=require('./chunk-AQQQVDBQ.cjs');Object.defineProperty(exports,"countOps",{enumerable:true,get:function(){return chunkAQQQVDBQ_cjs.c}});Object.defineProperty(exports,"longestIncreasingSubsequence",{enumerable:true,get:function(){return chunkAQQQVDBQ_cjs.a}});Object.defineProperty(exports,"reconcileKeys",{enumerable:true,get:function(){return chunkAQQQVDBQ_cjs.b}});//# sourceMappingURL=reconcile.cjs.map
+//# sourceMappingURL=reconcile.cjs.map

package/dist/reconcile.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"reconcile.cjs"}

package/dist/reconcile.d.cts

@@ -0,0 +1,42 @@
+/**
+ * List reconciliation with Longest Increasing Subsequence (LIS).
+ *
+ * When a keyed list updates, we need to determine the minimal set of
+ * DOM operations (inserts, moves, removes). The LIS of the new key
+ * positions tells us which nodes are already in the correct relative
+ * order and don't need to move.
+ *
+ * This is the same algorithm used by Vue 3, Solid, and Inferno.
+ */
+/**
+ * Find the Longest Increasing Subsequence of indices.
+ * Returns the indices into the input array that form the LIS.
+ *
+ * Time: O(n log n), Space: O(n)
+ */
+declare function longestIncreasingSubsequence(arr: number[]): number[];
+/**
+ * Reconcile two keyed lists and return the minimal DOM operations.
+ *
+ * @param oldKeys - Keys of the current DOM list
+ * @param newKeys - Keys of the new data list
+ * @returns Operations to transform old into new
+ */
+interface ReconcileOp {
+    type: 'insert' | 'move' | 'remove';
+    /** Index in the NEW array (for insert/move) */
+    newIndex?: number;
+    /** Index in the OLD array (for remove/move source) */
+    oldIndex?: number;
+}
+declare function reconcileKeys(oldKeys: unknown[], newKeys: unknown[]): ReconcileOp[];
+/**
+ * Count the minimum number of DOM operations needed.
+ */
+declare function countOps(oldKeys: unknown[], newKeys: unknown[]): {
+    inserts: number;
+    moves: number;
+    removes: number;
+};
+
+export { type ReconcileOp, countOps, longestIncreasingSubsequence, reconcileKeys };

package/dist/reconcile.d.ts

@@ -0,0 +1,42 @@
+/**
+ * List reconciliation with Longest Increasing Subsequence (LIS).
+ *
+ * When a keyed list updates, we need to determine the minimal set of
+ * DOM operations (inserts, moves, removes). The LIS of the new key
+ * positions tells us which nodes are already in the correct relative
+ * order and don't need to move.
+ *
+ * This is the same algorithm used by Vue 3, Solid, and Inferno.
+ */
+/**
+ * Find the Longest Increasing Subsequence of indices.
+ * Returns the indices into the input array that form the LIS.
+ *
+ * Time: O(n log n), Space: O(n)
+ */
+declare function longestIncreasingSubsequence(arr: number[]): number[];
+/**
+ * Reconcile two keyed lists and return the minimal DOM operations.
+ *
+ * @param oldKeys - Keys of the current DOM list
+ * @param newKeys - Keys of the new data list
+ * @returns Operations to transform old into new
+ */
+interface ReconcileOp {
+    type: 'insert' | 'move' | 'remove';
+    /** Index in the NEW array (for insert/move) */
+    newIndex?: number;
+    /** Index in the OLD array (for remove/move source) */
+    oldIndex?: number;
+}
+declare function reconcileKeys(oldKeys: unknown[], newKeys: unknown[]): ReconcileOp[];
+/**
+ * Count the minimum number of DOM operations needed.
+ */
+declare function countOps(oldKeys: unknown[], newKeys: unknown[]): {
+    inserts: number;
+    moves: number;
+    removes: number;
+};
+
+export { type ReconcileOp, countOps, longestIncreasingSubsequence, reconcileKeys };

package/dist/reconcile.js

@@ -0,0 +1,2 @@
+export{c as countOps,a as longestIncreasingSubsequence,b as reconcileKeys}from'./chunk-UT4MWGJ3.js';//# sourceMappingURL=reconcile.js.map
+//# sourceMappingURL=reconcile.js.map

package/dist/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"reconcile.js"}

package/dist/scheduler-CKi1esN-.d.cts

@@ -0,0 +1,9 @@
+/**
+ * Batch multiple signal writes — subscribers are notified only once
+ * at the end of the batch.
+ */
+declare function batch<T>(fn: () => T): T;
+/** Synchronously flush all pending effects. Useful for testing. */
+declare function flushSync(): void;
+
+export { batch as b, flushSync as f };

package/dist/scheduler-CKi1esN-.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Batch multiple signal writes — subscribers are notified only once
+ * at the end of the batch.
+ */
+declare function batch<T>(fn: () => T): T;
+/** Synchronously flush all pending effects. Useful for testing. */
+declare function flushSync(): void;
+
+export { batch as b, flushSync as f };

package/dist/security.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkBHP3UTTQ_cjs=require('./chunk-BHP3UTTQ.cjs');Object.defineProperty(exports,"createCSRFInterceptor",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.k}});Object.defineProperty(exports,"createRateLimiter",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.m}});Object.defineProperty(exports,"createSafeHTML",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.c}});Object.defineProperty(exports,"deepFreeze",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.h}});Object.defineProperty(exports,"escapeHtml",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.b}});Object.defineProperty(exports,"generateCSP",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.d}});Object.defineProperty(exports,"generateCSRFToken",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.j}});Object.defineProperty(exports,"generateSRI",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.i}});Object.defineProperty(exports,"generateSecurityHeaders",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.f}});Object.defineProperty(exports,"getCSPHeaderName",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.e}});Object.defineProperty(exports,"safeMerge",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.g}});Object.defineProperty(exports,"sanitize",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.a}});Object.defineProperty(exports,"sanitizeURL",{enumerable:true,get:function(){return chunkBHP3UTTQ_cjs.l}});//# sourceMappingURL=security.cjs.map
+//# sourceMappingURL=security.cjs.map

package/dist/security.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"security.cjs"}

package/dist/security.d.cts

@@ -0,0 +1,193 @@
+/**
+ * Security module — built-in protection for AkashJS apps.
+ *
+ * Auto-sanitization, CSP support, prototype pollution prevention,
+ * and secure defaults. AkashJS is secure by default.
+ */
+interface SanitizeOptions {
+    /** Additional allowed tags */
+    allowTags?: string[];
+    /** Additional allowed attributes */
+    allowAttrs?: string[];
+    /** Allow data-* attributes (default: true) */
+    allowDataAttrs?: boolean;
+    /** Allow aria-* attributes (default: true) */
+    allowAriaAttrs?: boolean;
+    /** Allow style attribute (default: false) */
+    allowStyle?: boolean;
+    /** Custom tag filter */
+    tagFilter?: (tag: string) => boolean;
+    /** Custom attribute filter */
+    attrFilter?: (attr: string, value: string, tag: string) => boolean;
+}
+/**
+ * Sanitize HTML string — remove dangerous tags, attributes, and URLs.
+ *
+ * ```ts
+ * const safe = sanitize(userInput);
+ * el.innerHTML = safe; // Safe from XSS
+ *
+ * // With options:
+ * const safe = sanitize(html, { allowTags: ['iframe'], allowStyle: true });
+ * ```
+ */
+declare function sanitize(html: string, options?: SanitizeOptions): string;
+/**
+ * Escape HTML entities — prevents XSS in text content.
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Create a safe HTML setter that sanitizes automatically.
+ *
+ * ```ts
+ * const setHTML = createSafeHTML(el);
+ * setHTML(userContent); // Auto-sanitized
+ * ```
+ */
+declare function createSafeHTML(el: HTMLElement, options?: SanitizeOptions): (html: string) => void;
+interface CSPConfig {
+    /** Nonce for inline scripts/styles */
+    nonce?: string;
+    /** Report-only mode (default: false) */
+    reportOnly?: boolean;
+    /** Report URI for CSP violations */
+    reportUri?: string;
+    /** Custom directives */
+    directives?: Record<string, string[]>;
+}
+/**
+ * Generate a CSP header string.
+ *
+ * ```ts
+ * const csp = generateCSP({
+ *   nonce: 'abc123',
+ *   directives: {
+ *     'script-src': ["'self'"],
+ *     'style-src': ["'self'", "'unsafe-inline'"],
+ *     'img-src': ["'self'", 'data:', 'https:'],
+ *   },
+ * });
+ * // "script-src 'self' 'nonce-abc123'; style-src 'self' 'unsafe-inline'; ..."
+ * ```
+ */
+declare function generateCSP(config?: CSPConfig): string;
+/**
+ * Get the CSP header name based on config.
+ */
+declare function getCSPHeaderName(config?: CSPConfig): string;
+interface SecurityHeadersConfig {
+    /** Content Security Policy (false to disable) */
+    csp?: CSPConfig | false;
+    /** X-Frame-Options (default: 'DENY') */
+    frameOptions?: 'DENY' | 'SAMEORIGIN' | false;
+    /** X-Content-Type-Options (default: 'nosniff') */
+    contentTypeOptions?: boolean;
+    /** X-XSS-Protection (default: '0' — let CSP handle it) */
+    xssProtection?: boolean;
+    /** Strict-Transport-Security */
+    hsts?: {
+        maxAge: number;
+        includeSubDomains?: boolean;
+        preload?: boolean;
+    } | false;
+    /** Referrer-Policy (default: 'strict-origin-when-cross-origin') */
+    referrerPolicy?: string | false;
+    /** Permissions-Policy */
+    permissionsPolicy?: Record<string, string[]> | false;
+    /** Cross-Origin-Opener-Policy */
+    coop?: 'same-origin' | 'same-origin-allow-popups' | 'unsafe-none' | false;
+    /** Cross-Origin-Embedder-Policy */
+    coep?: 'require-corp' | 'credentialless' | 'unsafe-none' | false;
+}
+/**
+ * Generate security headers for SSR responses.
+ *
+ * ```ts
+ * const headers = generateSecurityHeaders();
+ * // Apply to your server response
+ * for (const [name, value] of Object.entries(headers)) {
+ *   res.setHeader(name, value);
+ * }
+ * ```
+ */
+declare function generateSecurityHeaders(config?: SecurityHeadersConfig): Record<string, string>;
+/**
+ * Safe deep merge that prevents prototype pollution.
+ * Will not set __proto__, constructor, or prototype keys.
+ *
+ * ```ts
+ * const result = safeMerge(defaults, userConfig);
+ * ```
+ */
+declare function safeMerge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * Freeze an object deeply — prevents any modification.
+ */
+declare function deepFreeze<T>(obj: T): Readonly<T>;
+/**
+ * Generate SRI hash for a script/style resource.
+ * For use in <script integrity="..."> and <link integrity="...">.
+ *
+ * ```ts
+ * // In Node.js build script:
+ * const hash = await generateSRI(fileContent);
+ * // 'sha384-...'
+ * ```
+ */
+declare function generateSRI(content: string, algorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
+/**
+ * Generate a CSRF token.
+ */
+declare function generateCSRFToken(): string;
+/**
+ * Create an HTTP interceptor that attaches CSRF tokens.
+ *
+ * ```ts
+ * const csrf = createCSRFInterceptor();
+ * const http = createHttpClient({ interceptors: [csrf.interceptor] });
+ * // Token is auto-attached to every mutation request
+ * ```
+ */
+declare function createCSRFInterceptor(options?: {
+    headerName?: string;
+    cookieName?: string;
+    tokenGenerator?: () => string;
+}): {
+    interceptor: (request: Request, next: (req: Request) => Promise<Response>) => Promise<Response>;
+    token: () => string;
+    refresh(): void;
+};
+/**
+ * Validate and sanitize a URL — prevent open redirect attacks.
+ *
+ * ```ts
+ * const safe = sanitizeURL(userInput, { allowedHosts: ['example.com'] });
+ * if (safe) window.location.href = safe;
+ * ```
+ */
+declare function sanitizeURL(url: string, options?: {
+    allowedHosts?: string[];
+    allowedProtocols?: string[];
+    allowRelative?: boolean;
+}): string | null;
+/**
+ * Rate limiter for client-side actions (e.g., form submissions).
+ *
+ * ```ts
+ * const limiter = createRateLimiter({ maxAttempts: 5, windowMs: 60000 });
+ * if (!limiter.check()) {
+ *   toast.error('Too many attempts. Please wait.');
+ *   return;
+ * }
+ * ```
+ */
+declare function createRateLimiter(options: {
+    maxAttempts: number;
+    windowMs: number;
+}): {
+    check(): boolean;
+    remaining(): number;
+    reset(): void;
+};
+
+export { type CSPConfig, type SanitizeOptions, type SecurityHeadersConfig, createCSRFInterceptor, createRateLimiter, createSafeHTML, deepFreeze, escapeHtml, generateCSP, generateCSRFToken, generateSRI, generateSecurityHeaders, getCSPHeaderName, safeMerge, sanitize, sanitizeURL };

package/dist/security.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Security module — built-in protection for AkashJS apps.
+ *
+ * Auto-sanitization, CSP support, prototype pollution prevention,
+ * and secure defaults. AkashJS is secure by default.
+ */
+interface SanitizeOptions {
+    /** Additional allowed tags */
+    allowTags?: string[];
+    /** Additional allowed attributes */
+    allowAttrs?: string[];
+    /** Allow data-* attributes (default: true) */
+    allowDataAttrs?: boolean;
+    /** Allow aria-* attributes (default: true) */
+    allowAriaAttrs?: boolean;
+    /** Allow style attribute (default: false) */
+    allowStyle?: boolean;
+    /** Custom tag filter */
+    tagFilter?: (tag: string) => boolean;
+    /** Custom attribute filter */
+    attrFilter?: (attr: string, value: string, tag: string) => boolean;
+}
+/**
+ * Sanitize HTML string — remove dangerous tags, attributes, and URLs.
+ *
+ * ```ts
+ * const safe = sanitize(userInput);
+ * el.innerHTML = safe; // Safe from XSS
+ *
+ * // With options:
+ * const safe = sanitize(html, { allowTags: ['iframe'], allowStyle: true });
+ * ```
+ */
+declare function sanitize(html: string, options?: SanitizeOptions): string;
+/**
+ * Escape HTML entities — prevents XSS in text content.
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Create a safe HTML setter that sanitizes automatically.
+ *
+ * ```ts
+ * const setHTML = createSafeHTML(el);
+ * setHTML(userContent); // Auto-sanitized
+ * ```
+ */
+declare function createSafeHTML(el: HTMLElement, options?: SanitizeOptions): (html: string) => void;
+interface CSPConfig {
+    /** Nonce for inline scripts/styles */
+    nonce?: string;
+    /** Report-only mode (default: false) */
+    reportOnly?: boolean;
+    /** Report URI for CSP violations */
+    reportUri?: string;
+    /** Custom directives */
+    directives?: Record<string, string[]>;
+}
+/**
+ * Generate a CSP header string.
+ *
+ * ```ts
+ * const csp = generateCSP({
+ *   nonce: 'abc123',
+ *   directives: {
+ *     'script-src': ["'self'"],
+ *     'style-src': ["'self'", "'unsafe-inline'"],
+ *     'img-src': ["'self'", 'data:', 'https:'],
+ *   },
+ * });
+ * // "script-src 'self' 'nonce-abc123'; style-src 'self' 'unsafe-inline'; ..."
+ * ```
+ */
+declare function generateCSP(config?: CSPConfig): string;
+/**
+ * Get the CSP header name based on config.
+ */
+declare function getCSPHeaderName(config?: CSPConfig): string;
+interface SecurityHeadersConfig {
+    /** Content Security Policy (false to disable) */
+    csp?: CSPConfig | false;
+    /** X-Frame-Options (default: 'DENY') */
+    frameOptions?: 'DENY' | 'SAMEORIGIN' | false;
+    /** X-Content-Type-Options (default: 'nosniff') */
+    contentTypeOptions?: boolean;
+    /** X-XSS-Protection (default: '0' — let CSP handle it) */
+    xssProtection?: boolean;
+    /** Strict-Transport-Security */
+    hsts?: {
+        maxAge: number;
+        includeSubDomains?: boolean;
+        preload?: boolean;
+    } | false;
+    /** Referrer-Policy (default: 'strict-origin-when-cross-origin') */
+    referrerPolicy?: string | false;
+    /** Permissions-Policy */
+    permissionsPolicy?: Record<string, string[]> | false;
+    /** Cross-Origin-Opener-Policy */
+    coop?: 'same-origin' | 'same-origin-allow-popups' | 'unsafe-none' | false;
+    /** Cross-Origin-Embedder-Policy */
+    coep?: 'require-corp' | 'credentialless' | 'unsafe-none' | false;
+}
+/**
+ * Generate security headers for SSR responses.
+ *
+ * ```ts
+ * const headers = generateSecurityHeaders();
+ * // Apply to your server response
+ * for (const [name, value] of Object.entries(headers)) {
+ *   res.setHeader(name, value);
+ * }
+ * ```
+ */
+declare function generateSecurityHeaders(config?: SecurityHeadersConfig): Record<string, string>;
+/**
+ * Safe deep merge that prevents prototype pollution.
+ * Will not set __proto__, constructor, or prototype keys.
+ *
+ * ```ts
+ * const result = safeMerge(defaults, userConfig);
+ * ```
+ */
+declare function safeMerge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * Freeze an object deeply — prevents any modification.
+ */
+declare function deepFreeze<T>(obj: T): Readonly<T>;
+/**
+ * Generate SRI hash for a script/style resource.
+ * For use in <script integrity="..."> and <link integrity="...">.
+ *
+ * ```ts
+ * // In Node.js build script:
+ * const hash = await generateSRI(fileContent);
+ * // 'sha384-...'
+ * ```
+ */
+declare function generateSRI(content: string, algorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
+/**
+ * Generate a CSRF token.
+ */
+declare function generateCSRFToken(): string;
+/**
+ * Create an HTTP interceptor that attaches CSRF tokens.
+ *
+ * ```ts
+ * const csrf = createCSRFInterceptor();
+ * const http = createHttpClient({ interceptors: [csrf.interceptor] });
+ * // Token is auto-attached to every mutation request
+ * ```
+ */
+declare function createCSRFInterceptor(options?: {
+    headerName?: string;
+    cookieName?: string;
+    tokenGenerator?: () => string;
+}): {
+    interceptor: (request: Request, next: (req: Request) => Promise<Response>) => Promise<Response>;
+    token: () => string;
+    refresh(): void;
+};
+/**
+ * Validate and sanitize a URL — prevent open redirect attacks.
+ *
+ * ```ts
+ * const safe = sanitizeURL(userInput, { allowedHosts: ['example.com'] });
+ * if (safe) window.location.href = safe;
+ * ```
+ */
+declare function sanitizeURL(url: string, options?: {
+    allowedHosts?: string[];
+    allowedProtocols?: string[];
+    allowRelative?: boolean;
+}): string | null;
+/**
+ * Rate limiter for client-side actions (e.g., form submissions).
+ *
+ * ```ts
+ * const limiter = createRateLimiter({ maxAttempts: 5, windowMs: 60000 });
+ * if (!limiter.check()) {
+ *   toast.error('Too many attempts. Please wait.');
+ *   return;
+ * }
+ * ```
+ */
+declare function createRateLimiter(options: {
+    maxAttempts: number;
+    windowMs: number;
+}): {
+    check(): boolean;
+    remaining(): number;
+    reset(): void;
+};
+
+export { type CSPConfig, type SanitizeOptions, type SecurityHeadersConfig, createCSRFInterceptor, createRateLimiter, createSafeHTML, deepFreeze, escapeHtml, generateCSP, generateCSRFToken, generateSRI, generateSecurityHeaders, getCSPHeaderName, safeMerge, sanitize, sanitizeURL };

package/dist/security.js

@@ -0,0 +1,2 @@
+export{k as createCSRFInterceptor,m as createRateLimiter,c as createSafeHTML,h as deepFreeze,b as escapeHtml,d as generateCSP,j as generateCSRFToken,i as generateSRI,f as generateSecurityHeaders,e as getCSPHeaderName,g as safeMerge,a as sanitize,l as sanitizeURL}from'./chunk-KMEGUPH2.js';//# sourceMappingURL=security.js.map
+//# sourceMappingURL=security.js.map

package/dist/security.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"security.js"}

package/dist/seo.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkIKVHLORY_cjs=require('./chunk-IKVHLORY.cjs');require('./chunk-FVWHMFX6.cjs'),require('./chunk-XWVNLE2W.cjs'),require('./chunk-IQGSDFBI.cjs'),require('./chunk-PPNEAFKE.cjs'),require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"generateSitemap",{enumerable:true,get:function(){return chunkIKVHLORY_cjs.e}});Object.defineProperty(exports,"useOpenGraph",{enumerable:true,get:function(){return chunkIKVHLORY_cjs.b}});Object.defineProperty(exports,"useSEO",{enumerable:true,get:function(){return chunkIKVHLORY_cjs.d}});Object.defineProperty(exports,"useStructuredData",{enumerable:true,get:function(){return chunkIKVHLORY_cjs.a}});Object.defineProperty(exports,"useTwitterCard",{enumerable:true,get:function(){return chunkIKVHLORY_cjs.c}});//# sourceMappingURL=seo.cjs.map
+//# sourceMappingURL=seo.cjs.map

package/dist/seo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"seo.cjs"}