opfs-worker 1.2.3 → 1.2.4

package/dist/helpers-BwklIUit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers-BwklIUit.js","sources":["../src/utils/errors.ts","../src/utils/encoder.ts","../src/types.ts","../node_modules/@isaacs/balanced-match/dist/esm/index.js","../node_modules/@isaacs/brace-expansion/dist/esm/index.js","../node_modules/minimatch/dist/esm/assert-valid-pattern.js","../node_modules/minimatch/dist/esm/brace-expressions.js","../node_modules/minimatch/dist/esm/unescape.js","../node_modules/minimatch/dist/esm/ast.js","../node_modules/minimatch/dist/esm/escape.js","../node_modules/minimatch/dist/esm/index.js","../src/utils/helpers.ts"],"sourcesContent":["/**\n * Base error class for all OPFS-related errors\n */\nexport class OPFSError extends Error {\n    constructor(\n        message: string,\n        public readonly code: string,\n        public readonly path?: string,\n        cause?: any\n    ) {\n        super(message, { cause });\n        this.name = 'OPFSError';\n    }\n}\n\n/**\n * Error thrown when OPFS is not supported in the current browser\n */\nexport class OPFSNotSupportedError extends OPFSError {\n    constructor(cause?: unknown) {\n        super('OPFS is not supported in this browser', 'OPFS_NOT_SUPPORTED', undefined, cause);\n    }\n}\n\n\n/**\n * Error thrown when OPFS is not mounted\n */\nexport class OPFSNotMountedError extends OPFSError {\n    constructor(cause?: unknown) {\n        super('OPFS is not mounted', 'OPFS_NOT_MOUNTED', undefined, cause);\n    }\n}\n\n/**\n * Error thrown for invalid paths or path traversal attempts\n */\nexport class PathError extends OPFSError {\n    constructor(message: string, path: string, cause?: unknown) {\n        super(message, 'INVALID_PATH', path, cause);\n    }\n}\n\n/**\n * Error thrown when a requested file doesn't exist\n */\nexport class FileNotFoundError extends OPFSError {\n    constructor(path: string, cause?: unknown) {\n        super(`File not found: ${ path }`, 'FILE_NOT_FOUND', path, cause);\n    }\n}\n\n/**\n * Error thrown when a requested directory doesn't exist\n */\nexport class DirectoryNotFoundError extends OPFSError {\n    constructor(path: string, cause?: unknown) {\n        super(`Directory not found: ${ path }`, 'DIRECTORY_NOT_FOUND', path, cause);\n    }\n}\n\n/**\n * Error thrown when permission is denied for an operation\n */\nexport class PermissionError extends OPFSError {\n    constructor(path: string, operation: string, cause?: unknown) {\n        super(`Permission denied for ${ operation } on: ${ path }`, 'PERMISSION_DENIED', path, cause);\n    }\n}\n\n/**\n * Error thrown when an operation fails due to insufficient storage\n */\nexport class StorageError extends OPFSError {\n    constructor(message: string, path?: string, cause?: unknown) {\n        super(message, 'STORAGE_ERROR', path, cause);\n    }\n}\n\n/**\n * Error thrown when an operation times out\n */\nexport class TimeoutError extends OPFSError {\n    constructor(operation: string, path?: string, cause?: unknown) {\n        super(`Operation timed out: ${ operation }`, 'TIMEOUT_ERROR', path, cause);\n    }\n}\n\n\n/**\n * Create an OPFSError with file descriptor context\n * \n * @param operation - The operation that failed (e.g., 'read', 'write', 'close')\n * @param fd - The file descriptor number\n * @param path - The file path\n * @param error - The underlying error (optional)\n * @returns OPFSError with appropriate context\n */\nexport function createFDError(operation: string, fd: number, path: string, error?: any): OPFSError {\n    const errorCode = `${ operation.toUpperCase() }_FAILED` as any;\n\n    return new OPFSError(`Failed to ${ operation } file descriptor: ${ fd }`, errorCode, path, error);\n}\n\n/**\n * Map DOM exceptions to OPFS error codes\n * \n * @param error - The DOM exception to map\n * @param context - Context information for better error mapping\n * @param context.path - File path for context-specific errors\n * @param context.isDirectory - Whether the operation involves a directory\n * @returns OPFSError with appropriate error code\n */\nexport function mapDomError(error: any, context?: { path?: string; isDirectory?: boolean }): OPFSError {\n    const path = context?.path;\n    const isDirectory = context?.isDirectory;\n\n    switch (error.name) {\n        case 'InvalidStateError':\n            return new OPFSError(`File is busy: ${ path || 'unknown' }`, 'EBUSY', path, error);\n\n        case 'QuotaExceededError':\n            return new OPFSError(`No space left on device: ${ path || 'unknown' }`, 'ENOSPC', path, error);\n\n        case 'NotFoundError':\n            return new OPFSError(`No such file or directory: ${ path || 'unknown' }`, 'ENOENT', path, error);\n\n        case 'TypeMismatchError':\n            if (isDirectory !== undefined) {\n                if (isDirectory) {\n                    return new OPFSError(`Not a directory: ${ path || 'unknown' }`, 'ENOTDIR', path, error);\n                }\n                else {\n                    return new OPFSError(`Is a directory: ${ path || 'unknown' }`, 'EISDIR', path, error);\n                }\n            }\n\n            // Fall through to default for ambiguous cases\n            return new OPFSError(`Type mismatch: ${ path || 'unknown' }`, 'EINVAL', path, error);\n\n        case 'NotAllowedError':\n        case 'SecurityError':\n            return new OPFSError(`Permission denied: ${ path || 'unknown' }`, 'EACCES', path, error);\n\n        case 'InvalidModificationError':\n            return new OPFSError(`Invalid modification: ${ path || 'unknown' }`, 'EINVAL', path, error);\n\n        case 'AbortError':\n            return new OPFSError(`Operation aborted: ${ path || 'unknown' }`, 'EINTR', path, error);\n\n        case 'OperationError':\n            return new OPFSError(`Operation failed: ${ path || 'unknown' }`, 'EIO', path, error);\n\n        case 'TypeError':\n            return new OPFSError(`Operation not supported: ${ path || 'unknown' }`, 'ENOTSUP', path, error);\n\n        default:\n            return new OPFSError(`I/O error: ${ path || 'unknown' }`, 'EIO', path, error);\n    }\n}\n","import { OPFSError } from './errors';\n\nimport type { Encoding } from '../types';\n\n\n/**\n * Common binary file extensions\n */\nexport const BINARY_FILE_EXTENSIONS = [\n    // Images\n    '.jpg',\n    '.jpeg',\n    '.png',\n    '.gif',\n    '.bmp',\n    '.webp',\n    '.ico',\n    '.tiff',\n    '.tga',\n    // Audio\n    '.mp3',\n    '.wav',\n    '.ogg',\n    '.flac',\n    '.aac',\n    '.wma',\n    '.m4a',\n    // Video\n    '.mp4',\n    '.avi',\n    '.mov',\n    '.wmv',\n    '.flv',\n    '.webm',\n    '.mkv',\n    '.m4v',\n    // Documents\n    '.pdf',\n    '.doc',\n    '.docx',\n    '.xls',\n    '.xlsx',\n    '.ppt',\n    '.pptx',\n    // Archives\n    '.zip',\n    '.rar',\n    '.7z',\n    '.tar',\n    '.gz',\n    '.bz2',\n    // Executables\n    '.exe',\n    '.dll',\n    '.so',\n    '.dylib',\n    // Other binary formats\n    '.dat',\n    '.db',\n    '.sqlite',\n    '.bin',\n    '.obj',\n    '.fbx',\n    '.3ds',\n] as const;\n\n/**\n * Check if a file extension indicates a binary file\n * \n * @param path - The file path or filename\n * @returns True if the file extension suggests binary content\n * \n * @example\n * ```typescript\n * isBinaryFileExtension('/path/to/image.jpg'); // true\n * isBinaryFileExtension('/path/to/document.txt'); // false\n * isBinaryFileExtension('data.bin'); // true\n * isBinaryFileExtension('data'); // true\n * ```\n */\nexport function isBinaryFileExtension(path: string): boolean {\n    const i = path.lastIndexOf('.');\n\n    if (i <= 0) {\n        return true;\n    }\n\n    const ext = path.slice(i).toLowerCase();\n\n    return BINARY_FILE_EXTENSIONS.includes(ext as any);\n}\n\nexport function encodeString(data: string, encoding: Encoding = 'utf-8'): Uint8Array {\n    switch (encoding) {\n        case 'utf8':\n        case 'utf-8':\n            return new TextEncoder().encode(data);\n\n        case 'utf16le':\n        case 'utf-16le':\n        case 'ucs2':\n        case 'ucs-2':\n            return encodeUtf16LE(data);\n\n        case 'ascii':\n            return encodeAscii(data);\n\n        case 'latin1':\n            return encodeLatin1(data);\n\n        case 'binary':\n            return Uint8Array.from(data, char => char.charCodeAt(0));\n\n        case 'base64':\n            return Uint8Array.from(atob(data), c => c.charCodeAt(0));\n\n        case 'hex':\n            if (!/^[\\da-f]+$/i.test(data) || data.length % 2 !== 0) {\n                throw new OPFSError('Invalid hex string', 'INVALID_HEX_FORMAT');\n            }\n\n            return Uint8Array.from(data.match(/.{1,2}/g)!.map(b => parseInt(b, 16)));\n\n        default:\n            console.warn('Encoding not supported, falling back to UTF-8');\n\n            return new TextEncoder().encode(data);\n    }\n}\n\nexport function decodeBuffer(buffer: Uint8Array, encoding: Encoding = 'utf-8'): string {\n    // eslint-disable-next-line ts/switch-exhaustiveness-check\n    switch (encoding) {\n        case 'utf8':\n        case 'utf-8':\n            return new TextDecoder().decode(buffer);\n\n        case 'utf16le':\n        case 'utf-16le':\n        case 'ucs2':\n        case 'ucs-2':\n            return decodeUtf16LE(buffer);\n\n        case 'latin1':\n            return String.fromCharCode(...buffer);\n\n        case 'ascii':\n            return String.fromCharCode(...buffer.map(b => b & 0x7F));\n\n        case 'base64':\n            return btoa(String.fromCharCode(...buffer));\n\n        case 'hex':\n            return Array.from(buffer).map(b => b.toString(16).padStart(2, '0')).join('');\n\n        default:\n            console.warn('Unsupported encoding, falling back to UTF-8');\n\n            return new TextDecoder().decode(buffer);\n    }\n}\n\nfunction encodeUtf16LE(str: string): Uint8Array {\n    const buf = new Uint8Array(str.length * 2);\n\n    for (let i = 0; i < str.length; i++) {\n        const code = str.charCodeAt(i);\n\n        buf[(i * 2)] = code & 0xFF;\n        buf[(i * 2) + 1] = code >> 8;\n    }\n\n    return buf;\n}\n\nfunction decodeUtf16LE(buf: Uint8Array): string {\n    if (buf.length % 2 !== 0) {\n        console.warn('Invalid UTF-16LE buffer length, truncating last byte');\n        buf = buf.slice(0, buf.length - 1);\n    }\n\n    const codeUnits = new Uint16Array(buf.buffer, buf.byteOffset, buf.byteLength / 2);\n\n    return String.fromCharCode(...codeUnits);\n}\n\nfunction encodeLatin1(str: string): Uint8Array {\n    const buf = new Uint8Array(str.length);\n\n    for (let i = 0; i < str.length; i++) {\n        buf[i] = str.charCodeAt(i) & 0xFF;\n    }\n\n    return buf;\n}\n\nfunction encodeAscii(str: string): Uint8Array {\n    const buf = new Uint8Array(str.length);\n\n    for (let i = 0; i < str.length; i++) {\n        buf[i] = str.charCodeAt(i) & 0x7F;\n    }\n\n    return buf;\n}\n","import type { OPFSWorker } from './worker';\nimport type { Remote } from 'comlink';\n\n/**\n * Type for paths that can be either a string or URI\n */\nexport type PathLike = string | URL;\n\nexport type Kind = 'file' | 'directory';\n\nexport type StringEncoding = 'ascii'\n  | 'utf8'\n  | 'utf-8'\n  | 'utf16le'\n  | 'utf-16le'\n  | 'ucs2'\n  | 'ucs-2'\n  | 'base64'\n  | 'latin1'\n  | 'hex';\n\nexport type BinaryEncoding = 'binary';\n\nexport type Encoding = StringEncoding | BinaryEncoding;\n\nexport interface FileStat {\n    kind: Kind;\n    size: number;\n    mtime: string; // ISO string\n    ctime: string; // ISO string\n    isFile: boolean;\n    isDirectory: boolean;\n    /** Hash of file content (only for files, undefined for directories) */\n    hash?: string;\n}\n\nexport interface DirentData {\n    name: string;\n    kind: 'file' | 'directory';\n    isFile: boolean;\n    isDirectory: boolean;\n}\n\nexport enum WatchEventType {\n    Added = 'added',\n    Changed = 'changed',\n    Removed = 'removed'\n}\n\nexport interface WatchEvent {\n    namespace: string;\n    path: string;\n    type: WatchEventType;\n    isDirectory: boolean;\n    timestamp: string;\n    hash?: string;\n}\n\nexport type { OPFSWorker };\nexport type RemoteOPFSWorker = Remote<OPFSWorker>;\n\nexport interface OPFSOptions {\n    /** Root path for the file system (default: '/') */\n    root?: string;\n    /** Namespace for the events (default: 'opfs-worker:${root}') */\n    namespace?: string;\n    /** Hash algorithm for file hashing, or false/null to disable (default: 'etag') */\n    hashAlgorithm?: null | false | 'etag' | 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';\n    /** Maximum file size in bytes for hashing (default: 50MB) */\n    maxFileSize?: number;\n    /** Custom name for the broadcast channel (default: 'opfs-worker') */\n    broadcastChannel?: string | BroadcastChannel | null;\n}\n\nexport interface RenameOptions {\n    /** Whether to overwrite existing files (default: false) */\n    overwrite?: boolean;\n}\n\nexport interface WatchOptions {\n    /** Whether to watch recursively (default: true) */\n    recursive?: boolean;\n    /** Glob patterns to include in watching (minimatch syntax, default: ['**']) */\n    include?: string | string[];\n    /** Glob patterns to exclude from watching (minimatch syntax, default: []) */\n    exclude?: string | string[];\n}\n\nexport interface FileOpenOptions {\n    create?: boolean;\n    exclusive?: boolean;\n    truncate?: boolean;\n}\n\nexport interface WatchSnapshot {\n    pattern: string;\n    include: string[];\n    exclude: string[];\n}\n","export const balanced = (a, b, str) => {\n    const ma = a instanceof RegExp ? maybeMatch(a, str) : a;\n    const mb = b instanceof RegExp ? maybeMatch(b, str) : b;\n    const r = ma !== null && mb != null && range(ma, mb, str);\n    return (r && {\n        start: r[0],\n        end: r[1],\n        pre: str.slice(0, r[0]),\n        body: str.slice(r[0] + ma.length, r[1]),\n        post: str.slice(r[1] + mb.length),\n    });\n};\nconst maybeMatch = (reg, str) => {\n    const m = str.match(reg);\n    return m ? m[0] : null;\n};\nexport const range = (a, b, str) => {\n    let begs, beg, left, right = undefined, result;\n    let ai = str.indexOf(a);\n    let bi = str.indexOf(b, ai + 1);\n    let i = ai;\n    if (ai >= 0 && bi > 0) {\n        if (a === b) {\n            return [ai, bi];\n        }\n        begs = [];\n        left = str.length;\n        while (i >= 0 && !result) {\n            if (i === ai) {\n                begs.push(i);\n                ai = str.indexOf(a, i + 1);\n            }\n            else if (begs.length === 1) {\n                const r = begs.pop();\n                if (r !== undefined)\n                    result = [r, bi];\n            }\n            else {\n                beg = begs.pop();\n                if (beg !== undefined && beg < left) {\n                    left = beg;\n                    right = bi;\n                }\n                bi = str.indexOf(b, i + 1);\n            }\n            i = ai < bi && ai >= 0 ? ai : bi;\n        }\n        if (begs.length && right !== undefined) {\n            result = [left, right];\n        }\n    }\n    return result;\n};\n//# sourceMappingURL=index.js.map","import { balanced } from '@isaacs/balanced-match';\nconst escSlash = '\\0SLASH' + Math.random() + '\\0';\nconst escOpen = '\\0OPEN' + Math.random() + '\\0';\nconst escClose = '\\0CLOSE' + Math.random() + '\\0';\nconst escComma = '\\0COMMA' + Math.random() + '\\0';\nconst escPeriod = '\\0PERIOD' + Math.random() + '\\0';\nconst escSlashPattern = new RegExp(escSlash, 'g');\nconst escOpenPattern = new RegExp(escOpen, 'g');\nconst escClosePattern = new RegExp(escClose, 'g');\nconst escCommaPattern = new RegExp(escComma, 'g');\nconst escPeriodPattern = new RegExp(escPeriod, 'g');\nconst slashPattern = /\\\\\\\\/g;\nconst openPattern = /\\\\{/g;\nconst closePattern = /\\\\}/g;\nconst commaPattern = /\\\\,/g;\nconst periodPattern = /\\\\./g;\nfunction numeric(str) {\n    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);\n}\nfunction escapeBraces(str) {\n    return str\n        .replace(slashPattern, escSlash)\n        .replace(openPattern, escOpen)\n        .replace(closePattern, escClose)\n        .replace(commaPattern, escComma)\n        .replace(periodPattern, escPeriod);\n}\nfunction unescapeBraces(str) {\n    return str\n        .replace(escSlashPattern, '\\\\')\n        .replace(escOpenPattern, '{')\n        .replace(escClosePattern, '}')\n        .replace(escCommaPattern, ',')\n        .replace(escPeriodPattern, '.');\n}\n/**\n * Basically just str.split(\",\"), but handling cases\n * where we have nested braced sections, which should be\n * treated as individual members, like {a,{b,c},d}\n */\nfunction parseCommaParts(str) {\n    if (!str) {\n        return [''];\n    }\n    const parts = [];\n    const m = balanced('{', '}', str);\n    if (!m) {\n        return str.split(',');\n    }\n    const { pre, body, post } = m;\n    const p = pre.split(',');\n    p[p.length - 1] += '{' + body + '}';\n    const postParts = parseCommaParts(post);\n    if (post.length) {\n        ;\n        p[p.length - 1] += postParts.shift();\n        p.push.apply(p, postParts);\n    }\n    parts.push.apply(parts, p);\n    return parts;\n}\nexport function expand(str) {\n    if (!str) {\n        return [];\n    }\n    // I don't know why Bash 4.3 does this, but it does.\n    // Anything starting with {} will have the first two bytes preserved\n    // but *only* at the top level, so {},a}b will not expand to anything,\n    // but a{},b}c will be expanded to [a}c,abc].\n    // One could argue that this is a bug in Bash, but since the goal of\n    // this module is to match Bash's rules, we escape a leading {}\n    if (str.slice(0, 2) === '{}') {\n        str = '\\\\{\\\\}' + str.slice(2);\n    }\n    return expand_(escapeBraces(str), true).map(unescapeBraces);\n}\nfunction embrace(str) {\n    return '{' + str + '}';\n}\nfunction isPadded(el) {\n    return /^-?0\\d/.test(el);\n}\nfunction lte(i, y) {\n    return i <= y;\n}\nfunction gte(i, y) {\n    return i >= y;\n}\nfunction expand_(str, isTop) {\n    /** @type {string[]} */\n    const expansions = [];\n    const m = balanced('{', '}', str);\n    if (!m)\n        return [str];\n    // no need to expand pre, since it is guaranteed to be free of brace-sets\n    const pre = m.pre;\n    const post = m.post.length ? expand_(m.post, false) : [''];\n    if (/\\$$/.test(m.pre)) {\n        for (let k = 0; k < post.length; k++) {\n            const expansion = pre + '{' + m.body + '}' + post[k];\n            expansions.push(expansion);\n        }\n    }\n    else {\n        const isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n        const isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n        const isSequence = isNumericSequence || isAlphaSequence;\n        const isOptions = m.body.indexOf(',') >= 0;\n        if (!isSequence && !isOptions) {\n            // {a},b}\n            if (m.post.match(/,(?!,).*\\}/)) {\n                str = m.pre + '{' + m.body + escClose + m.post;\n                return expand_(str);\n            }\n            return [str];\n        }\n        let n;\n        if (isSequence) {\n            n = m.body.split(/\\.\\./);\n        }\n        else {\n            n = parseCommaParts(m.body);\n            if (n.length === 1 && n[0] !== undefined) {\n                // x{{a,b}}y ==> x{a}y x{b}y\n                n = expand_(n[0], false).map(embrace);\n                //XXX is this necessary? Can't seem to hit it in tests.\n                /* c8 ignore start */\n                if (n.length === 1) {\n                    return post.map(p => m.pre + n[0] + p);\n                }\n                /* c8 ignore stop */\n            }\n        }\n        // at this point, n is the parts, and we know it's not a comma set\n        // with a single entry.\n        let N;\n        if (isSequence && n[0] !== undefined && n[1] !== undefined) {\n            const x = numeric(n[0]);\n            const y = numeric(n[1]);\n            const width = Math.max(n[0].length, n[1].length);\n            let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;\n            let test = lte;\n            const reverse = y < x;\n            if (reverse) {\n                incr *= -1;\n                test = gte;\n            }\n            const pad = n.some(isPadded);\n            N = [];\n            for (let i = x; test(i, y); i += incr) {\n                let c;\n                if (isAlphaSequence) {\n                    c = String.fromCharCode(i);\n                    if (c === '\\\\') {\n                        c = '';\n                    }\n                }\n                else {\n                    c = String(i);\n                    if (pad) {\n                        const need = width - c.length;\n                        if (need > 0) {\n                            const z = new Array(need + 1).join('0');\n                            if (i < 0) {\n                                c = '-' + z + c.slice(1);\n                            }\n                            else {\n                                c = z + c;\n                            }\n                        }\n                    }\n                }\n                N.push(c);\n            }\n        }\n        else {\n            N = [];\n            for (let j = 0; j < n.length; j++) {\n                N.push.apply(N, expand_(n[j], false));\n            }\n        }\n        for (let j = 0; j < N.length; j++) {\n            for (let k = 0; k < post.length; k++) {\n                const expansion = pre + N[j] + post[k];\n                if (!isTop || isSequence || expansion) {\n                    expansions.push(expansion);\n                }\n            }\n        }\n    }\n    return expansions;\n}\n//# sourceMappingURL=index.js.map","const MAX_PATTERN_LENGTH = 1024 * 64;\nexport const assertValidPattern = (pattern) => {\n    if (typeof pattern !== 'string') {\n        throw new TypeError('invalid pattern');\n    }\n    if (pattern.length > MAX_PATTERN_LENGTH) {\n        throw new TypeError('pattern is too long');\n    }\n};\n//# sourceMappingURL=assert-valid-pattern.js.map","// translate the various posix character classes into unicode properties\n// this works across all unicode locales\n// { <posix class>: [<translation>, /u flag required, negated]\nconst posixClasses = {\n    '[:alnum:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}', true],\n    '[:alpha:]': ['\\\\p{L}\\\\p{Nl}', true],\n    '[:ascii:]': ['\\\\x' + '00-\\\\x' + '7f', false],\n    '[:blank:]': ['\\\\p{Zs}\\\\t', true],\n    '[:cntrl:]': ['\\\\p{Cc}', true],\n    '[:digit:]': ['\\\\p{Nd}', true],\n    '[:graph:]': ['\\\\p{Z}\\\\p{C}', true, true],\n    '[:lower:]': ['\\\\p{Ll}', true],\n    '[:print:]': ['\\\\p{C}', true],\n    '[:punct:]': ['\\\\p{P}', true],\n    '[:space:]': ['\\\\p{Z}\\\\t\\\\r\\\\n\\\\v\\\\f', true],\n    '[:upper:]': ['\\\\p{Lu}', true],\n    '[:word:]': ['\\\\p{L}\\\\p{Nl}\\\\p{Nd}\\\\p{Pc}', true],\n    '[:xdigit:]': ['A-Fa-f0-9', false],\n};\n// only need to escape a few things inside of brace expressions\n// escapes: [ \\ ] -\nconst braceEscape = (s) => s.replace(/[[\\]\\\\-]/g, '\\\\$&');\n// escape all regexp magic characters\nconst regexpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n// everything has already been escaped, we just have to join\nconst rangesToString = (ranges) => ranges.join('');\n// takes a glob string at a posix brace expression, and returns\n// an equivalent regular expression source, and boolean indicating\n// whether the /u flag needs to be applied, and the number of chars\n// consumed to parse the character class.\n// This also removes out of order ranges, and returns ($.) if the\n// entire class just no good.\nexport const parseClass = (glob, position) => {\n    const pos = position;\n    /* c8 ignore start */\n    if (glob.charAt(pos) !== '[') {\n        throw new Error('not in a brace expression');\n    }\n    /* c8 ignore stop */\n    const ranges = [];\n    const negs = [];\n    let i = pos + 1;\n    let sawStart = false;\n    let uflag = false;\n    let escaping = false;\n    let negate = false;\n    let endPos = pos;\n    let rangeStart = '';\n    WHILE: while (i < glob.length) {\n        const c = glob.charAt(i);\n        if ((c === '!' || c === '^') && i === pos + 1) {\n            negate = true;\n            i++;\n            continue;\n        }\n        if (c === ']' && sawStart && !escaping) {\n            endPos = i + 1;\n            break;\n        }\n        sawStart = true;\n        if (c === '\\\\') {\n            if (!escaping) {\n                escaping = true;\n                i++;\n                continue;\n            }\n            // escaped \\ char, fall through and treat like normal char\n        }\n        if (c === '[' && !escaping) {\n            // either a posix class, a collation equivalent, or just a [\n            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {\n                if (glob.startsWith(cls, i)) {\n                    // invalid, [a-[] is fine, but not [a-[:alpha]]\n                    if (rangeStart) {\n                        return ['$.', false, glob.length - pos, true];\n                    }\n                    i += cls.length;\n                    if (neg)\n                        negs.push(unip);\n                    else\n                        ranges.push(unip);\n                    uflag = uflag || u;\n                    continue WHILE;\n                }\n            }\n        }\n        // now it's just a normal character, effectively\n        escaping = false;\n        if (rangeStart) {\n            // throw this range away if it's not valid, but others\n            // can still match.\n            if (c > rangeStart) {\n                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));\n            }\n            else if (c === rangeStart) {\n                ranges.push(braceEscape(c));\n            }\n            rangeStart = '';\n            i++;\n            continue;\n        }\n        // now might be the start of a range.\n        // can be either c-d or c-] or c<more...>] or c] at this point\n        if (glob.startsWith('-]', i + 1)) {\n            ranges.push(braceEscape(c + '-'));\n            i += 2;\n            continue;\n        }\n        if (glob.startsWith('-', i + 1)) {\n            rangeStart = c;\n            i += 2;\n            continue;\n        }\n        // not the start of a range, just a single character\n        ranges.push(braceEscape(c));\n        i++;\n    }\n    if (endPos < i) {\n        // didn't see the end of the class, not a valid class,\n        // but might still be valid as a literal match.\n        return ['', false, 0, false];\n    }\n    // if we got no ranges and no negates, then we have a range that\n    // cannot possibly match anything, and that poisons the whole glob\n    if (!ranges.length && !negs.length) {\n        return ['$.', false, glob.length - pos, true];\n    }\n    // if we got one positive range, and it's a single character, then that's\n    // not actually a magic pattern, it's just that one literal character.\n    // we should not treat that as \"magic\", we should just return the literal\n    // character. [_] is a perfectly valid way to escape glob magic chars.\n    if (negs.length === 0 &&\n        ranges.length === 1 &&\n        /^\\\\?.$/.test(ranges[0]) &&\n        !negate) {\n        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];\n        return [regexpEscape(r), false, endPos - pos, false];\n    }\n    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';\n    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';\n    const comb = ranges.length && negs.length\n        ? '(' + sranges + '|' + snegs + ')'\n        : ranges.length\n            ? sranges\n            : snegs;\n    return [comb, uflag, endPos - pos, true];\n};\n//# sourceMappingURL=brace-expressions.js.map","/**\n * Un-escape a string that has been escaped with {@link escape}.\n *\n * If the {@link windowsPathsNoEscape} option is used, then square-brace\n * escapes are removed, but not backslash escapes.  For example, it will turn\n * the string `'[*]'` into `*`, but it will not turn `'\\\\*'` into `'*'`,\n * becuase `\\` is a path separator in `windowsPathsNoEscape` mode.\n *\n * When `windowsPathsNoEscape` is not set, then both brace escapes and\n * backslash escapes are removed.\n *\n * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped\n * or unescaped.\n */\nexport const unescape = (s, { windowsPathsNoEscape = false, } = {}) => {\n    return windowsPathsNoEscape\n        ? s.replace(/\\[([^\\/\\\\])\\]/g, '$1')\n        : s.replace(/((?!\\\\).|^)\\[([^\\/\\\\])\\]/g, '$1$2').replace(/\\\\([^\\/])/g, '$1');\n};\n//# sourceMappingURL=unescape.js.map","// parse a single path portion\nimport { parseClass } from './brace-expressions.js';\nimport { unescape } from './unescape.js';\nconst types = new Set(['!', '?', '+', '*', '@']);\nconst isExtglobType = (c) => types.has(c);\n// Patterns that get prepended to bind to the start of either the\n// entire string, or just a single path portion, to prevent dots\n// and/or traversal patterns, when needed.\n// Exts don't need the ^ or / bit, because the root binds that already.\nconst startNoTraversal = '(?!(?:^|/)\\\\.\\\\.?(?:$|/))';\nconst startNoDot = '(?!\\\\.)';\n// characters that indicate a start of pattern needs the \"no dots\" bit,\n// because a dot *might* be matched. ( is not in the list, because in\n// the case of a child extglob, it will handle the prevention itself.\nconst addPatternStart = new Set(['[', '.']);\n// cases where traversal is A-OK, no dot prevention needed\nconst justDots = new Set(['..', '.']);\nconst reSpecials = new Set('().*{}+?[]^$\\\\!');\nconst regExpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n// any single thing other than /\nconst qmark = '[^/]';\n// * => any number of characters\nconst star = qmark + '*?';\n// use + when we need to ensure that *something* matches, because the * is\n// the only thing in the path portion.\nconst starNoEmpty = qmark + '+?';\n// remove the \\ chars that we added if we end up doing a nonmagic compare\n// const deslash = (s: string) => s.replace(/\\\\(.)/g, '$1')\nexport class AST {\n    type;\n    #root;\n    #hasMagic;\n    #uflag = false;\n    #parts = [];\n    #parent;\n    #parentIndex;\n    #negs;\n    #filledNegs = false;\n    #options;\n    #toString;\n    // set to true if it's an extglob with no children\n    // (which really means one child of '')\n    #emptyExt = false;\n    constructor(type, parent, options = {}) {\n        this.type = type;\n        // extglobs are inherently magical\n        if (type)\n            this.#hasMagic = true;\n        this.#parent = parent;\n        this.#root = this.#parent ? this.#parent.#root : this;\n        this.#options = this.#root === this ? options : this.#root.#options;\n        this.#negs = this.#root === this ? [] : this.#root.#negs;\n        if (type === '!' && !this.#root.#filledNegs)\n            this.#negs.push(this);\n        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;\n    }\n    get hasMagic() {\n        /* c8 ignore start */\n        if (this.#hasMagic !== undefined)\n            return this.#hasMagic;\n        /* c8 ignore stop */\n        for (const p of this.#parts) {\n            if (typeof p === 'string')\n                continue;\n            if (p.type || p.hasMagic)\n                return (this.#hasMagic = true);\n        }\n        // note: will be undefined until we generate the regexp src and find out\n        return this.#hasMagic;\n    }\n    // reconstructs the pattern\n    toString() {\n        if (this.#toString !== undefined)\n            return this.#toString;\n        if (!this.type) {\n            return (this.#toString = this.#parts.map(p => String(p)).join(''));\n        }\n        else {\n            return (this.#toString =\n                this.type + '(' + this.#parts.map(p => String(p)).join('|') + ')');\n        }\n    }\n    #fillNegs() {\n        /* c8 ignore start */\n        if (this !== this.#root)\n            throw new Error('should only call on root');\n        if (this.#filledNegs)\n            return this;\n        /* c8 ignore stop */\n        // call toString() once to fill this out\n        this.toString();\n        this.#filledNegs = true;\n        let n;\n        while ((n = this.#negs.pop())) {\n            if (n.type !== '!')\n                continue;\n            // walk up the tree, appending everthing that comes AFTER parentIndex\n            let p = n;\n            let pp = p.#parent;\n            while (pp) {\n                for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {\n                    for (const part of n.#parts) {\n                        /* c8 ignore start */\n                        if (typeof part === 'string') {\n                            throw new Error('string part in extglob AST??');\n                        }\n                        /* c8 ignore stop */\n                        part.copyIn(pp.#parts[i]);\n                    }\n                }\n                p = pp;\n                pp = p.#parent;\n            }\n        }\n        return this;\n    }\n    push(...parts) {\n        for (const p of parts) {\n            if (p === '')\n                continue;\n            /* c8 ignore start */\n            if (typeof p !== 'string' && !(p instanceof AST && p.#parent === this)) {\n                throw new Error('invalid part: ' + p);\n            }\n            /* c8 ignore stop */\n            this.#parts.push(p);\n        }\n    }\n    toJSON() {\n        const ret = this.type === null\n            ? this.#parts.slice().map(p => (typeof p === 'string' ? p : p.toJSON()))\n            : [this.type, ...this.#parts.map(p => p.toJSON())];\n        if (this.isStart() && !this.type)\n            ret.unshift([]);\n        if (this.isEnd() &&\n            (this === this.#root ||\n                (this.#root.#filledNegs && this.#parent?.type === '!'))) {\n            ret.push({});\n        }\n        return ret;\n    }\n    isStart() {\n        if (this.#root === this)\n            return true;\n        // if (this.type) return !!this.#parent?.isStart()\n        if (!this.#parent?.isStart())\n            return false;\n        if (this.#parentIndex === 0)\n            return true;\n        // if everything AHEAD of this is a negation, then it's still the \"start\"\n        const p = this.#parent;\n        for (let i = 0; i < this.#parentIndex; i++) {\n            const pp = p.#parts[i];\n            if (!(pp instanceof AST && pp.type === '!')) {\n                return false;\n            }\n        }\n        return true;\n    }\n    isEnd() {\n        if (this.#root === this)\n            return true;\n        if (this.#parent?.type === '!')\n            return true;\n        if (!this.#parent?.isEnd())\n            return false;\n        if (!this.type)\n            return this.#parent?.isEnd();\n        // if not root, it'll always have a parent\n        /* c8 ignore start */\n        const pl = this.#parent ? this.#parent.#parts.length : 0;\n        /* c8 ignore stop */\n        return this.#parentIndex === pl - 1;\n    }\n    copyIn(part) {\n        if (typeof part === 'string')\n            this.push(part);\n        else\n            this.push(part.clone(this));\n    }\n    clone(parent) {\n        const c = new AST(this.type, parent);\n        for (const p of this.#parts) {\n            c.copyIn(p);\n        }\n        return c;\n    }\n    static #parseAST(str, ast, pos, opt) {\n        let escaping = false;\n        let inBrace = false;\n        let braceStart = -1;\n        let braceNeg = false;\n        if (ast.type === null) {\n            // outside of a extglob, append until we find a start\n            let i = pos;\n            let acc = '';\n            while (i < str.length) {\n                const c = str.charAt(i++);\n                // still accumulate escapes at this point, but we do ignore\n                // starts that are escaped\n                if (escaping || c === '\\\\') {\n                    escaping = !escaping;\n                    acc += c;\n                    continue;\n                }\n                if (inBrace) {\n                    if (i === braceStart + 1) {\n                        if (c === '^' || c === '!') {\n                            braceNeg = true;\n                        }\n                    }\n                    else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {\n                        inBrace = false;\n                    }\n                    acc += c;\n                    continue;\n                }\n                else if (c === '[') {\n                    inBrace = true;\n                    braceStart = i;\n                    braceNeg = false;\n                    acc += c;\n                    continue;\n                }\n                if (!opt.noext && isExtglobType(c) && str.charAt(i) === '(') {\n                    ast.push(acc);\n                    acc = '';\n                    const ext = new AST(c, ast);\n                    i = AST.#parseAST(str, ext, i, opt);\n                    ast.push(ext);\n                    continue;\n                }\n                acc += c;\n            }\n            ast.push(acc);\n            return i;\n        }\n        // some kind of extglob, pos is at the (\n        // find the next | or )\n        let i = pos + 1;\n        let part = new AST(null, ast);\n        const parts = [];\n        let acc = '';\n        while (i < str.length) {\n            const c = str.charAt(i++);\n            // still accumulate escapes at this point, but we do ignore\n            // starts that are escaped\n            if (escaping || c === '\\\\') {\n                escaping = !escaping;\n                acc += c;\n                continue;\n            }\n            if (inBrace) {\n                if (i === braceStart + 1) {\n                    if (c === '^' || c === '!') {\n                        braceNeg = true;\n                    }\n                }\n                else if (c === ']' && !(i === braceStart + 2 && braceNeg)) {\n                    inBrace = false;\n                }\n                acc += c;\n                continue;\n            }\n            else if (c === '[') {\n                inBrace = true;\n                braceStart = i;\n                braceNeg = false;\n                acc += c;\n                continue;\n            }\n            if (isExtglobType(c) && str.charAt(i) === '(') {\n                part.push(acc);\n                acc = '';\n                const ext = new AST(c, part);\n                part.push(ext);\n                i = AST.#parseAST(str, ext, i, opt);\n                continue;\n            }\n            if (c === '|') {\n                part.push(acc);\n                acc = '';\n                parts.push(part);\n                part = new AST(null, ast);\n                continue;\n            }\n            if (c === ')') {\n                if (acc === '' && ast.#parts.length === 0) {\n                    ast.#emptyExt = true;\n                }\n                part.push(acc);\n                acc = '';\n                ast.push(...parts, part);\n                return i;\n            }\n            acc += c;\n        }\n        // unfinished extglob\n        // if we got here, it was a malformed extglob! not an extglob, but\n        // maybe something else in there.\n        ast.type = null;\n        ast.#hasMagic = undefined;\n        ast.#parts = [str.substring(pos - 1)];\n        return i;\n    }\n    static fromGlob(pattern, options = {}) {\n        const ast = new AST(null, undefined, options);\n        AST.#parseAST(pattern, ast, 0, options);\n        return ast;\n    }\n    // returns the regular expression if there's magic, or the unescaped\n    // string if not.\n    toMMPattern() {\n        // should only be called on root\n        /* c8 ignore start */\n        if (this !== this.#root)\n            return this.#root.toMMPattern();\n        /* c8 ignore stop */\n        const glob = this.toString();\n        const [re, body, hasMagic, uflag] = this.toRegExpSource();\n        // if we're in nocase mode, and not nocaseMagicOnly, then we do\n        // still need a regular expression if we have to case-insensitively\n        // match capital/lowercase characters.\n        const anyMagic = hasMagic ||\n            this.#hasMagic ||\n            (this.#options.nocase &&\n                !this.#options.nocaseMagicOnly &&\n                glob.toUpperCase() !== glob.toLowerCase());\n        if (!anyMagic) {\n            return body;\n        }\n        const flags = (this.#options.nocase ? 'i' : '') + (uflag ? 'u' : '');\n        return Object.assign(new RegExp(`^${re}$`, flags), {\n            _src: re,\n            _glob: glob,\n        });\n    }\n    get options() {\n        return this.#options;\n    }\n    // returns the string match, the regexp source, whether there's magic\n    // in the regexp (so a regular expression is required) and whether or\n    // not the uflag is needed for the regular expression (for posix classes)\n    // TODO: instead of injecting the start/end at this point, just return\n    // the BODY of the regexp, along with the start/end portions suitable\n    // for binding the start/end in either a joined full-path makeRe context\n    // (where we bind to (^|/), or a standalone matchPart context (where\n    // we bind to ^, and not /).  Otherwise slashes get duped!\n    //\n    // In part-matching mode, the start is:\n    // - if not isStart: nothing\n    // - if traversal possible, but not allowed: ^(?!\\.\\.?$)\n    // - if dots allowed or not possible: ^\n    // - if dots possible and not allowed: ^(?!\\.)\n    // end is:\n    // - if not isEnd(): nothing\n    // - else: $\n    //\n    // In full-path matching mode, we put the slash at the START of the\n    // pattern, so start is:\n    // - if first pattern: same as part-matching mode\n    // - if not isStart(): nothing\n    // - if traversal possible, but not allowed: /(?!\\.\\.?(?:$|/))\n    // - if dots allowed or not possible: /\n    // - if dots possible and not allowed: /(?!\\.)\n    // end is:\n    // - if last pattern, same as part-matching mode\n    // - else nothing\n    //\n    // Always put the (?:$|/) on negated tails, though, because that has to be\n    // there to bind the end of the negated pattern portion, and it's easier to\n    // just stick it in now rather than try to inject it later in the middle of\n    // the pattern.\n    //\n    // We can just always return the same end, and leave it up to the caller\n    // to know whether it's going to be used joined or in parts.\n    // And, if the start is adjusted slightly, can do the same there:\n    // - if not isStart: nothing\n    // - if traversal possible, but not allowed: (?:/|^)(?!\\.\\.?$)\n    // - if dots allowed or not possible: (?:/|^)\n    // - if dots possible and not allowed: (?:/|^)(?!\\.)\n    //\n    // But it's better to have a simpler binding without a conditional, for\n    // performance, so probably better to return both start options.\n    //\n    // Then the caller just ignores the end if it's not the first pattern,\n    // and the start always gets applied.\n    //\n    // But that's always going to be $ if it's the ending pattern, or nothing,\n    // so the caller can just attach $ at the end of the pattern when building.\n    //\n    // So the todo is:\n    // - better detect what kind of start is needed\n    // - return both flavors of starting pattern\n    // - attach $ at the end of the pattern when creating the actual RegExp\n    //\n    // Ah, but wait, no, that all only applies to the root when the first pattern\n    // is not an extglob. If the first pattern IS an extglob, then we need all\n    // that dot prevention biz to live in the extglob portions, because eg\n    // +(*|.x*) can match .xy but not .yx.\n    //\n    // So, return the two flavors if it's #root and the first child is not an\n    // AST, otherwise leave it to the child AST to handle it, and there,\n    // use the (?:^|/) style of start binding.\n    //\n    // Even simplified further:\n    // - Since the start for a join is eg /(?!\\.) and the start for a part\n    // is ^(?!\\.), we can just prepend (?!\\.) to the pattern (either root\n    // or start or whatever) and prepend ^ or / at the Regexp construction.\n    toRegExpSource(allowDot) {\n        const dot = allowDot ?? !!this.#options.dot;\n        if (this.#root === this)\n            this.#fillNegs();\n        if (!this.type) {\n            const noEmpty = this.isStart() && this.isEnd();\n            const src = this.#parts\n                .map(p => {\n                const [re, _, hasMagic, uflag] = typeof p === 'string'\n                    ? AST.#parseGlob(p, this.#hasMagic, noEmpty)\n                    : p.toRegExpSource(allowDot);\n                this.#hasMagic = this.#hasMagic || hasMagic;\n                this.#uflag = this.#uflag || uflag;\n                return re;\n            })\n                .join('');\n            let start = '';\n            if (this.isStart()) {\n                if (typeof this.#parts[0] === 'string') {\n                    // this is the string that will match the start of the pattern,\n                    // so we need to protect against dots and such.\n                    // '.' and '..' cannot match unless the pattern is that exactly,\n                    // even if it starts with . or dot:true is set.\n                    const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);\n                    if (!dotTravAllowed) {\n                        const aps = addPatternStart;\n                        // check if we have a possibility of matching . or ..,\n                        // and prevent that.\n                        const needNoTrav = \n                        // dots are allowed, and the pattern starts with [ or .\n                        (dot && aps.has(src.charAt(0))) ||\n                            // the pattern starts with \\., and then [ or .\n                            (src.startsWith('\\\\.') && aps.has(src.charAt(2))) ||\n                            // the pattern starts with \\.\\., and then [ or .\n                            (src.startsWith('\\\\.\\\\.') && aps.has(src.charAt(4)));\n                        // no need to prevent dots if it can't match a dot, or if a\n                        // sub-pattern will be preventing it anyway.\n                        const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));\n                        start = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : '';\n                    }\n                }\n            }\n            // append the \"end of path portion\" pattern to negation tails\n            let end = '';\n            if (this.isEnd() &&\n                this.#root.#filledNegs &&\n                this.#parent?.type === '!') {\n                end = '(?:$|\\\\/)';\n            }\n            const final = start + src + end;\n            return [\n                final,\n                unescape(src),\n                (this.#hasMagic = !!this.#hasMagic),\n                this.#uflag,\n            ];\n        }\n        // We need to calculate the body *twice* if it's a repeat pattern\n        // at the start, once in nodot mode, then again in dot mode, so a\n        // pattern like *(?) can match 'x.y'\n        const repeated = this.type === '*' || this.type === '+';\n        // some kind of extglob\n        const start = this.type === '!' ? '(?:(?!(?:' : '(?:';\n        let body = this.#partsToRegExp(dot);\n        if (this.isStart() && this.isEnd() && !body && this.type !== '!') {\n            // invalid extglob, has to at least be *something* present, if it's\n            // the entire path portion.\n            const s = this.toString();\n            this.#parts = [s];\n            this.type = null;\n            this.#hasMagic = undefined;\n            return [s, unescape(this.toString()), false, false];\n        }\n        // XXX abstract out this map method\n        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot\n            ? ''\n            : this.#partsToRegExp(true);\n        if (bodyDotAllowed === body) {\n            bodyDotAllowed = '';\n        }\n        if (bodyDotAllowed) {\n            body = `(?:${body})(?:${bodyDotAllowed})*?`;\n        }\n        // an empty !() is exactly equivalent to a starNoEmpty\n        let final = '';\n        if (this.type === '!' && this.#emptyExt) {\n            final = (this.isStart() && !dot ? startNoDot : '') + starNoEmpty;\n        }\n        else {\n            const close = this.type === '!'\n                ? // !() must match something,but !(x) can match ''\n                    '))' +\n                        (this.isStart() && !dot && !allowDot ? startNoDot : '') +\n                        star +\n                        ')'\n                : this.type === '@'\n                    ? ')'\n                    : this.type === '?'\n                        ? ')?'\n                        : this.type === '+' && bodyDotAllowed\n                            ? ')'\n                            : this.type === '*' && bodyDotAllowed\n                                ? `)?`\n                                : `)${this.type}`;\n            final = start + body + close;\n        }\n        return [\n            final,\n            unescape(body),\n            (this.#hasMagic = !!this.#hasMagic),\n            this.#uflag,\n        ];\n    }\n    #partsToRegExp(dot) {\n        return this.#parts\n            .map(p => {\n            // extglob ASTs should only contain parent ASTs\n            /* c8 ignore start */\n            if (typeof p === 'string') {\n                throw new Error('string type in extglob ast??');\n            }\n            /* c8 ignore stop */\n            // can ignore hasMagic, because extglobs are already always magic\n            const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);\n            this.#uflag = this.#uflag || uflag;\n            return re;\n        })\n            .filter(p => !(this.isStart() && this.isEnd()) || !!p)\n            .join('|');\n    }\n    static #parseGlob(glob, hasMagic, noEmpty = false) {\n        let escaping = false;\n        let re = '';\n        let uflag = false;\n        for (let i = 0; i < glob.length; i++) {\n            const c = glob.charAt(i);\n            if (escaping) {\n                escaping = false;\n                re += (reSpecials.has(c) ? '\\\\' : '') + c;\n                continue;\n            }\n            if (c === '\\\\') {\n                if (i === glob.length - 1) {\n                    re += '\\\\\\\\';\n                }\n                else {\n                    escaping = true;\n                }\n                continue;\n            }\n            if (c === '[') {\n                const [src, needUflag, consumed, magic] = parseClass(glob, i);\n                if (consumed) {\n                    re += src;\n                    uflag = uflag || needUflag;\n                    i += consumed - 1;\n                    hasMagic = hasMagic || magic;\n                    continue;\n                }\n            }\n            if (c === '*') {\n                if (noEmpty && glob === '*')\n                    re += starNoEmpty;\n                else\n                    re += star;\n                hasMagic = true;\n                continue;\n            }\n            if (c === '?') {\n                re += qmark;\n                hasMagic = true;\n                continue;\n            }\n            re += regExpEscape(c);\n        }\n        return [re, unescape(glob), !!hasMagic, uflag];\n    }\n}\n//# sourceMappingURL=ast.js.map","/**\n * Escape all magic characters in a glob pattern.\n *\n * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}\n * option is used, then characters are escaped by wrapping in `[]`, because\n * a magic character wrapped in a character class can only be satisfied by\n * that exact character.  In this mode, `\\` is _not_ escaped, because it is\n * not interpreted as a magic character, but instead as a path separator.\n */\nexport const escape = (s, { windowsPathsNoEscape = false, } = {}) => {\n    // don't need to escape +@! because we escape the parens\n    // that make those magic, and escaping ! as [!] isn't valid,\n    // because [!]] is a valid glob class meaning not ']'.\n    return windowsPathsNoEscape\n        ? s.replace(/[?*()[\\]]/g, '[$&]')\n        : s.replace(/[?*()[\\]\\\\]/g, '\\\\$&');\n};\n//# sourceMappingURL=escape.js.map","import { expand } from '@isaacs/brace-expansion';\nimport { assertValidPattern } from './assert-valid-pattern.js';\nimport { AST } from './ast.js';\nimport { escape } from './escape.js';\nimport { unescape } from './unescape.js';\nexport const minimatch = (p, pattern, options = {}) => {\n    assertValidPattern(pattern);\n    // shortcut: comments match nothing.\n    if (!options.nocomment && pattern.charAt(0) === '#') {\n        return false;\n    }\n    return new Minimatch(pattern, options).match(p);\n};\n// Optimized checking for the most common glob patterns.\nconst starDotExtRE = /^\\*+([^+@!?\\*\\[\\(]*)$/;\nconst starDotExtTest = (ext) => (f) => !f.startsWith('.') && f.endsWith(ext);\nconst starDotExtTestDot = (ext) => (f) => f.endsWith(ext);\nconst starDotExtTestNocase = (ext) => {\n    ext = ext.toLowerCase();\n    return (f) => !f.startsWith('.') && f.toLowerCase().endsWith(ext);\n};\nconst starDotExtTestNocaseDot = (ext) => {\n    ext = ext.toLowerCase();\n    return (f) => f.toLowerCase().endsWith(ext);\n};\nconst starDotStarRE = /^\\*+\\.\\*+$/;\nconst starDotStarTest = (f) => !f.startsWith('.') && f.includes('.');\nconst starDotStarTestDot = (f) => f !== '.' && f !== '..' && f.includes('.');\nconst dotStarRE = /^\\.\\*+$/;\nconst dotStarTest = (f) => f !== '.' && f !== '..' && f.startsWith('.');\nconst starRE = /^\\*+$/;\nconst starTest = (f) => f.length !== 0 && !f.startsWith('.');\nconst starTestDot = (f) => f.length !== 0 && f !== '.' && f !== '..';\nconst qmarksRE = /^\\?+([^+@!?\\*\\[\\(]*)?$/;\nconst qmarksTestNocase = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExt([$0]);\n    if (!ext)\n        return noext;\n    ext = ext.toLowerCase();\n    return (f) => noext(f) && f.toLowerCase().endsWith(ext);\n};\nconst qmarksTestNocaseDot = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExtDot([$0]);\n    if (!ext)\n        return noext;\n    ext = ext.toLowerCase();\n    return (f) => noext(f) && f.toLowerCase().endsWith(ext);\n};\nconst qmarksTestDot = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExtDot([$0]);\n    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);\n};\nconst qmarksTest = ([$0, ext = '']) => {\n    const noext = qmarksTestNoExt([$0]);\n    return !ext ? noext : (f) => noext(f) && f.endsWith(ext);\n};\nconst qmarksTestNoExt = ([$0]) => {\n    const len = $0.length;\n    return (f) => f.length === len && !f.startsWith('.');\n};\nconst qmarksTestNoExtDot = ([$0]) => {\n    const len = $0.length;\n    return (f) => f.length === len && f !== '.' && f !== '..';\n};\n/* c8 ignore start */\nconst defaultPlatform = (typeof process === 'object' && process\n    ? (typeof process.env === 'object' &&\n        process.env &&\n        process.env.__MINIMATCH_TESTING_PLATFORM__) ||\n        process.platform\n    : 'posix');\nconst path = {\n    win32: { sep: '\\\\' },\n    posix: { sep: '/' },\n};\n/* c8 ignore stop */\nexport const sep = defaultPlatform === 'win32' ? path.win32.sep : path.posix.sep;\nminimatch.sep = sep;\nexport const GLOBSTAR = Symbol('globstar **');\nminimatch.GLOBSTAR = GLOBSTAR;\n// any single thing other than /\n// don't need to escape / when using new RegExp()\nconst qmark = '[^/]';\n// * => any number of characters\nconst star = qmark + '*?';\n// ** when dots are allowed.  Anything goes, except .. and .\n// not (^ or / followed by one or two dots followed by $ or /),\n// followed by anything, any number of times.\nconst twoStarDot = '(?:(?!(?:\\\\/|^)(?:\\\\.{1,2})($|\\\\/)).)*?';\n// not a ^ or / followed by a dot,\n// followed by anything, any number of times.\nconst twoStarNoDot = '(?:(?!(?:\\\\/|^)\\\\.).)*?';\nexport const filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);\nminimatch.filter = filter;\nconst ext = (a, b = {}) => Object.assign({}, a, b);\nexport const defaults = (def) => {\n    if (!def || typeof def !== 'object' || !Object.keys(def).length) {\n        return minimatch;\n    }\n    const orig = minimatch;\n    const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));\n    return Object.assign(m, {\n        Minimatch: class Minimatch extends orig.Minimatch {\n            constructor(pattern, options = {}) {\n                super(pattern, ext(def, options));\n            }\n            static defaults(options) {\n                return orig.defaults(ext(def, options)).Minimatch;\n            }\n        },\n        AST: class AST extends orig.AST {\n            /* c8 ignore start */\n            constructor(type, parent, options = {}) {\n                super(type, parent, ext(def, options));\n            }\n            /* c8 ignore stop */\n            static fromGlob(pattern, options = {}) {\n                return orig.AST.fromGlob(pattern, ext(def, options));\n            }\n        },\n        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),\n        escape: (s, options = {}) => orig.escape(s, ext(def, options)),\n        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),\n        defaults: (options) => orig.defaults(ext(def, options)),\n        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),\n        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),\n        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),\n        sep: orig.sep,\n        GLOBSTAR: GLOBSTAR,\n    });\n};\nminimatch.defaults = defaults;\n// Brace expansion:\n// a{b,c}d -> abd acd\n// a{b,}c -> abc ac\n// a{0..3}d -> a0d a1d a2d a3d\n// a{b,c{d,e}f}g -> abg acdfg acefg\n// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg\n//\n// Invalid sets are not expanded.\n// a{2..}b -> a{2..}b\n// a{b}c -> a{b}c\nexport const braceExpand = (pattern, options = {}) => {\n    assertValidPattern(pattern);\n    // Thanks to Yeting Li <https://github.com/yetingli> for\n    // improving this regexp to avoid a ReDOS vulnerability.\n    if (options.nobrace || !/\\{(?:(?!\\{).)*\\}/.test(pattern)) {\n        // shortcut. no need to expand.\n        return [pattern];\n    }\n    return expand(pattern);\n};\nminimatch.braceExpand = braceExpand;\n// parse a component of the expanded set.\n// At this point, no pattern may contain \"/\" in it\n// so we're going to return a 2d array, where each entry is the full\n// pattern, split on '/', and then turned into a regular expression.\n// A regexp is made at the end which joins each array with an\n// escaped /, and another full one which joins each regexp with |.\n//\n// Following the lead of Bash 4.1, note that \"**\" only has special meaning\n// when it is the *only* thing in a path portion.  Otherwise, any series\n// of * is equivalent to a single *.  Globstar behavior is enabled by\n// default, and can be disabled by setting options.noglobstar.\nexport const makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();\nminimatch.makeRe = makeRe;\nexport const match = (list, pattern, options = {}) => {\n    const mm = new Minimatch(pattern, options);\n    list = list.filter(f => mm.match(f));\n    if (mm.options.nonull && !list.length) {\n        list.push(pattern);\n    }\n    return list;\n};\nminimatch.match = match;\n// replace stuff like \\* with *\nconst globMagic = /[?*]|[+@!]\\(.*?\\)|\\[|\\]/;\nconst regExpEscape = (s) => s.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\nexport class Minimatch {\n    options;\n    set;\n    pattern;\n    windowsPathsNoEscape;\n    nonegate;\n    negate;\n    comment;\n    empty;\n    preserveMultipleSlashes;\n    partial;\n    globSet;\n    globParts;\n    nocase;\n    isWindows;\n    platform;\n    windowsNoMagicRoot;\n    regexp;\n    constructor(pattern, options = {}) {\n        assertValidPattern(pattern);\n        options = options || {};\n        this.options = options;\n        this.pattern = pattern;\n        this.platform = options.platform || defaultPlatform;\n        this.isWindows = this.platform === 'win32';\n        this.windowsPathsNoEscape =\n            !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;\n        if (this.windowsPathsNoEscape) {\n            this.pattern = this.pattern.replace(/\\\\/g, '/');\n        }\n        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;\n        this.regexp = null;\n        this.negate = false;\n        this.nonegate = !!options.nonegate;\n        this.comment = false;\n        this.empty = false;\n        this.partial = !!options.partial;\n        this.nocase = !!this.options.nocase;\n        this.windowsNoMagicRoot =\n            options.windowsNoMagicRoot !== undefined\n                ? options.windowsNoMagicRoot\n                : !!(this.isWindows && this.nocase);\n        this.globSet = [];\n        this.globParts = [];\n        this.set = [];\n        // make the set of regexps etc.\n        this.make();\n    }\n    hasMagic() {\n        if (this.options.magicalBraces && this.set.length > 1) {\n            return true;\n        }\n        for (const pattern of this.set) {\n            for (const part of pattern) {\n                if (typeof part !== 'string')\n                    return true;\n            }\n        }\n        return false;\n    }\n    debug(..._) { }\n    make() {\n        const pattern = this.pattern;\n        const options = this.options;\n        // empty patterns and comments match nothing.\n        if (!options.nocomment && pattern.charAt(0) === '#') {\n            this.comment = true;\n            return;\n        }\n        if (!pattern) {\n            this.empty = true;\n            return;\n        }\n        // step 1: figure out negation, etc.\n        this.parseNegate();\n        // step 2: expand braces\n        this.globSet = [...new Set(this.braceExpand())];\n        if (options.debug) {\n            this.debug = (...args) => console.error(...args);\n        }\n        this.debug(this.pattern, this.globSet);\n        // step 3: now we have a set, so turn each one into a series of\n        // path-portion matching patterns.\n        // These will be regexps, except in the case of \"**\", which is\n        // set to the GLOBSTAR object for globstar behavior,\n        // and will not contain any / characters\n        //\n        // First, we preprocess to make the glob pattern sets a bit simpler\n        // and deduped.  There are some perf-killing patterns that can cause\n        // problems with a glob walk, but we can simplify them down a bit.\n        const rawGlobParts = this.globSet.map(s => this.slashSplit(s));\n        this.globParts = this.preprocess(rawGlobParts);\n        this.debug(this.pattern, this.globParts);\n        // glob --> regexps\n        let set = this.globParts.map((s, _, __) => {\n            if (this.isWindows && this.windowsNoMagicRoot) {\n                // check if it's a drive or unc path.\n                const isUNC = s[0] === '' &&\n                    s[1] === '' &&\n                    (s[2] === '?' || !globMagic.test(s[2])) &&\n                    !globMagic.test(s[3]);\n                const isDrive = /^[a-z]:/i.test(s[0]);\n                if (isUNC) {\n                    return [...s.slice(0, 4), ...s.slice(4).map(ss => this.parse(ss))];\n                }\n                else if (isDrive) {\n                    return [s[0], ...s.slice(1).map(ss => this.parse(ss))];\n                }\n            }\n            return s.map(ss => this.parse(ss));\n        });\n        this.debug(this.pattern, set);\n        // filter out everything that didn't compile properly.\n        this.set = set.filter(s => s.indexOf(false) === -1);\n        // do not treat the ? in UNC paths as magic\n        if (this.isWindows) {\n            for (let i = 0; i < this.set.length; i++) {\n                const p = this.set[i];\n                if (p[0] === '' &&\n                    p[1] === '' &&\n                    this.globParts[i][2] === '?' &&\n                    typeof p[3] === 'string' &&\n                    /^[a-z]:$/i.test(p[3])) {\n                    p[2] = '?';\n                }\n            }\n        }\n        this.debug(this.pattern, this.set);\n    }\n    // various transforms to equivalent pattern sets that are\n    // faster to process in a filesystem walk.  The goal is to\n    // eliminate what we can, and push all ** patterns as far\n    // to the right as possible, even if it increases the number\n    // of patterns that we have to process.\n    preprocess(globParts) {\n        // if we're not in globstar mode, then turn all ** into *\n        if (this.options.noglobstar) {\n            for (let i = 0; i < globParts.length; i++) {\n                for (let j = 0; j < globParts[i].length; j++) {\n                    if (globParts[i][j] === '**') {\n                        globParts[i][j] = '*';\n                    }\n                }\n            }\n        }\n        const { optimizationLevel = 1 } = this.options;\n        if (optimizationLevel >= 2) {\n            // aggressive optimization for the purpose of fs walking\n            globParts = this.firstPhasePreProcess(globParts);\n            globParts = this.secondPhasePreProcess(globParts);\n        }\n        else if (optimizationLevel >= 1) {\n            // just basic optimizations to remove some .. parts\n            globParts = this.levelOneOptimize(globParts);\n        }\n        else {\n            // just collapse multiple ** portions into one\n            globParts = this.adjascentGlobstarOptimize(globParts);\n        }\n        return globParts;\n    }\n    // just get rid of adjascent ** portions\n    adjascentGlobstarOptimize(globParts) {\n        return globParts.map(parts => {\n            let gs = -1;\n            while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n                let i = gs;\n                while (parts[i + 1] === '**') {\n                    i++;\n                }\n                if (i !== gs) {\n                    parts.splice(gs, i - gs);\n                }\n            }\n            return parts;\n        });\n    }\n    // get rid of adjascent ** and resolve .. portions\n    levelOneOptimize(globParts) {\n        return globParts.map(parts => {\n            parts = parts.reduce((set, part) => {\n                const prev = set[set.length - 1];\n                if (part === '**' && prev === '**') {\n                    return set;\n                }\n                if (part === '..') {\n                    if (prev && prev !== '..' && prev !== '.' && prev !== '**') {\n                        set.pop();\n                        return set;\n                    }\n                }\n                set.push(part);\n                return set;\n            }, []);\n            return parts.length === 0 ? [''] : parts;\n        });\n    }\n    levelTwoFileOptimize(parts) {\n        if (!Array.isArray(parts)) {\n            parts = this.slashSplit(parts);\n        }\n        let didSomething = false;\n        do {\n            didSomething = false;\n            // <pre>/<e>/<rest> -> <pre>/<rest>\n            if (!this.preserveMultipleSlashes) {\n                for (let i = 1; i < parts.length - 1; i++) {\n                    const p = parts[i];\n                    // don't squeeze out UNC patterns\n                    if (i === 1 && p === '' && parts[0] === '')\n                        continue;\n                    if (p === '.' || p === '') {\n                        didSomething = true;\n                        parts.splice(i, 1);\n                        i--;\n                    }\n                }\n                if (parts[0] === '.' &&\n                    parts.length === 2 &&\n                    (parts[1] === '.' || parts[1] === '')) {\n                    didSomething = true;\n                    parts.pop();\n                }\n            }\n            // <pre>/<p>/../<rest> -> <pre>/<rest>\n            let dd = 0;\n            while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n                const p = parts[dd - 1];\n                if (p && p !== '.' && p !== '..' && p !== '**') {\n                    didSomething = true;\n                    parts.splice(dd - 1, 2);\n                    dd -= 2;\n                }\n            }\n        } while (didSomething);\n        return parts.length === 0 ? [''] : parts;\n    }\n    // First phase: single-pattern processing\n    // <pre> is 1 or more portions\n    // <rest> is 1 or more portions\n    // <p> is any portion other than ., .., '', or **\n    // <e> is . or ''\n    //\n    // **/.. is *brutal* for filesystem walking performance, because\n    // it effectively resets the recursive walk each time it occurs,\n    // and ** cannot be reduced out by a .. pattern part like a regexp\n    // or most strings (other than .., ., and '') can be.\n    //\n    // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\n    // <pre>/<e>/<rest> -> <pre>/<rest>\n    // <pre>/<p>/../<rest> -> <pre>/<rest>\n    // **/**/<rest> -> **/<rest>\n    //\n    // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow\n    // this WOULD be allowed if ** did follow symlinks, or * didn't\n    firstPhasePreProcess(globParts) {\n        let didSomething = false;\n        do {\n            didSomething = false;\n            // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}\n            for (let parts of globParts) {\n                let gs = -1;\n                while (-1 !== (gs = parts.indexOf('**', gs + 1))) {\n                    let gss = gs;\n                    while (parts[gss + 1] === '**') {\n                        // <pre>/**/**/<rest> -> <pre>/**/<rest>\n                        gss++;\n                    }\n                    // eg, if gs is 2 and gss is 4, that means we have 3 **\n                    // parts, and can remove 2 of them.\n                    if (gss > gs) {\n                        parts.splice(gs + 1, gss - gs);\n                    }\n                    let next = parts[gs + 1];\n                    const p = parts[gs + 2];\n                    const p2 = parts[gs + 3];\n                    if (next !== '..')\n                        continue;\n                    if (!p ||\n                        p === '.' ||\n                        p === '..' ||\n                        !p2 ||\n                        p2 === '.' ||\n                        p2 === '..') {\n                        continue;\n                    }\n                    didSomething = true;\n                    // edit parts in place, and push the new one\n                    parts.splice(gs, 1);\n                    const other = parts.slice(0);\n                    other[gs] = '**';\n                    globParts.push(other);\n                    gs--;\n                }\n                // <pre>/<e>/<rest> -> <pre>/<rest>\n                if (!this.preserveMultipleSlashes) {\n                    for (let i = 1; i < parts.length - 1; i++) {\n                        const p = parts[i];\n                        // don't squeeze out UNC patterns\n                        if (i === 1 && p === '' && parts[0] === '')\n                            continue;\n                        if (p === '.' || p === '') {\n                            didSomething = true;\n                            parts.splice(i, 1);\n                            i--;\n                        }\n                    }\n                    if (parts[0] === '.' &&\n                        parts.length === 2 &&\n                        (parts[1] === '.' || parts[1] === '')) {\n                        didSomething = true;\n                        parts.pop();\n                    }\n                }\n                // <pre>/<p>/../<rest> -> <pre>/<rest>\n                let dd = 0;\n                while (-1 !== (dd = parts.indexOf('..', dd + 1))) {\n                    const p = parts[dd - 1];\n                    if (p && p !== '.' && p !== '..' && p !== '**') {\n                        didSomething = true;\n                        const needDot = dd === 1 && parts[dd + 1] === '**';\n                        const splin = needDot ? ['.'] : [];\n                        parts.splice(dd - 1, 2, ...splin);\n                        if (parts.length === 0)\n                            parts.push('');\n                        dd -= 2;\n                    }\n                }\n            }\n        } while (didSomething);\n        return globParts;\n    }\n    // second phase: multi-pattern dedupes\n    // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>\n    // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>\n    // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>\n    //\n    // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>\n    // ^-- not valid because ** doens't follow symlinks\n    secondPhasePreProcess(globParts) {\n        for (let i = 0; i < globParts.length - 1; i++) {\n            for (let j = i + 1; j < globParts.length; j++) {\n                const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);\n                if (matched) {\n                    globParts[i] = [];\n                    globParts[j] = matched;\n                    break;\n                }\n            }\n        }\n        return globParts.filter(gs => gs.length);\n    }\n    partsMatch(a, b, emptyGSMatch = false) {\n        let ai = 0;\n        let bi = 0;\n        let result = [];\n        let which = '';\n        while (ai < a.length && bi < b.length) {\n            if (a[ai] === b[bi]) {\n                result.push(which === 'b' ? b[bi] : a[ai]);\n                ai++;\n                bi++;\n            }\n            else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {\n                result.push(a[ai]);\n                ai++;\n            }\n            else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {\n                result.push(b[bi]);\n                bi++;\n            }\n            else if (a[ai] === '*' &&\n                b[bi] &&\n                (this.options.dot || !b[bi].startsWith('.')) &&\n                b[bi] !== '**') {\n                if (which === 'b')\n                    return false;\n                which = 'a';\n                result.push(a[ai]);\n                ai++;\n                bi++;\n            }\n            else if (b[bi] === '*' &&\n                a[ai] &&\n                (this.options.dot || !a[ai].startsWith('.')) &&\n                a[ai] !== '**') {\n                if (which === 'a')\n                    return false;\n                which = 'b';\n                result.push(b[bi]);\n                ai++;\n                bi++;\n            }\n            else {\n                return false;\n            }\n        }\n        // if we fall out of the loop, it means they two are identical\n        // as long as their lengths match\n        return a.length === b.length && result;\n    }\n    parseNegate() {\n        if (this.nonegate)\n            return;\n        const pattern = this.pattern;\n        let negate = false;\n        let negateOffset = 0;\n        for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {\n            negate = !negate;\n            negateOffset++;\n        }\n        if (negateOffset)\n            this.pattern = pattern.slice(negateOffset);\n        this.negate = negate;\n    }\n    // set partial to true to test if, for example,\n    // \"/a/b\" matches the start of \"/*/b/*/d\"\n    // Partial means, if you run out of file before you run\n    // out of pattern, then that's fine, as long as all\n    // the parts match.\n    matchOne(file, pattern, partial = false) {\n        const options = this.options;\n        // UNC paths like //?/X:/... can match X:/... and vice versa\n        // Drive letters in absolute drive or unc paths are always compared\n        // case-insensitively.\n        if (this.isWindows) {\n            const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);\n            const fileUNC = !fileDrive &&\n                file[0] === '' &&\n                file[1] === '' &&\n                file[2] === '?' &&\n                /^[a-z]:$/i.test(file[3]);\n            const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);\n            const patternUNC = !patternDrive &&\n                pattern[0] === '' &&\n                pattern[1] === '' &&\n                pattern[2] === '?' &&\n                typeof pattern[3] === 'string' &&\n                /^[a-z]:$/i.test(pattern[3]);\n            const fdi = fileUNC ? 3 : fileDrive ? 0 : undefined;\n            const pdi = patternUNC ? 3 : patternDrive ? 0 : undefined;\n            if (typeof fdi === 'number' && typeof pdi === 'number') {\n                const [fd, pd] = [file[fdi], pattern[pdi]];\n                if (fd.toLowerCase() === pd.toLowerCase()) {\n                    pattern[pdi] = fd;\n                    if (pdi > fdi) {\n                        pattern = pattern.slice(pdi);\n                    }\n                    else if (fdi > pdi) {\n                        file = file.slice(fdi);\n                    }\n                }\n            }\n        }\n        // resolve and reduce . and .. portions in the file as well.\n        // dont' need to do the second phase, because it's only one string[]\n        const { optimizationLevel = 1 } = this.options;\n        if (optimizationLevel >= 2) {\n            file = this.levelTwoFileOptimize(file);\n        }\n        this.debug('matchOne', this, { file, pattern });\n        this.debug('matchOne', file.length, pattern.length);\n        for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {\n            this.debug('matchOne loop');\n            var p = pattern[pi];\n            var f = file[fi];\n            this.debug(pattern, p, f);\n            // should be impossible.\n            // some invalid regexp stuff in the set.\n            /* c8 ignore start */\n            if (p === false) {\n                return false;\n            }\n            /* c8 ignore stop */\n            if (p === GLOBSTAR) {\n                this.debug('GLOBSTAR', [pattern, p, f]);\n                // \"**\"\n                // a/**/b/**/c would match the following:\n                // a/b/x/y/z/c\n                // a/x/y/z/b/c\n                // a/b/x/b/x/c\n                // a/b/c\n                // To do this, take the rest of the pattern after\n                // the **, and see if it would match the file remainder.\n                // If so, return success.\n                // If not, the ** \"swallows\" a segment, and try again.\n                // This is recursively awful.\n                //\n                // a/**/b/**/c matching a/b/x/y/z/c\n                // - a matches a\n                // - doublestar\n                //   - matchOne(b/x/y/z/c, b/**/c)\n                //     - b matches b\n                //     - doublestar\n                //       - matchOne(x/y/z/c, c) -> no\n                //       - matchOne(y/z/c, c) -> no\n                //       - matchOne(z/c, c) -> no\n                //       - matchOne(c, c) yes, hit\n                var fr = fi;\n                var pr = pi + 1;\n                if (pr === pl) {\n                    this.debug('** at the end');\n                    // a ** at the end will just swallow the rest.\n                    // We have found a match.\n                    // however, it will not swallow /.x, unless\n                    // options.dot is set.\n                    // . and .. are *never* matched by **, for explosively\n                    // exponential reasons.\n                    for (; fi < fl; fi++) {\n                        if (file[fi] === '.' ||\n                            file[fi] === '..' ||\n                            (!options.dot && file[fi].charAt(0) === '.'))\n                            return false;\n                    }\n                    return true;\n                }\n                // ok, let's see if we can swallow whatever we can.\n                while (fr < fl) {\n                    var swallowee = file[fr];\n                    this.debug('\\nglobstar while', file, fr, pattern, pr, swallowee);\n                    // XXX remove this slice.  Just pass the start index.\n                    if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {\n                        this.debug('globstar found match!', fr, fl, swallowee);\n                        // found a match.\n                        return true;\n                    }\n                    else {\n                        // can't swallow \".\" or \"..\" ever.\n                        // can only swallow \".foo\" when explicitly asked.\n                        if (swallowee === '.' ||\n                            swallowee === '..' ||\n                            (!options.dot && swallowee.charAt(0) === '.')) {\n                            this.debug('dot detected!', file, fr, pattern, pr);\n                            break;\n                        }\n                        // ** swallows a segment, and continue.\n                        this.debug('globstar swallow a segment, and continue');\n                        fr++;\n                    }\n                }\n                // no match was found.\n                // However, in partial mode, we can't say this is necessarily over.\n                /* c8 ignore start */\n                if (partial) {\n                    // ran out of file\n                    this.debug('\\n>>> no match, partial?', file, fr, pattern, pr);\n                    if (fr === fl) {\n                        return true;\n                    }\n                }\n                /* c8 ignore stop */\n                return false;\n            }\n            // something other than **\n            // non-magic patterns just have to match exactly\n            // patterns with magic have been turned into regexps.\n            let hit;\n            if (typeof p === 'string') {\n                hit = f === p;\n                this.debug('string match', p, f, hit);\n            }\n            else {\n                hit = p.test(f);\n                this.debug('pattern match', p, f, hit);\n            }\n            if (!hit)\n                return false;\n        }\n        // Note: ending in / means that we'll get a final \"\"\n        // at the end of the pattern.  This can only match a\n        // corresponding \"\" at the end of the file.\n        // If the file ends in /, then it can only match a\n        // a pattern that ends in /, unless the pattern just\n        // doesn't have any more for it. But, a/b/ should *not*\n        // match \"a/b/*\", even though \"\" matches against the\n        // [^/]*? pattern, except in partial mode, where it might\n        // simply not be reached yet.\n        // However, a/b/ should still satisfy a/*\n        // now either we fell off the end of the pattern, or we're done.\n        if (fi === fl && pi === pl) {\n            // ran out of pattern and filename at the same time.\n            // an exact hit!\n            return true;\n        }\n        else if (fi === fl) {\n            // ran out of file, but still had pattern left.\n            // this is ok if we're doing the match as part of\n            // a glob fs traversal.\n            return partial;\n        }\n        else if (pi === pl) {\n            // ran out of pattern, still have file left.\n            // this is only acceptable if we're on the very last\n            // empty segment of a file with a trailing slash.\n            // a/* should match a/b/\n            return fi === fl - 1 && file[fi] === '';\n            /* c8 ignore start */\n        }\n        else {\n            // should be unreachable.\n            throw new Error('wtf?');\n        }\n        /* c8 ignore stop */\n    }\n    braceExpand() {\n        return braceExpand(this.pattern, this.options);\n    }\n    parse(pattern) {\n        assertValidPattern(pattern);\n        const options = this.options;\n        // shortcuts\n        if (pattern === '**')\n            return GLOBSTAR;\n        if (pattern === '')\n            return '';\n        // far and away, the most common glob pattern parts are\n        // *, *.*, and *.<ext>  Add a fast check method for those.\n        let m;\n        let fastTest = null;\n        if ((m = pattern.match(starRE))) {\n            fastTest = options.dot ? starTestDot : starTest;\n        }\n        else if ((m = pattern.match(starDotExtRE))) {\n            fastTest = (options.nocase\n                ? options.dot\n                    ? starDotExtTestNocaseDot\n                    : starDotExtTestNocase\n                : options.dot\n                    ? starDotExtTestDot\n                    : starDotExtTest)(m[1]);\n        }\n        else if ((m = pattern.match(qmarksRE))) {\n            fastTest = (options.nocase\n                ? options.dot\n                    ? qmarksTestNocaseDot\n                    : qmarksTestNocase\n                : options.dot\n                    ? qmarksTestDot\n                    : qmarksTest)(m);\n        }\n        else if ((m = pattern.match(starDotStarRE))) {\n            fastTest = options.dot ? starDotStarTestDot : starDotStarTest;\n        }\n        else if ((m = pattern.match(dotStarRE))) {\n            fastTest = dotStarTest;\n        }\n        const re = AST.fromGlob(pattern, this.options).toMMPattern();\n        if (fastTest && typeof re === 'object') {\n            // Avoids overriding in frozen environments\n            Reflect.defineProperty(re, 'test', { value: fastTest });\n        }\n        return re;\n    }\n    makeRe() {\n        if (this.regexp || this.regexp === false)\n            return this.regexp;\n        // at this point, this.set is a 2d array of partial\n        // pattern strings, or \"**\".\n        //\n        // It's better to use .match().  This function shouldn't\n        // be used, really, but it's pretty convenient sometimes,\n        // when you just want to work with a regex.\n        const set = this.set;\n        if (!set.length) {\n            this.regexp = false;\n            return this.regexp;\n        }\n        const options = this.options;\n        const twoStar = options.noglobstar\n            ? star\n            : options.dot\n                ? twoStarDot\n                : twoStarNoDot;\n        const flags = new Set(options.nocase ? ['i'] : []);\n        // regexpify non-globstar patterns\n        // if ** is only item, then we just do one twoStar\n        // if ** is first, and there are more, prepend (\\/|twoStar\\/)? to next\n        // if ** is last, append (\\/twoStar|) to previous\n        // if ** is in the middle, append (\\/|\\/twoStar\\/) to previous\n        // then filter out GLOBSTAR symbols\n        let re = set\n            .map(pattern => {\n            const pp = pattern.map(p => {\n                if (p instanceof RegExp) {\n                    for (const f of p.flags.split(''))\n                        flags.add(f);\n                }\n                return typeof p === 'string'\n                    ? regExpEscape(p)\n                    : p === GLOBSTAR\n                        ? GLOBSTAR\n                        : p._src;\n            });\n            pp.forEach((p, i) => {\n                const next = pp[i + 1];\n                const prev = pp[i - 1];\n                if (p !== GLOBSTAR || prev === GLOBSTAR) {\n                    return;\n                }\n                if (prev === undefined) {\n                    if (next !== undefined && next !== GLOBSTAR) {\n                        pp[i + 1] = '(?:\\\\/|' + twoStar + '\\\\/)?' + next;\n                    }\n                    else {\n                        pp[i] = twoStar;\n                    }\n                }\n                else if (next === undefined) {\n                    pp[i - 1] = prev + '(?:\\\\/|' + twoStar + ')?';\n                }\n                else if (next !== GLOBSTAR) {\n                    pp[i - 1] = prev + '(?:\\\\/|\\\\/' + twoStar + '\\\\/)' + next;\n                    pp[i + 1] = GLOBSTAR;\n                }\n            });\n            return pp.filter(p => p !== GLOBSTAR).join('/');\n        })\n            .join('|');\n        // need to wrap in parens if we had more than one thing with |,\n        // otherwise only the first will be anchored to ^ and the last to $\n        const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];\n        // must match entire pattern\n        // ending in a * or ** will make it less strict.\n        re = '^' + open + re + close + '$';\n        // can match anything, as long as it's not this.\n        if (this.negate)\n            re = '^(?!' + re + ').+$';\n        try {\n            this.regexp = new RegExp(re, [...flags].join(''));\n            /* c8 ignore start */\n        }\n        catch (ex) {\n            // should be impossible\n            this.regexp = false;\n        }\n        /* c8 ignore stop */\n        return this.regexp;\n    }\n    slashSplit(p) {\n        // if p starts with // on windows, we preserve that\n        // so that UNC paths aren't broken.  Otherwise, any number of\n        // / characters are coalesced into one, unless\n        // preserveMultipleSlashes is set to true.\n        if (this.preserveMultipleSlashes) {\n            return p.split('/');\n        }\n        else if (this.isWindows && /^\\/\\/[^\\/]+/.test(p)) {\n            // add an extra '' for the one we lose\n            return ['', ...p.split(/\\/+/)];\n        }\n        else {\n            return p.split(/\\/+/);\n        }\n    }\n    match(f, partial = this.partial) {\n        this.debug('match', f, this.pattern);\n        // short-circuit in the case of busted things.\n        // comments, etc.\n        if (this.comment) {\n            return false;\n        }\n        if (this.empty) {\n            return f === '';\n        }\n        if (f === '/' && partial) {\n            return true;\n        }\n        const options = this.options;\n        // windows: need to use /, not \\\n        if (this.isWindows) {\n            f = f.split('\\\\').join('/');\n        }\n        // treat the test path as a set of pathparts.\n        const ff = this.slashSplit(f);\n        this.debug(this.pattern, 'split', ff);\n        // just ONE of the pattern sets in this.set needs to match\n        // in order for it to be valid.  If negating, then just one\n        // match means that we have failed.\n        // Either way, return on the first hit.\n        const set = this.set;\n        this.debug(this.pattern, 'set', set);\n        // Find the basename of the path by looking for the last non-empty segment\n        let filename = ff[ff.length - 1];\n        if (!filename) {\n            for (let i = ff.length - 2; !filename && i >= 0; i--) {\n                filename = ff[i];\n            }\n        }\n        for (let i = 0; i < set.length; i++) {\n            const pattern = set[i];\n            let file = ff;\n            if (options.matchBase && pattern.length === 1) {\n                file = [filename];\n            }\n            const hit = this.matchOne(file, pattern, partial);\n            if (hit) {\n                if (options.flipNegate) {\n                    return true;\n                }\n                return !this.negate;\n            }\n        }\n        // didn't get any hits.  this is success if it's a negative\n        // pattern, failure otherwise.\n        if (options.flipNegate) {\n            return false;\n        }\n        return this.negate;\n    }\n    static defaults(def) {\n        return minimatch.defaults(def).Minimatch;\n    }\n}\n/* c8 ignore start */\nexport { AST } from './ast.js';\nexport { escape } from './escape.js';\nexport { unescape } from './unescape.js';\n/* c8 ignore stop */\nminimatch.AST = AST;\nminimatch.Minimatch = Minimatch;\nminimatch.escape = escape;\nminimatch.unescape = unescape;\n//# sourceMappingURL=index.js.map","import { minimatch } from 'minimatch';\n\nimport { encodeString } from './encoder';\nimport { OPFSError, OPFSNotSupportedError, mapDomError } from './errors';\n\nimport type { Encoding } from '../types';\n\n\n/**\n * Check if the browser supports the OPFS API\n * \n * @throws {OPFSNotSupportedError} If the browser does not support the OPFS API\n */\nexport function checkOPFSSupport(): void {\n    if (!('storage' in navigator) || !('getDirectory' in (navigator.storage as any))) {\n        throw new OPFSNotSupportedError();\n    }\n}\n\nexport async function withLock<T>(\n    path: string,\n    mode: 'shared' | 'exclusive',\n    fn: () => Promise<T>\n): Promise<T> {\n    if (typeof navigator !== 'undefined' && navigator.locks?.request) {\n        return navigator.locks.request(`opfs:${ path.replace(/\\/+/g, '/') }`, { mode }, fn);\n    }\n\n    return fn();\n}\n\n/** \n * Split a path into an array of segments\n * \n * @param path - The path to split\n * @returns The array of segments\n * \n * @example\n * ```typescript\n * splitPath('/path/to/file'); // ['path', 'to', 'file']\n * splitPath('~/path/to/file'); // ['path', 'to', 'file'] (home dir handled)\n * splitPath('relative/path'); // ['relative', 'path']\n * ```\n */\nexport function splitPath(path: string | string[]): string[] {\n    if (Array.isArray(path)) {\n        return path;\n    }\n\n    const normalizedPath = path.startsWith('~/') ? path.slice(2) : path;\n\n    return normalizedPath.split('/').filter(Boolean);\n}\n\n\n/**\n * Join an array of path segments into a single path\n * \n * @param segments - The array of path segments\n * @returns The joined path\n */\nexport function joinPath(segments: string[] | string): string {\n    return typeof segments === 'string'\n        ? (segments ?? '/')\n        : `/${ segments.join('/') }`;\n}\n\n/**\n * Extract the filename from a path\n * \n * @param path - The file path\n * @returns The filename without the directory path\n * \n * @example\n * ```typescript\n * basename('/path/to/file.txt'); // 'file.txt'\n * basename('/path/to/directory/'); // ''\n * basename('file.txt'); // 'file.txt'\n * ```\n */\nexport function basename(path: string): string {\n    const segments = splitPath(path);\n\n    return segments[segments.length - 1] || '';\n}\n\n/**\n * Extract the directory path from a file path\n * \n * @param path - The file path\n * @returns The directory path without the filename\n * \n * @example\n * ```typescript\n * dirname('/path/to/file.txt'); // '/path/to'\n * dirname('/path/to/directory/'); // '/path/to/directory'\n * dirname('file.txt'); // '/'\n * ```\n */\nexport function dirname(path: string): string {\n    const segments = splitPath(path);\n\n    segments.pop();\n\n    return joinPath(segments);\n}\n\n/**\n * Normalize a path to ensure it starts with '/'\n * \n * @param path - The path to normalize\n * @returns The normalized path\n * \n * @example\n * ```typescript\n * normalizePath('path/to/file'); // '/path/to/file'\n * normalizePath('/path/to/file'); // '/path/to/file'\n * normalizePath('~/path/to/file'); // '/path/to/file' (home dir normalized to root)\n * normalizePath(''); // '/'\n * ```\n */\nexport function normalizePath(path: string): string {\n    if (!path || path === '/') {\n        return '/';\n    }\n\n    if (path.startsWith('~/')) {\n        return `/${ path.slice(2) }`;\n    }\n\n    return path.startsWith('/') ? path : `/${ path }`;\n}\n\nexport function normalizeMinimatch(path: string, recursive: boolean = false): string {\n    path = path.replace(/\\/$/, '');\n    if (recursive && !path.includes('*')) {\n        return `${ path }/**`;\n    }\n\n    return path;\n}\n\nexport function matchMinimatch(path: string, pattern: string): boolean {\n    return minimatch(path, pattern, {\n        dot: true,\n        matchBase: true,\n    });\n}\n\n/**\n * Check if a path matches any of the provided exclude patterns (minimatch syntax)\n *\n * @param path - Absolute or relative path\n * @param patterns - Glob pattern(s) to match against\n * @returns true if excluded, false otherwise\n */\nexport function isPathExcluded(path: string, patterns?: string | string[]): boolean {\n    if (!patterns || (Array.isArray(patterns) && patterns.length === 0)) {\n        return false;\n    }\n\n    const normalized = normalizePath(path);\n    const list = Array.isArray(patterns) ? patterns : [patterns];\n\n    return list.some(pattern => minimatch(normalized, pattern, { dot: true }));\n}\n\n/**\n * Resolve a path to an absolute path, handling relative segments\n * \n * @param path - The path to resolve\n * @returns The resolved absolute path\n * \n * @example\n * ```typescript\n * resolvePath('./config/../data/file.txt'); // '/data/file.txt'\n * resolvePath('/path/to/../file.txt'); // '/path/file.txt'\n * resolvePath('../../file.txt'); // '/file.txt' (truncated to root)\n * resolvePath('~/config/../data/file.txt'); // '/data/file.txt' (home dir normalized to root)\n * ```\n */\nexport function resolvePath(path: string): string {\n    // First normalize the path to handle home directory references\n    const normalizedPath = normalizePath(path);\n    const segments = splitPath(normalizedPath);\n    const normalizedSegments: string[] = [];\n\n    for (const segment of segments) {\n        if (segment === '.' || segment === '') {\n            // Skip current directory references and empty segments\n            continue;\n        }\n        else if (segment === '..') {\n            if (normalizedSegments.length === 0) {\n                // Path escapes root, keep at root level\n                continue;\n            }\n\n            // Go up one directory\n            normalizedSegments.pop();\n        }\n        else {\n            normalizedSegments.push(segment);\n        }\n    }\n\n    return joinPath(normalizedSegments);\n}\n\n/**\n * Get the file extension from a path\n * \n * @param path - The file path\n * @returns The file extension including the dot, or empty string if no extension\n * \n * @example\n * ```typescript\n * extname('/path/to/file.txt'); // '.txt'\n * extname('/path/to/file'); // ''\n * extname('/path/to/file.name.ext'); // '.ext'\n * extname('/path/to/.hidden'); // ''\n * ```\n */\nexport function extname(path: string): string {\n    const filename = basename(path);\n    const lastDotIndex = filename.lastIndexOf('.');\n\n    if (lastDotIndex <= 0 || lastDotIndex === filename.length - 1) {\n        return '';\n    }\n\n    return filename.slice(lastDotIndex);\n}\n\nexport function createBuffer(data: string | Uint8Array | ArrayBuffer, encoding: Encoding = 'utf-8'): Uint8Array {\n    if (typeof data === 'string') {\n        return encodeString(data, encoding);\n    }\n\n    return data instanceof Uint8Array ? data : new Uint8Array(data);\n}\n\n/**\n * Calculate file hash using Web Crypto API\n * \n * @param buffer - The file content as File, ArrayBuffer, or Uint8Array\n * @param algorithm - Hash algorithm to use (default: 'SHA-1')\n * @param maxSize - Maximum file size in bytes. If file is larger, throws error (default: 50MB)\n * @returns Promise that resolves to the hash string\n * @throws Error if file size exceeds maxSize\n */\nexport async function calculateFileHash(\n    buffer: File | ArrayBuffer | Uint8Array,\n    algorithm: string = 'SHA-1',\n    maxSize: number = 50 * 1024 * 1024 // 50MB default\n): Promise<string> {\n    if (buffer instanceof File) {\n        buffer = await buffer.arrayBuffer();\n    }\n\n    // Check file size before processing\n    if (buffer.byteLength > maxSize) {\n        throw new Error(`File size ${ buffer.byteLength } bytes exceeds maximum allowed size ${ maxSize } bytes`);\n    }\n\n    const bufferSource = new Uint8Array(buffer);\n    const hashBuffer = await crypto.subtle.digest(algorithm, bufferSource);\n    const hashArray = Array.from(new Uint8Array(hashBuffer));\n\n    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');\n}\n\n/**\n * Compare two Uint8Array buffers for equality\n * \n * @param a - First buffer\n * @param b - Second buffer\n * @returns true if buffers are equal, false otherwise\n */\nexport function buffersEqual(a: Uint8Array, b: Uint8Array): boolean {\n    if (a.length !== b.length) {\n        return false;\n    }\n\n    for (let i = 0; i < a.length; i++) {\n        if (a[i] !== b[i]) {\n            return false;\n        }\n    }\n\n    return true;\n}\n\n/**\n * Convert a Blob to Uint8Array\n * \n * This function converts a Blob object to a Uint8Array for use with file operations.\n * It's useful when working with file uploads or other Blob data sources.\n * \n * @param blob - The Blob to convert\n * @returns Promise that resolves to the Uint8Array representation of the Blob\n * \n * @example\n * ```typescript\n * const fileInput = document.getElementById('file') as HTMLInputElement;\n * const file = fileInput.files?.[0];\n * if (file) {\n *   const data = await convertBlobToUint8Array(file);\n *   await fs.writeFile('/uploaded-file', data);\n * }\n * }\n * ```\n */\nexport async function convertBlobToUint8Array(blob: Blob): Promise<Uint8Array> {\n    const arrayBuffer = await blob.arrayBuffer();\n\n    return new Uint8Array(arrayBuffer);\n}\n\n/**\n * Remove a file or directory entry using a directory handle\n *\n * @param parentHandle - The parent directory handle\n * @param path - The full path of the entry to remove\n * @param options - Remove options (recursive, force, useTrash)\n */\nexport async function removeEntry(\n    parentHandle: FileSystemDirectoryHandle,\n    path: string,\n    options: { recursive?: boolean; force?: boolean; useTrash?: boolean } = {}\n): Promise<void> {\n    const name = basename(path);\n\n    return withLock(path, 'exclusive', async() => {\n        const recursive = options.recursive ?? false;\n        const force = options.force ?? false;\n\n        try {\n            await parentHandle.removeEntry(name, { recursive });\n        }\n        catch (e: any) {\n            if (e.name === 'NotFoundError') {\n                if (!force) {\n                    throw new OPFSError(`No such file or directory: ${ path }`, 'ENOENT', undefined, e);\n                }\n            }\n            else if (e.name === 'InvalidModificationError') {\n                throw new OPFSError(`Directory not empty: ${ path }. Use recursive option to force removal.`, 'ENOTEMPTY', undefined, e);\n            }\n            else if (e.name === 'TypeMismatchError' && !recursive) {\n                throw new OPFSError(`Cannot remove directory without recursive option: ${ path }`, 'EISDIR', undefined, e);\n            }\n            else {\n                throw new OPFSError(`Failed to remove entry: ${ path }`, 'RM_FAILED', undefined, e);\n            }\n        }\n    });\n}\n\n/**\n * Validate read/write arguments for file descriptor operations\n * \n * @param bufferLen - Length of the buffer\n * @param offset - Offset in the buffer\n * @param length - Number of bytes to read/write\n * @param position - Position in the file (null for current position)\n * @param opts - Options for validation\n * @throws {OPFSError} If arguments are invalid\n */\nexport function validateReadWriteArgs(\n    bufferLen: number,\n    offset: number,\n    length: number,\n    position: number | null | undefined\n): void {\n    if (!Number.isInteger(offset) || !Number.isInteger(length)) {\n        throw new OPFSError('Invalid offset or length', 'EINVAL');\n    }\n\n    if (offset < 0 || length < 0) {\n        throw new OPFSError('Negative offset or length not allowed', 'EINVAL');\n    }\n\n    if (offset + length > bufferLen) {\n        throw new OPFSError('Operation would overflow buffer', 'ERANGE');\n    }\n\n    if (position != null && (!Number.isInteger(position) || position < 0)) {\n        throw new OPFSError('Invalid position', 'EINVAL');\n    }\n}\n\n/**\n * Safely close a file descriptor's sync handle\n * \n * @param fd - The file descriptor number (for logging)\n * @param syncHandle - The sync handle to close\n * @param path - The file path (for logging)\n */\nexport function safeCloseSyncHandle(fd: number, syncHandle: any, path: string): void {\n    try {\n        syncHandle.flush();\n        syncHandle.close();\n    }\n    catch (error) {\n        // Log warning but don't throw, as the fd should still be removed\n        console.warn(`Warning: Failed to properly close file descriptor ${ fd } (${ path }):`, error);\n    }\n}\n\n/**\n * Check if position is at or beyond end of file and calculate actual read length\n * \n * @param position - The position to read from\n * @param requestedLength - The requested length to read\n * @param fileSize - The current file size\n * @returns Object with isEOF flag and actual length to read\n */\nexport function calculateReadLength(position: number, requestedLength: number, fileSize: number): { isEOF: boolean; actualLength: number } {\n    // Check if we're at or beyond end of file\n    if (position >= fileSize) {\n        return { isEOF: true, actualLength: 0 };\n    }\n\n    // Calculate actual length to read (don't read beyond file end)\n    const actualLength = Math.min(requestedLength, fileSize - position);\n\n    if (actualLength <= 0) {\n        return { isEOF: true, actualLength: 0 };\n    }\n\n    return { isEOF: false, actualLength };\n}\n\n/**\n * Safely create a sync access handle with proper error mapping\n * \n * @param fileHandle - The file handle to create sync access handle from\n * @param path - The file path for error context\n * @returns Promise that resolves to FileSystemSyncAccessHandle\n * @throws {OPFSError} If creation fails\n */\nexport async function createSyncHandleSafe(\n    fileHandle: FileSystemFileHandle,\n    path: string\n): Promise<FileSystemSyncAccessHandle> {\n    try {\n        return await fileHandle.createSyncAccessHandle();\n    }\n    catch (error: any) {\n        throw mapDomError(error, { path, isDirectory: false });\n    }\n}\n"],"names":["OPFSError","message","code","path","cause","OPFSNotSupportedError","OPFSNotMountedError","PathError","FileNotFoundError","DirectoryNotFoundError","PermissionError","operation","StorageError","TimeoutError","createFDError","fd","error","errorCode","mapDomError","context","isDirectory","BINARY_FILE_EXTENSIONS","isBinaryFileExtension","i","ext","encodeString","data","encoding","encodeUtf16LE","encodeAscii","encodeLatin1","char","c","b","decodeBuffer","buffer","decodeUtf16LE","str","buf","codeUnits","WatchEventType","balanced","a","ma","maybeMatch","mb","range","reg","m","begs","beg","left","right","result","ai","bi","r","escSlash","escOpen","escClose","escComma","escPeriod","escSlashPattern","escOpenPattern","escClosePattern","escCommaPattern","escPeriodPattern","slashPattern","openPattern","closePattern","commaPattern","periodPattern","numeric","escapeBraces","unescapeBraces","parseCommaParts","parts","pre","body","post","p","postParts","expand","expand_","embrace","isPadded","el","lte","y","gte","isTop","expansions","k","expansion","isNumericSequence","isAlphaSequence","isSequence","isOptions","n","N","x","width","incr","test","pad","need","z","j","MAX_PATTERN_LENGTH","assertValidPattern","pattern","posixClasses","braceEscape","regexpEscape","rangesToString","ranges","parseClass","glob","position","pos","negs","sawStart","uflag","escaping","negate","endPos","rangeStart","WHILE","cls","unip","u","neg","sranges","snegs","unescape","windowsPathsNoEscape","types","isExtglobType","startNoTraversal","startNoDot","addPatternStart","justDots","reSpecials","regExpEscape","qmark","star","starNoEmpty","AST","#root","#hasMagic","#uflag","#parts","#parent","#parentIndex","#negs","#filledNegs","#options","#toString","#emptyExt","type","parent","options","#fillNegs","pp","part","ret","pl","#parseAST","ast","opt","inBrace","braceStart","braceNeg","acc","re","hasMagic","flags","allowDot","dot","noEmpty","src","_","#parseGlob","start","aps","needNoTrav","needNoDot","end","repeated","#partsToRegExp","s","bodyDotAllowed","final","close","_hasMagic","needUflag","consumed","magic","escape","minimatch","Minimatch","starDotExtRE","starDotExtTest","f","starDotExtTestDot","starDotExtTestNocase","starDotExtTestNocaseDot","starDotStarRE","starDotStarTest","starDotStarTestDot","dotStarRE","dotStarTest","starRE","starTest","starTestDot","qmarksRE","qmarksTestNocase","$0","noext","qmarksTestNoExt","qmarksTestNocaseDot","qmarksTestNoExtDot","qmarksTestDot","qmarksTest","len","defaultPlatform","sep","GLOBSTAR","twoStarDot","twoStarNoDot","filter","defaults","def","orig","list","braceExpand","makeRe","match","mm","globMagic","args","rawGlobParts","set","__","isUNC","isDrive","ss","globParts","optimizationLevel","gs","prev","didSomething","dd","gss","next","p2","other","splin","matched","emptyGSMatch","which","negateOffset","file","partial","fileDrive","fileUNC","patternDrive","patternUNC","fdi","pdi","pd","fi","pi","fl","fr","pr","swallowee","hit","fastTest","twoStar","open","ff","filename","checkOPFSSupport","withLock","mode","fn","splitPath","joinPath","segments","basename","dirname","normalizePath","normalizeMinimatch","recursive","matchMinimatch","isPathExcluded","patterns","normalized","resolvePath","normalizedPath","normalizedSegments","segment","extname","lastDotIndex","createBuffer","calculateFileHash","algorithm","maxSize","bufferSource","hashBuffer","buffersEqual","convertBlobToUint8Array","blob","arrayBuffer","removeEntry","parentHandle","name","force","e","validateReadWriteArgs","bufferLen","offset","length","safeCloseSyncHandle","syncHandle","calculateReadLength","requestedLength","fileSize","actualLength","createSyncHandleSafe","fileHandle"],"mappings":"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","x_google_ignoreList":[3,4,5,6,7,8,9,10]}

package/dist/helpers-ppMRzIAJ.cjs

@@ -0,0 +1,4 @@
+"use strict";class g extends Error{constructor(t,e,s,r){super(t,{cause:r}),this.code=e,this.path=s,this.name="OPFSError"}}class Y extends g{constructor(t){super("OPFS is not supported in this browser","OPFS_NOT_SUPPORTED",void 0,t)}}class lt extends g{constructor(t){super("OPFS is not mounted","OPFS_NOT_MOUNTED",void 0,t)}}class ut extends g{constructor(t,e,s){super(t,"INVALID_PATH",e,s)}}class ft extends g{constructor(t,e){super(`File not found: ${t}`,"FILE_NOT_FOUND",t,e)}}class pt extends g{constructor(t,e){super(`Directory not found: ${t}`,"DIRECTORY_NOT_FOUND",t,e)}}class dt extends g{constructor(t,e,s){super(`Permission denied for ${e} on: ${t}`,"PERMISSION_DENIED",t,s)}}class gt extends g{constructor(t,e,s){super(t,"STORAGE_ERROR",e,s)}}class mt extends g{constructor(t,e,s){super(`Operation timed out: ${t}`,"TIMEOUT_ERROR",e,s)}}function wt(n,t,e,s){const r=`${n.toUpperCase()}_FAILED`;return new g(`Failed to ${n} file descriptor: ${t}`,r,e,s)}function Z(n,t){const e=t?.path,s=t?.isDirectory;switch(n.name){case"InvalidStateError":return new g(`File is busy: ${e||"unknown"}`,"EBUSY",e,n);case"QuotaExceededError":return new g(`No space left on device: ${e||"unknown"}`,"ENOSPC",e,n);case"NotFoundError":return new g(`No such file or directory: ${e||"unknown"}`,"ENOENT",e,n);case"TypeMismatchError":return s!==void 0?s?new g(`Not a directory: ${e||"unknown"}`,"ENOTDIR",e,n):new g(`Is a directory: ${e||"unknown"}`,"EISDIR",e,n):new g(`Type mismatch: ${e||"unknown"}`,"EINVAL",e,n);case"NotAllowedError":case"SecurityError":return new g(`Permission denied: ${e||"unknown"}`,"EACCES",e,n);case"InvalidModificationError":return new g(`Invalid modification: ${e||"unknown"}`,"EINVAL",e,n);case"AbortError":return new g(`Operation aborted: ${e||"unknown"}`,"EINTR",e,n);case"OperationError":return new g(`Operation failed: ${e||"unknown"}`,"EIO",e,n);case"TypeError":return new g(`Operation not supported: ${e||"unknown"}`,"ENOTSUP",e,n);default:return new g(`I/O error: ${e||"unknown"}`,"EIO",e,n)}}const X=[".jpg",".jpeg",".png",".gif",".bmp",".webp",".ico",".tiff",".tga",".mp3",".wav",".ogg",".flac",".aac",".wma",".m4a",".mp4",".avi",".mov",".wmv",".flv",".webm",".mkv",".m4v",".pdf",".doc",".docx",".xls",".xlsx",".ppt",".pptx",".zip",".rar",".7z",".tar",".gz",".bz2",".exe",".dll",".so",".dylib",".dat",".db",".sqlite",".bin",".obj",".fbx",".3ds"];function yt(n){const t=n.lastIndexOf(".");if(t<=0)return!0;const e=n.slice(t).toLowerCase();return X.includes(e)}function J(n,t="utf-8"){switch(t){case"utf8":case"utf-8":return new TextEncoder().encode(n);case"utf16le":case"utf-16le":case"ucs2":case"ucs-2":return St(n);case"ascii":return Ot(n);case"latin1":return Nt(n);case"binary":return Uint8Array.from(n,e=>e.charCodeAt(0));case"base64":return Uint8Array.from(atob(n),e=>e.charCodeAt(0));case"hex":if(!/^[\da-f]+$/i.test(n)||n.length%2!==0)throw new g("Invalid hex string","INVALID_HEX_FORMAT");return Uint8Array.from(n.match(/.{1,2}/g).map(e=>parseInt(e,16)));default:return console.warn("Encoding not supported, falling back to UTF-8"),new TextEncoder().encode(n)}}function Et(n,t="utf-8"){switch(t){case"utf8":case"utf-8":return new TextDecoder().decode(n);case"utf16le":case"utf-16le":case"ucs2":case"ucs-2":return xt(n);case"latin1":return String.fromCharCode(...n);case"ascii":return String.fromCharCode(...n.map(e=>e&127));case"base64":return btoa(String.fromCharCode(...n));case"hex":return Array.from(n).map(e=>e.toString(16).padStart(2,"0")).join("");default:return console.warn("Unsupported encoding, falling back to UTF-8"),new TextDecoder().decode(n)}}function St(n){const t=new Uint8Array(n.length*2);for(let e=0;e<n.length;e++){const s=n.charCodeAt(e);t[e*2]=s&255,t[e*2+1]=s>>8}return t}function xt(n){n.length%2!==0&&(console.warn("Invalid UTF-16LE buffer length, truncating last byte"),n=n.slice(0,n.length-1));const t=new Uint16Array(n.buffer,n.byteOffset,n.byteLength/2);return String.fromCharCode(...t)}function Nt(n){const t=new Uint8Array(n.length);for(let e=0;e<n.length;e++)t[e]=n.charCodeAt(e)&255;return t}function Ot(n){const t=new Uint8Array(n.length);for(let e=0;e<n.length;e++)t[e]=n.charCodeAt(e)&127;return t}var Q=(n=>(n.Added="added",n.Changed="changed",n.Removed="removed",n))(Q||{});const K=(n,t,e)=>{const s=n instanceof RegExp?z(n,e):n,r=t instanceof RegExp?z(t,e):t,i=s!==null&&r!=null&&bt(s,r,e);return i&&{start:i[0],end:i[1],pre:e.slice(0,i[0]),body:e.slice(i[0]+s.length,i[1]),post:e.slice(i[1]+r.length)}},z=(n,t)=>{const e=t.match(n);return e?e[0]:null},bt=(n,t,e)=>{let s,r,i,o,a,h=e.indexOf(n),l=e.indexOf(t,h+1),c=h;if(h>=0&&l>0){if(n===t)return[h,l];for(s=[],i=e.length;c>=0&&!a;){if(c===h)s.push(c),h=e.indexOf(n,c+1);else if(s.length===1){const p=s.pop();p!==void 0&&(a=[p,l])}else r=s.pop(),r!==void 0&&r<i&&(i=r,o=l),l=e.indexOf(t,c+1);c=h<l&&h>=0?h:l}s.length&&o!==void 0&&(a=[i,o])}return a},tt="\0SLASH"+Math.random()+"\0",et="\0OPEN"+Math.random()+"\0",F="\0CLOSE"+Math.random()+"\0",nt="\0COMMA"+Math.random()+"\0",st="\0PERIOD"+Math.random()+"\0",vt=new RegExp(tt,"g"),At=new RegExp(et,"g"),$t=new RegExp(F,"g"),Pt=new RegExp(nt,"g"),Tt=new RegExp(st,"g"),Mt=/\\\\/g,Rt=/\\{/g,It=/\\}/g,Ct=/\\,/g,Lt=/\\./g;function D(n){return isNaN(n)?n.charCodeAt(0):parseInt(n,10)}function Dt(n){return n.replace(Mt,tt).replace(Rt,et).replace(It,F).replace(Ct,nt).replace(Lt,st)}function Ft(n){return n.replace(vt,"\\").replace(At,"{").replace($t,"}").replace(Pt,",").replace(Tt,".")}function rt(n){if(!n)return[""];const t=[],e=K("{","}",n);if(!e)return n.split(",");const{pre:s,body:r,post:i}=e,o=s.split(",");o[o.length-1]+="{"+r+"}";const a=rt(i);return i.length&&(o[o.length-1]+=a.shift(),o.push.apply(o,a)),t.push.apply(t,o),t}function kt(n){return n?(n.slice(0,2)==="{}"&&(n="\\{\\}"+n.slice(2)),P(Dt(n),!0).map(Ft)):[]}function Ut(n){return"{"+n+"}"}function Wt(n){return/^-?0\d/.test(n)}function jt(n,t){return n<=t}function zt(n,t){return n>=t}function P(n,t){const e=[],s=K("{","}",n);if(!s)return[n];const r=s.pre,i=s.post.length?P(s.post,!1):[""];if(/\$$/.test(s.pre))for(let o=0;o<i.length;o++){const a=r+"{"+s.body+"}"+i[o];e.push(a)}else{const o=/^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(s.body),a=/^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(s.body),h=o||a,l=s.body.indexOf(",")>=0;if(!h&&!l)return s.post.match(/,(?!,).*\}/)?(n=s.pre+"{"+s.body+F+s.post,P(n)):[n];let c;if(h)c=s.body.split(/\.\./);else if(c=rt(s.body),c.length===1&&c[0]!==void 0&&(c=P(c[0],!1).map(Ut),c.length===1))return i.map(f=>s.pre+c[0]+f);let p;if(h&&c[0]!==void 0&&c[1]!==void 0){const f=D(c[0]),u=D(c[1]),m=Math.max(c[0].length,c[1].length);let d=c.length===3&&c[2]!==void 0?Math.abs(D(c[2])):1,S=jt;u<f&&(d*=-1,S=zt);const v=c.some(Wt);p=[];for(let x=f;S(x,u);x+=d){let w;if(a)w=String.fromCharCode(x),w==="\\"&&(w="");else if(w=String(x),v){const A=m-w.length;if(A>0){const M=new Array(A+1).join("0");x<0?w="-"+M+w.slice(1):w=M+w}}p.push(w)}}else{p=[];for(let f=0;f<c.length;f++)p.push.apply(p,P(c[f],!1))}for(let f=0;f<p.length;f++)for(let u=0;u<i.length;u++){const m=r+p[f]+i[u];(!t||h||m)&&e.push(m)}}return e}const _t=1024*64,I=n=>{if(typeof n!="string")throw new TypeError("invalid pattern");if(n.length>_t)throw new TypeError("pattern is too long")},Bt={"[:alnum:]":["\\p{L}\\p{Nl}\\p{Nd}",!0],"[:alpha:]":["\\p{L}\\p{Nl}",!0],"[:ascii:]":["\\x00-\\x7f",!1],"[:blank:]":["\\p{Zs}\\t",!0],"[:cntrl:]":["\\p{Cc}",!0],"[:digit:]":["\\p{Nd}",!0],"[:graph:]":["\\p{Z}\\p{C}",!0,!0],"[:lower:]":["\\p{Ll}",!0],"[:print:]":["\\p{C}",!0],"[:punct:]":["\\p{P}",!0],"[:space:]":["\\p{Z}\\t\\r\\n\\v\\f",!0],"[:upper:]":["\\p{Lu}",!0],"[:word:]":["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}",!0],"[:xdigit:]":["A-Fa-f0-9",!1]},$=n=>n.replace(/[[\]\\-]/g,"\\$&"),qt=n=>n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&"),_=n=>n.join(""),Gt=(n,t)=>{const e=t;if(n.charAt(e)!=="[")throw new Error("not in a brace expression");const s=[],r=[];let i=e+1,o=!1,a=!1,h=!1,l=!1,c=e,p="";t:for(;i<n.length;){const d=n.charAt(i);if((d==="!"||d==="^")&&i===e+1){l=!0,i++;continue}if(d==="]"&&o&&!h){c=i+1;break}if(o=!0,d==="\\"&&!h){h=!0,i++;continue}if(d==="["&&!h){for(const[S,[b,v,x]]of Object.entries(Bt))if(n.startsWith(S,i)){if(p)return["$.",!1,n.length-e,!0];i+=S.length,x?r.push(b):s.push(b),a=a||v;continue t}}if(h=!1,p){d>p?s.push($(p)+"-"+$(d)):d===p&&s.push($(d)),p="",i++;continue}if(n.startsWith("-]",i+1)){s.push($(d+"-")),i+=2;continue}if(n.startsWith("-",i+1)){p=d,i+=2;continue}s.push($(d)),i++}if(c<i)return["",!1,0,!1];if(!s.length&&!r.length)return["$.",!1,n.length-e,!0];if(r.length===0&&s.length===1&&/^\\?.$/.test(s[0])&&!l){const d=s[0].length===2?s[0].slice(-1):s[0];return[qt(d),!1,c-e,!1]}const f="["+(l?"^":"")+_(s)+"]",u="["+(l?"":"^")+_(r)+"]";return[s.length&&r.length?"("+f+"|"+u+")":s.length?f:u,a,c-e,!0]},T=(n,{windowsPathsNoEscape:t=!1}={})=>t?n.replace(/\[([^\/\\])\]/g,"$1"):n.replace(/((?!\\).|^)\[([^\/\\])\]/g,"$1$2").replace(/\\([^\/])/g,"$1"),Ht=new Set(["!","?","+","*","@"]),B=n=>Ht.has(n),Vt="(?!(?:^|/)\\.\\.?(?:$|/))",R="(?!\\.)",Yt=new Set(["[","."]),Zt=new Set(["..","."]),Xt=new Set("().*{}+?[]^$\\!"),Jt=n=>n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&"),k="[^/]",q=k+"*?",G=k+"+?";class E{type;#n;#s;#i=!1;#t=[];#e;#o;#a;#c=!1;#r;#h;#u=!1;constructor(t,e,s={}){this.type=t,t&&(this.#s=!0),this.#e=e,this.#n=this.#e?this.#e.#n:this,this.#r=this.#n===this?s:this.#n.#r,this.#a=this.#n===this?[]:this.#n.#a,t==="!"&&!this.#n.#c&&this.#a.push(this),this.#o=this.#e?this.#e.#t.length:0}get hasMagic(){if(this.#s!==void 0)return this.#s;for(const t of this.#t)if(typeof t!="string"&&(t.type||t.hasMagic))return this.#s=!0;return this.#s}toString(){return this.#h!==void 0?this.#h:this.type?this.#h=this.type+"("+this.#t.map(t=>String(t)).join("|")+")":this.#h=this.#t.map(t=>String(t)).join("")}#p(){if(this!==this.#n)throw new Error("should only call on root");if(this.#c)return this;this.toString(),this.#c=!0;let t;for(;t=this.#a.pop();){if(t.type!=="!")continue;let e=t,s=e.#e;for(;s;){for(let r=e.#o+1;!s.type&&r<s.#t.length;r++)for(const i of t.#t){if(typeof i=="string")throw new Error("string part in extglob AST??");i.copyIn(s.#t[r])}e=s,s=e.#e}}return this}push(...t){for(const e of t)if(e!==""){if(typeof e!="string"&&!(e instanceof E&&e.#e===this))throw new Error("invalid part: "+e);this.#t.push(e)}}toJSON(){const t=this.type===null?this.#t.slice().map(e=>typeof e=="string"?e:e.toJSON()):[this.type,...this.#t.map(e=>e.toJSON())];return this.isStart()&&!this.type&&t.unshift([]),this.isEnd()&&(this===this.#n||this.#n.#c&&this.#e?.type==="!")&&t.push({}),t}isStart(){if(this.#n===this)return!0;if(!this.#e?.isStart())return!1;if(this.#o===0)return!0;const t=this.#e;for(let e=0;e<this.#o;e++){const s=t.#t[e];if(!(s instanceof E&&s.type==="!"))return!1}return!0}isEnd(){if(this.#n===this||this.#e?.type==="!")return!0;if(!this.#e?.isEnd())return!1;if(!this.type)return this.#e?.isEnd();const t=this.#e?this.#e.#t.length:0;return this.#o===t-1}copyIn(t){typeof t=="string"?this.push(t):this.push(t.clone(this))}clone(t){const e=new E(this.type,t);for(const s of this.#t)e.copyIn(s);return e}static#l(t,e,s,r){let i=!1,o=!1,a=-1,h=!1;if(e.type===null){let u=s,m="";for(;u<t.length;){const d=t.charAt(u++);if(i||d==="\\"){i=!i,m+=d;continue}if(o){u===a+1?(d==="^"||d==="!")&&(h=!0):d==="]"&&!(u===a+2&&h)&&(o=!1),m+=d;continue}else if(d==="["){o=!0,a=u,h=!1,m+=d;continue}if(!r.noext&&B(d)&&t.charAt(u)==="("){e.push(m),m="";const S=new E(d,e);u=E.#l(t,S,u,r),e.push(S);continue}m+=d}return e.push(m),u}let l=s+1,c=new E(null,e);const p=[];let f="";for(;l<t.length;){const u=t.charAt(l++);if(i||u==="\\"){i=!i,f+=u;continue}if(o){l===a+1?(u==="^"||u==="!")&&(h=!0):u==="]"&&!(l===a+2&&h)&&(o=!1),f+=u;continue}else if(u==="["){o=!0,a=l,h=!1,f+=u;continue}if(B(u)&&t.charAt(l)==="("){c.push(f),f="";const m=new E(u,c);c.push(m),l=E.#l(t,m,l,r);continue}if(u==="|"){c.push(f),f="",p.push(c),c=new E(null,e);continue}if(u===")")return f===""&&e.#t.length===0&&(e.#u=!0),c.push(f),f="",e.push(...p,c),l;f+=u}return e.type=null,e.#s=void 0,e.#t=[t.substring(s-1)],l}static fromGlob(t,e={}){const s=new E(null,void 0,e);return E.#l(t,s,0,e),s}toMMPattern(){if(this!==this.#n)return this.#n.toMMPattern();const t=this.toString(),[e,s,r,i]=this.toRegExpSource();if(!(r||this.#s||this.#r.nocase&&!this.#r.nocaseMagicOnly&&t.toUpperCase()!==t.toLowerCase()))return s;const a=(this.#r.nocase?"i":"")+(i?"u":"");return Object.assign(new RegExp(`^${e}$`,a),{_src:e,_glob:t})}get options(){return this.#r}toRegExpSource(t){const e=t??!!this.#r.dot;if(this.#n===this&&this.#p(),!this.type){const h=this.isStart()&&this.isEnd(),l=this.#t.map(u=>{const[m,d,S,b]=typeof u=="string"?E.#d(u,this.#s,h):u.toRegExpSource(t);return this.#s=this.#s||S,this.#i=this.#i||b,m}).join("");let c="";if(this.isStart()&&typeof this.#t[0]=="string"&&!(this.#t.length===1&&Zt.has(this.#t[0]))){const m=Yt,d=e&&m.has(l.charAt(0))||l.startsWith("\\.")&&m.has(l.charAt(2))||l.startsWith("\\.\\.")&&m.has(l.charAt(4)),S=!e&&!t&&m.has(l.charAt(0));c=d?Vt:S?R:""}let p="";return this.isEnd()&&this.#n.#c&&this.#e?.type==="!"&&(p="(?:$|\\/)"),[c+l+p,T(l),this.#s=!!this.#s,this.#i]}const s=this.type==="*"||this.type==="+",r=this.type==="!"?"(?:(?!(?:":"(?:";let i=this.#f(e);if(this.isStart()&&this.isEnd()&&!i&&this.type!=="!"){const h=this.toString();return this.#t=[h],this.type=null,this.#s=void 0,[h,T(this.toString()),!1,!1]}let o=!s||t||e||!R?"":this.#f(!0);o===i&&(o=""),o&&(i=`(?:${i})(?:${o})*?`);let a="";if(this.type==="!"&&this.#u)a=(this.isStart()&&!e?R:"")+G;else{const h=this.type==="!"?"))"+(this.isStart()&&!e&&!t?R:"")+q+")":this.type==="@"?")":this.type==="?"?")?":this.type==="+"&&o?")":this.type==="*"&&o?")?":`)${this.type}`;a=r+i+h}return[a,T(i),this.#s=!!this.#s,this.#i]}#f(t){return this.#t.map(e=>{if(typeof e=="string")throw new Error("string type in extglob ast??");const[s,r,i,o]=e.toRegExpSource(t);return this.#i=this.#i||o,s}).filter(e=>!(this.isStart()&&this.isEnd())||!!e).join("|")}static#d(t,e,s=!1){let r=!1,i="",o=!1;for(let a=0;a<t.length;a++){const h=t.charAt(a);if(r){r=!1,i+=(Xt.has(h)?"\\":"")+h;continue}if(h==="\\"){a===t.length-1?i+="\\\\":r=!0;continue}if(h==="["){const[l,c,p,f]=Gt(t,a);if(p){i+=l,o=o||c,a+=p-1,e=e||f;continue}}if(h==="*"){s&&t==="*"?i+=G:i+=q,e=!0;continue}if(h==="?"){i+=k,e=!0;continue}i+=Jt(h)}return[i,T(t),!!e,o]}}const Qt=(n,{windowsPathsNoEscape:t=!1}={})=>t?n.replace(/[?*()[\]]/g,"[$&]"):n.replace(/[?*()[\]\\]/g,"\\$&"),y=(n,t,e={})=>(I(t),!e.nocomment&&t.charAt(0)==="#"?!1:new C(t,e).match(n)),Kt=/^\*+([^+@!?\*\[\(]*)$/,te=n=>t=>!t.startsWith(".")&&t.endsWith(n),ee=n=>t=>t.endsWith(n),ne=n=>(n=n.toLowerCase(),t=>!t.startsWith(".")&&t.toLowerCase().endsWith(n)),se=n=>(n=n.toLowerCase(),t=>t.toLowerCase().endsWith(n)),re=/^\*+\.\*+$/,ie=n=>!n.startsWith(".")&&n.includes("."),oe=n=>n!=="."&&n!==".."&&n.includes("."),ce=/^\.\*+$/,ae=n=>n!=="."&&n!==".."&&n.startsWith("."),he=/^\*+$/,le=n=>n.length!==0&&!n.startsWith("."),ue=n=>n.length!==0&&n!=="."&&n!=="..",fe=/^\?+([^+@!?\*\[\(]*)?$/,pe=([n,t=""])=>{const e=it([n]);return t?(t=t.toLowerCase(),s=>e(s)&&s.toLowerCase().endsWith(t)):e},de=([n,t=""])=>{const e=ot([n]);return t?(t=t.toLowerCase(),s=>e(s)&&s.toLowerCase().endsWith(t)):e},ge=([n,t=""])=>{const e=ot([n]);return t?s=>e(s)&&s.endsWith(t):e},me=([n,t=""])=>{const e=it([n]);return t?s=>e(s)&&s.endsWith(t):e},it=([n])=>{const t=n.length;return e=>e.length===t&&!e.startsWith(".")},ot=([n])=>{const t=n.length;return e=>e.length===t&&e!=="."&&e!==".."},ct=typeof process=="object"&&process?typeof process.env=="object"&&process.env&&process.env.__MINIMATCH_TESTING_PLATFORM__||process.platform:"posix",H={win32:{sep:"\\"},posix:{sep:"/"}},we=ct==="win32"?H.win32.sep:H.posix.sep;y.sep=we;const O=Symbol("globstar **");y.GLOBSTAR=O;const ye="[^/]",Ee=ye+"*?",Se="(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?",xe="(?:(?!(?:\\/|^)\\.).)*?",Ne=(n,t={})=>e=>y(e,n,t);y.filter=Ne;const N=(n,t={})=>Object.assign({},n,t),Oe=n=>{if(!n||typeof n!="object"||!Object.keys(n).length)return y;const t=y;return Object.assign((s,r,i={})=>t(s,r,N(n,i)),{Minimatch:class extends t.Minimatch{constructor(r,i={}){super(r,N(n,i))}static defaults(r){return t.defaults(N(n,r)).Minimatch}},AST:class extends t.AST{constructor(r,i,o={}){super(r,i,N(n,o))}static fromGlob(r,i={}){return t.AST.fromGlob(r,N(n,i))}},unescape:(s,r={})=>t.unescape(s,N(n,r)),escape:(s,r={})=>t.escape(s,N(n,r)),filter:(s,r={})=>t.filter(s,N(n,r)),defaults:s=>t.defaults(N(n,s)),makeRe:(s,r={})=>t.makeRe(s,N(n,r)),braceExpand:(s,r={})=>t.braceExpand(s,N(n,r)),match:(s,r,i={})=>t.match(s,r,N(n,i)),sep:t.sep,GLOBSTAR:O})};y.defaults=Oe;const at=(n,t={})=>(I(n),t.nobrace||!/\{(?:(?!\{).)*\}/.test(n)?[n]:kt(n));y.braceExpand=at;const be=(n,t={})=>new C(n,t).makeRe();y.makeRe=be;const ve=(n,t,e={})=>{const s=new C(t,e);return n=n.filter(r=>s.match(r)),s.options.nonull&&!n.length&&n.push(t),n};y.match=ve;const V=/[?*]|[+@!]\(.*?\)|\[|\]/,Ae=n=>n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,"\\$&");class C{options;set;pattern;windowsPathsNoEscape;nonegate;negate;comment;empty;preserveMultipleSlashes;partial;globSet;globParts;nocase;isWindows;platform;windowsNoMagicRoot;regexp;constructor(t,e={}){I(t),e=e||{},this.options=e,this.pattern=t,this.platform=e.platform||ct,this.isWindows=this.platform==="win32",this.windowsPathsNoEscape=!!e.windowsPathsNoEscape||e.allowWindowsEscape===!1,this.windowsPathsNoEscape&&(this.pattern=this.pattern.replace(/\\/g,"/")),this.preserveMultipleSlashes=!!e.preserveMultipleSlashes,this.regexp=null,this.negate=!1,this.nonegate=!!e.nonegate,this.comment=!1,this.empty=!1,this.partial=!!e.partial,this.nocase=!!this.options.nocase,this.windowsNoMagicRoot=e.windowsNoMagicRoot!==void 0?e.windowsNoMagicRoot:!!(this.isWindows&&this.nocase),this.globSet=[],this.globParts=[],this.set=[],this.make()}hasMagic(){if(this.options.magicalBraces&&this.set.length>1)return!0;for(const t of this.set)for(const e of t)if(typeof e!="string")return!0;return!1}debug(...t){}make(){const t=this.pattern,e=this.options;if(!e.nocomment&&t.charAt(0)==="#"){this.comment=!0;return}if(!t){this.empty=!0;return}this.parseNegate(),this.globSet=[...new Set(this.braceExpand())],e.debug&&(this.debug=(...i)=>console.error(...i)),this.debug(this.pattern,this.globSet);const s=this.globSet.map(i=>this.slashSplit(i));this.globParts=this.preprocess(s),this.debug(this.pattern,this.globParts);let r=this.globParts.map((i,o,a)=>{if(this.isWindows&&this.windowsNoMagicRoot){const h=i[0]===""&&i[1]===""&&(i[2]==="?"||!V.test(i[2]))&&!V.test(i[3]),l=/^[a-z]:/i.test(i[0]);if(h)return[...i.slice(0,4),...i.slice(4).map(c=>this.parse(c))];if(l)return[i[0],...i.slice(1).map(c=>this.parse(c))]}return i.map(h=>this.parse(h))});if(this.debug(this.pattern,r),this.set=r.filter(i=>i.indexOf(!1)===-1),this.isWindows)for(let i=0;i<this.set.length;i++){const o=this.set[i];o[0]===""&&o[1]===""&&this.globParts[i][2]==="?"&&typeof o[3]=="string"&&/^[a-z]:$/i.test(o[3])&&(o[2]="?")}this.debug(this.pattern,this.set)}preprocess(t){if(this.options.noglobstar)for(let s=0;s<t.length;s++)for(let r=0;r<t[s].length;r++)t[s][r]==="**"&&(t[s][r]="*");const{optimizationLevel:e=1}=this.options;return e>=2?(t=this.firstPhasePreProcess(t),t=this.secondPhasePreProcess(t)):e>=1?t=this.levelOneOptimize(t):t=this.adjascentGlobstarOptimize(t),t}adjascentGlobstarOptimize(t){return t.map(e=>{let s=-1;for(;(s=e.indexOf("**",s+1))!==-1;){let r=s;for(;e[r+1]==="**";)r++;r!==s&&e.splice(s,r-s)}return e})}levelOneOptimize(t){return t.map(e=>(e=e.reduce((s,r)=>{const i=s[s.length-1];return r==="**"&&i==="**"?s:r===".."&&i&&i!==".."&&i!=="."&&i!=="**"?(s.pop(),s):(s.push(r),s)},[]),e.length===0?[""]:e))}levelTwoFileOptimize(t){Array.isArray(t)||(t=this.slashSplit(t));let e=!1;do{if(e=!1,!this.preserveMultipleSlashes){for(let r=1;r<t.length-1;r++){const i=t[r];r===1&&i===""&&t[0]===""||(i==="."||i==="")&&(e=!0,t.splice(r,1),r--)}t[0]==="."&&t.length===2&&(t[1]==="."||t[1]==="")&&(e=!0,t.pop())}let s=0;for(;(s=t.indexOf("..",s+1))!==-1;){const r=t[s-1];r&&r!=="."&&r!==".."&&r!=="**"&&(e=!0,t.splice(s-1,2),s-=2)}}while(e);return t.length===0?[""]:t}firstPhasePreProcess(t){let e=!1;do{e=!1;for(let s of t){let r=-1;for(;(r=s.indexOf("**",r+1))!==-1;){let o=r;for(;s[o+1]==="**";)o++;o>r&&s.splice(r+1,o-r);let a=s[r+1];const h=s[r+2],l=s[r+3];if(a!==".."||!h||h==="."||h===".."||!l||l==="."||l==="..")continue;e=!0,s.splice(r,1);const c=s.slice(0);c[r]="**",t.push(c),r--}if(!this.preserveMultipleSlashes){for(let o=1;o<s.length-1;o++){const a=s[o];o===1&&a===""&&s[0]===""||(a==="."||a==="")&&(e=!0,s.splice(o,1),o--)}s[0]==="."&&s.length===2&&(s[1]==="."||s[1]==="")&&(e=!0,s.pop())}let i=0;for(;(i=s.indexOf("..",i+1))!==-1;){const o=s[i-1];if(o&&o!=="."&&o!==".."&&o!=="**"){e=!0;const h=i===1&&s[i+1]==="**"?["."]:[];s.splice(i-1,2,...h),s.length===0&&s.push(""),i-=2}}}}while(e);return t}secondPhasePreProcess(t){for(let e=0;e<t.length-1;e++)for(let s=e+1;s<t.length;s++){const r=this.partsMatch(t[e],t[s],!this.preserveMultipleSlashes);if(r){t[e]=[],t[s]=r;break}}return t.filter(e=>e.length)}partsMatch(t,e,s=!1){let r=0,i=0,o=[],a="";for(;r<t.length&&i<e.length;)if(t[r]===e[i])o.push(a==="b"?e[i]:t[r]),r++,i++;else if(s&&t[r]==="**"&&e[i]===t[r+1])o.push(t[r]),r++;else if(s&&e[i]==="**"&&t[r]===e[i+1])o.push(e[i]),i++;else if(t[r]==="*"&&e[i]&&(this.options.dot||!e[i].startsWith("."))&&e[i]!=="**"){if(a==="b")return!1;a="a",o.push(t[r]),r++,i++}else if(e[i]==="*"&&t[r]&&(this.options.dot||!t[r].startsWith("."))&&t[r]!=="**"){if(a==="a")return!1;a="b",o.push(e[i]),r++,i++}else return!1;return t.length===e.length&&o}parseNegate(){if(this.nonegate)return;const t=this.pattern;let e=!1,s=0;for(let r=0;r<t.length&&t.charAt(r)==="!";r++)e=!e,s++;s&&(this.pattern=t.slice(s)),this.negate=e}matchOne(t,e,s=!1){const r=this.options;if(this.isWindows){const d=typeof t[0]=="string"&&/^[a-z]:$/i.test(t[0]),S=!d&&t[0]===""&&t[1]===""&&t[2]==="?"&&/^[a-z]:$/i.test(t[3]),b=typeof e[0]=="string"&&/^[a-z]:$/i.test(e[0]),v=!b&&e[0]===""&&e[1]===""&&e[2]==="?"&&typeof e[3]=="string"&&/^[a-z]:$/i.test(e[3]),x=S?3:d?0:void 0,w=v?3:b?0:void 0;if(typeof x=="number"&&typeof w=="number"){const[A,M]=[t[x],e[w]];A.toLowerCase()===M.toLowerCase()&&(e[w]=A,w>x?e=e.slice(w):x>w&&(t=t.slice(x)))}}const{optimizationLevel:i=1}=this.options;i>=2&&(t=this.levelTwoFileOptimize(t)),this.debug("matchOne",this,{file:t,pattern:e}),this.debug("matchOne",t.length,e.length);for(var o=0,a=0,h=t.length,l=e.length;o<h&&a<l;o++,a++){this.debug("matchOne loop");var c=e[a],p=t[o];if(this.debug(e,c,p),c===!1)return!1;if(c===O){this.debug("GLOBSTAR",[e,c,p]);var f=o,u=a+1;if(u===l){for(this.debug("** at the end");o<h;o++)if(t[o]==="."||t[o]===".."||!r.dot&&t[o].charAt(0)===".")return!1;return!0}for(;f<h;){var m=t[f];if(this.debug(`
+globstar while`,t,f,e,u,m),this.matchOne(t.slice(f),e.slice(u),s))return this.debug("globstar found match!",f,h,m),!0;if(m==="."||m===".."||!r.dot&&m.charAt(0)==="."){this.debug("dot detected!",t,f,e,u);break}this.debug("globstar swallow a segment, and continue"),f++}return!!(s&&(this.debug(`
+>>> no match, partial?`,t,f,e,u),f===h))}let d;if(typeof c=="string"?(d=p===c,this.debug("string match",c,p,d)):(d=c.test(p),this.debug("pattern match",c,p,d)),!d)return!1}if(o===h&&a===l)return!0;if(o===h)return s;if(a===l)return o===h-1&&t[o]==="";throw new Error("wtf?")}braceExpand(){return at(this.pattern,this.options)}parse(t){I(t);const e=this.options;if(t==="**")return O;if(t==="")return"";let s,r=null;(s=t.match(he))?r=e.dot?ue:le:(s=t.match(Kt))?r=(e.nocase?e.dot?se:ne:e.dot?ee:te)(s[1]):(s=t.match(fe))?r=(e.nocase?e.dot?de:pe:e.dot?ge:me)(s):(s=t.match(re))?r=e.dot?oe:ie:(s=t.match(ce))&&(r=ae);const i=E.fromGlob(t,this.options).toMMPattern();return r&&typeof i=="object"&&Reflect.defineProperty(i,"test",{value:r}),i}makeRe(){if(this.regexp||this.regexp===!1)return this.regexp;const t=this.set;if(!t.length)return this.regexp=!1,this.regexp;const e=this.options,s=e.noglobstar?Ee:e.dot?Se:xe,r=new Set(e.nocase?["i"]:[]);let i=t.map(h=>{const l=h.map(c=>{if(c instanceof RegExp)for(const p of c.flags.split(""))r.add(p);return typeof c=="string"?Ae(c):c===O?O:c._src});return l.forEach((c,p)=>{const f=l[p+1],u=l[p-1];c!==O||u===O||(u===void 0?f!==void 0&&f!==O?l[p+1]="(?:\\/|"+s+"\\/)?"+f:l[p]=s:f===void 0?l[p-1]=u+"(?:\\/|"+s+")?":f!==O&&(l[p-1]=u+"(?:\\/|\\/"+s+"\\/)"+f,l[p+1]=O))}),l.filter(c=>c!==O).join("/")}).join("|");const[o,a]=t.length>1?["(?:",")"]:["",""];i="^"+o+i+a+"$",this.negate&&(i="^(?!"+i+").+$");try{this.regexp=new RegExp(i,[...r].join(""))}catch{this.regexp=!1}return this.regexp}slashSplit(t){return this.preserveMultipleSlashes?t.split("/"):this.isWindows&&/^\/\/[^\/]+/.test(t)?["",...t.split(/\/+/)]:t.split(/\/+/)}match(t,e=this.partial){if(this.debug("match",t,this.pattern),this.comment)return!1;if(this.empty)return t==="";if(t==="/"&&e)return!0;const s=this.options;this.isWindows&&(t=t.split("\\").join("/"));const r=this.slashSplit(t);this.debug(this.pattern,"split",r);const i=this.set;this.debug(this.pattern,"set",i);let o=r[r.length-1];if(!o)for(let a=r.length-2;!o&&a>=0;a--)o=r[a];for(let a=0;a<i.length;a++){const h=i[a];let l=r;if(s.matchBase&&h.length===1&&(l=[o]),this.matchOne(l,h,e))return s.flipNegate?!0:!this.negate}return s.flipNegate?!1:this.negate}static defaults(t){return y.defaults(t).Minimatch}}y.AST=E;y.Minimatch=C;y.escape=Qt;y.unescape=T;function $e(){if(!("storage"in navigator)||!("getDirectory"in navigator.storage))throw new Y}async function ht(n,t,e){return typeof navigator<"u"&&navigator.locks?.request?navigator.locks.request(`opfs:${n.replace(/\/+/g,"/")}`,{mode:t},e):e()}function L(n){return Array.isArray(n)?n:(n.startsWith("~/")?n.slice(2):n).split("/").filter(Boolean)}function U(n){return typeof n=="string"?n??"/":`/${n.join("/")}`}function W(n){const t=L(n);return t[t.length-1]||""}function Pe(n){const t=L(n);return t.pop(),U(t)}function j(n){return!n||n==="/"?"/":n.startsWith("~/")?`/${n.slice(2)}`:n.startsWith("/")?n:`/${n}`}function Te(n,t=!1){return n=n.replace(/\/$/,""),t&&!n.includes("*")?`${n}/**`:n}function Me(n,t){return y(n,t,{dot:!0,matchBase:!0})}function Re(n,t){if(!t||Array.isArray(t)&&t.length===0)return!1;const e=j(n);return(Array.isArray(t)?t:[t]).some(r=>y(e,r,{dot:!0}))}function Ie(n){const t=j(n),e=L(t),s=[];for(const r of e)if(!(r==="."||r===""))if(r===".."){if(s.length===0)continue;s.pop()}else s.push(r);return U(s)}function Ce(n){const t=W(n),e=t.lastIndexOf(".");return e<=0||e===t.length-1?"":t.slice(e)}function Le(n,t="utf-8"){return typeof n=="string"?J(n,t):n instanceof Uint8Array?n:new Uint8Array(n)}async function De(n,t="SHA-1",e=50*1024*1024){if(n instanceof File&&(n=await n.arrayBuffer()),n.byteLength>e)throw new Error(`File size ${n.byteLength} bytes exceeds maximum allowed size ${e} bytes`);const s=new Uint8Array(n),r=await crypto.subtle.digest(t,s);return Array.from(new Uint8Array(r)).map(o=>o.toString(16).padStart(2,"0")).join("")}function Fe(n,t){if(n.length!==t.length)return!1;for(let e=0;e<n.length;e++)if(n[e]!==t[e])return!1;return!0}async function ke(n){const t=await n.arrayBuffer();return new Uint8Array(t)}async function Ue(n,t,e={}){const s=W(t);return ht(t,"exclusive",async()=>{const r=e.recursive??!1,i=e.force??!1;try{await n.removeEntry(s,{recursive:r})}catch(o){if(o.name==="NotFoundError"){if(!i)throw new g(`No such file or directory: ${t}`,"ENOENT",void 0,o)}else throw o.name==="InvalidModificationError"?new g(`Directory not empty: ${t}. Use recursive option to force removal.`,"ENOTEMPTY",void 0,o):o.name==="TypeMismatchError"&&!r?new g(`Cannot remove directory without recursive option: ${t}`,"EISDIR",void 0,o):new g(`Failed to remove entry: ${t}`,"RM_FAILED",void 0,o)}})}function We(n,t,e,s){if(!Number.isInteger(t)||!Number.isInteger(e))throw new g("Invalid offset or length","EINVAL");if(t<0||e<0)throw new g("Negative offset or length not allowed","EINVAL");if(t+e>n)throw new g("Operation would overflow buffer","ERANGE");if(s!=null&&(!Number.isInteger(s)||s<0))throw new g("Invalid position","EINVAL")}function je(n,t,e){try{t.flush(),t.close()}catch(s){console.warn(`Warning: Failed to properly close file descriptor ${n} (${e}):`,s)}}function ze(n,t,e){if(n>=e)return{isEOF:!0,actualLength:0};const s=Math.min(t,e-n);return s<=0?{isEOF:!0,actualLength:0}:{isEOF:!1,actualLength:s}}async function _e(n,t){try{return await n.createSyncAccessHandle()}catch(e){throw Z(e,{path:t,isDirectory:!1})}}exports.BINARY_FILE_EXTENSIONS=X;exports.DirectoryNotFoundError=pt;exports.FileNotFoundError=ft;exports.OPFSError=g;exports.OPFSNotMountedError=lt;exports.OPFSNotSupportedError=Y;exports.PathError=ut;exports.PermissionError=dt;exports.StorageError=gt;exports.TimeoutError=mt;exports.WatchEventType=Q;exports.basename=W;exports.buffersEqual=Fe;exports.calculateFileHash=De;exports.calculateReadLength=ze;exports.checkOPFSSupport=$e;exports.convertBlobToUint8Array=ke;exports.createBuffer=Le;exports.createFDError=wt;exports.createSyncHandleSafe=_e;exports.decodeBuffer=Et;exports.dirname=Pe;exports.encodeString=J;exports.extname=Ce;exports.isBinaryFileExtension=yt;exports.isPathExcluded=Re;exports.joinPath=U;exports.mapDomError=Z;exports.matchMinimatch=Me;exports.normalizeMinimatch=Te;exports.normalizePath=j;exports.removeEntry=Ue;exports.resolvePath=Ie;exports.safeCloseSyncHandle=je;exports.splitPath=L;exports.validateReadWriteArgs=We;exports.withLock=ht;
+//# sourceMappingURL=helpers-ppMRzIAJ.cjs.map