@c15t/backend 0.0.1-rc.10

package/dist/utils/env.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Environment variables object
+ *
+ * Provides access to environment variables in a way that works in both
+ * browser and Node.js environments. In Node.js, this will be process.env,
+ * and in browsers, it will be an empty object.
+ *
+ * @returns An object containing environment variables accessible in the current runtime
+ *
+ * @example
+ * ```ts
+ * // Access an environment variable
+ * const apiKey = env.API_KEY;
+ * ```
+ */
+export declare const env: NodeJS.ProcessEnv;
+/**
+ * Determines if the application is running in production mode
+ *
+ * Checks if NODE_ENV is set to 'production'. This is useful for
+ * conditionally enabling or disabling features based on the environment.
+ *
+ * @returns Boolean indicating whether the application is running in production mode
+ *
+ * @example
+ * ```ts
+ * // Conditionally execute code based on environment
+ * if (isProduction) {
+ *   // Production-only code
+ * }
+ * ```
+ */
+export declare const isProduction: boolean;
+/**
+ * Determines if the application is running in development mode
+ *
+ * Checks if NODE_ENV is set to 'development'. This is useful for
+ * conditionally enabling debugging features in development environments.
+ *
+ * @returns Boolean indicating whether the application is running in development mode
+ *
+ * @example
+ * ```ts
+ * // Enable development-only features
+ * if (isDevelopment) {
+ *   enableDebugTools();
+ * }
+ * ```
+ */
+export declare const isDevelopment: boolean;
+/**
+ * The current Node.js environment value
+ *
+ * Retrieves the NODE_ENV environment variable value if available,
+ * otherwise returns an empty string.
+ *
+ * @returns The current NODE_ENV value or empty string if not set
+ */
+export declare const nodeENV: string;
+/**
+ * Determines if the application is running in test mode
+ *
+ * Checks if NODE_ENV is set to 'test' or if the TEST environment
+ * variable is truthy and not 'false'.
+ *
+ * @returns Boolean indicating whether the application is running in test mode
+ *
+ * @example
+ * ```ts
+ * // Skip expensive operations in tests
+ * if (!isTest) {
+ *   runExpensiveOperation();
+ * }
+ * ```
+ */
+export declare const isTest: boolean;
+//# sourceMappingURL=env.d.ts.map

package/dist/utils/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/utils/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,GAAG,mBAAoD,CAAC;AAErE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,SAC+C,CAAC;AAEzE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,SAC+C,CAAC;AAsB1E;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,QAC0D,CAAC;AAE/E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,SAA4C,CAAC"}

package/dist/utils/hide-metadata.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Constant metadata flag to identify non-action objects
+ *
+ * This constant provides metadata that can be attached to objects to indicate
+ * they should not be treated as actions by the system. The value is explicitly
+ * typed as a const assertion to ensure type safety.
+ *
+ * @see Used to differentiate between actionable and non-actionable objects in the system
+ *
+ * @example
+ * ```ts
+ * // Mark an object as not being an action
+ * const nonActionObject = {
+ *   ...HIDE_METADATA,
+ *   // other properties
+ * };
+ * ```
+ */
+export declare const HIDE_METADATA: {
+    isAction: false;
+};
+//# sourceMappingURL=hide-metadata.d.ts.map

package/dist/utils/hide-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hide-metadata.d.ts","sourceRoot":"","sources":["../../src/utils/hide-metadata.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa;;CAEzB,CAAC"}

package/dist/utils/index.cjs

@@ -0,0 +1,268 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    HIDE_METADATA: ()=>HIDE_METADATA,
+    env: ()=>env,
+    createLogger: ()=>createLogger,
+    stringifyJson: ()=>stringifyJson,
+    getHost: ()=>getHost,
+    shouldPublishLog: ()=>shouldPublishLog,
+    getBaseURL: ()=>getBaseURL,
+    isProduction: ()=>isProduction,
+    nodeENV: ()=>nodeENV,
+    levels: ()=>levels,
+    isTest: ()=>isTest,
+    checkURLValidity: ()=>checkURLValidity,
+    logger: ()=>logger,
+    isDevelopment: ()=>isDevelopment,
+    parseJson: ()=>parseJson,
+    getOrigin: ()=>getOrigin,
+    getProtocol: ()=>getProtocol
+});
+const env = 'undefined' != typeof process ? process.env : {};
+const isProduction = 'undefined' != typeof process && 'production' === process.env.NODE_ENV;
+const isDevelopment = 'undefined' != typeof process && 'development' === process.env.NODE_ENV;
+function toBoolean(val) {
+    return val ? 'false' !== val : false;
+}
+const nodeENV = 'undefined' != typeof process && process.env && process.env.NODE_ENV || '';
+const isTest = 'test' === nodeENV || toBoolean(env.TEST);
+const HIDE_METADATA = {
+    isAction: false
+};
+const levels = [
+    'info',
+    'success',
+    'warn',
+    'error',
+    'debug'
+];
+function shouldPublishLog(currentLogLevel, logLevel) {
+    return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+}
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    underscore: '\x1b[4m',
+    blink: '\x1b[5m',
+    reverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+    fg: {
+        black: '\x1b[30m',
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        white: '\x1b[37m'
+    },
+    bg: {
+        black: '\x1b[40m',
+        red: '\x1b[41m',
+        green: '\x1b[42m',
+        yellow: '\x1b[43m',
+        blue: '\x1b[44m',
+        magenta: '\x1b[45m',
+        cyan: '\x1b[46m',
+        white: '\x1b[47m'
+    }
+};
+const levelColors = {
+    info: colors.fg.blue,
+    success: colors.fg.green,
+    warn: colors.fg.yellow,
+    error: colors.fg.red,
+    debug: colors.fg.magenta
+};
+const formatMessage = (level, message)=>{
+    const timestamp = new Date().toISOString();
+    return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[c15t]:${colors.reset} ${message}`;
+};
+const createLogger = (options)=>{
+    const enabled = options?.disabled !== true;
+    const logLevel = options?.level ?? 'error';
+    const LogFunc = (level, message, args = [])=>{
+        if (!enabled || !shouldPublishLog(logLevel, level)) return;
+        const formattedMessage = formatMessage(level, message);
+        if (!options || 'function' != typeof options.log) {
+            if ('error' === level) console.error(formattedMessage, ...args);
+            else if ('warn' === level) console.warn(formattedMessage, ...args);
+            else if ('info' === level) console.log(formattedMessage, ...args);
+            else if ('debug' === level) console.debug(formattedMessage, ...args);
+            else if ('success' === level) console.log(formattedMessage, ...args);
+            return;
+        }
+        options.log('success' === level ? 'info' : level, message, ...args);
+    };
+    return Object.fromEntries(levels.map((level)=>[
+            level,
+            (...[message, ...args])=>LogFunc(level, message, args)
+        ]));
+};
+const logger = createLogger();
+const codes_BASE_ERROR_CODES = {
+    NOT_FOUND: 'Resource not found',
+    BAD_REQUEST: 'Bad request',
+    CONFLICT: 'Conflict with current state',
+    CONSENT_NOT_FOUND: 'Consent not found',
+    CONSENT_EXPIRED: 'Consent has expired',
+    FAILED_TO_CREATE_CONSENT: 'Failed to create consent',
+    FAILED_TO_UPDATE_CONSENT: 'Failed to update consent',
+    FAILED_TO_GET_CONSENT: 'Failed to get consent',
+    FAILED_TO_CREATE_PURPOSE: 'Failed to create consentPurpose',
+    PURPOSE_NOT_FOUND: 'Consent Purpose not found',
+    INVALID_CONFIGURATION: 'Invalid configuration',
+    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INITIALIZATION_FAILED: 'Initialization failed',
+    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+    DATABASE_CONNECTION_ERROR: 'Database connection error',
+    DATABASE_QUERY_ERROR: 'Database query error',
+    REQUEST_HANDLER_ERROR: 'Request handler error',
+    API_RETRIEVAL_ERROR: 'API retrieval error',
+    INVALID_REQUEST: 'Invalid request',
+    UNKNOWN_ERROR: 'Unknown error'
+};
+class error_C15TError extends Error {
+    code;
+    status;
+    data;
+    category;
+    constructor(message, options){
+        super(message);
+        this.name = 'C15TError';
+        if (options) {
+            this.code = options.code;
+            this.status = options.status;
+            this.data = options.data;
+            this.category = options.category;
+        }
+        Object.setPrototypeOf(this, error_C15TError.prototype);
+    }
+    static fromResponse(response, data) {
+        let message = `HTTP error ${response.status}`;
+        let code;
+        let errorData;
+        if (data && 'object' == typeof data && null !== data) {
+            const errorObj = data;
+            if ('string' == typeof errorObj.message) message = errorObj.message;
+            if ('string' == typeof errorObj.code) {
+                const isKnownCode = Object.values(codes_BASE_ERROR_CODES).includes(errorObj.code);
+                if (isKnownCode) code = errorObj.code;
+            }
+            if ('object' == typeof errorObj.data && null !== errorObj.data) errorData = errorObj.data;
+        }
+        return new error_C15TError(message, {
+            code,
+            status: response.status,
+            data: errorData
+        });
+    }
+    static isC15TError(error) {
+        return error instanceof error_C15TError;
+    }
+}
+require("neverthrow");
+const TRAILING_SLASHES_REGEX = /\/+$/;
+function checkHasPath(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return '/' !== parsedUrl.pathname;
+    } catch  {
+        throw new error_C15TError(`Invalid base URL: ${url}. Please provide a valid base URL.`, {
+            code: codes_BASE_ERROR_CODES.BAD_REQUEST,
+            status: 400,
+            data: {
+                url
+            }
+        });
+    }
+}
+function withPath(url, path = '/api/auth') {
+    const hasPath = checkHasPath(url);
+    if (hasPath) return url;
+    const pathWithSlash = path.startsWith('/') ? path : `/${path}`;
+    return `${url.replace(TRAILING_SLASHES_REGEX, '')}${pathWithSlash}`;
+}
+function getBaseURL(url, path) {
+    if (url) return withPath(url, path);
+    const fromEnv = env.C15T_URL || env.NEXT_PUBLIC_C15T_URL || env.PUBLIC_C15T_URL || env.NUXT_PUBLIC_C15T_URL || env.NUXT_PUBLIC_AUTH_URL || ('/' !== env.BASE_URL ? env.BASE_URL : void 0);
+    if (fromEnv) return withPath(fromEnv, path);
+    if ('undefined' != typeof window && window.location) return withPath(window.location.origin, path);
+}
+function getOrigin(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return parsedUrl.origin;
+    } catch  {
+        return null;
+    }
+}
+function getProtocol(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return parsedUrl.protocol;
+    } catch  {
+        return null;
+    }
+}
+const checkURLValidity = (url)=>{
+    const urlPattern = url.includes('://');
+    return urlPattern;
+};
+function getHost(url) {
+    if (url.includes('://')) {
+        const parsedUrl = new URL(url);
+        return parsedUrl.host;
+    }
+    return url;
+}
+const external_superjson_namespaceObject = require("superjson");
+var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_namespaceObject);
+function parseJson(json) {
+    return external_superjson_default().parse(json);
+}
+function stringifyJson(value) {
+    return external_superjson_default().stringify(value);
+}
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * c15t Utility Functions
+ *
+ * This module serves as the main entry point for all utility functions used in the c15t
+ * consent management system. It re-exports utilities from specialized modules for easier access.
+ *
+ * Import utilities from this module for a cleaner import structure:
+ * @example
+ * ```typescript
+ * import { generateId, encrypt, formatDate } from '../utils';
+ * ```
+ */
+export * from './env';
+export * from './hide-metadata';
+export * from './logger';
+export * from './url';
+export * from './json';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,OAAO,CAAC;AACtB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,210 @@
+import "neverthrow";
+import * as __WEBPACK_EXTERNAL_MODULE_superjson__ from "superjson";
+const env = 'undefined' != typeof process ? process.env : {};
+const isProduction = 'undefined' != typeof process && 'production' === process.env.NODE_ENV;
+const isDevelopment = 'undefined' != typeof process && 'development' === process.env.NODE_ENV;
+function toBoolean(val) {
+    return val ? 'false' !== val : false;
+}
+const nodeENV = 'undefined' != typeof process && process.env && process.env.NODE_ENV || '';
+const isTest = 'test' === nodeENV || toBoolean(env.TEST);
+const HIDE_METADATA = {
+    isAction: false
+};
+const levels = [
+    'info',
+    'success',
+    'warn',
+    'error',
+    'debug'
+];
+function shouldPublishLog(currentLogLevel, logLevel) {
+    return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+}
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    underscore: '\x1b[4m',
+    blink: '\x1b[5m',
+    reverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+    fg: {
+        black: '\x1b[30m',
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        white: '\x1b[37m'
+    },
+    bg: {
+        black: '\x1b[40m',
+        red: '\x1b[41m',
+        green: '\x1b[42m',
+        yellow: '\x1b[43m',
+        blue: '\x1b[44m',
+        magenta: '\x1b[45m',
+        cyan: '\x1b[46m',
+        white: '\x1b[47m'
+    }
+};
+const levelColors = {
+    info: colors.fg.blue,
+    success: colors.fg.green,
+    warn: colors.fg.yellow,
+    error: colors.fg.red,
+    debug: colors.fg.magenta
+};
+const formatMessage = (level, message)=>{
+    const timestamp = new Date().toISOString();
+    return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[c15t]:${colors.reset} ${message}`;
+};
+const createLogger = (options)=>{
+    const enabled = options?.disabled !== true;
+    const logLevel = options?.level ?? 'error';
+    const LogFunc = (level, message, args = [])=>{
+        if (!enabled || !shouldPublishLog(logLevel, level)) return;
+        const formattedMessage = formatMessage(level, message);
+        if (!options || 'function' != typeof options.log) {
+            if ('error' === level) console.error(formattedMessage, ...args);
+            else if ('warn' === level) console.warn(formattedMessage, ...args);
+            else if ('info' === level) console.log(formattedMessage, ...args);
+            else if ('debug' === level) console.debug(formattedMessage, ...args);
+            else if ('success' === level) console.log(formattedMessage, ...args);
+            return;
+        }
+        options.log('success' === level ? 'info' : level, message, ...args);
+    };
+    return Object.fromEntries(levels.map((level)=>[
+            level,
+            (...[message, ...args])=>LogFunc(level, message, args)
+        ]));
+};
+const logger_logger = createLogger();
+const codes_BASE_ERROR_CODES = {
+    NOT_FOUND: 'Resource not found',
+    BAD_REQUEST: 'Bad request',
+    CONFLICT: 'Conflict with current state',
+    CONSENT_NOT_FOUND: 'Consent not found',
+    CONSENT_EXPIRED: 'Consent has expired',
+    FAILED_TO_CREATE_CONSENT: 'Failed to create consent',
+    FAILED_TO_UPDATE_CONSENT: 'Failed to update consent',
+    FAILED_TO_GET_CONSENT: 'Failed to get consent',
+    FAILED_TO_CREATE_PURPOSE: 'Failed to create consentPurpose',
+    PURPOSE_NOT_FOUND: 'Consent Purpose not found',
+    INVALID_CONFIGURATION: 'Invalid configuration',
+    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INITIALIZATION_FAILED: 'Initialization failed',
+    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+    DATABASE_CONNECTION_ERROR: 'Database connection error',
+    DATABASE_QUERY_ERROR: 'Database query error',
+    REQUEST_HANDLER_ERROR: 'Request handler error',
+    API_RETRIEVAL_ERROR: 'API retrieval error',
+    INVALID_REQUEST: 'Invalid request',
+    UNKNOWN_ERROR: 'Unknown error'
+};
+class error_C15TError extends Error {
+    code;
+    status;
+    data;
+    category;
+    constructor(message, options){
+        super(message);
+        this.name = 'C15TError';
+        if (options) {
+            this.code = options.code;
+            this.status = options.status;
+            this.data = options.data;
+            this.category = options.category;
+        }
+        Object.setPrototypeOf(this, error_C15TError.prototype);
+    }
+    static fromResponse(response, data) {
+        let message = `HTTP error ${response.status}`;
+        let code;
+        let errorData;
+        if (data && 'object' == typeof data && null !== data) {
+            const errorObj = data;
+            if ('string' == typeof errorObj.message) message = errorObj.message;
+            if ('string' == typeof errorObj.code) {
+                const isKnownCode = Object.values(codes_BASE_ERROR_CODES).includes(errorObj.code);
+                if (isKnownCode) code = errorObj.code;
+            }
+            if ('object' == typeof errorObj.data && null !== errorObj.data) errorData = errorObj.data;
+        }
+        return new error_C15TError(message, {
+            code,
+            status: response.status,
+            data: errorData
+        });
+    }
+    static isC15TError(error) {
+        return error instanceof error_C15TError;
+    }
+}
+const TRAILING_SLASHES_REGEX = /\/+$/;
+function checkHasPath(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return '/' !== parsedUrl.pathname;
+    } catch  {
+        throw new error_C15TError(`Invalid base URL: ${url}. Please provide a valid base URL.`, {
+            code: codes_BASE_ERROR_CODES.BAD_REQUEST,
+            status: 400,
+            data: {
+                url
+            }
+        });
+    }
+}
+function withPath(url, path = '/api/auth') {
+    const hasPath = checkHasPath(url);
+    if (hasPath) return url;
+    const pathWithSlash = path.startsWith('/') ? path : `/${path}`;
+    return `${url.replace(TRAILING_SLASHES_REGEX, '')}${pathWithSlash}`;
+}
+function getBaseURL(url, path) {
+    if (url) return withPath(url, path);
+    const fromEnv = env.C15T_URL || env.NEXT_PUBLIC_C15T_URL || env.PUBLIC_C15T_URL || env.NUXT_PUBLIC_C15T_URL || env.NUXT_PUBLIC_AUTH_URL || ('/' !== env.BASE_URL ? env.BASE_URL : void 0);
+    if (fromEnv) return withPath(fromEnv, path);
+    if ('undefined' != typeof window && window.location) return withPath(window.location.origin, path);
+}
+function getOrigin(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return parsedUrl.origin;
+    } catch  {
+        return null;
+    }
+}
+function getProtocol(url) {
+    try {
+        const parsedUrl = new URL(url);
+        return parsedUrl.protocol;
+    } catch  {
+        return null;
+    }
+}
+const checkURLValidity = (url)=>{
+    const urlPattern = url.includes('://');
+    return urlPattern;
+};
+function getHost(url) {
+    if (url.includes('://')) {
+        const parsedUrl = new URL(url);
+        return parsedUrl.host;
+    }
+    return url;
+}
+function parseJson(json) {
+    return __WEBPACK_EXTERNAL_MODULE_superjson__["default"].parse(json);
+}
+function stringifyJson(value) {
+    return __WEBPACK_EXTERNAL_MODULE_superjson__["default"].stringify(value);
+}
+export { HIDE_METADATA, checkURLValidity, createLogger, env, getBaseURL, getHost, getOrigin, getProtocol, isDevelopment, isProduction, isTest, levels, logger_logger as logger, nodeENV, parseJson, shouldPublishLog, stringifyJson };

package/dist/utils/ip.d.ts

@@ -0,0 +1,10 @@
+import type { C15TOptions } from '../types';
+/**
+ * Gets the client IP address from request headers
+ *
+ * @param req - The request object or headers
+ * @param options - C15T options containing IP address configuration
+ * @returns The client IP address or null if tracking is disabled
+ */
+export declare function getIp(req: Request | Headers, options: C15TOptions): string | null;
+//# sourceMappingURL=ip.d.ts.map

package/dist/utils/ip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.d.ts","sourceRoot":"","sources":["../../src/utils/ip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;GAMG;AACH,wBAAgB,KAAK,CACpB,GAAG,EAAE,OAAO,GAAG,OAAO,EACtB,OAAO,EAAE,WAAW,GAClB,MAAM,GAAG,IAAI,CA+Bf"}

package/dist/utils/json.d.ts

@@ -0,0 +1,14 @@
+import type { SuperJSONValue } from '../../node_modules/superjson/dist/types';
+/**
+ * Parse a JSON string using SuperJSON
+ * @param json - The JSON string to parse
+ * @returns The parsed JSON value
+ */
+export declare function parseJson(json: SuperJSONValue): unknown;
+/**
+ * Stringify a value using SuperJSON
+ * @param value - The value to stringify
+ * @returns The stringified value
+ */
+export declare function stringifyJson(value: SuperJSONValue): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/utils/json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAExE;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,cAAc,WAE7C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,UAElD"}