@socketsecurity/lib 3.2.6 → 3.2.8

package/dist/external/picomatch.js

@@ -3,4 +3,1523 @@
  * Bundled from picomatch
  * This is a zero-dependency bundle created by esbuild.
  */
-"use strict";var Xt=Object.defineProperty;var _=(t,a)=>Xt(t,"name",{value:a,configurable:!0});var J=(t,a)=>()=>(a||t((a={exports:{}}).exports,a),a.exports);var et=J((de,Ht)=>{"use strict";var Ft=require("path"),Q="\\\\/",St=`[^${Q}]`,Z="\\.",Wt="\\+",Qt="\\?",at="\\/",Zt="(?=.)",$t="[^/]",ft=`(?:${at}|$)`,yt=`(?:^|${at})`,At=`${Z}{1,2}${ft}`,jt=`(?!${Z})`,Vt=`(?!${yt}${At})`,Yt=`(?!${Z}{0,1}${ft})`,zt=`(?!${At})`,Jt=`[^.${at}]`,te=`${$t}*?`,dt={DOT_LITERAL:Z,PLUS_LITERAL:Wt,QMARK_LITERAL:Qt,SLASH_LITERAL:at,ONE_CHAR:Zt,QMARK:$t,END_ANCHOR:ft,DOTS_SLASH:At,NO_DOT:jt,NO_DOTS:Vt,NO_DOT_SLASH:Yt,NO_DOTS_SLASH:zt,QMARK_NO_DOT:Jt,STAR:te,START_ANCHOR:yt},ee={...dt,SLASH_LITERAL:`[${Q}]`,QMARK:St,STAR:`${St}*?`,DOTS_SLASH:`${Z}{1,2}(?:[${Q}]|$)`,NO_DOT:`(?!${Z})`,NO_DOTS:`(?!(?:^|[${Q}])${Z}{1,2}(?:[${Q}]|$))`,NO_DOT_SLASH:`(?!${Z}{0,1}(?:[${Q}]|$))`,NO_DOTS_SLASH:`(?!${Z}{1,2}(?:[${Q}]|$))`,QMARK_NO_DOT:`[^.${Q}]`,START_ANCHOR:`(?:^|[${Q}])`,END_ANCHOR:`(?:[${Q}]|$)`},se={alnum:"a-zA-Z0-9",alpha:"a-zA-Z",ascii:"\\x00-\\x7F",blank:" \\t",cntrl:"\\x00-\\x1F\\x7F",digit:"0-9",graph:"\\x21-\\x7E",lower:"a-z",print:"\\x20-\\x7E ",punct:"\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",space:" \\t\\r\\n\\v\\f",upper:"A-Z",word:"A-Za-z0-9_",xdigit:"A-Fa-f0-9"};Ht.exports={MAX_LENGTH:1024*64,POSIX_REGEX_SOURCE:se,REGEX_BACKSLASH:/\\(?![*+?^${}(|)[\]])/g,REGEX_NON_SPECIAL_CHARS:/^[^@![\].,$*+?^{}()|\\/]+/,REGEX_SPECIAL_CHARS:/[-*+?.^${}(|)[\]]/,REGEX_SPECIAL_CHARS_BACKREF:/(\\?)((\W)(\3*))/g,REGEX_SPECIAL_CHARS_GLOBAL:/([-*+?.^${}(|)[\]])/g,REGEX_REMOVE_BACKSLASH:/(?:\[.*?[^\\]\]|\\(?=.))/g,REPLACEMENTS:{"***":"*","**/**":"**","**/**/**":"**"},CHAR_0:48,CHAR_9:57,CHAR_UPPERCASE_A:65,CHAR_LOWERCASE_A:97,CHAR_UPPERCASE_Z:90,CHAR_LOWERCASE_Z:122,CHAR_LEFT_PARENTHESES:40,CHAR_RIGHT_PARENTHESES:41,CHAR_ASTERISK:42,CHAR_AMPERSAND:38,CHAR_AT:64,CHAR_BACKWARD_SLASH:92,CHAR_CARRIAGE_RETURN:13,CHAR_CIRCUMFLEX_ACCENT:94,CHAR_COLON:58,CHAR_COMMA:44,CHAR_DOT:46,CHAR_DOUBLE_QUOTE:34,CHAR_EQUAL:61,CHAR_EXCLAMATION_MARK:33,CHAR_FORM_FEED:12,CHAR_FORWARD_SLASH:47,CHAR_GRAVE_ACCENT:96,CHAR_HASH:35,CHAR_HYPHEN_MINUS:45,CHAR_LEFT_ANGLE_BRACKET:60,CHAR_LEFT_CURLY_BRACE:123,CHAR_LEFT_SQUARE_BRACKET:91,CHAR_LINE_FEED:10,CHAR_NO_BREAK_SPACE:160,CHAR_PERCENT:37,CHAR_PLUS:43,CHAR_QUESTION_MARK:63,CHAR_RIGHT_ANGLE_BRACKET:62,CHAR_RIGHT_CURLY_BRACE:125,CHAR_RIGHT_SQUARE_BRACKET:93,CHAR_SEMICOLON:59,CHAR_SINGLE_QUOTE:39,CHAR_SPACE:32,CHAR_TAB:9,CHAR_UNDERSCORE:95,CHAR_VERTICAL_LINE:124,CHAR_ZERO_WIDTH_NOBREAK_SPACE:65279,SEP:Ft.sep,extglobChars(t){return{"!":{type:"negate",open:"(?:(?!(?:",close:`))${t.STAR})`},"?":{type:"qmark",open:"(?:",close:")?"},"+":{type:"plus",open:"(?:",close:")+"},"*":{type:"star",open:"(?:",close:")*"},"@":{type:"at",open:"(?:",close:")"}}},globChars(t){return t===!0?ee:dt}}});var ct=J(M=>{"use strict";var re=require("path"),ue=process.platform==="win32",{REGEX_BACKSLASH:ne,REGEX_REMOVE_BACKSLASH:oe,REGEX_SPECIAL_CHARS:ae,REGEX_SPECIAL_CHARS_GLOBAL:ce}=et();M.isObject=t=>t!==null&&typeof t=="object"&&!Array.isArray(t);M.hasRegexChars=t=>ae.test(t);M.isRegexChar=t=>t.length===1&&M.hasRegexChars(t);M.escapeRegex=t=>t.replace(ce,"\\$1");M.toPosixSlashes=t=>t.replace(ne,"/");M.removeBackslashes=t=>t.replace(oe,a=>a==="\\"?"":a);M.supportsLookbehinds=()=>{let t=process.version.slice(1).split(".").map(Number);return t.length===3&&t[0]>=9||t[0]===8&&t[1]>=10};M.isWindows=t=>t&&typeof t.windows=="boolean"?t.windows:ue===!0||re.sep==="\\";M.escapeLast=(t,a,e)=>{let E=t.lastIndexOf(a,e);return E===-1?t:t[E-1]==="\\"?M.escapeLast(t,a,E-1):`${t.slice(0,E)}\\${t.slice(E)}`};M.removePrefix=(t,a={})=>{let e=t;return e.startsWith("./")&&(e=e.slice(2),a.prefix="./"),e};M.wrapOutput=(t,a={},e={})=>{let E=e.contains?"":"^",i=e.contains?"":"$",g=`${E}(?:${t})${i}`;return a.negated===!0&&(g=`(?:^(?!${g}).*$)`),g}});var wt=J((Le,kt)=>{"use strict";var Lt=ct(),{CHAR_ASTERISK:Rt,CHAR_AT:ie,CHAR_BACKWARD_SLASH:st,CHAR_COMMA:le,CHAR_DOT:_t,CHAR_EXCLAMATION_MARK:ht,CHAR_FORWARD_SLASH:Nt,CHAR_LEFT_CURLY_BRACE:Et,CHAR_LEFT_PARENTHESES:xt,CHAR_LEFT_SQUARE_BRACKET:pe,CHAR_PLUS:fe,CHAR_QUESTION_MARK:Tt,CHAR_RIGHT_CURLY_BRACE:Ae,CHAR_RIGHT_PARENTHESES:Ot,CHAR_RIGHT_SQUARE_BRACKET:Re}=et(),vt=_(t=>t===Nt||t===st,"isPathSeparator"),mt=_(t=>{t.isPrefix!==!0&&(t.depth=t.isGlobstar?1/0:1)},"depth"),_e=_((t,a)=>{let e=a||{},E=t.length-1,i=e.parts===!0||e.scanToEnd===!0,g=[],l=[],x=[],A=t,m=-1,b=0,v=0,k=!1,I=!1,C=!1,H=!1,j=!1,q=!1,U=!1,L=!1,X=!1,w=!1,V=0,B,c,h={value:"",depth:0,isGlob:!1},N=_(()=>m>=E,"eos"),u=_(()=>A.charCodeAt(m+1),"peek"),y=_(()=>(B=c,A.charCodeAt(++m)),"advance");for(;m<E;){c=y();let G;if(c===st){U=h.backslashes=!0,c=y(),c===Et&&(q=!0);continue}if(q===!0||c===Et){for(V++;N()!==!0&&(c=y());){if(c===st){U=h.backslashes=!0,y();continue}if(c===Et){V++;continue}if(q!==!0&&c===_t&&(c=y())===_t){if(k=h.isBrace=!0,C=h.isGlob=!0,w=!0,i===!0)continue;break}if(q!==!0&&c===le){if(k=h.isBrace=!0,C=h.isGlob=!0,w=!0,i===!0)continue;break}if(c===Ae&&(V--,V===0)){q=!1,k=h.isBrace=!0,w=!0;break}}if(i===!0)continue;break}if(c===Nt){if(g.push(m),l.push(h),h={value:"",depth:0,isGlob:!1},w===!0)continue;if(B===_t&&m===b+1){b+=2;continue}v=m+1;continue}if(e.noext!==!0&&(c===fe||c===ie||c===Rt||c===Tt||c===ht)===!0&&u()===xt){if(C=h.isGlob=!0,H=h.isExtglob=!0,w=!0,c===ht&&m===b&&(X=!0),i===!0){for(;N()!==!0&&(c=y());){if(c===st){U=h.backslashes=!0,c=y();continue}if(c===Ot){C=h.isGlob=!0,w=!0;break}}continue}break}if(c===Rt){if(B===Rt&&(j=h.isGlobstar=!0),C=h.isGlob=!0,w=!0,i===!0)continue;break}if(c===Tt){if(C=h.isGlob=!0,w=!0,i===!0)continue;break}if(c===pe){for(;N()!==!0&&(G=y());){if(G===st){U=h.backslashes=!0,y();continue}if(G===Re){I=h.isBracket=!0,C=h.isGlob=!0,w=!0;break}}if(i===!0)continue;break}if(e.nonegate!==!0&&c===ht&&m===b){L=h.negated=!0,b++;continue}if(e.noparen!==!0&&c===xt){if(C=h.isGlob=!0,i===!0){for(;N()!==!0&&(c=y());){if(c===xt){U=h.backslashes=!0,c=y();continue}if(c===Ot){w=!0;break}}continue}break}if(C===!0){if(w=!0,i===!0)continue;break}}e.noext===!0&&(H=!1,C=!1);let S=A,Y="",s="";b>0&&(Y=A.slice(0,b),A=A.slice(b),v-=b),S&&C===!0&&v>0?(S=A.slice(0,v),s=A.slice(v)):C===!0?(S="",s=A):S=A,S&&S!==""&&S!=="/"&&S!==A&&vt(S.charCodeAt(S.length-1))&&(S=S.slice(0,-1)),e.unescape===!0&&(s&&(s=Lt.removeBackslashes(s)),S&&U===!0&&(S=Lt.removeBackslashes(S)));let r={prefix:Y,input:t,start:b,base:S,glob:s,isBrace:k,isBracket:I,isGlob:C,isExtglob:H,isGlobstar:j,negated:L,negatedExtglob:X};if(e.tokens===!0&&(r.maxDepth=0,vt(c)||l.push(h),r.tokens=l),e.parts===!0||e.tokens===!0){let G;for(let R=0;R<g.length;R++){let F=G?G+1:b,W=g[R],P=t.slice(F,W);e.tokens&&(R===0&&b!==0?(l[R].isPrefix=!0,l[R].value=Y):l[R].value=P,mt(l[R]),r.maxDepth+=l[R].depth),(R!==0||P!=="")&&x.push(P),G=W}if(G&&G+1<t.length){let R=t.slice(G+1);x.push(R),e.tokens&&(l[l.length-1].value=R,mt(l[l.length-1]),r.maxDepth+=l[l.length-1].depth)}r.slashes=g,r.parts=x}return r},"scan");kt.exports=_e});var Gt=J((Oe,Bt)=>{"use strict";var it=et(),K=ct(),{MAX_LENGTH:lt,POSIX_REGEX_SOURCE:he,REGEX_NON_SPECIAL_CHARS:Ee,REGEX_SPECIAL_CHARS_BACKREF:xe,REPLACEMENTS:It}=it,ge=_((t,a)=>{if(typeof a.expandRange=="function")return a.expandRange(...t,a);t.sort();let e=`[${t.join("-")}]`;try{new RegExp(e)}catch{return t.map(i=>K.escapeRegex(i)).join("..")}return e},"expandRange"),tt=_((t,a)=>`Missing ${t}: "${a}" - use "\\\\${a}" to match literal characters`,"syntaxError"),gt=_((t,a)=>{if(typeof t!="string")throw new TypeError("Expected a string");t=It[t]||t;let e={...a},E=typeof e.maxLength=="number"?Math.min(lt,e.maxLength):lt,i=t.length;if(i>E)throw new SyntaxError(`Input length: ${i}, exceeds maximum allowed length: ${E}`);let g={type:"bos",value:"",output:e.prepend||""},l=[g],x=e.capture?"":"?:",A=K.isWindows(a),m=it.globChars(A),b=it.extglobChars(m),{DOT_LITERAL:v,PLUS_LITERAL:k,SLASH_LITERAL:I,ONE_CHAR:C,DOTS_SLASH:H,NO_DOT:j,NO_DOT_SLASH:q,NO_DOTS_SLASH:U,QMARK:L,QMARK_NO_DOT:X,STAR:w,START_ANCHOR:V}=m,B=_(o=>`(${x}(?:(?!${V}${o.dot?H:v}).)*?)`,"globstar"),c=e.dot?"":j,h=e.dot?L:X,N=e.bash===!0?B(e):w;e.capture&&(N=`(${N})`),typeof e.noext=="boolean"&&(e.noextglob=e.noext);let u={input:t,index:-1,start:0,dot:e.dot===!0,consumed:"",output:"",prefix:"",backtrack:!1,negated:!1,brackets:0,braces:0,parens:0,quotes:0,globstar:!1,tokens:l};t=K.removePrefix(t,u),i=t.length;let y=[],S=[],Y=[],s=g,r,G=_(()=>u.index===i-1,"eos"),R=u.peek=(o=1)=>t[u.index+o],F=u.advance=()=>t[++u.index]||"",W=_(()=>t.slice(u.index+1),"remaining"),P=_((o="",$=0)=>{u.consumed+=o,u.index+=$},"consume"),rt=_(o=>{u.output+=o.output!=null?o.output:o.value,P(o.value)},"append"),Ut=_(()=>{let o=1;for(;R()==="!"&&(R(2)!=="("||R(3)==="?");)F(),u.start++,o++;return o%2===0?!1:(u.negated=!0,u.start++,!0)},"negate"),ut=_(o=>{u[o]++,Y.push(o)},"increment"),z=_(o=>{u[o]--,Y.pop()},"decrement"),f=_(o=>{if(s.type==="globstar"){let $=u.braces>0&&(o.type==="comma"||o.type==="brace"),n=o.extglob===!0||y.length&&(o.type==="pipe"||o.type==="paren");o.type!=="slash"&&o.type!=="paren"&&!$&&!n&&(u.output=u.output.slice(0,-s.output.length),s.type="star",s.value="*",s.output=N,u.output+=s.output)}if(y.length&&o.type!=="paren"&&(y[y.length-1].inner+=o.value),(o.value||o.output)&&rt(o),s&&s.type==="text"&&o.type==="text"){s.value+=o.value,s.output=(s.output||"")+o.value;return}o.prev=s,l.push(o),s=o},"push"),nt=_((o,$)=>{let n={...b[$],conditions:1,inner:""};n.prev=s,n.parens=u.parens,n.output=u.output;let p=(e.capture?"(":"")+n.open;ut("parens"),f({type:o,value:$,output:u.output?"":C}),f({type:"paren",extglob:!0,value:F(),output:p}),y.push(n)},"extglobOpen"),qt=_(o=>{let $=o.close+(e.capture?")":""),n;if(o.type==="negate"){let p=N;if(o.inner&&o.inner.length>1&&o.inner.includes("/")&&(p=B(e)),(p!==N||G()||/^\)+$/.test(W()))&&($=o.close=`)$))${p}`),o.inner.includes("*")&&(n=W())&&/^\.[^\\/.]+$/.test(n)){let d=gt(n,{...a,fastpaths:!1}).output;$=o.close=`)${d})${p})`}o.prev.type==="bos"&&(u.negatedExtglob=!0)}f({type:"paren",extglob:!0,value:r,output:$}),z("parens")},"extglobClose");if(e.fastpaths!==!1&&!/(^[*!]|[/()[\]{}"])/.test(t)){let o=!1,$=t.replace(xe,(n,p,d,D,O,pt)=>D==="\\"?(o=!0,n):D==="?"?p?p+D+(O?L.repeat(O.length):""):pt===0?h+(O?L.repeat(O.length):""):L.repeat(d.length):D==="."?v.repeat(d.length):D==="*"?p?p+D+(O?N:""):N:p?n:`\\${n}`);return o===!0&&(e.unescape===!0?$=$.replace(/\\/g,""):$=$.replace(/\\+/g,n=>n.length%2===0?"\\\\":n?"\\":"")),$===t&&e.contains===!0?(u.output=t,u):(u.output=K.wrapOutput($,u,a),u)}for(;!G();){if(r=F(),r==="\0")continue;if(r==="\\"){let n=R();if(n==="/"&&e.bash!==!0||n==="."||n===";")continue;if(!n){r+="\\",f({type:"text",value:r});continue}let p=/^\\+/.exec(W()),d=0;if(p&&p[0].length>2&&(d=p[0].length,u.index+=d,d%2!==0&&(r+="\\")),e.unescape===!0?r=F():r+=F(),u.brackets===0){f({type:"text",value:r});continue}}if(u.brackets>0&&(r!=="]"||s.value==="["||s.value==="[^")){if(e.posix!==!1&&r===":"){let n=s.value.slice(1);if(n.includes("[")&&(s.posix=!0,n.includes(":"))){let p=s.value.lastIndexOf("["),d=s.value.slice(0,p),D=s.value.slice(p+2),O=he[D];if(O){s.value=d+O,u.backtrack=!0,F(),!g.output&&l.indexOf(s)===1&&(g.output=C);continue}}}(r==="["&&R()!==":"||r==="-"&&R()==="]")&&(r=`\\${r}`),r==="]"&&(s.value==="["||s.value==="[^")&&(r=`\\${r}`),e.posix===!0&&r==="!"&&s.value==="["&&(r="^"),s.value+=r,rt({value:r});continue}if(u.quotes===1&&r!=='"'){r=K.escapeRegex(r),s.value+=r,rt({value:r});continue}if(r==='"'){u.quotes=u.quotes===1?0:1,e.keepQuotes===!0&&f({type:"text",value:r});continue}if(r==="("){ut("parens"),f({type:"paren",value:r});continue}if(r===")"){if(u.parens===0&&e.strictBrackets===!0)throw new SyntaxError(tt("opening","("));let n=y[y.length-1];if(n&&u.parens===n.parens+1){qt(y.pop());continue}f({type:"paren",value:r,output:u.parens?")":"\\)"}),z("parens");continue}if(r==="["){if(e.nobracket===!0||!W().includes("]")){if(e.nobracket!==!0&&e.strictBrackets===!0)throw new SyntaxError(tt("closing","]"));r=`\\${r}`}else ut("brackets");f({type:"bracket",value:r});continue}if(r==="]"){if(e.nobracket===!0||s&&s.type==="bracket"&&s.value.length===1){f({type:"text",value:r,output:`\\${r}`});continue}if(u.brackets===0){if(e.strictBrackets===!0)throw new SyntaxError(tt("opening","["));f({type:"text",value:r,output:`\\${r}`});continue}z("brackets");let n=s.value.slice(1);if(s.posix!==!0&&n[0]==="^"&&!n.includes("/")&&(r=`/${r}`),s.value+=r,rt({value:r}),e.literalBrackets===!1||K.hasRegexChars(n))continue;let p=K.escapeRegex(s.value);if(u.output=u.output.slice(0,-s.value.length),e.literalBrackets===!0){u.output+=p,s.value=p;continue}s.value=`(${x}${p}|${s.value})`,u.output+=s.value;continue}if(r==="{"&&e.nobrace!==!0){ut("braces");let n={type:"brace",value:r,output:"(",outputIndex:u.output.length,tokensIndex:u.tokens.length};S.push(n),f(n);continue}if(r==="}"){let n=S[S.length-1];if(e.nobrace===!0||!n){f({type:"text",value:r,output:r});continue}let p=")";if(n.dots===!0){let d=l.slice(),D=[];for(let O=d.length-1;O>=0&&(l.pop(),d[O].type!=="brace");O--)d[O].type!=="dots"&&D.unshift(d[O].value);p=ge(D,e),u.backtrack=!0}if(n.comma!==!0&&n.dots!==!0){let d=u.output.slice(0,n.outputIndex),D=u.tokens.slice(n.tokensIndex);n.value=n.output="\\{",r=p="\\}",u.output=d;for(let O of D)u.output+=O.output||O.value}f({type:"brace",value:r,output:p}),z("braces"),S.pop();continue}if(r==="|"){y.length>0&&y[y.length-1].conditions++,f({type:"text",value:r});continue}if(r===","){let n=r,p=S[S.length-1];p&&Y[Y.length-1]==="braces"&&(p.comma=!0,n="|"),f({type:"comma",value:r,output:n});continue}if(r==="/"){if(s.type==="dot"&&u.index===u.start+1){u.start=u.index+1,u.consumed="",u.output="",l.pop(),s=g;continue}f({type:"slash",value:r,output:I});continue}if(r==="."){if(u.braces>0&&s.type==="dot"){s.value==="."&&(s.output=v);let n=S[S.length-1];s.type="dots",s.output+=r,s.value+=r,n.dots=!0;continue}if(u.braces+u.parens===0&&s.type!=="bos"&&s.type!=="slash"){f({type:"text",value:r,output:v});continue}f({type:"dot",value:r,output:v});continue}if(r==="?"){if(!(s&&s.value==="(")&&e.noextglob!==!0&&R()==="("&&R(2)!=="?"){nt("qmark",r);continue}if(s&&s.type==="paren"){let p=R(),d=r;if(p==="<"&&!K.supportsLookbehinds())throw new Error("Node.js v10 or higher is required for regex lookbehinds");(s.value==="("&&!/[!=<:]/.test(p)||p==="<"&&!/<([!=]|\w+>)/.test(W()))&&(d=`\\${r}`),f({type:"text",value:r,output:d});continue}if(e.dot!==!0&&(s.type==="slash"||s.type==="bos")){f({type:"qmark",value:r,output:X});continue}f({type:"qmark",value:r,output:L});continue}if(r==="!"){if(e.noextglob!==!0&&R()==="("&&(R(2)!=="?"||!/[!=<:]/.test(R(3)))){nt("negate",r);continue}if(e.nonegate!==!0&&u.index===0){Ut();continue}}if(r==="+"){if(e.noextglob!==!0&&R()==="("&&R(2)!=="?"){nt("plus",r);continue}if(s&&s.value==="("||e.regex===!1){f({type:"plus",value:r,output:k});continue}if(s&&(s.type==="bracket"||s.type==="paren"||s.type==="brace")||u.parens>0){f({type:"plus",value:r});continue}f({type:"plus",value:k});continue}if(r==="@"){if(e.noextglob!==!0&&R()==="("&&R(2)!=="?"){f({type:"at",extglob:!0,value:r,output:""});continue}f({type:"text",value:r});continue}if(r!=="*"){(r==="$"||r==="^")&&(r=`\\${r}`);let n=Ee.exec(W());n&&(r+=n[0],u.index+=n[0].length),f({type:"text",value:r});continue}if(s&&(s.type==="globstar"||s.star===!0)){s.type="star",s.star=!0,s.value+=r,s.output=N,u.backtrack=!0,u.globstar=!0,P(r);continue}let o=W();if(e.noextglob!==!0&&/^\([^?]/.test(o)){nt("star",r);continue}if(s.type==="star"){if(e.noglobstar===!0){P(r);continue}let n=s.prev,p=n.prev,d=n.type==="slash"||n.type==="bos",D=p&&(p.type==="star"||p.type==="globstar");if(e.bash===!0&&(!d||o[0]&&o[0]!=="/")){f({type:"star",value:r,output:""});continue}let O=u.braces>0&&(n.type==="comma"||n.type==="brace"),pt=y.length&&(n.type==="pipe"||n.type==="paren");if(!d&&n.type!=="paren"&&!O&&!pt){f({type:"star",value:r,output:""});continue}for(;o.slice(0,3)==="/**";){let ot=t[u.index+4];if(ot&&ot!=="/")break;o=o.slice(3),P("/**",3)}if(n.type==="bos"&&G()){s.type="globstar",s.value+=r,s.output=B(e),u.output=s.output,u.globstar=!0,P(r);continue}if(n.type==="slash"&&n.prev.type!=="bos"&&!D&&G()){u.output=u.output.slice(0,-(n.output+s.output).length),n.output=`(?:${n.output}`,s.type="globstar",s.output=B(e)+(e.strictSlashes?")":"|$)"),s.value+=r,u.globstar=!0,u.output+=n.output+s.output,P(r);continue}if(n.type==="slash"&&n.prev.type!=="bos"&&o[0]==="/"){let ot=o[1]!==void 0?"|$":"";u.output=u.output.slice(0,-(n.output+s.output).length),n.output=`(?:${n.output}`,s.type="globstar",s.output=`${B(e)}${I}|${I}${ot})`,s.value+=r,u.output+=n.output+s.output,u.globstar=!0,P(r+F()),f({type:"slash",value:"/",output:""});continue}if(n.type==="bos"&&o[0]==="/"){s.type="globstar",s.value+=r,s.output=`(?:^|${I}|${B(e)}${I})`,u.output=s.output,u.globstar=!0,P(r+F()),f({type:"slash",value:"/",output:""});continue}u.output=u.output.slice(0,-s.output.length),s.type="globstar",s.output=B(e),s.value+=r,u.output+=s.output,u.globstar=!0,P(r);continue}let $={type:"star",value:r,output:N};if(e.bash===!0){$.output=".*?",(s.type==="bos"||s.type==="slash")&&($.output=c+$.output),f($);continue}if(s&&(s.type==="bracket"||s.type==="paren")&&e.regex===!0){$.output=r,f($);continue}(u.index===u.start||s.type==="slash"||s.type==="dot")&&(s.type==="dot"?(u.output+=q,s.output+=q):e.dot===!0?(u.output+=U,s.output+=U):(u.output+=c,s.output+=c),R()!=="*"&&(u.output+=C,s.output+=C)),f($)}for(;u.brackets>0;){if(e.strictBrackets===!0)throw new SyntaxError(tt("closing","]"));u.output=K.escapeLast(u.output,"["),z("brackets")}for(;u.parens>0;){if(e.strictBrackets===!0)throw new SyntaxError(tt("closing",")"));u.output=K.escapeLast(u.output,"("),z("parens")}for(;u.braces>0;){if(e.strictBrackets===!0)throw new SyntaxError(tt("closing","}"));u.output=K.escapeLast(u.output,"{"),z("braces")}if(e.strictSlashes!==!0&&(s.type==="star"||s.type==="bracket")&&f({type:"maybe_slash",value:"",output:`${I}?`}),u.backtrack===!0){u.output="";for(let o of u.tokens)u.output+=o.output!=null?o.output:o.value,o.suffix&&(u.output+=o.suffix)}return u},"parse");gt.fastpaths=(t,a)=>{let e={...a},E=typeof e.maxLength=="number"?Math.min(lt,e.maxLength):lt,i=t.length;if(i>E)throw new SyntaxError(`Input length: ${i}, exceeds maximum allowed length: ${E}`);t=It[t]||t;let g=K.isWindows(a),{DOT_LITERAL:l,SLASH_LITERAL:x,ONE_CHAR:A,DOTS_SLASH:m,NO_DOT:b,NO_DOTS:v,NO_DOTS_SLASH:k,STAR:I,START_ANCHOR:C}=it.globChars(g),H=e.dot?v:b,j=e.dot?k:b,q=e.capture?"":"?:",U={negated:!1,prefix:""},L=e.bash===!0?".*?":I;e.capture&&(L=`(${L})`);let X=_(c=>c.noglobstar===!0?L:`(${q}(?:(?!${C}${c.dot?m:l}).)*?)`,"globstar"),w=_(c=>{switch(c){case"*":return`${H}${A}${L}`;case".*":return`${l}${A}${L}`;case"*.*":return`${H}${L}${l}${A}${L}`;case"*/*":return`${H}${L}${x}${A}${j}${L}`;case"**":return H+X(e);case"**/*":return`(?:${H}${X(e)}${x})?${j}${A}${L}`;case"**/*.*":return`(?:${H}${X(e)}${x})?${j}${L}${l}${A}${L}`;case"**/.*":return`(?:${H}${X(e)}${x})?${l}${A}${L}`;default:{let h=/^(.*?)\.(\w+)$/.exec(c);if(!h)return;let N=w(h[1]);return N?N+l+h[2]:void 0}}},"create"),V=K.removePrefix(t,U),B=w(V);return B&&e.strictSlashes!==!0&&(B+=`${x}?`),B};Bt.exports=gt});var Mt=J((me,Dt)=>{"use strict";var be=require("path"),Ce=wt(),bt=Gt(),Ct=ct(),Se=et(),$e=_(t=>t&&typeof t=="object"&&!Array.isArray(t),"isObject"),T=_((t,a,e=!1)=>{if(Array.isArray(t)){let b=t.map(k=>T(k,a,e));return _(k=>{for(let I of b){let C=I(k);if(C)return C}return!1},"arrayMatcher")}let E=$e(t)&&t.tokens&&t.input;if(t===""||typeof t!="string"&&!E)throw new TypeError("Expected pattern to be a non-empty string");let i=a||{},g=Ct.isWindows(a),l=E?T.compileRe(t,a):T.makeRe(t,a,!1,!0),x=l.state;delete l.state;let A=_(()=>!1,"isIgnored");if(i.ignore){let b={...a,ignore:null,onMatch:null,onResult:null};A=T(i.ignore,b,e)}let m=_((b,v=!1)=>{let{isMatch:k,match:I,output:C}=T.test(b,l,a,{glob:t,posix:g}),H={glob:t,state:x,regex:l,posix:g,input:b,output:C,match:I,isMatch:k};return typeof i.onResult=="function"&&i.onResult(H),k===!1?(H.isMatch=!1,v?H:!1):A(b)?(typeof i.onIgnore=="function"&&i.onIgnore(H),H.isMatch=!1,v?H:!1):(typeof i.onMatch=="function"&&i.onMatch(H),v?H:!0)},"matcher");return e&&(m.state=x),m},"picomatch");T.test=(t,a,e,{glob:E,posix:i}={})=>{if(typeof t!="string")throw new TypeError("Expected input to be a string");if(t==="")return{isMatch:!1,output:""};let g=e||{},l=g.format||(i?Ct.toPosixSlashes:null),x=t===E,A=x&&l?l(t):t;return x===!1&&(A=l?l(t):t,x=A===E),(x===!1||g.capture===!0)&&(g.matchBase===!0||g.basename===!0?x=T.matchBase(t,a,e,i):x=a.exec(A)),{isMatch:!!x,match:x,output:A}};T.matchBase=(t,a,e,E=Ct.isWindows(e))=>(a instanceof RegExp?a:T.makeRe(a,e)).test(be.basename(t));T.isMatch=(t,a,e)=>T(a,e)(t);T.parse=(t,a)=>Array.isArray(t)?t.map(e=>T.parse(e,a)):bt(t,{...a,fastpaths:!1});T.scan=(t,a)=>Ce(t,a);T.compileRe=(t,a,e=!1,E=!1)=>{if(e===!0)return t.output;let i=a||{},g=i.contains?"":"^",l=i.contains?"":"$",x=`${g}(?:${t.output})${l}`;t&&t.negated===!0&&(x=`^(?!${x}).*$`);let A=T.toRegex(x,a);return E===!0&&(A.state=t),A};T.makeRe=(t,a={},e=!1,E=!1)=>{if(!t||typeof t!="string")throw new TypeError("Expected a non-empty string");let i={negated:!1,fastpaths:!0};return a.fastpaths!==!1&&(t[0]==="."||t[0]==="*")&&(i.output=bt.fastpaths(t,a)),i.output||(i=bt(t,a)),T.compileRe(i,a,e,E)};T.toRegex=(t,a)=>{try{let e=a||{};return new RegExp(t,e.flags||(e.nocase?"i":""))}catch(e){if(a&&a.debug===!0)throw e;return/$^/}};T.constants=Se;Dt.exports=T});var Kt=J((ke,Pt)=>{"use strict";Pt.exports=Mt()});module.exports=Kt();
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js
+var require_constants = __commonJS({
+  "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/constants.js"(exports2, module2) {
+    "use strict";
+    var path = require("path");
+    var WIN_SLASH = "\\\\/";
+    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DOT_LITERAL = "\\.";
+    var PLUS_LITERAL = "\\+";
+    var QMARK_LITERAL = "\\?";
+    var SLASH_LITERAL = "\\/";
+    var ONE_CHAR = "(?=.)";
+    var QMARK = "[^/]";
+    var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+    var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+    var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+    var NO_DOT = `(?!${DOT_LITERAL})`;
+    var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+    var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+    var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+    var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+    var STAR = `${QMARK}*?`;
+    var POSIX_CHARS = {
+      DOT_LITERAL,
+      PLUS_LITERAL,
+      QMARK_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      QMARK,
+      END_ANCHOR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOT_SLASH,
+      NO_DOTS_SLASH,
+      QMARK_NO_DOT,
+      STAR,
+      START_ANCHOR
+    };
+    var WINDOWS_CHARS = {
+      ...POSIX_CHARS,
+      SLASH_LITERAL: `[${WIN_SLASH}]`,
+      QMARK: WIN_NO_SLASH,
+      STAR: `${WIN_NO_SLASH}*?`,
+      DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+      NO_DOT: `(?!${DOT_LITERAL})`,
+      NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+      NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+      START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+      END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
+    };
+    var POSIX_REGEX_SOURCE = {
+      alnum: "a-zA-Z0-9",
+      alpha: "a-zA-Z",
+      ascii: "\\x00-\\x7F",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1F\\x7F",
+      digit: "0-9",
+      graph: "\\x21-\\x7E",
+      lower: "a-z",
+      print: "\\x20-\\x7E ",
+      punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+      space: " \\t\\r\\n\\v\\f",
+      upper: "A-Z",
+      word: "A-Za-z0-9_",
+      xdigit: "A-Fa-f0-9"
+    };
+    module2.exports = {
+      MAX_LENGTH: 1024 * 64,
+      POSIX_REGEX_SOURCE,
+      // regular expressions
+      REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+      REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+      REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+      REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+      REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+      REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+      // Replace globs with equivalent patterns to reduce parsing time.
+      REPLACEMENTS: {
+        "***": "*",
+        "**/**": "**",
+        "**/**/**": "**"
+      },
+      // Digits
+      CHAR_0: 48,
+      /* 0 */
+      CHAR_9: 57,
+      /* 9 */
+      // Alphabet chars.
+      CHAR_UPPERCASE_A: 65,
+      /* A */
+      CHAR_LOWERCASE_A: 97,
+      /* a */
+      CHAR_UPPERCASE_Z: 90,
+      /* Z */
+      CHAR_LOWERCASE_Z: 122,
+      /* z */
+      CHAR_LEFT_PARENTHESES: 40,
+      /* ( */
+      CHAR_RIGHT_PARENTHESES: 41,
+      /* ) */
+      CHAR_ASTERISK: 42,
+      /* * */
+      // Non-alphabetic chars.
+      CHAR_AMPERSAND: 38,
+      /* & */
+      CHAR_AT: 64,
+      /* @ */
+      CHAR_BACKWARD_SLASH: 92,
+      /* \ */
+      CHAR_CARRIAGE_RETURN: 13,
+      /* \r */
+      CHAR_CIRCUMFLEX_ACCENT: 94,
+      /* ^ */
+      CHAR_COLON: 58,
+      /* : */
+      CHAR_COMMA: 44,
+      /* , */
+      CHAR_DOT: 46,
+      /* . */
+      CHAR_DOUBLE_QUOTE: 34,
+      /* " */
+      CHAR_EQUAL: 61,
+      /* = */
+      CHAR_EXCLAMATION_MARK: 33,
+      /* ! */
+      CHAR_FORM_FEED: 12,
+      /* \f */
+      CHAR_FORWARD_SLASH: 47,
+      /* / */
+      CHAR_GRAVE_ACCENT: 96,
+      /* ` */
+      CHAR_HASH: 35,
+      /* # */
+      CHAR_HYPHEN_MINUS: 45,
+      /* - */
+      CHAR_LEFT_ANGLE_BRACKET: 60,
+      /* < */
+      CHAR_LEFT_CURLY_BRACE: 123,
+      /* { */
+      CHAR_LEFT_SQUARE_BRACKET: 91,
+      /* [ */
+      CHAR_LINE_FEED: 10,
+      /* \n */
+      CHAR_NO_BREAK_SPACE: 160,
+      /* \u00A0 */
+      CHAR_PERCENT: 37,
+      /* % */
+      CHAR_PLUS: 43,
+      /* + */
+      CHAR_QUESTION_MARK: 63,
+      /* ? */
+      CHAR_RIGHT_ANGLE_BRACKET: 62,
+      /* > */
+      CHAR_RIGHT_CURLY_BRACE: 125,
+      /* } */
+      CHAR_RIGHT_SQUARE_BRACKET: 93,
+      /* ] */
+      CHAR_SEMICOLON: 59,
+      /* ; */
+      CHAR_SINGLE_QUOTE: 39,
+      /* ' */
+      CHAR_SPACE: 32,
+      /*   */
+      CHAR_TAB: 9,
+      /* \t */
+      CHAR_UNDERSCORE: 95,
+      /* _ */
+      CHAR_VERTICAL_LINE: 124,
+      /* | */
+      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+      /* \uFEFF */
+      SEP: path.sep,
+      /**
+       * Create EXTGLOB_CHARS
+       */
+      extglobChars(chars) {
+        return {
+          "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+          "?": { type: "qmark", open: "(?:", close: ")?" },
+          "+": { type: "plus", open: "(?:", close: ")+" },
+          "*": { type: "star", open: "(?:", close: ")*" },
+          "@": { type: "at", open: "(?:", close: ")" }
+        };
+      },
+      /**
+       * Create GLOB_CHARS
+       */
+      globChars(win32) {
+        return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js
+var require_utils = __commonJS({
+  "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/utils.js"(exports2) {
+    "use strict";
+    var path = require("path");
+    var win32 = process.platform === "win32";
+    var {
+      REGEX_BACKSLASH,
+      REGEX_REMOVE_BACKSLASH,
+      REGEX_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_GLOBAL
+    } = require_constants();
+    exports2.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    exports2.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+    exports2.isRegexChar = (str) => str.length === 1 && exports2.hasRegexChars(str);
+    exports2.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports2.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+    exports2.removeBackslashes = (str) => {
+      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+        return match === "\\" ? "" : match;
+      });
+    };
+    exports2.supportsLookbehinds = () => {
+      const segs = process.version.slice(1).split(".").map(Number);
+      if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) {
+        return true;
+      }
+      return false;
+    };
+    exports2.isWindows = (options) => {
+      if (options && typeof options.windows === "boolean") {
+        return options.windows;
+      }
+      return win32 === true || path.sep === "\\";
+    };
+    exports2.escapeLast = (input, char, lastIdx) => {
+      const idx = input.lastIndexOf(char, lastIdx);
+      if (idx === -1) return input;
+      if (input[idx - 1] === "\\") return exports2.escapeLast(input, char, idx - 1);
+      return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+    };
+    exports2.removePrefix = (input, state = {}) => {
+      let output = input;
+      if (output.startsWith("./")) {
+        output = output.slice(2);
+        state.prefix = "./";
+      }
+      return output;
+    };
+    exports2.wrapOutput = (input, state = {}, options = {}) => {
+      const prepend = options.contains ? "" : "^";
+      const append = options.contains ? "" : "$";
+      let output = `${prepend}(?:${input})${append}`;
+      if (state.negated === true) {
+        output = `(?:^(?!${output}).*$)`;
+      }
+      return output;
+    };
+  }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS({
+  "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/scan.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils();
+    var {
+      CHAR_ASTERISK,
+      /* * */
+      CHAR_AT,
+      /* @ */
+      CHAR_BACKWARD_SLASH,
+      /* \ */
+      CHAR_COMMA,
+      /* , */
+      CHAR_DOT,
+      /* . */
+      CHAR_EXCLAMATION_MARK,
+      /* ! */
+      CHAR_FORWARD_SLASH,
+      /* / */
+      CHAR_LEFT_CURLY_BRACE,
+      /* { */
+      CHAR_LEFT_PARENTHESES,
+      /* ( */
+      CHAR_LEFT_SQUARE_BRACKET,
+      /* [ */
+      CHAR_PLUS,
+      /* + */
+      CHAR_QUESTION_MARK,
+      /* ? */
+      CHAR_RIGHT_CURLY_BRACE,
+      /* } */
+      CHAR_RIGHT_PARENTHESES,
+      /* ) */
+      CHAR_RIGHT_SQUARE_BRACKET
+      /* ] */
+    } = require_constants();
+    var isPathSeparator = /* @__PURE__ */ __name((code) => {
+      return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+    }, "isPathSeparator");
+    var depth = /* @__PURE__ */ __name((token) => {
+      if (token.isPrefix !== true) {
+        token.depth = token.isGlobstar ? Infinity : 1;
+      }
+    }, "depth");
+    var scan = /* @__PURE__ */ __name((input, options) => {
+      const opts = options || {};
+      const length = input.length - 1;
+      const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+      const slashes = [];
+      const tokens = [];
+      const parts = [];
+      let str = input;
+      let index = -1;
+      let start = 0;
+      let lastIndex = 0;
+      let isBrace = false;
+      let isBracket = false;
+      let isGlob = false;
+      let isExtglob = false;
+      let isGlobstar = false;
+      let braceEscaped = false;
+      let backslashes = false;
+      let negated = false;
+      let negatedExtglob = false;
+      let finished = false;
+      let braces = 0;
+      let prev;
+      let code;
+      let token = { value: "", depth: 0, isGlob: false };
+      const eos = /* @__PURE__ */ __name(() => index >= length, "eos");
+      const peek = /* @__PURE__ */ __name(() => str.charCodeAt(index + 1), "peek");
+      const advance = /* @__PURE__ */ __name(() => {
+        prev = code;
+        return str.charCodeAt(++index);
+      }, "advance");
+      while (index < length) {
+        code = advance();
+        let next;
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          code = advance();
+          if (code === CHAR_LEFT_CURLY_BRACE) {
+            braceEscaped = true;
+          }
+          continue;
+        }
+        if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (code === CHAR_LEFT_CURLY_BRACE) {
+              braces++;
+              continue;
+            }
+            if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (braceEscaped !== true && code === CHAR_COMMA) {
+              isBrace = token.isBrace = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_RIGHT_CURLY_BRACE) {
+              braces--;
+              if (braces === 0) {
+                braceEscaped = false;
+                isBrace = token.isBrace = true;
+                finished = true;
+                break;
+              }
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_FORWARD_SLASH) {
+          slashes.push(index);
+          tokens.push(token);
+          token = { value: "", depth: 0, isGlob: false };
+          if (finished === true) continue;
+          if (prev === CHAR_DOT && index === start + 1) {
+            start += 2;
+            continue;
+          }
+          lastIndex = index + 1;
+          continue;
+        }
+        if (opts.noext !== true) {
+          const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+          if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+            isGlob = token.isGlob = true;
+            isExtglob = token.isExtglob = true;
+            finished = true;
+            if (code === CHAR_EXCLAMATION_MARK && index === start) {
+              negatedExtglob = true;
+            }
+            if (scanToEnd === true) {
+              while (eos() !== true && (code = advance())) {
+                if (code === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  code = advance();
+                  continue;
+                }
+                if (code === CHAR_RIGHT_PARENTHESES) {
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  break;
+                }
+              }
+              continue;
+            }
+            break;
+          }
+        }
+        if (code === CHAR_ASTERISK) {
+          if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_QUESTION_MARK) {
+          isGlob = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_LEFT_SQUARE_BRACKET) {
+          while (eos() !== true && (next = advance())) {
+            if (next === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance();
+              continue;
+            }
+            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+              isBracket = token.isBracket = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+          negated = token.negated = true;
+          start++;
+          continue;
+        }
+        if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+          isGlob = token.isGlob = true;
+          if (scanToEnd === true) {
+            while (eos() !== true && (code = advance())) {
+              if (code === CHAR_LEFT_PARENTHESES) {
+                backslashes = token.backslashes = true;
+                code = advance();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                finished = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+        if (isGlob === true) {
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+      }
+      if (opts.noext === true) {
+        isExtglob = false;
+        isGlob = false;
+      }
+      let base = str;
+      let prefix = "";
+      let glob = "";
+      if (start > 0) {
+        prefix = str.slice(0, start);
+        str = str.slice(start);
+        lastIndex -= start;
+      }
+      if (base && isGlob === true && lastIndex > 0) {
+        base = str.slice(0, lastIndex);
+        glob = str.slice(lastIndex);
+      } else if (isGlob === true) {
+        base = "";
+        glob = str;
+      } else {
+        base = str;
+      }
+      if (base && base !== "" && base !== "/" && base !== str) {
+        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+          base = base.slice(0, -1);
+        }
+      }
+      if (opts.unescape === true) {
+        if (glob) glob = utils.removeBackslashes(glob);
+        if (base && backslashes === true) {
+          base = utils.removeBackslashes(base);
+        }
+      }
+      const state = {
+        prefix,
+        input,
+        start,
+        base,
+        glob,
+        isBrace,
+        isBracket,
+        isGlob,
+        isExtglob,
+        isGlobstar,
+        negated,
+        negatedExtglob
+      };
+      if (opts.tokens === true) {
+        state.maxDepth = 0;
+        if (!isPathSeparator(code)) {
+          tokens.push(token);
+        }
+        state.tokens = tokens;
+      }
+      if (opts.parts === true || opts.tokens === true) {
+        let prevIndex;
+        for (let idx = 0; idx < slashes.length; idx++) {
+          const n = prevIndex ? prevIndex + 1 : start;
+          const i = slashes[idx];
+          const value = input.slice(n, i);
+          if (opts.tokens) {
+            if (idx === 0 && start !== 0) {
+              tokens[idx].isPrefix = true;
+              tokens[idx].value = prefix;
+            } else {
+              tokens[idx].value = value;
+            }
+            depth(tokens[idx]);
+            state.maxDepth += tokens[idx].depth;
+          }
+          if (idx !== 0 || value !== "") {
+            parts.push(value);
+          }
+          prevIndex = i;
+        }
+        if (prevIndex && prevIndex + 1 < input.length) {
+          const value = input.slice(prevIndex + 1);
+          parts.push(value);
+          if (opts.tokens) {
+            tokens[tokens.length - 1].value = value;
+            depth(tokens[tokens.length - 1]);
+            state.maxDepth += tokens[tokens.length - 1].depth;
+          }
+        }
+        state.slashes = slashes;
+        state.parts = parts;
+      }
+      return state;
+    }, "scan");
+    module2.exports = scan;
+  }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js
+var require_parse = __commonJS({
+  "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/parse.js"(exports2, module2) {
+    "use strict";
+    var constants = require_constants();
+    var utils = require_utils();
+    var {
+      MAX_LENGTH,
+      POSIX_REGEX_SOURCE,
+      REGEX_NON_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_BACKREF,
+      REPLACEMENTS
+    } = constants;
+    var expandRange = /* @__PURE__ */ __name((args, options) => {
+      if (typeof options.expandRange === "function") {
+        return options.expandRange(...args, options);
+      }
+      args.sort();
+      const value = `[${args.join("-")}]`;
+      try {
+        new RegExp(value);
+      } catch (ex) {
+        return args.map((v) => utils.escapeRegex(v)).join("..");
+      }
+      return value;
+    }, "expandRange");
+    var syntaxError = /* @__PURE__ */ __name((type, char) => {
+      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+    }, "syntaxError");
+    var parse = /* @__PURE__ */ __name((input, options) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      input = REPLACEMENTS[input] || input;
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      let len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      const bos = { type: "bos", value: "", output: opts.prepend || "" };
+      const tokens = [bos];
+      const capture = opts.capture ? "" : "?:";
+      const win32 = utils.isWindows(options);
+      const PLATFORM_CHARS = constants.globChars(win32);
+      const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+      const {
+        DOT_LITERAL,
+        PLUS_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOT_SLASH,
+        NO_DOTS_SLASH,
+        QMARK,
+        QMARK_NO_DOT,
+        STAR,
+        START_ANCHOR
+      } = PLATFORM_CHARS;
+      const globstar = /* @__PURE__ */ __name((opts2) => {
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      }, "globstar");
+      const nodot = opts.dot ? "" : NO_DOT;
+      const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+      let star = opts.bash === true ? globstar(opts) : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      if (typeof opts.noext === "boolean") {
+        opts.noextglob = opts.noext;
+      }
+      const state = {
+        input,
+        index: -1,
+        start: 0,
+        dot: opts.dot === true,
+        consumed: "",
+        output: "",
+        prefix: "",
+        backtrack: false,
+        negated: false,
+        brackets: 0,
+        braces: 0,
+        parens: 0,
+        quotes: 0,
+        globstar: false,
+        tokens
+      };
+      input = utils.removePrefix(input, state);
+      len = input.length;
+      const extglobs = [];
+      const braces = [];
+      const stack = [];
+      let prev = bos;
+      let value;
+      const eos = /* @__PURE__ */ __name(() => state.index === len - 1, "eos");
+      const peek = state.peek = (n = 1) => input[state.index + n];
+      const advance = state.advance = () => input[++state.index] || "";
+      const remaining = /* @__PURE__ */ __name(() => input.slice(state.index + 1), "remaining");
+      const consume = /* @__PURE__ */ __name((value2 = "", num = 0) => {
+        state.consumed += value2;
+        state.index += num;
+      }, "consume");
+      const append = /* @__PURE__ */ __name((token) => {
+        state.output += token.output != null ? token.output : token.value;
+        consume(token.value);
+      }, "append");
+      const negate = /* @__PURE__ */ __name(() => {
+        let count = 1;
+        while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+          advance();
+          state.start++;
+          count++;
+        }
+        if (count % 2 === 0) {
+          return false;
+        }
+        state.negated = true;
+        state.start++;
+        return true;
+      }, "negate");
+      const increment = /* @__PURE__ */ __name((type) => {
+        state[type]++;
+        stack.push(type);
+      }, "increment");
+      const decrement = /* @__PURE__ */ __name((type) => {
+        state[type]--;
+        stack.pop();
+      }, "decrement");
+      const push = /* @__PURE__ */ __name((tok) => {
+        if (prev.type === "globstar") {
+          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+          const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+          if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+            state.output = state.output.slice(0, -prev.output.length);
+            prev.type = "star";
+            prev.value = "*";
+            prev.output = star;
+            state.output += prev.output;
+          }
+        }
+        if (extglobs.length && tok.type !== "paren") {
+          extglobs[extglobs.length - 1].inner += tok.value;
+        }
+        if (tok.value || tok.output) append(tok);
+        if (prev && prev.type === "text" && tok.type === "text") {
+          prev.value += tok.value;
+          prev.output = (prev.output || "") + tok.value;
+          return;
+        }
+        tok.prev = prev;
+        tokens.push(tok);
+        prev = tok;
+      }, "push");
+      const extglobOpen = /* @__PURE__ */ __name((type, value2) => {
+        const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+        token.prev = prev;
+        token.parens = state.parens;
+        token.output = state.output;
+        const output = (opts.capture ? "(" : "") + token.open;
+        increment("parens");
+        push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+        push({ type: "paren", extglob: true, value: advance(), output });
+        extglobs.push(token);
+      }, "extglobOpen");
+      const extglobClose = /* @__PURE__ */ __name((token) => {
+        let output = token.close + (opts.capture ? ")" : "");
+        let rest;
+        if (token.type === "negate") {
+          let extglobStar = star;
+          if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+            extglobStar = globstar(opts);
+          }
+          if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+            output = token.close = `)$))${extglobStar}`;
+          }
+          if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+            const expression = parse(rest, { ...options, fastpaths: false }).output;
+            output = token.close = `)${expression})${extglobStar})`;
+          }
+          if (token.prev.type === "bos") {
+            state.negatedExtglob = true;
+          }
+        }
+        push({ type: "paren", extglob: true, value, output });
+        decrement("parens");
+      }, "extglobClose");
+      if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+        let backslashes = false;
+        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+          if (first === "\\") {
+            backslashes = true;
+            return m;
+          }
+          if (first === "?") {
+            if (esc) {
+              return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            if (index === 0) {
+              return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            return QMARK.repeat(chars.length);
+          }
+          if (first === ".") {
+            return DOT_LITERAL.repeat(chars.length);
+          }
+          if (first === "*") {
+            if (esc) {
+              return esc + first + (rest ? star : "");
+            }
+            return star;
+          }
+          return esc ? m : `\\${m}`;
+        });
+        if (backslashes === true) {
+          if (opts.unescape === true) {
+            output = output.replace(/\\/g, "");
+          } else {
+            output = output.replace(/\\+/g, (m) => {
+              return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+            });
+          }
+        }
+        if (output === input && opts.contains === true) {
+          state.output = input;
+          return state;
+        }
+        state.output = utils.wrapOutput(output, state, options);
+        return state;
+      }
+      while (!eos()) {
+        value = advance();
+        if (value === "\0") {
+          continue;
+        }
+        if (value === "\\") {
+          const next = peek();
+          if (next === "/" && opts.bash !== true) {
+            continue;
+          }
+          if (next === "." || next === ";") {
+            continue;
+          }
+          if (!next) {
+            value += "\\";
+            push({ type: "text", value });
+            continue;
+          }
+          const match = /^\\+/.exec(remaining());
+          let slashes = 0;
+          if (match && match[0].length > 2) {
+            slashes = match[0].length;
+            state.index += slashes;
+            if (slashes % 2 !== 0) {
+              value += "\\";
+            }
+          }
+          if (opts.unescape === true) {
+            value = advance();
+          } else {
+            value += advance();
+          }
+          if (state.brackets === 0) {
+            push({ type: "text", value });
+            continue;
+          }
+        }
+        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+          if (opts.posix !== false && value === ":") {
+            const inner = prev.value.slice(1);
+            if (inner.includes("[")) {
+              prev.posix = true;
+              if (inner.includes(":")) {
+                const idx = prev.value.lastIndexOf("[");
+                const pre = prev.value.slice(0, idx);
+                const rest2 = prev.value.slice(idx + 2);
+                const posix = POSIX_REGEX_SOURCE[rest2];
+                if (posix) {
+                  prev.value = pre + posix;
+                  state.backtrack = true;
+                  advance();
+                  if (!bos.output && tokens.indexOf(prev) === 1) {
+                    bos.output = ONE_CHAR;
+                  }
+                  continue;
+                }
+              }
+            }
+          }
+          if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+            value = `\\${value}`;
+          }
+          if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+            value = `\\${value}`;
+          }
+          if (opts.posix === true && value === "!" && prev.value === "[") {
+            value = "^";
+          }
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (state.quotes === 1 && value !== '"') {
+          value = utils.escapeRegex(value);
+          prev.value += value;
+          append({ value });
+          continue;
+        }
+        if (value === '"') {
+          state.quotes = state.quotes === 1 ? 0 : 1;
+          if (opts.keepQuotes === true) {
+            push({ type: "text", value });
+          }
+          continue;
+        }
+        if (value === "(") {
+          increment("parens");
+          push({ type: "paren", value });
+          continue;
+        }
+        if (value === ")") {
+          if (state.parens === 0 && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "("));
+          }
+          const extglob = extglobs[extglobs.length - 1];
+          if (extglob && state.parens === extglob.parens + 1) {
+            extglobClose(extglobs.pop());
+            continue;
+          }
+          push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+          decrement("parens");
+          continue;
+        }
+        if (value === "[") {
+          if (opts.nobracket === true || !remaining().includes("]")) {
+            if (opts.nobracket !== true && opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("closing", "]"));
+            }
+            value = `\\${value}`;
+          } else {
+            increment("brackets");
+          }
+          push({ type: "bracket", value });
+          continue;
+        }
+        if (value === "]") {
+          if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          if (state.brackets === 0) {
+            if (opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("opening", "["));
+            }
+            push({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          decrement("brackets");
+          const prevValue = prev.value.slice(1);
+          if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+            value = `/${value}`;
+          }
+          prev.value += value;
+          append({ value });
+          if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+            continue;
+          }
+          const escaped = utils.escapeRegex(prev.value);
+          state.output = state.output.slice(0, -prev.value.length);
+          if (opts.literalBrackets === true) {
+            state.output += escaped;
+            prev.value = escaped;
+            continue;
+          }
+          prev.value = `(${capture}${escaped}|${prev.value})`;
+          state.output += prev.value;
+          continue;
+        }
+        if (value === "{" && opts.nobrace !== true) {
+          increment("braces");
+          const open = {
+            type: "brace",
+            value,
+            output: "(",
+            outputIndex: state.output.length,
+            tokensIndex: state.tokens.length
+          };
+          braces.push(open);
+          push(open);
+          continue;
+        }
+        if (value === "}") {
+          const brace = braces[braces.length - 1];
+          if (opts.nobrace === true || !brace) {
+            push({ type: "text", value, output: value });
+            continue;
+          }
+          let output = ")";
+          if (brace.dots === true) {
+            const arr = tokens.slice();
+            const range = [];
+            for (let i = arr.length - 1; i >= 0; i--) {
+              tokens.pop();
+              if (arr[i].type === "brace") {
+                break;
+              }
+              if (arr[i].type !== "dots") {
+                range.unshift(arr[i].value);
+              }
+            }
+            output = expandRange(range, opts);
+            state.backtrack = true;
+          }
+          if (brace.comma !== true && brace.dots !== true) {
+            const out = state.output.slice(0, brace.outputIndex);
+            const toks = state.tokens.slice(brace.tokensIndex);
+            brace.value = brace.output = "\\{";
+            value = output = "\\}";
+            state.output = out;
+            for (const t of toks) {
+              state.output += t.output || t.value;
+            }
+          }
+          push({ type: "brace", value, output });
+          decrement("braces");
+          braces.pop();
+          continue;
+        }
+        if (value === "|") {
+          if (extglobs.length > 0) {
+            extglobs[extglobs.length - 1].conditions++;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value === ",") {
+          let output = value;
+          const brace = braces[braces.length - 1];
+          if (brace && stack[stack.length - 1] === "braces") {
+            brace.comma = true;
+            output = "|";
+          }
+          push({ type: "comma", value, output });
+          continue;
+        }
+        if (value === "/") {
+          if (prev.type === "dot" && state.index === state.start + 1) {
+            state.start = state.index + 1;
+            state.consumed = "";
+            state.output = "";
+            tokens.pop();
+            prev = bos;
+            continue;
+          }
+          push({ type: "slash", value, output: SLASH_LITERAL });
+          continue;
+        }
+        if (value === ".") {
+          if (state.braces > 0 && prev.type === "dot") {
+            if (prev.value === ".") prev.output = DOT_LITERAL;
+            const brace = braces[braces.length - 1];
+            prev.type = "dots";
+            prev.output += value;
+            prev.value += value;
+            brace.dots = true;
+            continue;
+          }
+          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+            push({ type: "text", value, output: DOT_LITERAL });
+            continue;
+          }
+          push({ type: "dot", value, output: DOT_LITERAL });
+          continue;
+        }
+        if (value === "?") {
+          const isGroup = prev && prev.value === "(";
+          if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("qmark", value);
+            continue;
+          }
+          if (prev && prev.type === "paren") {
+            const next = peek();
+            let output = value;
+            if (next === "<" && !utils.supportsLookbehinds()) {
+              throw new Error("Node.js v10 or higher is required for regex lookbehinds");
+            }
+            if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+              output = `\\${value}`;
+            }
+            push({ type: "text", value, output });
+            continue;
+          }
+          if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+            push({ type: "qmark", value, output: QMARK_NO_DOT });
+            continue;
+          }
+          push({ type: "qmark", value, output: QMARK });
+          continue;
+        }
+        if (value === "!") {
+          if (opts.noextglob !== true && peek() === "(") {
+            if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+              extglobOpen("negate", value);
+              continue;
+            }
+          }
+          if (opts.nonegate !== true && state.index === 0) {
+            negate();
+            continue;
+          }
+        }
+        if (value === "+") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("plus", value);
+            continue;
+          }
+          if (prev && prev.value === "(" || opts.regex === false) {
+            push({ type: "plus", value, output: PLUS_LITERAL });
+            continue;
+          }
+          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+            push({ type: "plus", value });
+            continue;
+          }
+          push({ type: "plus", value: PLUS_LITERAL });
+          continue;
+        }
+        if (value === "@") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            push({ type: "at", extglob: true, value, output: "" });
+            continue;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (value !== "*") {
+          if (value === "$" || value === "^") {
+            value = `\\${value}`;
+          }
+          const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+          if (match) {
+            value += match[0];
+            state.index += match[0].length;
+          }
+          push({ type: "text", value });
+          continue;
+        }
+        if (prev && (prev.type === "globstar" || prev.star === true)) {
+          prev.type = "star";
+          prev.star = true;
+          prev.value += value;
+          prev.output = star;
+          state.backtrack = true;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        let rest = remaining();
+        if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+          extglobOpen("star", value);
+          continue;
+        }
+        if (prev.type === "star") {
+          if (opts.noglobstar === true) {
+            consume(value);
+            continue;
+          }
+          const prior = prev.prev;
+          const before = prior.prev;
+          const isStart = prior.type === "slash" || prior.type === "bos";
+          const afterStar = before && (before.type === "star" || before.type === "globstar");
+          if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+          const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+          if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+            push({ type: "star", value, output: "" });
+            continue;
+          }
+          while (rest.slice(0, 3) === "/**") {
+            const after = input[state.index + 4];
+            if (after && after !== "/") {
+              break;
+            }
+            rest = rest.slice(3);
+            consume("/**", 3);
+          }
+          if (prior.type === "bos" && eos()) {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = globstar(opts);
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+            prev.value += value;
+            state.globstar = true;
+            state.output += prior.output + prev.output;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+            const end = rest[1] !== void 0 ? "|$" : "";
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+            prev.value += value;
+            state.output += prior.output + prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          if (prior.type === "bos" && rest[0] === "/") {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value + advance());
+            push({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          state.output = state.output.slice(0, -prev.output.length);
+          prev.type = "globstar";
+          prev.output = globstar(opts);
+          prev.value += value;
+          state.output += prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        const token = { type: "star", value, output: star };
+        if (opts.bash === true) {
+          token.output = ".*?";
+          if (prev.type === "bos" || prev.type === "slash") {
+            token.output = nodot + token.output;
+          }
+          push(token);
+          continue;
+        }
+        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+          token.output = value;
+          push(token);
+          continue;
+        }
+        if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+          if (prev.type === "dot") {
+            state.output += NO_DOT_SLASH;
+            prev.output += NO_DOT_SLASH;
+          } else if (opts.dot === true) {
+            state.output += NO_DOTS_SLASH;
+            prev.output += NO_DOTS_SLASH;
+          } else {
+            state.output += nodot;
+            prev.output += nodot;
+          }
+          if (peek() !== "*") {
+            state.output += ONE_CHAR;
+            prev.output += ONE_CHAR;
+          }
+        }
+        push(token);
+      }
+      while (state.brackets > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+        state.output = utils.escapeLast(state.output, "[");
+        decrement("brackets");
+      }
+      while (state.parens > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+        state.output = utils.escapeLast(state.output, "(");
+        decrement("parens");
+      }
+      while (state.braces > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+        state.output = utils.escapeLast(state.output, "{");
+        decrement("braces");
+      }
+      if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+        push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+      }
+      if (state.backtrack === true) {
+        state.output = "";
+        for (const token of state.tokens) {
+          state.output += token.output != null ? token.output : token.value;
+          if (token.suffix) {
+            state.output += token.suffix;
+          }
+        }
+      }
+      return state;
+    }, "parse");
+    parse.fastpaths = (input, options) => {
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      input = REPLACEMENTS[input] || input;
+      const win32 = utils.isWindows(options);
+      const {
+        DOT_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOTS,
+        NO_DOTS_SLASH,
+        STAR,
+        START_ANCHOR
+      } = constants.globChars(win32);
+      const nodot = opts.dot ? NO_DOTS : NO_DOT;
+      const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+      const capture = opts.capture ? "" : "?:";
+      const state = { negated: false, prefix: "" };
+      let star = opts.bash === true ? ".*?" : STAR;
+      if (opts.capture) {
+        star = `(${star})`;
+      }
+      const globstar = /* @__PURE__ */ __name((opts2) => {
+        if (opts2.noglobstar === true) return star;
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      }, "globstar");
+      const create = /* @__PURE__ */ __name((str) => {
+        switch (str) {
+          case "*":
+            return `${nodot}${ONE_CHAR}${star}`;
+          case ".*":
+            return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*.*":
+            return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "*/*":
+            return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+          case "**":
+            return nodot + globstar(opts);
+          case "**/*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+          case "**/*.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+          case "**/.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+          default: {
+            const match = /^(.*?)\.(\w+)$/.exec(str);
+            if (!match) return;
+            const source2 = create(match[1]);
+            if (!source2) return;
+            return source2 + DOT_LITERAL + match[2];
+          }
+        }
+      }, "create");
+      const output = utils.removePrefix(input, state);
+      let source = create(output);
+      if (source && opts.strictSlashes !== true) {
+        source += `${SLASH_LITERAL}?`;
+      }
+      return source;
+    };
+    module2.exports = parse;
+  }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS({
+  "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
+    "use strict";
+    var path = require("path");
+    var scan = require_scan();
+    var parse = require_parse();
+    var utils = require_utils();
+    var constants = require_constants();
+    var isObject = /* @__PURE__ */ __name((val) => val && typeof val === "object" && !Array.isArray(val), "isObject");
+    var picomatch = /* @__PURE__ */ __name((glob, options, returnState = false) => {
+      if (Array.isArray(glob)) {
+        const fns = glob.map((input) => picomatch(input, options, returnState));
+        const arrayMatcher = /* @__PURE__ */ __name((str) => {
+          for (const isMatch of fns) {
+            const state2 = isMatch(str);
+            if (state2) return state2;
+          }
+          return false;
+        }, "arrayMatcher");
+        return arrayMatcher;
+      }
+      const isState = isObject(glob) && glob.tokens && glob.input;
+      if (glob === "" || typeof glob !== "string" && !isState) {
+        throw new TypeError("Expected pattern to be a non-empty string");
+      }
+      const opts = options || {};
+      const posix = utils.isWindows(options);
+      const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+      const state = regex.state;
+      delete regex.state;
+      let isIgnored = /* @__PURE__ */ __name(() => false, "isIgnored");
+      if (opts.ignore) {
+        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+        isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+      }
+      const matcher = /* @__PURE__ */ __name((input, returnObject = false) => {
+        const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+        const result = { glob, state, regex, posix, input, output, match, isMatch };
+        if (typeof opts.onResult === "function") {
+          opts.onResult(result);
+        }
+        if (isMatch === false) {
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (isIgnored(input)) {
+          if (typeof opts.onIgnore === "function") {
+            opts.onIgnore(result);
+          }
+          result.isMatch = false;
+          return returnObject ? result : false;
+        }
+        if (typeof opts.onMatch === "function") {
+          opts.onMatch(result);
+        }
+        return returnObject ? result : true;
+      }, "matcher");
+      if (returnState) {
+        matcher.state = state;
+      }
+      return matcher;
+    }, "picomatch");
+    picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected input to be a string");
+      }
+      if (input === "") {
+        return { isMatch: false, output: "" };
+      }
+      const opts = options || {};
+      const format = opts.format || (posix ? utils.toPosixSlashes : null);
+      let match = input === glob;
+      let output = match && format ? format(input) : input;
+      if (match === false) {
+        output = format ? format(input) : input;
+        match = output === glob;
+      }
+      if (match === false || opts.capture === true) {
+        if (opts.matchBase === true || opts.basename === true) {
+          match = picomatch.matchBase(input, regex, options, posix);
+        } else {
+          match = regex.exec(output);
+        }
+      }
+      return { isMatch: Boolean(match), match, output };
+    };
+    picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+      const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+      return regex.test(path.basename(input));
+    };
+    picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+    picomatch.parse = (pattern, options) => {
+      if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
+      return parse(pattern, { ...options, fastpaths: false });
+    };
+    picomatch.scan = (input, options) => scan(input, options);
+    picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+      if (returnOutput === true) {
+        return state.output;
+      }
+      const opts = options || {};
+      const prepend = opts.contains ? "" : "^";
+      const append = opts.contains ? "" : "$";
+      let source = `${prepend}(?:${state.output})${append}`;
+      if (state && state.negated === true) {
+        source = `^(?!${source}).*$`;
+      }
+      const regex = picomatch.toRegex(source, options);
+      if (returnState === true) {
+        regex.state = state;
+      }
+      return regex;
+    };
+    picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+      if (!input || typeof input !== "string") {
+        throw new TypeError("Expected a non-empty string");
+      }
+      let parsed = { negated: false, fastpaths: true };
+      if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+        parsed.output = parse.fastpaths(input, options);
+      }
+      if (!parsed.output) {
+        parsed = parse(input, options);
+      }
+      return picomatch.compileRe(parsed, options, returnOutput, returnState);
+    };
+    picomatch.toRegex = (source, options) => {
+      try {
+        const opts = options || {};
+        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+      } catch (err) {
+        if (options && options.debug === true) throw err;
+        return /$^/;
+      }
+    };
+    picomatch.constants = constants;
+    module2.exports = picomatch;
+  }
+});
+
+// node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS({
+  "node_modules/.pnpm/picomatch@2.3.1/node_modules/picomatch/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_picomatch();
+  }
+});
+
+// src/external/picomatch.js
+module.exports = require_picomatch2();