{
  "classes": [
    {
      "constants": [],
      "types": [
        {
          "lua_type": "type MatchOptions = { includeHidden: boolean?, caseSensitive: boolean? }",
          "name": "MatchOptions",
          "tags": [],
          "source": {
            "path": "",
            "line": 22
          },
          "fields": [
            {
              "lua_type": "includeHidden: boolean?",
              "name": "includeHidden",
              "desc": "Whether wildcard segments may match names beginning with `.`.\nDefaults to `false`."
            },
            {
              "lua_type": "caseSensitive: boolean?",
              "name": "caseSensitive",
              "desc": "Whether comparisons are case-sensitive.\nDefaults to `true`."
            }
          ],
          "desc": "Options used by string/array-based glob matching.\n"
        },
        {
          "lua_type": "type GlobOptions = MatchOptions & { root: string?, ignore: string | { string }?, followSymlinks: boolean?, onlyFiles: boolean?, onlyDirectories: boolean? }",
          "name": "GlobOptions",
          "tags": [],
          "source": {
            "path": "",
            "line": 35
          },
          "fields": [
            {
              "lua_type": "root: string?",
              "name": "root",
              "desc": "Root directory used for filesystem traversal.\nDefaults to `\".\"`."
            },
            {
              "lua_type": "ignore: string | { string }?",
              "name": "ignore",
              "desc": "Ignore pattern(s) evaluated against relative paths.\nCan be a single pattern or an array of patterns."
            },
            {
              "lua_type": "followSymlinks: boolean?",
              "name": "followSymlinks",
              "desc": "Whether directory symlinks should be traversed recursively.\nDefaults to `false`."
            },
            {
              "lua_type": "onlyFiles: boolean?",
              "name": "onlyFiles",
              "desc": "If `true`, only files are returned."
            },
            {
              "lua_type": "onlyDirectories: boolean?",
              "name": "onlyDirectories",
              "desc": "If `true`, only directories are returned."
            }
          ],
          "desc": "Options used by filesystem glob expansion.\nExtends [[MatchOptions]] with traversal controls.\n"
        }
      ],
      "name": "@eryx/glob",
      "tags": [],
      "functions": [
        {
          "source": {
            "path": "",
            "line": 422
          },
          "is_method": false,
          "signature": "glob.escape(\n    literal: string  -- raw text to treat as a literal path fragment\n) → (\n    string  -- escaped glob pattern \n)",
          "owner": "glob",
          "desc": "Escape glob metacharacters in `literal` so the result matches literally.\n",
          "tags": [],
          "name": "escape",
          "return_str": "string",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "string",
              "desc": "escaped glob pattern "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "literal",
              "desc": "raw text to treat as a literal path fragment"
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 432
          },
          "is_method": false,
          "signature": "glob.hasMagic(\n    pattern: string  -- pattern text to inspect\n) → (\n    boolean  -- `true` when `*`, `?`, or `[` appears unescaped \n)",
          "owner": "glob",
          "desc": "Return whether `pattern` contains unescaped glob metacharacters.\n",
          "tags": [],
          "name": "hasMagic",
          "return_str": "boolean",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "`true` when `*`, `?`, or `[` appears unescaped "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "pattern",
              "desc": "pattern text to inspect"
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 455
          },
          "is_method": false,
          "signature": "glob.compile(\n    pattern: string,  -- glob pattern to compile\n    options: MatchOptions?  -- matching behavior options\n) → (\n    Compiled  -- frozen compiled matcher with `pattern` and `match` \n)",
          "owner": "glob",
          "desc": "Compile a glob pattern into a reusable matcher object.\n",
          "tags": [],
          "name": "compile",
          "return_str": "Compiled",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "Compiled",
              "desc": "frozen compiled matcher with `pattern` and `match` "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "pattern",
              "desc": "glob pattern to compile"
            },
            {
              "lua_type": "MatchOptions?",
              "name": "options",
              "desc": "matching behavior options"
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 474
          },
          "is_method": false,
          "signature": "glob.match(\n    path: string,  -- candidate path\n    pattern: string,  -- glob pattern\n    options: MatchOptions?  -- matching behavior options\n) → (\n    boolean  -- `true` when the path matches \n)",
          "owner": "glob",
          "desc": "Test whether `path` matches `pattern`.\n",
          "tags": [],
          "name": "match",
          "return_str": "boolean",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": "`true` when the path matches "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "path",
              "desc": "candidate path"
            },
            {
              "lua_type": "string",
              "name": "pattern",
              "desc": "glob pattern"
            },
            {
              "lua_type": "MatchOptions?",
              "name": "options",
              "desc": "matching behavior options"
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 487
          },
          "is_method": false,
          "signature": "glob.filter(\n    paths: { string },  -- candidate paths\n    pattern: string,  -- glob pattern\n    options: MatchOptions?  -- matching behavior options\n) → (\n    {string}  -- matching paths in original order \n)",
          "owner": "glob",
          "desc": "Filter an array of paths, returning only entries that match `pattern`.\n",
          "tags": [],
          "name": "filter",
          "return_str": "{ string }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ string }",
              "desc": "matching paths in original order "
            }
          ],
          "params": [
            {
              "lua_type": "{ string }",
              "name": "paths",
              "desc": "candidate paths"
            },
            {
              "lua_type": "string",
              "name": "pattern",
              "desc": "glob pattern"
            },
            {
              "lua_type": "MatchOptions?",
              "name": "options",
              "desc": "matching behavior options"
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 506
          },
          "is_method": false,
          "signature": "glob.gmatch(\n    paths: { string },  -- candidate paths\n    pattern: string,  -- glob pattern\n    options: MatchOptions?  -- matching behavior options\n) → (\n    () -> string?  -- iterator yielding matching paths, then `nil` \n)",
          "owner": "glob",
          "desc": "Create an iterator over entries in `paths` that match `pattern`.\n",
          "tags": [],
          "name": "gmatch",
          "return_str": "(() → string?)",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "(() → string?)",
              "desc": "iterator yielding matching paths, then `nil` "
            }
          ],
          "params": [
            {
              "lua_type": "{ string }",
              "name": "paths",
              "desc": "candidate paths"
            },
            {
              "lua_type": "string",
              "name": "pattern",
              "desc": "glob pattern"
            },
            {
              "lua_type": "MatchOptions?",
              "name": "options",
              "desc": "matching behavior options"
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 550
          },
          "is_method": false,
          "signature": "glob.glob(\n    pattern: string,  -- glob pattern to evaluate\n    options: GlobOptions?  -- traversal and matching options\n) → (\n    {string}  -- matched paths \n)",
          "owner": "glob",
          "desc": "Expand a filesystem glob relative to `options.root`.\n\nReturned paths are relative to the root and normalized to `/` separators.\n",
          "tags": [],
          "name": "glob",
          "return_str": "{ string }",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "{ string }",
              "desc": "matched paths "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "pattern",
              "desc": "glob pattern to evaluate"
            },
            {
              "lua_type": "GlobOptions?",
              "name": "options",
              "desc": "traversal and matching options"
            }
          ]
        },
        {
          "source": {
            "path": "",
            "line": 604
          },
          "is_method": false,
          "signature": "glob.iglob(\n    pattern: string,  -- glob pattern to evaluate\n    options: GlobOptions?  -- traversal and matching options\n) → (\n    () -> string?  -- iterator yielding matched paths, then `nil` \n)",
          "owner": "glob",
          "desc": "Create an iterator over filesystem glob results.\n",
          "tags": [],
          "name": "iglob",
          "return_str": "(() → string?)",
          "function_type": "Function",
          "returns": [
            {
              "lua_type": "(() → string?)",
              "desc": "iterator yielding matched paths, then `nil` "
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "pattern",
              "desc": "glob pattern to evaluate"
            },
            {
              "lua_type": "GlobOptions?",
              "name": "options",
              "desc": "traversal and matching options"
            }
          ]
        }
      ],
      "properties": [],
      "source": {
        "path": "",
        "line": 0
      },
      "desc": "Path globbing for strings, arrays, and filesystem traversal.\n\nSupported pattern features:\n- `*`  : zero or more characters (within one path segment)\n- `?`  : exactly one character (within one path segment)\n- `[abc]`, `[a-z]`, `[!abc]` : character classes\n- `**` : zero or more path segments (globstar, segment-only)\n- `\\\\` escapes metacharacters for literal matching\n\nThe engine is pure Luau and shared by both array matching and filesystem\ntraversal helpers.\n"
    },
    {
      "is_primary_export": false,
      "source": {
        "path": "",
        "line": 54
      },
      "tags": [],
      "properties": [
        {
          "tags": [],
          "lua_type": "pattern: string",
          "name": "pattern",
          "desc": "The original pattern string used for compilation."
        }
      ],
      "desc": "A compiled glob pattern that can be reused for repeated matching.\n",
      "name": "Compiled",
      "functions": [
        {
          "source": {
            "path": "",
            "line": 58
          },
          "is_method": true,
          "signature": "Compiled:match(path: string) → boolean",
          "desc": "Match a candidate path against this compiled pattern.",
          "tags": [],
          "name": "match",
          "return_str": "boolean",
          "function_type": "Method",
          "returns": [
            {
              "lua_type": "boolean",
              "desc": ""
            }
          ],
          "params": [
            {
              "lua_type": "string",
              "name": "path",
              "desc": ""
            }
          ]
        }
      ],
      "metamethods": [],
      "types": []
    }
  ]
}