@hyperfrontend/builder 0.1.0

package/_dependencies/@hyperfrontend/project-scope/core/index.esm.js

@@ -0,0 +1,440 @@
+
+import { freeze, entries, keys, defineProperties } from '../../immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../../immutable-api-utils/built-in-copy/set/index.esm.js';
+import { createError } from '../../immutable-api-utils/built-in-copy/error/index.esm.js';
+import { isArray } from '../../immutable-api-utils/built-in-copy/array/index.esm.js';
+import { error, warn, log, info, debug } from '../../immutable-api-utils/built-in-copy/console/index.esm.js';
+import { stringify, parse } from '../../immutable-api-utils/built-in-copy/json/index.esm.js';
+import { createLogger } from '../../logging/index.esm.js';
+import { existsSync, readFileSync, statSync, lstatSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join as join$1, normalize, sep, relative, dirname } from 'node:path';
+
+const cacheRegistry = createSet();
+
+const loggerRegistry = createSet();
+let globalLogLevel = null;
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+function createScopedLogger(namespace, options = {}) {
+    const { level = 'error', sanitizeSecrets = true } = options;
+    const createLogFn = (baseFn) => (message, meta) => {
+        const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
+        baseFn(formatMessage(namespace, message, processedMeta));
+    };
+    const baseLogger = createLogger(createLogFn(error), createLogFn(warn), createLogFn(log), createLogFn(info), createLogFn(debug));
+    baseLogger.setLogLevel(globalLogLevel ?? level);
+    const scopedLogger = freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+const logger = createScopedLogger('project-scope');
+
+const encodingLogger = createScopedLogger('project-scope:encoding');
+
+const convertLogger = createScopedLogger('project-scope:encoding:convert');
+
+const fsLogger = createScopedLogger('project-scope:fs');
+function createFileSystemError(message, code, context) {
+    const error = createError(message);
+    defineProperties(error, {
+        code: { value: code, enumerable: true },
+        context: { value: context, enumerable: true },
+    });
+    return error;
+}
+function readFileContent(filePath, encoding = 'utf-8') {
+    if (!existsSync(filePath)) {
+        fsLogger.debug('File not found', { path: filePath });
+        throw createFileSystemError(`File not found: ${filePath}`, 'FS_NOT_FOUND', { path: filePath, operation: 'read' });
+    }
+    try {
+        return readFileSync(filePath, { encoding });
+    }
+    catch (error) {
+        fsLogger.warn('Failed to read file', { path: filePath });
+        throw createFileSystemError(`Failed to read file: ${filePath}`, 'FS_READ_ERROR', { path: filePath, operation: 'read', cause: error });
+    }
+}
+function readJsonFile(filePath, options) {
+    if (!existsSync(filePath)) {
+        if (options && 'default' in options) {
+            fsLogger.debug('JSON file not found, using default', { path: filePath });
+            return options.default;
+        }
+        fsLogger.debug('JSON file not found', { path: filePath });
+        throw createFileSystemError(`File not found: ${filePath}`, 'FS_NOT_FOUND', { path: filePath, operation: 'read' });
+    }
+    try {
+        const content = readFileSync(filePath, { encoding: 'utf-8' });
+        return parse(content);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            fsLogger.debug('JSON file not found (ENOENT)', { path: filePath });
+            throw createFileSystemError(`File not found: ${filePath}`, 'FS_NOT_FOUND', { path: filePath, operation: 'read', cause: error });
+        }
+        fsLogger.warn('Failed to parse JSON file', { path: filePath });
+        throw createFileSystemError(`Failed to parse JSON file: ${filePath}`, 'FS_PARSE_ERROR', {
+            path: filePath,
+            operation: 'read',
+            cause: error,
+        });
+    }
+}
+
+function getFileStat(filePath, followSymlinks = true) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const stat = followSymlinks ? statSync(filePath) : lstatSync(filePath);
+        return {
+            isFile: stat.isFile(),
+            isDirectory: stat.isDirectory(),
+            isSymlink: stat.isSymbolicLink(),
+            size: stat.size,
+            created: stat.birthtime,
+            modified: stat.mtime,
+            accessed: stat.atime,
+            mode: stat.mode,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function isFile(filePath) {
+    const stats = getFileStat(filePath);
+    return stats?.isFile ?? false;
+}
+function isDirectory(dirPath) {
+    const stats = getFileStat(dirPath);
+    return stats?.isDirectory ?? false;
+}
+function exists(filePath) {
+    return existsSync(filePath);
+}
+
+const fsDirLogger = createScopedLogger('project-scope:fs:dir');
+function readDirectory(dirPath) {
+    fsDirLogger.debug('Reading directory', { path: dirPath });
+    if (!existsSync(dirPath)) {
+        fsDirLogger.debug('Directory not found', { path: dirPath });
+        throw createFileSystemError(`Directory not found: ${dirPath}`, 'FS_NOT_FOUND', { path: dirPath, operation: 'readdir' });
+    }
+    if (!isDirectory(dirPath)) {
+        fsDirLogger.debug('Path is not a directory', { path: dirPath });
+        throw createFileSystemError(`Not a directory: ${dirPath}`, 'FS_NOT_A_DIRECTORY', { path: dirPath, operation: 'readdir' });
+    }
+    try {
+        const entries = readdirSync(dirPath, { withFileTypes: true });
+        fsDirLogger.debug('Directory read complete', { path: dirPath, entryCount: entries.length });
+        return entries.map((entry) => ({
+            name: entry.name,
+            path: join$1(dirPath, entry.name),
+            isFile: entry.isFile(),
+            isDirectory: entry.isDirectory(),
+            isSymlink: entry.isSymbolicLink(),
+        }));
+    }
+    catch (error) {
+        fsDirLogger.warn('Failed to read directory', { path: dirPath, error: error instanceof Error ? error.message : String(error) });
+        throw createFileSystemError(`Failed to read directory: ${dirPath}`, 'FS_READ_ERROR', {
+            path: dirPath,
+            operation: 'readdir',
+            cause: error,
+        });
+    }
+}
+function readDirectoryRecursive(dirPath, options) {
+    const maxDepth = options?.maxDepth ?? Infinity;
+    const includeHidden = options?.includeHidden ?? false;
+    const followSymlinks = options?.followSymlinks ?? false;
+    fsDirLogger.debug('Starting recursive directory read', {
+        path: dirPath,
+        maxDepth: maxDepth === Infinity ? 'unlimited' : maxDepth,
+        includeHidden,
+        followSymlinks,
+    });
+    const results = [];
+    function walk(currentPath, depth) {
+        if (depth > maxDepth) {
+            fsDirLogger.debug('Max depth reached, skipping', { path: currentPath, depth, maxDepth });
+            return;
+        }
+        let entries;
+        try {
+            entries = readDirectory(currentPath);
+        }
+        catch {
+            fsDirLogger.debug('Skipping inaccessible directory', { path: currentPath });
+            return;
+        }
+        for (const entry of entries) {
+            if (!includeHidden && entry.name.startsWith('.')) {
+                continue;
+            }
+            results.push({ ...entry, depth });
+            if (entry.isDirectory || (entry.isSymlink && followSymlinks && isDirectory(entry.path))) {
+                walk(entry.path, depth + 1);
+            }
+        }
+    }
+    walk(dirPath, 0);
+    fsDirLogger.debug('Recursive directory read complete', { path: dirPath, totalEntries: results.length });
+    return results;
+}
+function removeDirectory(dirPath, options) {
+    fsDirLogger.debug('Removing directory', { path: dirPath, recursive: options?.recursive, force: options?.force });
+    rmSync(dirPath, {
+        recursive: options?.recursive ?? false,
+        force: options?.force ?? false,
+    });
+}
+
+function join(...paths) {
+    return join$1(...paths);
+}
+
+function normalizePath(filePath) {
+    if (!filePath)
+        return '';
+    const normalized = normalize(filePath);
+    return sep === '\\' ? normalized.replace(/\\/g, '/') : normalized;
+}
+function relativePath(from, to) {
+    return normalizePath(relative(from, to));
+}
+function getDirname(filePath) {
+    return normalizePath(dirname(filePath));
+}
+
+const fsTraversalLogger = createScopedLogger('project-scope:fs:traversal');
+
+const fsWriteLogger = createScopedLogger('project-scope:fs:write');
+function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        fsWriteLogger.debug('Creating directory recursively', { path: dirPath });
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+function writeFileContent(filePath, content, options) {
+    try {
+        fsWriteLogger.debug('Writing file content', { path: filePath, size: content.length, encoding: options?.encoding ?? 'utf-8' });
+        ensureDir(dirname(filePath));
+        writeFileSync(filePath, content, {
+            encoding: options?.encoding ?? 'utf-8',
+            mode: options?.mode,
+        });
+        fsWriteLogger.debug('File written successfully', { path: filePath });
+    }
+    catch (error) {
+        fsWriteLogger.warn('Failed to write file', { path: filePath, error: error instanceof Error ? error.message : String(error) });
+        throw createFileSystemError(`Failed to write file: ${filePath}`, 'FS_WRITE_ERROR', { path: filePath, operation: 'write', cause: error });
+    }
+}
+function writeJsonFile(filePath, data, options) {
+    try {
+        fsWriteLogger.debug('Writing JSON file', { path: filePath, indent: options?.indent ?? 2 });
+        const indent = options?.indent ?? 2;
+        const content = stringify(data, null, indent) + '\n';
+        writeFileContent(filePath, content, options);
+        fsWriteLogger.debug('JSON file written successfully', { path: filePath });
+    }
+    catch (error) {
+        if (error?.code === 'FS_WRITE_ERROR') {
+            throw error;
+        }
+        fsWriteLogger.warn('Failed to write JSON file', { path: filePath, error: error instanceof Error ? error.message : String(error) });
+        throw createFileSystemError(`Failed to write JSON file: ${filePath}`, 'FS_WRITE_ERROR', {
+            path: filePath,
+            operation: 'write',
+            cause: error,
+        });
+    }
+}
+
+function matchGlobPattern(path, pattern) {
+    return matchSegments(path.split('/'), pattern.split('/'), 0, 0);
+}
+function matchSegments(pathParts, patternParts, pathIdx, patternIdx) {
+    if (pathIdx === pathParts.length && patternIdx === patternParts.length) {
+        return true;
+    }
+    if (patternIdx >= patternParts.length) {
+        return false;
+    }
+    const patternPart = patternParts[patternIdx];
+    if (patternPart === '**') {
+        for (let i = pathIdx; i <= pathParts.length; i++) {
+            if (matchSegments(pathParts, patternParts, i, patternIdx + 1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    if (pathIdx >= pathParts.length) {
+        return false;
+    }
+    const pathPart = pathParts[pathIdx];
+    if (matchSegment(pathPart, patternPart)) {
+        return matchSegments(pathParts, patternParts, pathIdx + 1, patternIdx + 1);
+    }
+    return false;
+}
+function matchSegment(text, pattern) {
+    let textIdx = 0;
+    let patternIdx = 0;
+    while (patternIdx < pattern.length) {
+        const char = pattern[patternIdx];
+        if (char === '*') {
+            patternIdx++;
+            if (patternIdx === pattern.length) {
+                return true;
+            }
+            for (let i = textIdx; i <= text.length; i++) {
+                if (matchSegmentFrom(text, i, pattern, patternIdx)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else if (char === '?') {
+            if (textIdx >= text.length) {
+                return false;
+            }
+            textIdx++;
+            patternIdx++;
+        }
+        else if (char === '{') {
+            const closeIdx = findClosingBrace(pattern, patternIdx);
+            if (closeIdx === -1) {
+                if (textIdx >= text.length || text[textIdx] !== char) {
+                    return false;
+                }
+                textIdx++;
+                patternIdx++;
+            }
+            else {
+                const alternatives = extractAlternatives(pattern.slice(patternIdx + 1, closeIdx));
+                for (const alt of alternatives) {
+                    if (matchSegmentFrom(text, textIdx, text.slice(0, textIdx) + alt + pattern.slice(closeIdx + 1), textIdx)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        else {
+            if (textIdx >= text.length || text[textIdx] !== char) {
+                return false;
+            }
+            textIdx++;
+            patternIdx++;
+        }
+    }
+    return textIdx === text.length;
+}
+function matchSegmentFrom(text, textIdx, pattern, patternIdx) {
+    const remainingText = text.slice(textIdx);
+    const remainingPattern = pattern.slice(patternIdx);
+    return matchSegment(remainingText, remainingPattern);
+}
+function findClosingBrace(pattern, startIdx) {
+    let depth = 0;
+    for (let i = startIdx; i < pattern.length; i++) {
+        if (pattern[i] === '{') {
+            depth++;
+        }
+        else if (pattern[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function extractAlternatives(content) {
+    const alternatives = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        if (char === '{') {
+            depth++;
+            current += char;
+        }
+        else if (char === '}') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            alternatives.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        alternatives.push(current);
+    }
+    return alternatives;
+}
+
+export { createFileSystemError, createScopedLogger, ensureDir, exists, getDirname, getFileStat, isDirectory, isFile, join, logger, matchGlobPattern, normalizePath, readDirectory, readDirectoryRecursive, readFileContent, readJsonFile, relativePath, removeDirectory, sanitize, writeFileContent, writeJsonFile };

package/_dependencies/@hyperfrontend/project-scope/core/logger/index.cjs.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const index_cjs_js$4 = require('../../../immutable-api-utils/built-in-copy/array/index.cjs.js');
+const index_cjs_js$3 = require('../../../immutable-api-utils/built-in-copy/console/index.cjs.js');
+const index_cjs_js$5 = require('../../../immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$2 = require('../../../immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js = require('../../../immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$1 = require('../../../logging/index.cjs.js');
+
+const loggerRegistry = index_cjs_js.createSet();
+let globalLogLevel = null;
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (index_cjs_js$4.isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of index_cjs_js$2.entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && index_cjs_js$2.keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${index_cjs_js$5.stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+function createScopedLogger(namespace, options = {}) {
+    const { level = 'error', sanitizeSecrets = true } = options;
+    const createLogFn = (baseFn) => (message, meta) => {
+        const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
+        baseFn(formatMessage(namespace, message, processedMeta));
+    };
+    const baseLogger = index_cjs_js$1.createLogger(createLogFn(index_cjs_js$3.error), createLogFn(index_cjs_js$3.warn), createLogFn(index_cjs_js$3.log), createLogFn(index_cjs_js$3.info), createLogFn(index_cjs_js$3.debug));
+    baseLogger.setLogLevel(globalLogLevel ?? level);
+    const scopedLogger = index_cjs_js$2.freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+const logger = createScopedLogger('project-scope');
+
+exports.createScopedLogger = createScopedLogger;
+exports.logger = logger;
+exports.sanitize = sanitize;

package/_dependencies/@hyperfrontend/project-scope/core/logger/index.esm.js

@@ -0,0 +1,80 @@
+import { isArray } from '../../../immutable-api-utils/built-in-copy/array/index.esm.js';
+import { error, warn, log, info, debug } from '../../../immutable-api-utils/built-in-copy/console/index.esm.js';
+import { stringify } from '../../../immutable-api-utils/built-in-copy/json/index.esm.js';
+import { freeze, entries, keys } from '../../../immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../../../immutable-api-utils/built-in-copy/set/index.esm.js';
+import { createLogger } from '../../../logging/index.esm.js';
+
+const loggerRegistry = createSet();
+let globalLogLevel = null;
+const REDACTED = '[REDACTED]';
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+function createScopedLogger(namespace, options = {}) {
+    const { level = 'error', sanitizeSecrets = true } = options;
+    const createLogFn = (baseFn) => (message, meta) => {
+        const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
+        baseFn(formatMessage(namespace, message, processedMeta));
+    };
+    const baseLogger = createLogger(createLogFn(error), createLogFn(warn), createLogFn(log), createLogFn(info), createLogFn(debug));
+    baseLogger.setLogLevel(globalLogLevel ?? level);
+    const scopedLogger = freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+const logger = createScopedLogger('project-scope');
+
+export { createScopedLogger, logger, sanitize };

package/_dependencies/@hyperfrontend/project-scope/core/path/index.cjs.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const node_path = require('node:path');
+
+function join(...paths) {
+    return node_path.join(...paths);
+}
+
+function normalizePath(filePath) {
+    if (!filePath)
+        return '';
+    const normalized = node_path.normalize(filePath);
+    return node_path.sep === '\\' ? normalized.replace(/\\/g, '/') : normalized;
+}
+function normalizeToForwardSlashes(filePath) {
+    if (!filePath)
+        return '';
+    return node_path.normalize(filePath).split(node_path.sep).join('/');
+}
+function getDirname(filePath) {
+    return normalizePath(node_path.dirname(filePath));
+}
+exports.getDirname = getDirname;
+exports.join = join;
+exports.normalizePath = normalizePath;
+exports.normalizeToForwardSlashes = normalizeToForwardSlashes;

package/_dependencies/@hyperfrontend/project-scope/core/path/index.esm.js

@@ -0,0 +1,22 @@
+import { join as join$1, normalize, sep, dirname } from 'node:path';
+
+function join(...paths) {
+    return join$1(...paths);
+}
+
+function normalizePath(filePath) {
+    if (!filePath)
+        return '';
+    const normalized = normalize(filePath);
+    return sep === '\\' ? normalized.replace(/\\/g, '/') : normalized;
+}
+function normalizeToForwardSlashes(filePath) {
+    if (!filePath)
+        return '';
+    return normalize(filePath).split(sep).join('/');
+}
+function getDirname(filePath) {
+    return normalizePath(dirname(filePath));
+}
+
+export { getDirname, join, normalizePath, normalizeToForwardSlashes };

package/_dependencies/@hyperfrontend/project-scope/core/platform/index.cjs.js

@@ -0,0 +1 @@
+'use strict';

package/_dependencies/@hyperfrontend/project-scope/core/platform/index.esm.js

@@ -0,0 +1 @@
+