@svp-labs/talos 0.0.0 → 0.1.1

package/dist/langs/lua/paths.js

@@ -0,0 +1,94 @@
+import { access } from 'node:fs/promises';
+import { isAbsolute, join, posix, relative } from 'node:path';
+import { EngineError } from '../../core/check.js';
+import { underRoot } from '../../repo/facts.js';
+/** The tree `install()` builds in the component's root: Lua, LuaRocks and the rocks. */
+export const TREE = '.lua';
+/** The project's own luacheck settings, which the generated `.luacheckrc` loads. */
+export const LUACHECK_PROJECT = 'luacheck_project.lua';
+/** The component a component check runs for; the engine always sets it. */
+export function component(ctx) {
+    if (ctx.component !== undefined)
+        return ctx.component;
+    throw new EngineError('a lua check ran without a component');
+}
+/** The component's directory, absolute. */
+export function componentDir(place) {
+    return join(place.root, place.component.root);
+}
+/** A path without the slashes it ends with. */
+export function withoutTrailingSlashes(path) {
+    let end = path.length;
+    while (end > 0 && path[end - 1] === '/')
+        end -= 1;
+    return path.slice(0, end);
+}
+/** A repository-relative path made relative to the component's root, or undefined outside it. */
+export function inComponent(root, path) {
+    const inside = posix.relative(posix.normalize(root), posix.normalize(path));
+    return inside === '' || inside === '..' || inside.startsWith('../') ? undefined : inside;
+}
+/** A component-relative path made repository-relative. */
+export function inRepo(root, path) {
+    return posix.join(root, path);
+}
+/** A path a tool printed (absolute, or relative to the component) made repository-relative. */
+export function fromTool(place, file) {
+    const path = isAbsolute(file) ? relative(place.root, file) : inRepo(place.component.root, file);
+    return posix.normalize(path.replaceAll('\\', '/'));
+}
+/** The component's tracked Lua sources, relative to its root, the installed tree left out. */
+export function luaFiles(ctx) {
+    const root = component(ctx).root;
+    return underRoot(ctx.facts.matching('**/*.lua'), root)
+        .map((file) => inComponent(root, file))
+        .filter((file) => file !== undefined && !file.startsWith(`${TREE}/`));
+}
+/** Test code as busted lays it out: `*_spec.lua` files and anything under a spec or test dir. */
+export function isTestPath(path) {
+    return path.endsWith('_spec.lua') || /(?:^|\/)(?:spec|tests?)\//.test(path);
+}
+/** The files busted runs: every `*_spec.lua`. */
+export function specFiles(files) {
+    return files.filter((file) => file.endsWith('_spec.lua'));
+}
+/** Code the coverage measures: everything but tests and the project's luacheck settings. */
+export function sourceFiles(files) {
+    return files.filter((file) => !isTestPath(file) && file !== LUACHECK_PROJECT);
+}
+export async function fileExists(path) {
+    return access(path).then(() => true, () => false);
+}
+/** The installed tree's directory, absolute. */
+export function treeDir(place) {
+    return join(componentDir(place), TREE);
+}
+/**
+ * A program in the tree's `bin`: the Lua interpreter is an executable everywhere; LuaRocks and
+ * the rocks' commands are shell scripts, which are `.bat` files on Windows.
+ */
+export function treeProgram(place, name) {
+    const bin = join(treeDir(place), 'bin');
+    if (place.os !== 'windows')
+        return join(bin, name);
+    return join(bin, name === 'lua' ? 'lua.exe' : `${name}.bat`);
+}
+/** A program the tree must have, or an engine error naming what is missing. */
+export async function installedProgram(place, name) {
+    const path = treeProgram(place, name);
+    if (await fileExists(path))
+        return path;
+    throw new EngineError(`${name} is not installed in ${inRepo(place.component.root, TREE)}: install() did not run`);
+}
+/**
+ * The environment for Talos's own Lua scripts: modules from the tree only, so nothing in the
+ * component's directory can stand in for luacheck or luacov, and no startup code from the
+ * environment. Lua 5.4 reads the `_5_4` names before the plain ones.
+ */
+export function scriptEnv(place) {
+    const tree = treeDir(place).replaceAll('\\', '/');
+    const lua = [`${tree}/share/lua/5.4/?.lua`, `${tree}/share/lua/5.4/?/init.lua`].join(';');
+    const native = `${tree}/lib/lua/5.4/?.${place.os === 'windows' ? 'dll' : 'so'}`;
+    return { LUA_PATH_5_4: lua, LUA_CPATH_5_4: native, LUA_INIT_5_4: '', LUA_INIT: '' };
+}
+//# sourceMappingURL=paths.js.map

package/dist/langs/lua/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../src/langs/lua/paths.ts"],"names":[],"mappings":"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"}

package/dist/langs/lua/run.js

@@ -0,0 +1,63 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { component, componentDir, installedProgram, scriptEnv } from './paths.js';
+import { EngineError } from '../../core/check.js';
+export const bind = (ctx) => ({ ...ctx, component: component(ctx) });
+/**
+ * Runs a program from the component's tree (`lua`, `luarocks`, or a rock's command), in the
+ * component's directory unless told otherwise.
+ */
+export async function runTree(ctx, name, args, options = {}) {
+    return ctx.exec(await installedProgram(ctx, name), args, { cwd: componentDir(ctx), ...options });
+}
+/** An engine error for a program that failed, ending with the last of what it printed. */
+export function failed(what, result) {
+    const printed = result.stderr.trim() === '' ? result.stdout : result.stderr;
+    const last = printed.trim().split('\n').slice(-15).join('\n');
+    return new EngineError(`${what} exited ${result.code}:\n${last}`);
+}
+/**
+ * Runs one of Talos's Lua scripts with the tree's interpreter, in the component's directory,
+ * with modules from the tree only. Returns its standard output; any failure is an engine error.
+ */
+export async function runScript(ctx, script, args) {
+    const path = join(ctx.scratch, script.name);
+    await writeFile(path, script.source);
+    const result = await runTree(ctx, 'lua', [path, ...args], { env: scriptEnv(ctx) });
+    if (result.code !== 0)
+        throw failed(`lua ${script.name}`, result);
+    return result.stdout;
+}
+/** Text a tool printed as JSON. */
+export function parseJson(text, what) {
+    try {
+        const value = JSON.parse(text);
+        return value;
+    }
+    catch {
+        throw new EngineError(`${what} printed no readable JSON: ${text.trim().slice(0, 200)}`);
+    }
+}
+/**
+ * Splits arguments into runs that each stay under `limit` characters, since Windows starts the
+ * rocks' `.bat` commands through cmd.exe, whose command line holds 8191 characters; each
+ * argument costs its length, its two quotes and a space there.
+ */
+export function chunks(items, limit = 6000) {
+    const out = [];
+    let current = [];
+    let length = 0;
+    for (const item of items) {
+        if (current.length > 0 && length + item.length + 3 > limit) {
+            out.push(current);
+            current = [];
+            length = 0;
+        }
+        current.push(item);
+        length += item.length + 3;
+    }
+    if (current.length > 0)
+        out.push(current);
+    return out;
+}
+//# sourceMappingURL=run.js.map

package/dist/langs/lua/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../../src/langs/lua/run.ts"],"names":[],"mappings":"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"}

package/dist/langs/lua/scripts/json.js

@@ -0,0 +1,39 @@
+/**
+ * A JSON encoder for Talos's Lua scripts, which run with nothing but the component's tree. A
+ * table with a first element, or no elements, is an array; any other table is an object.
+ */
+export const LUA_JSON = String.raw `local ESCAPES = { ['"'] = '\\"', ["\\"] = "\\\\", ["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t" }
+
+local function quote(text)
+  local escaped = text:gsub('[%c"\\]', function(c)
+    return ESCAPES[c] or ("\\u%04x"):format(c:byte())
+  end)
+  return '"' .. escaped .. '"'
+end
+
+local function encode(value)
+  local kind = type(value)
+  if kind == "string" then
+    return quote(value)
+  elseif kind ~= "table" then
+    return tostring(value)
+  end
+  local parts = {}
+  if value[1] ~= nil or next(value) == nil then
+    for _, item in ipairs(value) do
+      parts[#parts + 1] = encode(item)
+    end
+    return "[" .. table.concat(parts, ",") .. "]"
+  end
+  local keys = {}
+  for key in pairs(value) do
+    keys[#keys + 1] = key
+  end
+  table.sort(keys)
+  for _, key in ipairs(keys) do
+    parts[#parts + 1] = quote(key) .. ":" .. encode(value[key])
+  end
+  return "{" .. table.concat(parts, ",") .. "}"
+end
+`;
+//# sourceMappingURL=json.js.map

package/dist/langs/lua/scripts/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../../src/langs/lua/scripts/json.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCjC,CAAC"}

package/dist/langs/lua/scripts/lcov.js

@@ -0,0 +1,77 @@
+/**
+ * Writes LCOV for the listed sources from a luacov stats file, using luacov's own view of which
+ * lines can run (with cluacov, from the compiled code). A source no test loaded is reported with
+ * every line it can run missed. Stats name files as Lua loaded them (`./src/x.lua`,
+ * `src\x.lua`), so names are normalised to the list's form: relative, forward slashes.
+ * Arguments: the stats file, the output file, the file listing the sources, one per line.
+ */
+const BODY = String.raw `local reporter = require("luacov.reporter")
+local stats = require("luacov.stats")
+
+local stats_path, out_path, list_path = arg[1], arg[2], arg[3]
+
+local function normalize(name)
+  name = name:gsub("\\", "/")
+  while name:sub(1, 2) == "./" do
+    name = name:sub(3)
+  end
+  return name
+end
+
+local data = {}
+for name, hits in pairs(stats.load(stats_path) or {}) do
+  local key = normalize(name)
+  local known = data[key]
+  if known then
+    for line, count in pairs(hits) do
+      if type(line) == "number" then
+        known[line] = (known[line] or 0) + count
+      end
+    end
+  else
+    data[key] = hits
+  end
+end
+
+local files = {}
+for line in io.lines(list_path) do
+  if line ~= "" then
+    files[#files + 1] = line
+    data[line] = data[line] or { max = 0, max_hits = 0 }
+  end
+end
+
+local Lcov = setmetatable({}, reporter.ReporterBase)
+Lcov.__index = Lcov
+
+function Lcov:on_new_file(filename)
+  self:write("SF:", filename, "\n")
+end
+
+function Lcov:on_file_error(filename, kind, message)
+  io.stderr:write(("could not %s %s: %s\n"):format(kind, filename, message))
+  os.exit(2)
+end
+
+function Lcov:on_mis_line(_, lineno)
+  self:write("DA:", lineno, ",0\n")
+end
+
+function Lcov:on_hit_line(_, lineno, _, hits)
+  self:write("DA:", lineno, ",", hits, "\n")
+end
+
+function Lcov:on_end_file()
+  self:write("end_of_record\n")
+end
+
+local out = assert(io.open(out_path, "w"))
+local report = setmetatable({ _out = out, _cfg = {}, _data = data, _files = files, _mhit = 0 }, Lcov)
+report:run()
+report:close()
+`;
+export const LCOV_SCRIPT = {
+    name: 'talos_lcov.lua',
+    source: `-- Talos: luacov's statistics as LCOV.\n${BODY}`,
+};
+//# sourceMappingURL=lcov.js.map

package/dist/langs/lua/scripts/lcov.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lcov.js","sourceRoot":"","sources":["../../../../src/langs/lua/scripts/lcov.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEtB,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE,2CAA2C,IAAI,EAAE;CAC1D,CAAC"}

package/dist/langs/lua/scripts/luacheck.js

@@ -0,0 +1,97 @@
+import { LUA_JSON } from './json.js';
+/** The formatter's module name; luacheck requires it by name, so it must be unusual. */
+export const FORMATTER_MODULE = 'talos_luacheck_json';
+/**
+ * A luacheck formatter: every file luacheck checked, with its warnings in luacheck's own words
+ * and its fatal error if it had one, as one JSON object. A file luacheck skipped is absent.
+ */
+const FORMATTER_BODY = String.raw `local format = require("luacheck.format")
+
+return function(report, file_names)
+  local files = {}
+  for index, file_report in ipairs(report) do
+    local events = {}
+    for _, event in ipairs(file_report) do
+      events[#events + 1] = {
+        code = event.code,
+        line = event.line,
+        column = event.column,
+        endColumn = event.end_column or event.column,
+        message = format.get_message(event),
+      }
+    end
+    files[#files + 1] = {
+      file = file_names[index],
+      fatal = file_report.fatal or "",
+      error = file_report.msg or "",
+      events = events,
+    }
+  end
+  return encode({ files = files })
+end
+`;
+export const LUACHECK_FORMATTER = {
+    name: `${FORMATTER_MODULE}.lua`,
+    source: `-- Talos: luacheck's report as JSON.\n${LUA_JSON}\n${FORMATTER_BODY}`,
+};
+/**
+ * Loads `.luacheckrc` the way luacheck does, from the current directory (so it requires the
+ * project's file relative to it), validates it, and prints the options that can weaken a check,
+ * at the top level and for each `files` pattern. Values are strings, numbers, booleans or lists
+ * of strings; a std given as a table prints as "(table)".
+ */
+const CONFIG_BODY = String.raw `local config = require("luacheck.config")
+
+local OPTIONS = {
+  "std", "compat", "global", "unused", "redefined", "unused_args", "unused_secondaries", "self",
+  "allow_defined", "allow_defined_top", "module", "max_line_length", "max_code_line_length",
+  "max_string_line_length", "max_comment_line_length", "max_cyclomatic_complexity",
+  "ignore", "only", "exclude_files", "include_files",
+}
+
+local function value_of(name, value)
+  if type(value) ~= "table" then
+    return value
+  elseif name == "std" then
+    return "(table)"
+  end
+  local items = {}
+  for _, item in ipairs(value) do
+    items[#items + 1] = tostring(item)
+  end
+  return items
+end
+
+local function pick(options)
+  local picked = {}
+  for _, name in ipairs(OPTIONS) do
+    if options[name] ~= nil then
+      picked[#picked + 1] = { name = name, value = value_of(name, options[name]) }
+    end
+  end
+  return picked
+end
+
+local conf, err = config.load_config(".luacheckrc", false)
+local stacked
+if conf then
+  stacked, err = config.stack_configs({ conf })
+end
+if not stacked then
+  io.write(encode({ error = tostring(err) }), "\n")
+  return
+end
+local files = {}
+for glob, options in pairs(conf.options.files or {}) do
+  if type(glob) == "string" then
+    files[#files + 1] = { glob = glob, options = pick(options) }
+  end
+end
+table.sort(files, function(a, b) return a.glob < b.glob end)
+io.write(encode({ error = "", top = pick(conf.options), files = files }), "\n")
+`;
+export const LUACHECK_CONFIG_SCRIPT = {
+    name: 'talos_luacheck_config.lua',
+    source: `-- Talos: the options luacheck loads.\n${LUA_JSON}\n${CONFIG_BODY}`,
+};
+//# sourceMappingURL=luacheck.js.map

package/dist/langs/lua/scripts/luacheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"luacheck.js","sourceRoot":"","sources":["../../../../src/langs/lua/scripts/luacheck.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,wFAAwF;AACxF,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AAEtD;;;GAGG;AACH,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;CAwBhC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,GAAG,gBAAgB,MAAM;IAC/B,MAAM,EAAE,yCAAyC,QAAQ,KAAK,cAAc,EAAE;CAC/E,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD7B,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,IAAI,EAAE,2BAA2B;IACjC,MAAM,EAAE,0CAA0C,QAAQ,KAAK,WAAW,EAAE;CAC7E,CAAC"}

package/dist/langs/lua/scripts/shape.js

@@ -0,0 +1,197 @@
+import { LUA_JSON } from './json.js';
+/**
+ * Measures every function of the files it is given with luacheck's own parser: its span, its
+ * parameters (an implicit `self` and `...` left out), its lines of code, its deepest nesting
+ * of control statements, and its cognitive complexity. Each function is measured alone, so a
+ * nested function counts toward itself, not the function around it. The main chunk is measured
+ * for nesting only, and each file gets its line count and the numbers of its lines of code.
+ * Prints one JSON object; a file luacheck can't parse is marked, not measured.
+ */
+const BODY = String.raw `local decoder = require("luacheck.decoder")
+local parser = require("luacheck.parser")
+
+local CONTROL = { If = true, While = true, Repeat = true, Fornum = true, Forin = true }
+local ASSIGNING = { Set = true, Local = true, Localrec = true }
+
+local function line_of(offsets, offset)
+  local low, high = 1, #offsets
+  while low < high do
+    local middle = (low + high + 1) // 2
+    if offsets[middle] <= offset then
+      low = middle
+    else
+      high = middle - 1
+    end
+  end
+  return low
+end
+
+local function name_of(node)
+  if node.tag == "Id" then
+    return node[1]
+  elseif node.tag == "Index" and node[2].tag == "String" then
+    local base = name_of(node[1])
+    return base and (base .. "." .. node[2][1])
+  end
+end
+
+local Walk = {}
+Walk.__index = Walk
+
+function Walk:list(nodes, depth)
+  for _, node in ipairs(nodes) do
+    if type(node) == "table" then
+      self:node(node, depth)
+    end
+  end
+end
+
+function Walk:logical(node, depth, outer)
+  local operator = node[1]
+  if operator ~= "and" and operator ~= "or" then
+    self:list({ node[2], node[3] }, depth)
+    return
+  end
+  if operator ~= outer then
+    self.cognitive = self.cognitive + 1
+  end
+  for index = 2, 3 do
+    local operand = node[index]
+    if operand.tag == "Op" then
+      self:logical(operand, depth, operator)
+    else
+      self:node(operand, depth)
+    end
+  end
+end
+
+function Walk:control(node, depth)
+  local nesting = depth + 1
+  self.cognitive = self.cognitive + nesting
+  if node.tag == "If" then
+    self.cognitive = self.cognitive + (#node // 2 - 1) + #node % 2
+  end
+  if nesting > self.deepest.depth then
+    self.deepest = { depth = nesting, line = node.line, endLine = line_of(self.offsets, node.end_offset) }
+  end
+  for _, child in ipairs(node) do
+    if type(child) == "table" then
+      if child.tag == nil then
+        self:list(child, nesting)
+      else
+        self:node(child, depth)
+      end
+    end
+  end
+end
+
+function Walk:node(node, depth)
+  local tag = node.tag
+  if tag == "Function" then
+    self.queue[#self.queue + 1] = node
+  elseif CONTROL[tag] then
+    self:control(node, depth)
+  elseif tag == "Op" then
+    self:logical(node, depth)
+  else
+    if tag == "Goto" then
+      self.cognitive = self.cognitive + 1
+    elseif ASSIGNING[tag] then
+      for index, value in ipairs(node[2] or {}) do
+        if value.tag == "Function" and node[1][index] then
+          self.names[value] = name_of(node[1][index])
+        end
+      end
+    end
+    self:list(node, depth)
+  end
+end
+
+local function count_lines(code_lines, first, last)
+  local count = 0
+  for line = first, last do
+    count = count + (code_lines[line] and 1 or 0)
+  end
+  return count
+end
+
+local function line_numbers(code_lines, last)
+  local numbers = {}
+  for line = 1, last do
+    if code_lines[line] then
+      numbers[#numbers + 1] = line
+    end
+  end
+  return numbers
+end
+
+local function walk(body, file)
+  local state = setmetatable({ cognitive = 0, deepest = { depth = 0 }, queue = file.queue,
+    names = file.names, offsets = file.offsets }, Walk)
+  state:list(body, 0)
+  return state
+end
+
+local function measure(file, node)
+  local state = walk(node[2], file)
+  local params = 0
+  for _, arg in ipairs(node[1]) do
+    params = params + ((arg.tag == "Id" and not arg.implicit) and 1 or 0)
+  end
+  local last = node.end_range.line
+  return {
+    name = file.names[node] or "",
+    line = node.line,
+    endLine = last,
+    params = params,
+    codeLines = count_lines(file.code_lines, node.line, last),
+    cognitive = state.cognitive,
+    depth = state.deepest.depth,
+    deepLine = state.deepest.line or node.line,
+    deepEndLine = state.deepest.endLine or last,
+  }
+end
+
+local function measure_file(path)
+  local handle = io.open(path, "rb")
+  if not handle then
+    return { file = path, error = "unreadable" }
+  end
+  local bytes = handle:read("a")
+  handle:close()
+  local offsets = {}
+  local ok, ast, _, code_lines = pcall(parser.parse, decoder.decode(bytes), offsets, {})
+  if not ok then
+    return { file = path, error = "syntax" }
+  end
+  local file = { queue = {}, names = {}, offsets = offsets, code_lines = code_lines }
+  local main = walk(ast, file)
+  local functions = {}
+  local index = 1
+  while file.queue[index] do
+    functions[#functions + 1] = measure(file, file.queue[index])
+    index = index + 1
+  end
+  return {
+    file = path,
+    error = "",
+    lines = #offsets,
+    code = line_numbers(code_lines, #offsets),
+    depth = main.deepest.depth,
+    deepLine = main.deepest.line or 1,
+    deepEndLine = main.deepest.endLine or 1,
+    functions = functions,
+  }
+end
+
+local files = {}
+for index = 1, #arg do
+  files[#files + 1] = measure_file(arg[index])
+end
+io.write(encode({ files = files }), "\n")
+`;
+export const SHAPE_SCRIPT = {
+    name: 'talos_shape.lua',
+    source: `-- Talos: measures Lua functions with luacheck's parser.\n${LUA_JSON}\n${BODY}`,
+};
+//# sourceMappingURL=shape.js.map

package/dist/langs/lua/scripts/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","sourceRoot":"","sources":["../../../../src/langs/lua/scripts/shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsLtB,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,iBAAiB;IACvB,MAAM,EAAE,6DAA6D,QAAQ,KAAK,IAAI,EAAE;CACzF,CAAC"}