opfs-worker 0.4.2 → 0.5.1

package/dist/assets/worker-Bra0Mewp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker-Bra0Mewp.js","sources":["../node_modules/comlink/dist/esm/comlink.mjs","../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/errors.ts","../src/utils/encoder.ts","../src/utils/helpers.ts","../src/worker.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2019 Google LLC\n * SPDX-License-Identifier: Apache-2.0\n */\nconst proxyMarker = Symbol(\"Comlink.proxy\");\nconst createEndpoint = Symbol(\"Comlink.endpoint\");\nconst releaseProxy = Symbol(\"Comlink.releaseProxy\");\nconst finalizer = Symbol(\"Comlink.finalizer\");\nconst throwMarker = Symbol(\"Comlink.thrown\");\nconst isObject = (val) => (typeof val === \"object\" && val !== null) || typeof val === \"function\";\n/**\n * Internal transfer handle to handle objects marked to proxy.\n */\nconst proxyTransferHandler = {\n    canHandle: (val) => isObject(val) && val[proxyMarker],\n    serialize(obj) {\n        const { port1, port2 } = new MessageChannel();\n        expose(obj, port1);\n        return [port2, [port2]];\n    },\n    deserialize(port) {\n        port.start();\n        return wrap(port);\n    },\n};\n/**\n * Internal transfer handler to handle thrown exceptions.\n */\nconst throwTransferHandler = {\n    canHandle: (value) => isObject(value) && throwMarker in value,\n    serialize({ value }) {\n        let serialized;\n        if (value instanceof Error) {\n            serialized = {\n                isError: true,\n                value: {\n                    message: value.message,\n                    name: value.name,\n                    stack: value.stack,\n                },\n            };\n        }\n        else {\n            serialized = { isError: false, value };\n        }\n        return [serialized, []];\n    },\n    deserialize(serialized) {\n        if (serialized.isError) {\n            throw Object.assign(new Error(serialized.value.message), serialized.value);\n        }\n        throw serialized.value;\n    },\n};\n/**\n * Allows customizing the serialization of certain values.\n */\nconst transferHandlers = new Map([\n    [\"proxy\", proxyTransferHandler],\n    [\"throw\", throwTransferHandler],\n]);\nfunction isAllowedOrigin(allowedOrigins, origin) {\n    for (const allowedOrigin of allowedOrigins) {\n        if (origin === allowedOrigin || allowedOrigin === \"*\") {\n            return true;\n        }\n        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction expose(obj, ep = globalThis, allowedOrigins = [\"*\"]) {\n    ep.addEventListener(\"message\", function callback(ev) {\n        if (!ev || !ev.data) {\n            return;\n        }\n        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {\n            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);\n            return;\n        }\n        const { id, type, path } = Object.assign({ path: [] }, ev.data);\n        const argumentList = (ev.data.argumentList || []).map(fromWireValue);\n        let returnValue;\n        try {\n            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\n            const rawValue = path.reduce((obj, prop) => obj[prop], obj);\n            switch (type) {\n                case \"GET\" /* MessageType.GET */:\n                    {\n                        returnValue = rawValue;\n                    }\n                    break;\n                case \"SET\" /* MessageType.SET */:\n                    {\n                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\n                        returnValue = true;\n                    }\n                    break;\n                case \"APPLY\" /* MessageType.APPLY */:\n                    {\n                        returnValue = rawValue.apply(parent, argumentList);\n                    }\n                    break;\n                case \"CONSTRUCT\" /* MessageType.CONSTRUCT */:\n                    {\n                        const value = new rawValue(...argumentList);\n                        returnValue = proxy(value);\n                    }\n                    break;\n                case \"ENDPOINT\" /* MessageType.ENDPOINT */:\n                    {\n                        const { port1, port2 } = new MessageChannel();\n                        expose(obj, port2);\n                        returnValue = transfer(port1, [port1]);\n                    }\n                    break;\n                case \"RELEASE\" /* MessageType.RELEASE */:\n                    {\n                        returnValue = undefined;\n                    }\n                    break;\n                default:\n                    return;\n            }\n        }\n        catch (value) {\n            returnValue = { value, [throwMarker]: 0 };\n        }\n        Promise.resolve(returnValue)\n            .catch((value) => {\n            return { value, [throwMarker]: 0 };\n        })\n            .then((returnValue) => {\n            const [wireValue, transferables] = toWireValue(returnValue);\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\n            if (type === \"RELEASE\" /* MessageType.RELEASE */) {\n                // detach and deactive after sending release response above.\n                ep.removeEventListener(\"message\", callback);\n                closeEndPoint(ep);\n                if (finalizer in obj && typeof obj[finalizer] === \"function\") {\n                    obj[finalizer]();\n                }\n            }\n        })\n            .catch((error) => {\n            // Send Serialization Error To Caller\n            const [wireValue, transferables] = toWireValue({\n                value: new TypeError(\"Unserializable return value\"),\n                [throwMarker]: 0,\n            });\n            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);\n        });\n    });\n    if (ep.start) {\n        ep.start();\n    }\n}\nfunction isMessagePort(endpoint) {\n    return endpoint.constructor.name === \"MessagePort\";\n}\nfunction closeEndPoint(endpoint) {\n    if (isMessagePort(endpoint))\n        endpoint.close();\n}\nfunction wrap(ep, target) {\n    const pendingListeners = new Map();\n    ep.addEventListener(\"message\", function handleMessage(ev) {\n        const { data } = ev;\n        if (!data || !data.id) {\n            return;\n        }\n        const resolver = pendingListeners.get(data.id);\n        if (!resolver) {\n            return;\n        }\n        try {\n            resolver(data);\n        }\n        finally {\n            pendingListeners.delete(data.id);\n        }\n    });\n    return createProxy(ep, pendingListeners, [], target);\n}\nfunction throwIfProxyReleased(isReleased) {\n    if (isReleased) {\n        throw new Error(\"Proxy has been released and is not useable\");\n    }\n}\nfunction releaseEndpoint(ep) {\n    return requestResponseMessage(ep, new Map(), {\n        type: \"RELEASE\" /* MessageType.RELEASE */,\n    }).then(() => {\n        closeEndPoint(ep);\n    });\n}\nconst proxyCounter = new WeakMap();\nconst proxyFinalizers = \"FinalizationRegistry\" in globalThis &&\n    new FinalizationRegistry((ep) => {\n        const newCount = (proxyCounter.get(ep) || 0) - 1;\n        proxyCounter.set(ep, newCount);\n        if (newCount === 0) {\n            releaseEndpoint(ep);\n        }\n    });\nfunction registerProxy(proxy, ep) {\n    const newCount = (proxyCounter.get(ep) || 0) + 1;\n    proxyCounter.set(ep, newCount);\n    if (proxyFinalizers) {\n        proxyFinalizers.register(proxy, ep, proxy);\n    }\n}\nfunction unregisterProxy(proxy) {\n    if (proxyFinalizers) {\n        proxyFinalizers.unregister(proxy);\n    }\n}\nfunction createProxy(ep, pendingListeners, path = [], target = function () { }) {\n    let isProxyReleased = false;\n    const proxy = new Proxy(target, {\n        get(_target, prop) {\n            throwIfProxyReleased(isProxyReleased);\n            if (prop === releaseProxy) {\n                return () => {\n                    unregisterProxy(proxy);\n                    releaseEndpoint(ep);\n                    pendingListeners.clear();\n                    isProxyReleased = true;\n                };\n            }\n            if (prop === \"then\") {\n                if (path.length === 0) {\n                    return { then: () => proxy };\n                }\n                const r = requestResponseMessage(ep, pendingListeners, {\n                    type: \"GET\" /* MessageType.GET */,\n                    path: path.map((p) => p.toString()),\n                }).then(fromWireValue);\n                return r.then.bind(r);\n            }\n            return createProxy(ep, pendingListeners, [...path, prop]);\n        },\n        set(_target, prop, rawValue) {\n            throwIfProxyReleased(isProxyReleased);\n            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\n            // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\n            const [value, transferables] = toWireValue(rawValue);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"SET\" /* MessageType.SET */,\n                path: [...path, prop].map((p) => p.toString()),\n                value,\n            }, transferables).then(fromWireValue);\n        },\n        apply(_target, _thisArg, rawArgumentList) {\n            throwIfProxyReleased(isProxyReleased);\n            const last = path[path.length - 1];\n            if (last === createEndpoint) {\n                return requestResponseMessage(ep, pendingListeners, {\n                    type: \"ENDPOINT\" /* MessageType.ENDPOINT */,\n                }).then(fromWireValue);\n            }\n            // We just pretend that `bind()` didn’t happen.\n            if (last === \"bind\") {\n                return createProxy(ep, pendingListeners, path.slice(0, -1));\n            }\n            const [argumentList, transferables] = processArguments(rawArgumentList);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"APPLY\" /* MessageType.APPLY */,\n                path: path.map((p) => p.toString()),\n                argumentList,\n            }, transferables).then(fromWireValue);\n        },\n        construct(_target, rawArgumentList) {\n            throwIfProxyReleased(isProxyReleased);\n            const [argumentList, transferables] = processArguments(rawArgumentList);\n            return requestResponseMessage(ep, pendingListeners, {\n                type: \"CONSTRUCT\" /* MessageType.CONSTRUCT */,\n                path: path.map((p) => p.toString()),\n                argumentList,\n            }, transferables).then(fromWireValue);\n        },\n    });\n    registerProxy(proxy, ep);\n    return proxy;\n}\nfunction myFlat(arr) {\n    return Array.prototype.concat.apply([], arr);\n}\nfunction processArguments(argumentList) {\n    const processed = argumentList.map(toWireValue);\n    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\n}\nconst transferCache = new WeakMap();\nfunction transfer(obj, transfers) {\n    transferCache.set(obj, transfers);\n    return obj;\n}\nfunction proxy(obj) {\n    return Object.assign(obj, { [proxyMarker]: true });\n}\nfunction windowEndpoint(w, context = globalThis, targetOrigin = \"*\") {\n    return {\n        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),\n        addEventListener: context.addEventListener.bind(context),\n        removeEventListener: context.removeEventListener.bind(context),\n    };\n}\nfunction toWireValue(value) {\n    for (const [name, handler] of transferHandlers) {\n        if (handler.canHandle(value)) {\n            const [serializedValue, transferables] = handler.serialize(value);\n            return [\n                {\n                    type: \"HANDLER\" /* WireValueType.HANDLER */,\n                    name,\n                    value: serializedValue,\n                },\n                transferables,\n            ];\n        }\n    }\n    return [\n        {\n            type: \"RAW\" /* WireValueType.RAW */,\n            value,\n        },\n        transferCache.get(value) || [],\n    ];\n}\nfunction fromWireValue(value) {\n    switch (value.type) {\n        case \"HANDLER\" /* WireValueType.HANDLER */:\n            return transferHandlers.get(value.name).deserialize(value.value);\n        case \"RAW\" /* WireValueType.RAW */:\n            return value.value;\n    }\n}\nfunction requestResponseMessage(ep, pendingListeners, msg, transfers) {\n    return new Promise((resolve) => {\n        const id = generateUUID();\n        pendingListeners.set(id, resolve);\n        if (ep.start) {\n            ep.start();\n        }\n        ep.postMessage(Object.assign({ id }, msg), transfers);\n    });\n}\nfunction generateUUID() {\n    return new Array(4)\n        .fill(0)\n        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\n        .join(\"-\");\n}\n\nexport { createEndpoint, expose, finalizer, proxy, proxyMarker, releaseProxy, transfer, transferHandlers, windowEndpoint, wrap };\n//# sourceMappingURL=comlink.mjs.map\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","/**\n * Base error class for all OPFS-related errors\n */\nexport class OPFSError extends Error {\n    constructor(message: string, public readonly code: string, public readonly path?: string) {\n        super(message);\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() {\n        super('OPFS is not supported in this browser', 'OPFS_NOT_SUPPORTED');\n    }\n}\n\n\n/**\n * Error thrown when OPFS is not mounted\n */\nexport class OPFSNotMountedError extends OPFSError {\n    constructor() {\n        super('OPFS is not mounted', 'OPFS_NOT_MOUNTED');\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) {\n        super(message, 'INVALID_PATH', path);\n    }\n}\n\n/**\n * Error thrown when a requested file doesn't exist\n */\nexport class FileNotFoundError extends OPFSError {\n    constructor(path: string) {\n        super(`File not found: ${ path }`, 'FILE_NOT_FOUND', path);\n    }\n}\n\n/**\n * Error thrown when a requested directory doesn't exist\n */\nexport class DirectoryNotFoundError extends OPFSError {\n    constructor(path: string) {\n        super(`Directory not found: ${ path }`, 'DIRECTORY_NOT_FOUND', path);\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) {\n        super(`Permission denied for ${ operation } on: ${ path }`, 'PERMISSION_DENIED', path);\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) {\n        super(message, 'STORAGE_ERROR', path);\n    }\n}\n\n/**\n * Error thrown when an operation times out\n */\nexport class TimeoutError extends OPFSError {\n    constructor(operation: string, path?: string) {\n        super(`Operation timed out: ${ operation }`, 'TIMEOUT_ERROR', path);\n    }\n}\n","import { OPFSError } from './errors';\n\nimport type { BufferEncoding } from 'typescript';\n\nexport function encodeString(data: string, encoding: BufferEncoding = '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 '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: BufferEncoding = 'utf-8'): string {\n    switch (encoding) {\n        case 'utf8':\n        case 'utf-8':\n            return new TextDecoder().decode(buffer);\n\n        case 'utf16le':\n        case 'ucs2':\n        case 'ucs-2':\n            return decodeUtf16LE(buffer);\n\n        case 'latin1':\n            return String.fromCharCode(...buffer);\n\n        case 'binary':\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 { minimatch } from 'minimatch';\n\nimport { encodeString } from './encoder';\nimport { OPFSError, OPFSNotSupportedError } from './errors';\n\nimport type { BufferEncoding } from 'typescript';\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\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\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: BufferEncoding = '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/**\n * Read raw binary data from a file using a file handle\n *\n * @param fileHandle - The file handle to read from\n * @returns The raw binary data as Uint8Array\n */\nexport async function readFileData(fileHandle: FileSystemFileHandle): Promise<Uint8Array> {\n    const handle = await fileHandle.createSyncAccessHandle();\n\n    try {\n        const size = handle.getSize();\n        const buffer = new Uint8Array(size);\n\n        handle.read(buffer, { at: 0 });\n\n        return buffer;\n    }\n    finally {\n        handle.close();\n    }\n}\n\n/**\n * Write data to a file using a file handle\n *\n * @param fileHandle - The file handle to write to\n * @param data - The data to write to the file\n * @param encoding - The encoding to use\n * @param options - Write options (truncate or append)\n */\nexport async function writeFileData(\n    fileHandle: FileSystemFileHandle,\n    data: string | Uint8Array | ArrayBuffer,\n    encoding?: BufferEncoding,\n    options: { truncate?: boolean; append?: boolean } = {}\n): Promise<void> {\n    let handle: FileSystemSyncAccessHandle | null = null;\n\n    try {\n        handle = await fileHandle.createSyncAccessHandle();\n\n        const buffer = createBuffer(data, encoding);\n        const writeOffset = options.append ? handle.getSize() : 0;\n\n        handle.write(buffer, { at: writeOffset });\n\n        if (options.truncate && !options.append) {\n            handle.truncate(buffer.byteLength);\n        }\n\n        handle.flush();\n    }\n    catch (error) {\n        console.error(error);\n        const operation = options.append ? 'append' : 'write';\n\n        throw new OPFSError(`Failed to ${ operation } file`, `${ operation.toUpperCase() }_FAILED`);\n    }\n    finally {\n        if (handle) {\n            try {\n                handle.close();\n            }\n            catch { /* ~ */ }\n        }\n    }\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 * 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 */\nexport async function convertBlobToUint8Array(blob: Blob): Promise<Uint8Array> {\n    const arrayBuffer = await blob.arrayBuffer();\n\n    return new Uint8Array(arrayBuffer);\n}\n","import { expose } from 'comlink';\nimport { minimatch } from 'minimatch';\n\nimport { decodeBuffer } from './utils/encoder';\nimport {\n    FileNotFoundError,\n    OPFSError,\n    OPFSNotMountedError,\n    PathError\n} from './utils/errors';\n\nimport { \n    calculateFileHash, \n    checkOPFSSupport, \n    joinPath, \n    readFileData, \n    splitPath, \n    writeFileData,\n    basename,\n    dirname,\n    normalizePath,\n    resolvePath,\n    convertBlobToUint8Array,\n    isPathExcluded\n} from './utils/helpers';\n\nimport type { DirentData, FileStat, WatchEvent, OPFSOptions, WatchOptions } from './types';\nimport type { BufferEncoding } from 'typescript';\n\n/**\n * OPFS (Origin Private File System) File System implementation\n * \n * This class provides a high-level interface for working with the browser's\n * Origin Private File System API, offering file and directory operations\n * similar to Node.js fs module.\n * \n * @example\n * ```typescript\n * const fs = new OPFSFileSystem();\n * await fs.init('/my-app');\n * await fs.writeFile('/data/config.json', JSON.stringify({ theme: 'dark' }));\n * const config = await fs.readFile('/data/config.json');\n * ```\n */\nexport class OPFSWorker {\n    /** Root directory handle for the file system */\n    private root: FileSystemDirectoryHandle | null = null;\n    \n    /** Map of watched paths to their last known state and options */\n    private watchers = new Map<string, { snapshot: Map<string, FileStat>; options: WatchOptions }>();\n\n    /** Interval handle for polling watched paths */\n    private watchTimer: ReturnType<typeof setInterval> | null = null;\n\n    /** Flag to avoid concurrent scans */\n    private scanning = false;\n\n    /** Promise to prevent concurrent mount operations */\n    private mountingPromise: Promise<boolean> | null = null;\n\n    /** BroadcastChannel instance for sending events */\n    private broadcastChannel: BroadcastChannel | null = null;\n\n    /** Configuration options */\n    private options: Required<OPFSOptions> = {\n        root: '/',\n        watchInterval: 1000,\n        maxFileSize: 50 * 1024 * 1024,\n        hashAlgorithm: null,\n        broadcastChannel: 'opfs-worker',\n    };\n    \n\n    /**\n     * Notify about internal changes to the file system\n     * \n     * This method is called by internal operations to notify clients about\n     * changes, even when no specific paths are being watched.\n     * \n     * @param path - The path that was changed\n     * @param type - The type of change (create, change, delete)\n     */\n    private async notifyChange(event: Omit<WatchEvent, 'timestamp' | 'hash' | 'root'>): Promise<void> {\n        if (!this.options.broadcastChannel) {\n            return;\n        }\n\n        // Calculate hash if hashing is enabled and this is a file operation\n        let hash: string | undefined;\n        \n        if (this.options.hashAlgorithm && !event.isDirectory && event.type !== 'removed') {\n            try {\n                const stats = await this.stat(event.path);\n\n                if (stats.isFile && stats.hash) {\n                    hash = stats.hash;\n                }\n            } \n        catch (error) {\n                console.warn(`Failed to calculate hash for ${event.path}:`, error);\n            }\n        }\n\n        // Send event via BroadcastChannel\n        try {\n            if (!this.broadcastChannel) {\n                this.broadcastChannel = new BroadcastChannel(this.options.broadcastChannel);\n            }\n            \n            const watchEvent: WatchEvent = {\n                root: this.options.root,\n                timestamp: new Date().toISOString(),\n                ...event,\n                ...(hash && { hash })\n            };\n            \n            this.broadcastChannel.postMessage(watchEvent);\n        } \n        catch (error) {\n            console.warn(`Failed to send event via BroadcastChannel:`, error);\n        }\n    }\n\n    /**\n     * Creates a new OPFSFileSystem instance\n     * \n     * @param options - Optional configuration options\n     * @param options.root - Root path for the file system (default: '/')\n     * @param options.watchInterval - Polling interval in milliseconds for file watching\n     * @param options.hashAlgorithm - Hash algorithm for file hashing\n     * @param options.maxFileSize - Maximum file size for hashing in bytes (default: 50MB)\n     * @throws {OPFSError} If OPFS is not supported in the current browser\n     */\n    constructor(options?: OPFSOptions) {\n        checkOPFSSupport();\n        \n        if (options) {\n            this.setOptions(options);\n        }\n    }\n\n    /**\n     * Initialize the file system within a given directory\n     * \n     * This method sets up the root directory for all subsequent operations.\n     * If no root is specified, it will use the OPFS root directory.\n     * \n     * @param root - The root path for the file system (default: '/')\n     * @returns Promise that resolves to true if initialization was successful\n     * @throws {OPFSError} If initialization fails\n     * \n     * @example\n     * ```typescript\n     * const fs = new OPFSFileSystem();\n     * \n     * // Use OPFS root (default)\n     * await fs.mount();\n     * \n     * // Use custom directory\n     * await fs.mount('/my-app');\n     * ```\n     */\n    private async mount(root: string = this.options.root): Promise<boolean> {\n        // If already mounting, wait for previous operation to complete first\n        if (this.mountingPromise) {\n            await this.mountingPromise;\n        }\n        \n        root = normalizePath(root);\n\n        this.mountingPromise = new Promise<boolean>(async(resolve, reject) => {\n            this.root = null;\n    \n            try {\n                const rootDir = await navigator.storage.getDirectory();\n    \n                if (root === '/') {\n                    this.root = rootDir;\n                } \n                else {\n                    this.root = await this.getDirectoryHandle(root, true, rootDir);\n                }\n                \n                resolve(true);\n            }\n            catch (error) {\n                console.error(error);\n                reject(new OPFSError('Failed to initialize OPFS', 'INIT_FAILED'));\n            }\n            finally {\n                this.mountingPromise = null;\n            }\n        });\n\n        return this.mountingPromise;\n    }\n\n\n    /**\n     * Update configuration options\n     * \n     * @param options - Configuration options to update\n     * @param options.root - Root path for the file system\n     * @param options.watchInterval - Polling interval in milliseconds for file watching\n     * @param options.hashAlgorithm - Hash algorithm for file hashing\n     * @param options.maxFileSize - Maximum file size for hashing in bytes\n     * @param options.broadcastChannel - Custom name for the broadcast channel\n     */\n    async setOptions(options: OPFSOptions): Promise<void> {\n        if (options.watchInterval !== undefined) {\n            this.options.watchInterval = options.watchInterval;\n        }\n\n        if (options.hashAlgorithm !== undefined) {\n            this.options.hashAlgorithm = options.hashAlgorithm;\n        }\n\n        if (options.maxFileSize !== undefined) {\n            this.options.maxFileSize = options.maxFileSize;\n        }\n\n        if (options.broadcastChannel !== undefined) {\n            // Close existing channel if name changed\n            if (this.broadcastChannel && this.options.broadcastChannel !== options.broadcastChannel) {\n                this.broadcastChannel.close();\n                this.broadcastChannel = null;\n            }\n            \n            this.options.broadcastChannel = options.broadcastChannel;\n        }\n        \n        if (options.root !== undefined) {\n            this.options.root = options.root;\n            await this.mount(this.options.root);\n        }\n    }\n\n    /**\n     * Get a directory handle from a path\n     * \n     * Navigates through the directory structure to find or create a directory\n     * at the specified path.\n     * \n     * @param path - The path to the directory (string or array of segments)\n     * @param create - Whether to create the directory if it doesn't exist (default: false)\n     * @param from - The directory to start from (default: root directory)\n     * @returns Promise that resolves to the directory handle\n     * @throws {OPFSError} If the directory cannot be accessed or created\n     * \n     * @example\n     * ```typescript\n     * const docsDir = await fs.getDirectoryHandle('/users/john/documents', true);\n     * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);\n     * ```\n     */\n    private async getDirectoryHandle(path: string | string[], create: boolean = false, from: FileSystemDirectoryHandle | null = this.root): Promise<FileSystemDirectoryHandle> {\n        if (!from) {\n            throw new OPFSNotMountedError();\n        }\n\n        const segments = Array.isArray(path) ? path : splitPath(path);\n        let current = from;\n\n        for (const segment of segments) {\n            current = await current.getDirectoryHandle(segment, { create });\n        }\n\n        return current;\n    }\n\n    /**\n     * Get a file handle from a path\n     * \n     * Navigates to the parent directory and retrieves or creates a file handle\n     * for the specified file path.\n     * \n     * @param path - The path to the file (string or array of segments)\n     * @param create - Whether to create the file if it doesn't exist (default: false)\n     * @param from - The directory to start from (default: root directory)\n     * @returns Promise that resolves to the file handle\n     * @throws {PathError} If the path is empty\n     * @throws {OPFSError} If the file cannot be accessed or created\n     * \n     * @example\n     * ```typescript\n     * const fileHandle = await fs.getFileHandle('/config/settings.json', true);\n     * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);\n     * ```\n     */\n    private async getFileHandle(path: string | string[], create = false, from: FileSystemDirectoryHandle | null = this.root): Promise<FileSystemFileHandle> {\n        if (!from) {\n            throw new OPFSNotMountedError();\n        }\n\n        const segments = splitPath(path);\n\n        if (segments.length === 0) {\n            throw new PathError('Path must not be empty', Array.isArray(path) ? path.join('/') : path);\n        }\n\n        const fileName = segments.pop()!;\n        const dir = await this.getDirectoryHandle(segments, create, from);\n\n        return dir.getFileHandle(fileName, { create });\n    }\n\n    /**\n     * Get a complete index of all files and directories in the file system\n     * \n     * This method recursively traverses the entire file system and returns\n     * a Map containing FileStat objects for every file and directory.\n     * \n     * @returns Promise that resolves to a Map of paths to FileStat objects\n     * @throws {OPFSError} If the file system is not mounted\n     * \n     * @example\n     * ```typescript\n     * const index = await fs.index();\n     * const fileStats = index.get('/data/config.json');\n     * if (fileStats) {\n     *   console.log(`File size: ${fileStats.size} bytes`);\n     *   if (fileStats.hash) console.log(`Hash: ${fileStats.hash}`);\n     * }\n     * ```\n     */\n    async index(): Promise<Map<string, FileStat>> {\n        const result = new Map<string, FileStat>();\n\n        const walk = async(dirPath: string) => {\n            const items = await this.readDir(dirPath);\n\n            for (const item of items) {\n                const fullPath = `${ dirPath === '/' ? '' : dirPath }/${ item.name }`;\n\n                try {\n                    const stat = await this.stat(fullPath);\n\n                    result.set(fullPath, stat);\n\n                    if (stat.isDirectory) {\n                        await walk(fullPath);\n                    }\n                }\n                catch (err) {\n                    console.warn(`Skipping broken entry: ${ fullPath }`, err);\n                }\n            }\n        };\n\n        result.set('/', {\n            kind: 'directory',\n            size: 0,\n            mtime: new Date(0).toISOString(),\n            ctime: new Date(0).toISOString(),\n            isFile: false,\n            isDirectory: true,\n        });\n\n        await walk('/');\n\n        return result;\n    }\n\n    /**\n     * Read a file from the file system\n     * \n     * Reads the contents of a file and returns it as a string or binary data\n     * depending on the specified encoding.\n     * \n     * @param path - The path to the file to read\n     * @param encoding - The encoding to use for reading the file\n     * @returns Promise that resolves to the file contents\n     * @throws {FileNotFoundError} If the file does not exist\n     * @throws {OPFSError} If reading the file fails\n     * \n     * @example\n     * ```typescript\n     * // Read as text\n     * const content = await fs.readFile('/config/settings.json');\n     * \n     * // Read as binary\n     * const binaryData = await fs.readFile('/images/logo.png', 'binary');\n     * \n     * // Read with specific encoding\n     * const utf8Content = await fs.readFile('/data/utf8.txt', 'utf-8');\n     * ```\n     */\n    async readFile(path: string, encoding: 'binary'): Promise<Uint8Array>;\n    async readFile(path: string, encoding?: BufferEncoding): Promise<string>;\n    async readFile(\n        path: string,\n        encoding: BufferEncoding | 'binary' = 'utf-8'\n    ): Promise<string | Uint8Array> {\n        await this.mount();\n        \n        try {\n            const fileHandle = await this.getFileHandle(path, false);\n            const buffer = await readFileData(fileHandle);\n\n            if (encoding === 'binary') {\n                return buffer;\n            }\n\n            return decodeBuffer(buffer, encoding);\n        }\n        catch (err) {\n            console.error(err);\n\n            throw new FileNotFoundError(path);\n        }\n    }\n\n    /**\n     * Write data to a file\n     * \n     * Creates or overwrites a file with the specified data. If the file already\n     * exists, it will be truncated before writing.\n     * \n     * @param path - The path to the file to write\n     * @param data - The data to write to the file (string, Uint8Array, or ArrayBuffer)\n     * @param encoding - The encoding to use when writing string data (default: 'utf-8')\n     * @returns Promise that resolves when the write operation is complete\n     * @throws {OPFSError} If writing the file fails\n     * \n     * @example\n     * ```typescript\n     * // Write text data\n     * await fs.writeFile('/config/settings.json', JSON.stringify({ theme: 'dark' }));\n     * \n     * // Write binary data\n     * const binaryData = new Uint8Array([1, 2, 3, 4, 5]);\n     * await fs.writeFile('/data/binary.dat', binaryData);\n     * \n     * // Write with specific encoding\n     * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');\n     * ```\n     */\n    async writeFile(\n        path: string,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: BufferEncoding\n    ): Promise<void> {\n        await this.mount();\n        \n        const fileHandle = await this.getFileHandle(path, true);\n\n        await writeFileData(fileHandle, data, encoding, { truncate: true });\n        await this.notifyChange({ path, type: 'changed', isDirectory: false });\n    }\n\n    /**\n     * Append data to a file\n     * \n     * Adds data to the end of an existing file. If the file doesn't exist,\n     * it will be created.\n     * \n     * @param path - The path to the file to append to\n     * @param data - The data to append to the file (string, Uint8Array, or ArrayBuffer)\n     * @param encoding - The encoding to use when appending string data (default: 'utf-8')\n     * @returns Promise that resolves when the append operation is complete\n     * @throws {OPFSError} If appending to the file fails\n     * \n     * @example\n     * ```typescript\n     * // Append text to a log file\n     * await fs.appendFile('/logs/app.log', `[${new Date().toISOString()}] User logged in\\n`);\n     * \n     * // Append binary data\n     * const additionalData = new Uint8Array([6, 7, 8]);\n     * await fs.appendFile('/data/binary.dat', additionalData);\n     * ```\n     */\n    async appendFile(\n        path: string,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: BufferEncoding\n    ): Promise<void> {\n        await this.mount();\n        \n        const fileHandle = await this.getFileHandle(path, true);\n\n        await writeFileData(fileHandle, data, encoding, { append: true });\n        await this.notifyChange({ path, type: 'changed', isDirectory: false });\n    }\n\n    /**\n     * Create a directory\n     * \n     * Creates a new directory at the specified path. If the recursive option\n     * is enabled, parent directories will be created as needed.\n     * \n     * @param path - The path where the directory should be created\n     * @param options - Options for directory creation\n     * @param options.recursive - Whether to create parent directories if they don't exist (default: false)\n     * @returns Promise that resolves when the directory is created\n     * @throws {OPFSError} If the directory cannot be created\n     * \n     * @example\n     * ```typescript\n     * // Create a single directory\n     * await fs.mkdir('/users/john');\n     * \n     * // Create nested directories\n     * await fs.mkdir('/users/john/documents/projects', { recursive: true });\n     * ```\n     */\n    async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {\n        await this.mount();\n\n        if (!this.root) {\n            throw new OPFSNotMountedError();\n        }\n\n        const recursive = options?.recursive ?? false;\n        const segments = splitPath(path);\n\n        let current = this.root;\n\n        for (let i = 0; i < segments.length; i++) {\n            const segment = segments[i];\n\n            try {\n                current = await current.getDirectoryHandle(segment!, { create: recursive || i === segments.length - 1 });\n            }\n            catch (e: any) {\n                if (e.name === 'NotFoundError') {\n                    throw new OPFSError(\n                        `Parent directory does not exist: ${ joinPath(segments.slice(0, i + 1)) }`,\n                        'ENOENT'\n                    );\n                }\n\n                if (e.name === 'TypeMismatchError') {\n                    throw new OPFSError(`Path segment is not a directory: ${ segment }`, 'ENOTDIR');\n                }\n\n                throw new OPFSError('Failed to create directory', 'MKDIR_FAILED');\n            }\n        }\n        await this.notifyChange({ path, type: 'added', isDirectory: true });\n    }\n\n    /**\n     * Get file or directory statistics\n     * \n     * Returns detailed information about a file or directory, including\n     * size, modification time, and optionally a hash of the file content.\n     * \n     * @param path - The path to the file or directory\n     * @returns Promise that resolves to FileStat object\n     * @throws {OPFSError} If the path does not exist or cannot be accessed\n     * \n     * @example\n     * ```typescript\n     * const stats = await fs.stat('/data/config.json');\n     * console.log(`File size: ${stats.size} bytes`);\n     * console.log(`Last modified: ${stats.mtime}`);\n     * \n     * // If hashing is enabled, hash will be included\n     * if (stats.hash) {\n     *   console.log(`Hash: ${stats.hash}`);\n     * }\n     * ```\n     */\n    async stat(path: string): Promise<FileStat> {\n        await this.mount();\n        \n        // Special handling for root directory\n        if (path === '/') {\n            return {\n                kind: 'directory',\n                size: 0,\n                mtime: new Date(0).toISOString(),\n                ctime: new Date(0).toISOString(),\n                isFile: false,\n                isDirectory: true,\n            };\n        }\n        \n        const name = basename(path);\n        const parentDir = await this.getDirectoryHandle(dirname(path), false);\n        const includeHash = this.options.hashAlgorithm !== null;\n\n        try {\n            const fileHandle = await parentDir.getFileHandle(name!, { create: false });\n            const file = await fileHandle.getFile();\n\n            const baseStat: FileStat = {\n                kind: 'file',\n                size: file.size,\n                mtime: new Date(file.lastModified).toISOString(),\n                ctime: new Date(file.lastModified).toISOString(),\n                isFile: true,\n                isDirectory: false,\n            };\n\n            if (includeHash && this.options.hashAlgorithm) {\n                try {\n                    const hash = await calculateFileHash(file, this.options.hashAlgorithm, this.options.maxFileSize);\n\n                    baseStat.hash = hash;\n                }\n                catch (error) {\n                    console.warn(`Failed to calculate hash for ${ path }:`, error);\n                }\n            }\n\n            return baseStat;\n        }\n        catch (e: any) {\n            if (e.name !== 'TypeMismatchError' && e.name !== 'NotFoundError') {\n                throw new OPFSError('Failed to stat (file)', 'STAT_FAILED');\n            }\n        }\n\n        try {\n            await parentDir.getDirectoryHandle(name!, { create: false });\n\n            return {\n                kind: 'directory',\n                size: 0,\n                mtime: new Date(0).toISOString(),\n                ctime: new Date(0).toISOString(),\n                isFile: false,\n                isDirectory: true,\n            };\n        }\n        catch (e: any) {\n            if (e.name === 'NotFoundError') {\n                throw new OPFSError(`No such file or directory: ${ path }`, 'ENOENT');\n            }\n\n            throw new OPFSError('Failed to stat (directory)', 'STAT_FAILED');\n        }\n    }\n\n    /**\n     * Read a directory's contents\n     * \n     * Lists all files and subdirectories within the specified directory.\n     * \n     * @param path - The path to the directory to read\n     * @returns Promise that resolves to an array of detailed file/directory information\n     * @throws {OPFSError} If the directory does not exist or cannot be accessed\n     * \n     * @example\n     * ```typescript\n     * // Get detailed information about files and directories\n     * const detailed = await fs.readDir('/users/john/documents');\n     * detailed.forEach(item => {\n     *   console.log(`${item.name} - ${item.isFile ? 'file' : 'directory'}`);\n     * });\n     * ```\n     */\n    async readDir(path: string): Promise<DirentData[]> {\n        await this.mount();\n        \n        const dir = await this.getDirectoryHandle(path, false);\n\n        const results: DirentData[] = [];\n\n        for await (const [name, handle] of (dir as any).entries()) {\n            const isFile = handle.kind === 'file';\n\n            results.push({\n                name,\n                kind: handle.kind,\n                isFile,\n                isDirectory: !isFile,\n            });\n        }\n\n        return results;\n    }\n\n    /**\n     * Check if a file or directory exists\n     * \n     * Verifies if a file or directory exists at the specified path.\n     * \n     * @param path - The path to check\n     * @returns Promise that resolves to true if the file or directory exists, false otherwise  \n     * \n     * @example\n     * ```typescript\n     * const exists = await fs.exists('/config/settings.json');\n     * console.log(`File exists: ${exists}`);\n     * ```\n     */\n    async exists(path: string): Promise<boolean> {\n        await this.mount();\n        \n        if (path === '/') {\n            return true;\n        }\n        \n        const name = basename(path);\n        let dir: FileSystemDirectoryHandle | null = null;\n\n        try {\n            dir = await this.getDirectoryHandle(dirname(path), false);\n        }\n        catch (e: any) {\n            if (e.name === 'NotFoundError' || e.name === 'TypeMismatchError') {\n                dir = null;\n            }\n\n            throw e;\n        }\n\n        if (!dir || !name) {\n            return false;\n        }\n\n        try {\n            await dir.getFileHandle(name, { create: false });\n\n            return true;\n        }\n        catch (e: any) {\n            if (e.name !== 'NotFoundError' && e.name !== 'TypeMismatchError') {\n                throw e;\n            }\n        }\n\n        try {\n            await dir.getDirectoryHandle(name, { create: false });\n\n            return true;\n        }\n        catch (e: any) {\n            if (e.name !== 'NotFoundError' && e.name !== 'TypeMismatchError') {\n                throw e;\n            }\n        }\n\n        return false;\n    }\n\n    /**\n     * Clear all contents of a directory without removing the directory itself\n     * \n     * Removes all files and subdirectories within the specified directory,\n     * but keeps the directory itself.\n     * \n     * @param path - The path to the directory to clear (default: '/')\n     * @returns Promise that resolves when all contents are removed\n     * @throws {OPFSError} If the operation fails\n     * \n     * @example\n     * ```typescript\n     * // Clear root directory contents\n     * await fs.clear('/');\n     * \n     * // Clear specific directory contents\n     * await fs.clear('/data');\n     * ```\n     */\n    async clear(path: string = '/'): Promise<void> {\n        await this.mount();\n        \n        try {\n            const items = await this.readDir(path);\n\n            for (const item of items) {\n                const itemPath = `${ path === '/' ? '' : path }/${ item.name }`;\n\n                await this.remove(itemPath, { recursive: true });\n            }\n            \n            // Notify about the clear operation\n            await this.notifyChange({ path, type: 'changed', isDirectory: true });\n        }\n        catch (error: any) {\n            if (error instanceof OPFSError) {\n                throw error;\n            }\n\n            throw new OPFSError(`Failed to clear directory: ${ path }`, 'CLEAR_FAILED');\n        }\n    }\n\n    /**\n     * Remove files and directories\n     * \n     * Removes files and directories. Similar to Node.js fs.rm().\n     * \n     * @param path - The path to remove\n     * @param options - Options for removal\n     * @param options.recursive - Whether to remove directories and their contents recursively (default: false)\n     * @param options.force - Whether to ignore errors if the path doesn't exist (default: false)\n     * @returns Promise that resolves when the removal is complete\n     * @throws {OPFSError} If the removal fails\n     * \n     * @example\n     * ```typescript\n     * // Remove a file\n     * await fs.rm('/path/to/file.txt');\n     * \n     * // Remove a directory and all its contents\n     * await fs.rm('/path/to/directory', { recursive: true });\n     * \n     * // Remove with force (ignore if doesn't exist)\n     * await fs.rm('/maybe/exists', { force: true });\n     * ```\n     */\n    async remove(path: string, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        await this.mount();\n        \n        const recursive = options?.recursive ?? false;\n        const force = options?.force ?? false;\n\n        // Special handling for root directory\n        if (path === '/') {\n            throw new OPFSError('Cannot remove root directory', 'EROOT');\n        }\n\n        const name = basename(path);\n\n        if (!name) {\n            throw new PathError('Invalid path', path);\n        }\n\n        const parent = await this.getDirectoryHandle(dirname(path), false);\n\n        try {\n            await parent.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');\n                }\n            }\n            else if (e.name === 'InvalidModificationError') {\n                throw new OPFSError(`Directory not empty: ${ path }. Use recursive option to force removal.`, 'ENOTEMPTY');\n            }\n            else if (e.name === 'TypeMismatchError' && !recursive) {\n                throw new OPFSError(`Cannot remove directory without recursive option: ${ path }`, 'EISDIR');\n            }\n            else {\n                throw new OPFSError(`Failed to remove path: ${ path }`, 'RM_FAILED');\n            }\n        }\n        \n        await this.notifyChange({ path, type: 'removed', isDirectory: false });\n    }\n\n    /**\n     * Resolve a path to an absolute path\n     * \n     * Resolves relative paths and normalizes path segments (like '..' and '.').\n     * Similar to Node.js fs.realpath() but without symlink resolution since OPFS doesn't support symlinks.\n     * \n     * @param path - The path to resolve\n     * @returns Promise that resolves to the absolute normalized path\n     * @throws {FileNotFoundError} If the path does not exist\n     * @throws {OPFSError} If path resolution fails\n     * \n     * @example\n     * ```typescript\n     * // Resolve relative path\n     * const absolute = await fs.realpath('./config/../data/file.txt');\n     * console.log(absolute); // '/data/file.txt'\n     * ```\n     */\n    async realpath(path: string): Promise<string> {\n        await this.mount();\n        \n        try {\n            const normalizedPath = resolvePath(path);\n            const exists = await this.exists(normalizedPath);\n\n            if (!exists) {\n                throw new FileNotFoundError(normalizedPath);\n            }\n\n            return normalizedPath;\n        }\n        catch (error) {\n            if (error instanceof OPFSError) {\n                throw error;\n            }\n\n            throw new OPFSError(`Failed to resolve path: ${ path }`, 'REALPATH_FAILED');\n        }\n    }\n\n    /**\n     * Rename a file or directory\n     * \n     * Changes the name of a file or directory. If the target path already exists,\n     * it will be replaced.\n     * \n     * @param oldPath - The current path of the file or directory\n     * @param newPath - The new path for the file or directory\n     * @returns Promise that resolves when the rename operation is complete\n     * @throws {OPFSError} If the rename operation fails\n     * \n     * @example\n     * ```typescript\n     * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');\n     * ```\n     */\n    async rename(oldPath: string, newPath: string): Promise<void> {\n        await this.mount();\n        \n        try {\n            const sourceExists = await this.exists(oldPath);\n\n            if (!sourceExists) {\n                throw new FileNotFoundError(oldPath);\n            }\n\n            await this.copy(oldPath, newPath, { recursive: true });\n            await this.remove(oldPath, { recursive: true });\n            \n            // Notify about the rename operation\n            await this.notifyChange({ path: oldPath, type: 'removed', isDirectory: false });\n            await this.notifyChange({ path: newPath, type: 'added', isDirectory: false });\n        }\n        catch (error) {\n            if (error instanceof OPFSError) {\n                throw error;\n            }\n\n            throw new OPFSError(`Failed to rename from ${ oldPath } to ${ newPath }`, 'RENAME_FAILED');\n        }\n    }\n\n    /**\n     * Copy files and directories\n     * \n     * Copies files and directories. Similar to Node.js fs.cp().\n     * \n     * @param source - The source path to copy from\n     * @param destination - The destination path to copy to\n     * @param options - Options for copying\n     * @param options.recursive - Whether to copy directories recursively (default: false)\n     * @param options.force - Whether to overwrite existing files (default: true)\n     * @returns Promise that resolves when the copy operation is complete\n     * @throws {OPFSError} If the copy operation fails\n     * \n     * @example\n     * ```typescript\n     * // Copy a file\n     * await fs.copy('/source/file.txt', '/dest/file.txt');\n     * \n     * // Copy a directory and all its contents\n     * await fs.copy('/source/dir', '/dest/dir', { recursive: true });\n     * \n     * // Copy without overwriting existing files\n     * await fs.copy('/source', '/dest', { recursive: true, force: false });\n     * ```\n     */\n    async copy(source: string, destination: string, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        await this.mount();\n        \n        try {\n            const recursive = options?.recursive ?? false;\n            const force = options?.force ?? true;\n\n            const sourceExists = await this.exists(source);\n\n            if (!sourceExists) {\n                throw new OPFSError(`Source does not exist: ${ source }`, 'ENOENT');\n            }\n\n            const destExists = await this.exists(destination);\n\n            if (destExists && !force) {\n                throw new OPFSError(`Destination already exists: ${ destination }`, 'EEXIST');\n            }\n\n            const sourceStats = await this.stat(source);\n\n            if (sourceStats.isFile) {\n                const content = await this.readFile(source, 'binary');\n                \n                await this.writeFile(destination, content);\n            }\n            else {\n                if (!recursive) {\n                    throw new OPFSError(`Cannot copy directory without recursive option: ${ source }`, 'EISDIR');\n                }\n\n                await this.mkdir(destination, { recursive: true });\n\n                const items = await this.readDir(source);\n\n                for (const item of items) {\n                    const sourceItemPath = `${ source }/${ item.name }`;\n                    const destItemPath = `${ destination }/${ item.name }`;\n\n                    await this.copy(sourceItemPath, destItemPath, { recursive: true, force });\n                }\n            }\n            \n            // Notify about the copy operation\n            await this.notifyChange({ path: destination, type: 'added', isDirectory: false });\n        }\n        catch (error) {\n            if (error instanceof OPFSError) {\n                throw error;\n            }\n\n            throw new OPFSError(`Failed to copy from ${ source } to ${ destination }`, 'CP_FAILED');\n        }\n    }\n\n    /**\n     * Start watching a file or directory for changes\n     * \n     * @param path - The path to watch\n     * @param options - Watch options\n     * @param options.recursive - Whether to watch recursively (default: true)\n     * @param options.excludes - Glob pattern(s) to exclude (minimatch).\n     * @returns Promise that resolves when watching starts\n     * \n     * @example\n     * ```typescript\n     * // Watch entire directory tree recursively (default)\n     * await fs.watch('/data');\n     * \n     * // Watch only immediate children (shallow)\n     * await fs.watch('/data', { recursive: false });\n     * \n     * // Watch a single file\n     * await fs.watch('/config.json', { recursive: false });\n     * ```\n     */\n    async watch(path: string, options?: WatchOptions): Promise<void> {\n        await this.mount();\n        \n        const normalizedPath = normalizePath(path);\n        const watchOptions: WatchOptions = { recursive: true, ...options };\n        const snapshot = await this.buildSnapshot(normalizedPath, watchOptions);\n\n        this.watchers.set(normalizedPath, { snapshot, options: watchOptions });\n\n        if (!this.watchTimer) {\n            this.watchTimer = setInterval(() => {\n                void this.scanWatches();\n            }, this.options.watchInterval);\n        }\n    }\n\n    /**\n     * Stop watching a previously watched path\n     */\n    unwatch(path: string): void {\n        const normalizedPath = normalizePath(path);\n        this.watchers.delete(normalizedPath);\n\n        if (this.watchers.size === 0 && this.watchTimer) {\n            clearInterval(this.watchTimer);\n            this.watchTimer = null;\n        }\n    }\n\n    /**\n     * Dispose of resources and clean up the file system instance\n     * \n     * This method should be called when the file system instance is no longer needed\n     * to properly clean up resources like the broadcast channel and watch timers.\n     */\n    dispose(): void {\n        if (this.broadcastChannel) {\n            this.broadcastChannel.close();\n            this.broadcastChannel = null;\n        }\n        \n        if (this.watchTimer) {\n            clearInterval(this.watchTimer);\n            this.watchTimer = null;\n        }\n        \n        this.watchers.clear();\n    }\n\n    private async buildSnapshot(root: string, options?: WatchOptions): Promise<Map<string, FileStat>> {\n        const result = new Map<string, FileStat>();\n        const recursive = options?.recursive ?? true;\n        const excludePatterns: string | string[] | undefined = options?.excludes;\n        \n        const save = async(path: string) => {\n            const stat = await this.stat(path);\n            result.set(path, stat);\n            return stat;\n        }\n\n        const walk = async (current: string) => {\n            if (isPathExcluded(current, excludePatterns)) {\n                return;\n            }\n            \n            const stat = await save(current);\n\n            if (stat.isDirectory) {\n                const entries = await this.readDir(current);\n                for (const entry of entries) {\n                    const child = `${ current === '/' ? '' : current }/${ entry.name }`;\n                    \n                    // Recursive mode: walk into all subdirectories\n                    if (recursive) {\n                        await walk(child);\n                    } \n                    // Non-recursive mode: add immediate children to snapshot but don't walk into subdirectories\n                    else if (!isPathExcluded(child, excludePatterns)) {\n                        await save(child);\n                    }\n                }\n            }\n        };\n\n        await walk(root);\n        return result;\n    }\n\n    private async scanWatches(): Promise<void> {\n        if (this.scanning) {\n            return;\n        }\n\n        this.scanning = true;\n\n        try {\n            await Promise.all(\n                [...this.watchers.entries()].map(async([root, { snapshot: prev, options }]) => {\n                    let next: Map<string, FileStat>;\n\n                    try {\n                        next = await this.buildSnapshot(root, options);\n                    }\n                    catch (error) {\n                        next = new Map();\n                    }\n\n                    for (const [p, stat] of next) {\n                        const old = prev.get(p);\n                        \n                        if (isPathExcluded(p, options.excludes)) {\n                            continue;\n                        }\n                        \n                        if (!old) {\n                            await this.notifyChange({ path: p, type: 'added', isDirectory: stat.isDirectory });\n                        }\n                        else if (old.mtime !== stat.mtime || old.size !== stat.size) {\n                            await this.notifyChange({ path: p, type: 'changed', isDirectory: stat.isDirectory });\n                        }\n                    }\n\n                    for (const p of prev.keys()) {\n                        if (isPathExcluded(p, options.excludes)) {\n                            continue;\n                        }\n                        \n                        if (!next.has(p)) {\n                            const oldStat = prev.get(p);\n                            await this.notifyChange({ path: p, type: 'removed', isDirectory: oldStat?.isDirectory ?? false });\n                        }\n                    }\n\n                    this.watchers.set(root, { snapshot: next, options });\n                })\n            );\n        }\n        finally {\n            this.scanning = false;\n        }\n    }\n\n    /**\n     * Synchronize the file system with external data\n     * \n     * Syncs the file system with an array of entries containing paths and data.\n     * This is useful for importing data from external sources or syncing with remote data.\n     * \n     * @param entries - Array of [path, data] tuples to sync\n     * @param options - Options for synchronization\n     * @param options.cleanBefore - Whether to clear the file system before syncing (default: false)\n     * @returns Promise that resolves when synchronization is complete\n     * @throws {OPFSError} If the synchronization fails\n     * \n     * @example\n     * ```typescript\n     * // Sync with external data\n     * const entries: [string, string | Uint8Array | Blob][] = [\n     *   ['/config.json', JSON.stringify({ theme: 'dark' })],\n     *   ['/data/binary.dat', new Uint8Array([1, 2, 3, 4])],\n     *   ['/upload.txt', new Blob(['file content'], { type: 'text/plain' })]\n     * ];\n     * \n     * // Sync without clearing existing files\n     * await fs.sync(entries);\n     * \n     * // Clean file system and then sync\n     * await fs.sync(entries, { cleanBefore: true });\n     * ```\n     */\n    async sync(entries: [string, string | Uint8Array | Blob][], options?: { cleanBefore?: boolean }): Promise<void> {\n        await this.mount();\n        \n        try {\n            const cleanBefore = options?.cleanBefore ?? false;\n\n            if (cleanBefore) {\n                await this.clear('/');\n            }\n\n            for (const [path, data] of entries) {\n                const normalizedPath = normalizePath(path);\n\n                let fileData: string | Uint8Array;\n\n                if (data instanceof Blob) {\n                    fileData = await convertBlobToUint8Array(data);\n                }\n                else {\n                    fileData = data;\n                }\n\n                await this.writeFile(normalizedPath, fileData);\n            }\n            \n            // Notify about the sync operation\n            await this.notifyChange({ path: '/', type: 'changed', isDirectory: true });\n        }\n        catch (error) {\n            if (error instanceof OPFSError) {\n                throw error;\n            }\n\n            throw new OPFSError('Failed to sync file system', 'SYNC_FAILED');\n        }\n    }\n}\n\n// Only expose the worker when running in a Web Worker environment\nif (typeof self !== 'undefined' && self.constructor.name === 'DedicatedWorkerGlobalScope') {\n  expose(new OPFSWorker());\n}"],"names":["proxyMarker","createEndpoint","releaseProxy","finalizer","throwMarker","isObject","val","proxyTransferHandler","obj","port1","port2","expose","port","wrap","throwTransferHandler","value","serialized","transferHandlers","isAllowedOrigin","allowedOrigins","origin","allowedOrigin","ep","callback","ev","id","type","path","argumentList","fromWireValue","returnValue","parent","prop","rawValue","proxy","transfer","wireValue","transferables","toWireValue","closeEndPoint","error","isMessagePort","endpoint","target","pendingListeners","data","resolver","createProxy","throwIfProxyReleased","isReleased","releaseEndpoint","requestResponseMessage","proxyCounter","proxyFinalizers","newCount","registerProxy","unregisterProxy","isProxyReleased","_target","r","p","_thisArg","rawArgumentList","last","processArguments","myFlat","arr","processed","v","transferCache","transfers","name","handler","serializedValue","msg","resolve","generateUUID","balanced","a","b","str","ma","maybeMatch","mb","range","reg","m","begs","beg","left","right","result","ai","bi","i","escSlash","escOpen","escClose","escComma","escPeriod","escSlashPattern","escOpenPattern","escClosePattern","escCommaPattern","escPeriodPattern","slashPattern","openPattern","closePattern","commaPattern","periodPattern","numeric","escapeBraces","unescapeBraces","parseCommaParts","parts","pre","body","post","postParts","expand","expand_","embrace","isPadded","el","lte","y","gte","isTop","expansions","k","expansion","isNumericSequence","isAlphaSequence","isSequence","isOptions","n","N","x","width","incr","test","pad","c","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","options","#fillNegs","pp","part","ret","pl","#parseAST","ast","opt","inBrace","braceStart","braceNeg","acc","ext","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","fd","pd","fi","pi","fl","fr","pr","swallowee","hit","fastTest","twoStar","open","ff","filename","OPFSError","message","code","OPFSNotSupportedError","OPFSNotMountedError","PathError","FileNotFoundError","encodeString","encoding","encodeUtf16LE","encodeAscii","encodeLatin1","char","decodeBuffer","buffer","decodeUtf16LE","buf","codeUnits","checkOPFSSupport","splitPath","joinPath","segments","basename","dirname","normalizePath","isPathExcluded","patterns","normalized","resolvePath","normalizedPath","normalizedSegments","segment","createBuffer","readFileData","fileHandle","handle","size","writeFileData","writeOffset","operation","calculateFileHash","algorithm","maxSize","bufferSource","hashBuffer","convertBlobToUint8Array","blob","arrayBuffer","OPFSWorker","event","hash","stats","watchEvent","root","reject","rootDir","create","from","current","fileName","walk","dirPath","items","item","fullPath","stat","err","recursive","e","parentDir","includeHash","baseStat","dir","results","isFile","itemPath","force","oldPath","newPath","source","destination","content","sourceItemPath","destItemPath","watchOptions","snapshot","excludePatterns","save","entries","entry","child","old","oldStat","fileData"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8]}