@defold-typescript/types 0.53.0 → 0.54.0

package/fixtures/defold-1.13.2/string_doc.json

@@ -0,0 +1,413 @@
+{
+  "elements": [
+    {
+      "type": "FUNCTION",
+      "name": "string.byte",
+      "brief": "converts a character into its ASCII (decimal) equivalent",
+      "description": "Returns the internal numerical codes of the characters <code>s[i]</code>,\n<code>s[i+1]</code>, ..., <code>s[j]</code>.\nThe default value for i is 1;\nthe default value for j is i.\nNote that numerical codes are not necessarily portable across platforms.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "i",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "True"
+        },
+        {
+          "name": "j",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.char",
+      "brief": "converts ASCII codes into their equivalent characters",
+      "description": "Receives zero or more integers.\nReturns a string with length equal to the number of arguments,\nin which each character has the internal numerical code equal\nto its corresponding argument.\nNote that numerical codes are not necessarily portable across platforms.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "...",
+          "doc": "",
+          "types": ["any"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.dump",
+      "brief": "converts a function into binary",
+      "description": "Returns a string containing a binary representation of the given function,\nso that a later loadstring on this string returns\na copy of the function.\nfunction must be a Lua function without upvalues.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "function",
+          "doc": "",
+          "types": ["function"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.find",
+      "brief": "searches a string for a pattern",
+      "description": "Looks for the first match of\npattern in the string s.\nIf it finds a match, then find returns the indices of <code>s</code>\nwhere this occurrence starts and ends;\notherwise, it returns <span class=\"type\"> nil</span>.\nA third, optional numerical argument init specifies\nwhere to start the search;\nits default value is 1 and can be negative.\nA value of <span class=\"type\"> true</span> as a fourth, optional argument plain\nturns off the pattern matching facilities,\nso the function does a plain \"find substring\" operation,\nwith no characters in pattern being considered \"magic\".\nNote that if plain is given, then init must be given as well.\nIf the pattern has captures,\nthen in a successful match\nthe captured values are also returned,\nafter the two indices.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "pattern",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "init",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "True"
+        },
+        {
+          "name": "plain",
+          "doc": "",
+          "types": ["boolean"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.format",
+      "brief": "formats a string",
+      "description": "Returns a formatted version of its variable number of arguments\nfollowing the description given in its first argument (which must be a string).\nThe format string follows the same rules as the printf family of\nstandard C functions.\nThe only differences are that the options/modifiers\n<code>*</code>, l, L, n, p,\nand h are not supported\nand that there is an extra option, q.\nThe q option formats a string in a form suitable to be safely read\nback by the Lua interpreter:\nthe string is written between double quotes,\nand all double quotes, newlines, embedded zeros,\nand backslashes in the string\nare correctly escaped when written.\nFor instance, the call\n<div class=\"codehilite\"><pre><span></span><code><span class=\"nb\">string.format</span><span class=\"p\">(</span><span class=\"s1\">&#39;%q&#39;</span><span class=\"p\">,</span> <span class=\"s1\">&#39;a string with &quot;quotes&quot; and </span><span class=\"se\">\\n</span><span class=\"s1\"> new line&#39;</span><span class=\"p\">)</span>\n</code></pre></div>\n\nwill produce the string:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"s2\">&quot;a string with </span><span class=\"se\">\\&quot;</span><span class=\"s2\">quotes</span><span class=\"se\">\\&quot;</span><span class=\"s2\"> and </span><span class=\"se\">\\</span>\n<span class=\"s2\"> new line&quot;</span>\n</code></pre></div>\n\nThe options c, d, E, e, f,\ng, G, i, o, u, X, and x all\nexpect a number as argument,\nwhereas q and s expect a string.\nThis function does not accept string values\ncontaining embedded zeros,\nexcept as arguments to the q option.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "formatstring",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "...",
+          "doc": "",
+          "types": ["any"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.gmatch",
+      "brief": "iterate over a string",
+      "description": "Returns an iterator function that,\neach time it is called,\nreturns the next captures from pattern over string s.\nIf pattern specifies no captures,\nthen the whole match is produced in each call.\nAs an example, the following loop\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"s2\">&quot;hello world from Lua&quot;</span>\n<span class=\"kr\">for</span> <span class=\"n\">w</span> <span class=\"kr\">in</span> <span class=\"nb\">string.gmatch</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%a+&quot;</span><span class=\"p\">)</span> <span class=\"kr\">do</span>\n  <span class=\"nb\">print</span><span class=\"p\">(</span><span class=\"n\">w</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>\n\nwill iterate over all the words from string s,\nprinting one per line.\nThe next example collects all pairs <code>key=value</code> from the\ngiven string into a table:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"p\">{}</span>\n<span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"s2\">&quot;from=world, to=Lua&quot;</span>\n<span class=\"kr\">for</span> <span class=\"n\">k</span><span class=\"p\">,</span> <span class=\"n\">v</span> <span class=\"kr\">in</span> <span class=\"nb\">string.gmatch</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"s2\">&quot;(%w+)=(%w+)&quot;</span><span class=\"p\">)</span> <span class=\"kr\">do</span>\n  <span class=\"n\">t</span><span class=\"p\">[</span><span class=\"n\">k</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">v</span>\n<span class=\"kr\">end</span>\n</code></pre></div>\n\nFor this function, a '^' at the start of a pattern does not\nwork as an anchor, as this would prevent the iteration.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "pattern",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.gsub",
+      "brief": "substitute strings inside another string",
+      "description": "Returns a copy of s\nin which all (or the first n, if given)\noccurrences of the pattern have been\nreplaced by a replacement string specified by repl,\nwhich can be a string, a table, or a function.\ngsub also returns, as its second value,\nthe total number of matches that occurred.\nIf repl is a string, then its value is used for replacement.\nThe character <code>%</code> works as an escape character:\nany sequence in repl of the form <code>%n</code>,\nwith n between 1 and 9,\nstands for the value of the n-th captured substring (see below).\nThe sequence <code>%0</code> stands for the whole match.\nThe sequence <code>%%</code> stands for a single <code>%</code>.\nIf repl is a table, then the table is queried for every match,\nusing the first capture as the key;\nif the pattern specifies no captures,\nthen the whole match is used as the key.\nIf repl is a function, then this function is called every time a\nmatch occurs, with all captured substrings passed as arguments,\nin order;\nif the pattern specifies no captures,\nthen the whole match is passed as a sole argument.\nIf the value returned by the table query or by the function call\nis a string or a number,\nthen it is used as the replacement string;\notherwise, if it is false or <span class=\"type\"> nil</span>,\nthen there is no replacement\n(that is, the original match is kept in the string).\nHere are some examples:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"nb\">string.gsub</span><span class=\"p\">(</span><span class=\"s2\">&quot;hello world&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;(%w+)&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%1 %1&quot;</span><span class=\"p\">)</span>\n<span class=\"c1\">--&gt; x=&quot;hello hello world world&quot;</span>\n\n<span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"nb\">string.gsub</span><span class=\"p\">(</span><span class=\"s2\">&quot;hello world&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%w+&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%0 %0&quot;</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"c1\">--&gt; x=&quot;hello hello world&quot;</span>\n\n<span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"nb\">string.gsub</span><span class=\"p\">(</span><span class=\"s2\">&quot;hello world from Lua&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;(%w+)%s*(%w+)&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%2 %1&quot;</span><span class=\"p\">)</span>\n<span class=\"c1\">--&gt; x=&quot;world hello Lua from&quot;</span>\n\n<span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"nb\">string.gsub</span><span class=\"p\">(</span><span class=\"s2\">&quot;home = $HOME, user = $USER&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%$(%w+)&quot;</span><span class=\"p\">,</span> <span class=\"nb\">os.getenv</span><span class=\"p\">)</span>\n<span class=\"c1\">--&gt; x=&quot;home = /home/roberto, user = roberto&quot;</span>\n\n<span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"nb\">string.gsub</span><span class=\"p\">(</span><span class=\"s2\">&quot;4+5 = $return 4+5$&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%$(.-)%$&quot;</span><span class=\"p\">,</span> <span class=\"kr\">function</span> <span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">)</span>\n      <span class=\"kr\">return</span> <span class=\"n\">loadstring</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">)()</span>\n    <span class=\"kr\">end</span><span class=\"p\">)</span>\n<span class=\"c1\">--&gt; x=&quot;4+5 = 9&quot;</span>\n\n<span class=\"kd\">local</span> <span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"p\">{</span><span class=\"n\">name</span><span class=\"o\">=</span><span class=\"s2\">&quot;lua&quot;</span><span class=\"p\">,</span> <span class=\"n\">version</span><span class=\"o\">=</span><span class=\"s2\">&quot;5.1&quot;</span><span class=\"p\">}</span>\n<span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"nb\">string.gsub</span><span class=\"p\">(</span><span class=\"s2\">&quot;$name-$version.tar.gz&quot;</span><span class=\"p\">,</span> <span class=\"s2\">&quot;%$(%w+)&quot;</span><span class=\"p\">,</span> <span class=\"n\">t</span><span class=\"p\">)</span>\n<span class=\"c1\">--&gt; x=&quot;lua-5.1.tar.gz&quot;</span>\n</code></pre></div>",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "pattern",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "repl",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "n",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.len",
+      "brief": "return the length of a string",
+      "description": "Receives a string and returns its length.\nThe empty string <code>\"\"</code> has length 0.\nEmbedded zeros are counted,\nso <code>\"a\\000bc\\000\"</code> has length 5.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.lower",
+      "brief": "converts a string to lower-case",
+      "description": "Receives a string and returns a copy of this string with all\nuppercase letters changed to lowercase.\nAll other characters are left unchanged.\nThe definition of what an uppercase letter is depends on the current locale.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.match",
+      "brief": "searches a string for a pattern",
+      "description": "Looks for the first <em>match</em> of\npattern in the string s.\nIf it finds one, then match returns\nthe captures from the pattern;\notherwise it returns <span class=\"type\"> nil</span>.\nIf pattern specifies no captures,\nthen the whole match is returned.\nA third, optional numerical argument init specifies\nwhere to start the search;\nits default value is 1 and can be negative.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "pattern",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "init",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.rep",
+      "brief": "returns repeated copies of a string",
+      "description": "Returns a string that is the concatenation of n copies of\nthe string s.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "n",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.reverse",
+      "brief": "reverses the order of characters in a string",
+      "description": "Returns a string that is the string s reversed.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.sub",
+      "brief": "returns a substring of a string",
+      "description": "Returns the substring of s that\nstarts at i  and continues until j;\ni and j can be negative.\nIf j is absent, then it is assumed to be equal to -1\n(which is the same as the string length).\nIn particular,\nthe call <code>string.sub(s,1,j)</code> returns a prefix of s\nwith length j,\nand <code>string.sub(s, -i)</code> returns a suffix of s\nwith length i.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "i",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "j",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "string.upper",
+      "brief": "converts a string to upper-case",
+      "description": "Receives a string and returns a copy of this string with all\nlowercase letters changed to uppercase.\nAll other characters are left unchanged.\nThe definition of what a lowercase letter is depends on the current locale.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "s",
+          "doc": "",
+          "types": ["string"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    }
+  ],
+  "info": {
+    "namespace": "string",
+    "name": "String",
+    "brief": "Lua string standard library",
+    "description": "Documentation for the Lua string standard library.\n\nFrom [Lua 5.1 Reference Manual](https://www.lua.org/manual/5.1/)\nby Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes.\n\nCopyright &copy; 2006-2012 Lua.org, PUC-Rio.\n\nFreely available under the terms of the [Lua license](https://www.lua.org/license.html).\n\n\n### Patterns\n\n_Character Class:_\n\nA character class is used to represent a set of characters.\nThe following combinations are allowed in describing a character class:\n\nx\n: (where x is not one of the <em>magic characters</em> `^$()%.[]*+-?`)\n  represents the character <em>x</em> itself.\n\n`.`\n: (a dot) represents all characters.\n\n`%a`\n: represents all letters.\n\n`%c`\n: represents all control characters.\n\n`%d`\n: represents all digits.\n\n`%l`\n: represents all lowercase letters.\n\n`%p`\n: represents all punctuation characters.\n\n`%s`\n: represents all space characters.\n\n`%u`\n: represents all uppercase letters.\n\n`%w`\n: represents all alphanumeric characters.\n\n`%x`\n: represents all hexadecimal digits.\n\n`%z`\n: represents the character with representation 0.\n\n`%x`\n: (where x is any non-alphanumeric character) represents the character x.\n  This is the standard way to escape the magic characters.\n  Any punctuation character (even the non magic) can be preceded by a '%'\n  when used to represent itself in a pattern.\n\n`[set]`\n: represents the class which is the union of all characters in set.\n  A range of characters can be specified by separating the end characters\n  of the range with a '-'.\n  All classes `%`<em>x</em> described above can also be used as components in set.\n  All other characters in set represent themselves.\n  For example, `[%w_]` (or `[_%w]`) represents all alphanumeric characters\n  plus the underscore, `[0-7]` represents the octal digits,\n  and `[0-7%l%-]` represents the octal digits plus the lowercase letters\n  plus the '-' character.\n\n  The interaction between ranges and classes is not defined.\n  Therefore, patterns like `[%a-z]` or `[a-%%]` have no meaning.\n\n`[^set]`\n: represents the complement of set,\n  where set is interpreted as above.\n\nFor all classes represented by single letters (`%a`, `%c`, etc.),\nthe corresponding uppercase letter represents the complement of the class.\nFor instance, `%S` represents all non-space characters.\n\nThe definitions of letter, space, and other character groups\ndepend on the current locale. In particular, the class `[a-z]` may not be\nequivalent to `%l`.\n\n_Pattern Item:_\n\nA pattern item can be\n\n- a single character class, which matches any single character in the class;\n\n- a single character class followed by '*',\n  which matches 0 or more repetitions of characters in the class.\n  These repetition items will always match the longest possible sequence;\n\n- a single character class followed by '+',\n  which matches 1 or more repetitions of characters in the class.\n  These repetition items will always match the longest possible sequence;\n\n- a single character class followed by '-',\n  which also matches 0 or more repetitions of characters in the class.\n  Unlike '*', these repetition items will always match the <em>shortest</em>\n  possible sequence;\n\n- a single character class followed by '?',\n  which matches 0 or 1 occurrence of a character in the class;\n\n- `%n`, for n between 1 and 9; such item matches a substring equal to the\n  n-th captured string (see below);\n\n- `%bxy`, where x and y are two distinct characters;\n  such item matches strings that start with x, end with y,\n  and where the x and y are <em>balanced</em>.\n  This means that, if one reads the string from left to right,\n  counting +1 for an x and -1 for a y,\n  the ending y is the first y where the count reaches 0.\n  For instance, the item `%b()` matches expressions with balanced parentheses.\n\n_Pattern:_\n\nA pattern is a sequence of pattern items.\nA '^' at the beginning of a pattern anchors the match at the\nbeginning of the subject string.\nA '$' at the end of a pattern anchors the match at the\nend of the subject string.\nAt other positions, '^' and '$' have no special meaning and represent themselves.\n\n_Captures:_\n\nA pattern can contain sub-patterns enclosed in parentheses;\nthey describe captures.\nWhen a match succeeds, the substrings of the subject string\nthat match captures are stored (<em>captured</em>) for future use.\nCaptures are numbered according to their left parentheses.\nFor instance, in the pattern `\"(a*(.)%w(%s*))\"`,\nthe part of the string matching `\"a*(.)%w(%s*)\"` is\nstored as the first capture (and therefore has number 1);\nthe character matching \".\" is captured with number 2,\nand the part matching \"%s*\" has number 3.\n\nAs a special case, the empty capture `()` captures\nthe current string position (a number).\nFor instance, if we apply the pattern `\"()aa()\"` on the\nstring `\"flaaap\"`, there will be two captures: 3 and 5.\n\nA pattern cannot contain embedded zeros.  Use `%z` instead.",
+    "path": "engine/lua/src/lua_string.doc_h",
+    "file": "",
+    "notes": [],
+    "language": "Lua"
+  },
+  "format_version": 2
+}