@lzehrung/codegraph 2.3.20 → 2.3.22

package/dist/bin/rawQueryWorker.js

@@ -1,383 +0,0 @@
-import { createRequire as __codegraphCreateRequire } from 'node:module';
-const require = __codegraphCreateRequire(import.meta.url);
-
-
-// dist/sqlite-driver.js
-import { createRequire } from "node:module";
-
-// dist/util/errors.js
-function errorMessage(error) {
-  if (error instanceof Error)
-    return error.message;
-  if (typeof error === "string")
-    return error;
-  if (error === null || error === void 0)
-    return String(error);
-  if (typeof error === "object") {
-    try {
-      const serialized = JSON.stringify(error);
-      if (serialized)
-        return serialized;
-    } catch {
-      return String(error);
-    }
-  }
-  return String(error);
-}
-
-// dist/util/windowsProcessDrain.js
-var WINDOWS_LIBUV_EXIT_DRAIN_MS = 100;
-var drainRequired = false;
-var beforeExitListener;
-function markWindowsProcessDrainRequired() {
-  drainRequired = true;
-  ensureWindowsProcessDrainHook();
-}
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function ensureWindowsProcessDrainHook() {
-  if (process.platform !== "win32" || beforeExitListener)
-    return;
-  beforeExitListener = () => {
-    void drainWindowsProcessHandles();
-  };
-  process.once("beforeExit", beforeExitListener);
-}
-async function drainWindowsProcessHandles(options) {
-  const platform = options?.platform ?? process.platform;
-  const required = options?.required ?? drainRequired;
-  if (platform !== "win32" || !required)
-    return;
-  await (options?.wait ?? delay)(WINDOWS_LIBUV_EXIT_DRAIN_MS);
-}
-
-// dist/sqlite-driver.js
-var requireNodeModule = createRequire(import.meta.url);
-var sqliteModule;
-var reportedReadonlyAuthorizerDegradation = false;
-function reportReadonlyAuthorizerDegraded() {
-  if (reportedReadonlyAuthorizerDegradation)
-    return;
-  reportedReadonlyAuthorizerDegradation = true;
-  console.error("[codegraph] node:sqlite read-only authorizer is unavailable or incomplete; relying on connection readOnly enforcement.");
-}
-var sqliteLoadError;
-function loadNodeSqlite() {
-  if (sqliteModule)
-    return sqliteModule;
-  if (sqliteLoadError)
-    throw sqliteLoadError;
-  try {
-    const loaded = requireNodeModule("node:sqlite");
-    sqliteModule = loaded;
-    return loaded;
-  } catch (error) {
-    sqliteLoadError = error instanceof Error ? error : new Error(String(error));
-    throw sqliteLoadError;
-  }
-}
-function isNodeSqliteUnavailableError(error) {
-  const message = errorMessage(error);
-  return /node:sqlite|No such built-in module:\s*node:sqlite|setReturnArrays is not a function|columns is not a function/i.test(message);
-}
-var nodeSqliteUnsupportedError;
-function markNodeSqliteUnavailable(error) {
-  if (nodeSqliteUnsupportedError)
-    return;
-  nodeSqliteUnsupportedError = error instanceof Error ? error : new Error(String(error));
-}
-function nodeSqliteUnavailableError() {
-  return nodeSqliteUnsupportedError ?? sqliteLoadError;
-}
-var nodeSqliteUsable;
-function requireNodeSqliteStatement(statement) {
-  const candidate = statement;
-  if (typeof candidate.setReturnArrays !== "function") {
-    throw new TypeError("setReturnArrays is not a function");
-  }
-  if (typeof candidate.columns !== "function") {
-    throw new TypeError("columns is not a function");
-  }
-  return candidate;
-}
-function isNodeSqliteUsable() {
-  if (nodeSqliteUnavailableError()) {
-    nodeSqliteUsable = false;
-    return false;
-  }
-  if (nodeSqliteUsable !== void 0)
-    return nodeSqliteUsable;
-  try {
-    const sqlite = loadNodeSqlite();
-    const probe = new sqlite.DatabaseSync(":memory:");
-    try {
-      const statement = requireNodeSqliteStatement(probe.prepare("SELECT 1"));
-      statement.setReturnArrays(false);
-      statement.columns();
-      nodeSqliteUsable = true;
-    } finally {
-      probe.close();
-    }
-  } catch (error) {
-    markNodeSqliteUnavailable(error);
-    nodeSqliteUsable = false;
-  }
-  return nodeSqliteUsable;
-}
-var READONLY_AUTHORIZER_CONSTANTS = [
-  "SQLITE_DENY",
-  "SQLITE_FUNCTION",
-  "SQLITE_OK",
-  "SQLITE_PRAGMA",
-  "SQLITE_READ",
-  "SQLITE_RECURSIVE",
-  "SQLITE_SELECT",
-  "SQLITE_TRANSACTION"
-];
-function canInstallReadonlyAuthorizer(constants) {
-  return READONLY_AUTHORIZER_CONSTANTS.every((name) => typeof constants[name] === "number");
-}
-function isReadOnlyAllowedAction(actionCode, constants) {
-  return actionCode === constants.SQLITE_FUNCTION || actionCode === constants.SQLITE_PRAGMA || actionCode === constants.SQLITE_READ || actionCode === constants.SQLITE_SELECT || actionCode === constants.SQLITE_TRANSACTION || actionCode === constants.SQLITE_RECURSIVE;
-}
-var isSqliteValueArray = (value) => Array.isArray(value);
-var normalizeParams = (params) => {
-  if (params.length === 1) {
-    const [only] = params;
-    if (only !== void 0 && isSqliteValueArray(only))
-      return [...only];
-  }
-  const normalized = [];
-  for (const param of params) {
-    if (isSqliteValueArray(param)) {
-      throw new Error("SQLite parameters must be passed as a single array or as positional values.");
-    }
-    normalized.push(param);
-  }
-  return normalized;
-};
-var SqliteStatement = class _SqliteStatement {
-  statement;
-  returnArrays;
-  constructor(statement, returnArrays = false) {
-    this.statement = statement;
-    this.returnArrays = returnArrays;
-    this.statement.setReturnArrays(returnArrays);
-  }
-  raw() {
-    return new _SqliteStatement(this.statement, true);
-  }
-  all(...params) {
-    return this.statement.all(...normalizeParams(params));
-  }
-  get(...params) {
-    return this.statement.get(...normalizeParams(params));
-  }
-  iterate(...params) {
-    return this.statement.iterate(...normalizeParams(params));
-  }
-  run(...params) {
-    return this.statement.run(...normalizeParams(params));
-  }
-  columns() {
-    return this.statement.columns();
-  }
-};
-var SqliteDatabase = class {
-  db;
-  statements = /* @__PURE__ */ new Map();
-  closed = false;
-  constructor(filePath, options) {
-    if (!isNodeSqliteUsable()) {
-      throw nodeSqliteUnavailableError() ?? new Error("node:sqlite is unavailable");
-    }
-    const sqlite = loadNodeSqlite();
-    this.db = new sqlite.DatabaseSync(filePath, {
-      readOnly: options?.readonly,
-      timeout: options?.timeout ?? 5e3
-    });
-    markWindowsProcessDrainRequired();
-    if (options?.readonly) {
-      const { constants } = sqlite;
-      if (this.db.setAuthorizer && canInstallReadonlyAuthorizer(constants)) {
-        this.db.setAuthorizer((actionCode) => isReadOnlyAllowedAction(actionCode, constants) ? constants.SQLITE_OK : constants.SQLITE_DENY);
-      } else {
-        reportReadonlyAuthorizerDegraded();
-      }
-    }
-  }
-  exec(sql) {
-    this.statements.clear();
-    this.db.exec(sql);
-  }
-  pragma(sql) {
-    this.exec(`PRAGMA ${sql};`);
-  }
-  prepare(sql) {
-    const cached = this.statements.get(sql);
-    if (cached)
-      return cached;
-    try {
-      const statement = new SqliteStatement(this.db.prepare(sql));
-      this.statements.set(sql, statement);
-      return statement;
-    } catch (error) {
-      if (isNodeSqliteUnavailableError(error))
-        markNodeSqliteUnavailable(error);
-      throw error;
-    }
-  }
-  transaction(fn) {
-    return () => {
-      this.exec("BEGIN;");
-      try {
-        const result = fn();
-        this.exec("COMMIT;");
-        return result;
-      } catch (error) {
-        this.exec("ROLLBACK;");
-        throw error;
-      }
-    };
-  }
-  close() {
-    if (this.closed)
-      return;
-    this.statements.clear();
-    this.db.close();
-    this.closed = true;
-  }
-};
-function isReadOnlySqliteError(error) {
-  if (!(error instanceof Error))
-    return false;
-  const message = error.message.toLowerCase();
-  return message.includes("not authorized") || message.includes("read-only") || message.includes("readonly") || message.includes("attempt to write");
-}
-
-// dist/sqlite/database.js
-import fs from "node:fs/promises";
-import path from "node:path";
-var readOrCreateDb = async (outputPath, options) => {
-  const readonly = options?.readonly ?? false;
-  const dir = path.dirname(outputPath);
-  if (dir && !readonly) {
-    await fs.mkdir(dir, { recursive: true });
-  }
-  const db = new SqliteDatabase(outputPath, {
-    readonly
-  });
-  return { db };
-};
-async function withReadOnlySqliteDatabase(outputPath, callback) {
-  const { db } = await readOrCreateDb(outputPath, { readonly: true });
-  try {
-    return await callback(db);
-  } finally {
-    db.close();
-  }
-}
-function assertReadOnlyQueryStatement(stmt) {
-  if (stmt.columns().length)
-    return;
-  throw new Error("Raw SQLite queries must be read-only result-producing statements such as SELECT or PRAGMA.");
-}
-
-// dist/sqlite/rowBounds.js
-var MAX_SQLITE_CELL_BYTES = 8e3;
-var SQLITE_TRUNCATED_MARKER = "...[truncated]";
-function collectBoundedRawSqlRows(columns, rowIterator, options) {
-  const maxCellBytes = options.maxCellBytes ?? MAX_SQLITE_CELL_BYTES;
-  const maxRows = Math.max(0, Math.floor(options.maxRows));
-  const maxBytes = options.maxBytes;
-  const rows = [];
-  let bytes = Buffer.byteLength(JSON.stringify({ columns, rows: [] }), "utf8");
-  let truncated = false;
-  let sawExtraRow = false;
-  for (const rawRow of rowIterator) {
-    if (rows.length >= maxRows) {
-      sawExtraRow = true;
-      truncated = true;
-      break;
-    }
-    let cellTruncated = false;
-    const row = rawRow.map((value) => {
-      const normalized = normalizeSqliteValue(value, maxCellBytes);
-      if (normalized.truncated)
-        cellTruncated = true;
-      return normalized.value;
-    });
-    if (cellTruncated)
-      truncated = true;
-    const rowBytes = Buffer.byteLength(JSON.stringify(row), "utf8");
-    if (maxBytes !== void 0 && bytes + rowBytes > maxBytes) {
-      truncated = true;
-      break;
-    }
-    rows.push(row);
-    bytes += rowBytes;
-  }
-  return {
-    columns,
-    rows,
-    rowLimit: maxRows,
-    ...maxBytes !== void 0 ? { byteLimit: maxBytes, bytes } : { bytes },
-    ...truncated || sawExtraRow ? { truncated: true } : {}
-  };
-}
-function normalizeSqliteValue(value, maxCellBytes = MAX_SQLITE_CELL_BYTES) {
-  if (typeof value === "string") {
-    const truncated = Buffer.byteLength(value, "utf8") > maxCellBytes;
-    return { value: truncateUtf8(value, maxCellBytes), truncated };
-  }
-  if (typeof value === "bigint")
-    return { value: value.toString(), truncated: false };
-  if (value instanceof Uint8Array) {
-    return { value: `<${value.byteLength} bytes>`, truncated: true };
-  }
-  return { value, truncated: false };
-}
-function truncateUtf8(value, maxBytes) {
-  if (Buffer.byteLength(value, "utf8") <= maxBytes)
-    return value;
-  const marker = SQLITE_TRUNCATED_MARKER;
-  const markerBytes = Buffer.byteLength(marker, "utf8");
-  const budget = Math.max(0, maxBytes - markerBytes);
-  let output = "";
-  let bytes = 0;
-  for (const char of value) {
-    const charBytes = Buffer.byteLength(char, "utf8");
-    if (bytes + charBytes > budget)
-      break;
-    output += char;
-    bytes += charBytes;
-  }
-  return `${output}${marker}`;
-}
-
-// dist/sqlite/rawQueryWorker.js
-async function runRawQueryWorkerTask(task) {
-  return await withReadOnlySqliteDatabase(task.outputPath, (db) => {
-    try {
-      const stmt = db.prepare(task.sql);
-      assertReadOnlyQueryStatement(stmt);
-      const columns = stmt.columns().map((col) => col.name);
-      return collectBoundedRawSqlRows(columns, stmt.raw().iterate(task.params), {
-        maxRows: task.maxRows,
-        maxBytes: task.maxBytes,
-        maxCellBytes: task.maxCellBytes
-      });
-    } catch (error) {
-      if (isReadOnlySqliteError(error)) {
-        throw new Error("Raw SQLite queries must be read-only result-producing statements such as SELECT or PRAGMA.");
-      }
-      throw error;
-    }
-  });
-}
-export {
-  runRawQueryWorkerTask as default
-};

package/dist/bootstrap/treeSitterLanguages.d.ts

@@ -1,5 +0,0 @@
-import { type LanguageConfig } from "../chunking/languageConfig.js";
-import "../languages/all.js";
-export type { LanguageConfig };
-export declare const LANG_CONFIGS: Record<string, LanguageConfig>;
-//# sourceMappingURL=treeSitterLanguages.d.ts.map

package/dist/bootstrap/treeSitterLanguages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeSitterLanguages.d.ts","sourceRoot":"","sources":["../../src/bootstrap/treeSitterLanguages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAExF,OAAO,qBAAqB,CAAC;AAE7B,YAAY,EAAE,cAAc,EAAE,CAAC;AAwB/B,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAM,CAAC"}

package/dist/bootstrap/treeSitterLanguages.js

@@ -1,41 +0,0 @@
-import { makeLanguageConfig } from "../chunking/languageConfig.js";
-import { getAllLanguages } from "../languages/registry.js";
-import "../languages/all.js";
-const idToConfigKey = {
-    js: "javascript",
-    ts: "typescript",
-    tsx: "tsx",
-    python: "python",
-    php: "php",
-    html: "html",
-    css: "css",
-    scss: "scss",
-    less: "less",
-    ruby: "ruby",
-    go: "go",
-    java: "java",
-    csharp: "csharp",
-    rust: "rust",
-    c: "c",
-    cpp: "cpp",
-    kotlin: "kotlin",
-    swift: "swift",
-    zig: "zig",
-};
-export const LANG_CONFIGS = {};
-for (const lang of getAllLanguages()) {
-    const key = idToConfigKey[lang.id] || lang.id;
-    // Skip languages that are not used for direct semantic chunking
-    if (lang.id === "vue" ||
-        lang.id === "svelte" ||
-        lang.id === "markdown" ||
-        lang.id === "mdx" ||
-        lang.id === "astro" ||
-        lang.id === "hbs" ||
-        lang.id === "rst" ||
-        lang.id === "adoc") {
-        continue;
-    }
-    LANG_CONFIGS[key] = makeLanguageConfig(lang, key);
-}
-//# sourceMappingURL=treeSitterLanguages.js.map

package/dist/bootstrap/treeSitterLanguages.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"treeSitterLanguages.js","sourceRoot":"","sources":["../../src/bootstrap/treeSitterLanguages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAuB,MAAM,+BAA+B,CAAC;AACxF,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,qBAAqB,CAAC;AAI7B,MAAM,aAAa,GAA2B;IAC5C,EAAE,EAAE,YAAY;IAChB,EAAE,EAAE,YAAY;IAChB,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,CAAC,EAAE,GAAG;IACN,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;CACX,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAmC,EAAE,CAAC;AAE/D,KAAK,MAAM,IAAI,IAAI,eAAe,EAAE,EAAE,CAAC;IACrC,MAAM,GAAG,GAAG,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC;IAC9C,gEAAgE;IAChE,IACE,IAAI,CAAC,EAAE,KAAK,KAAK;QACjB,IAAI,CAAC,EAAE,KAAK,QAAQ;QACpB,IAAI,CAAC,EAAE,KAAK,UAAU;QACtB,IAAI,CAAC,EAAE,KAAK,KAAK;QACjB,IAAI,CAAC,EAAE,KAAK,OAAO;QACnB,IAAI,CAAC,EAAE,KAAK,KAAK;QACjB,IAAI,CAAC,EAAE,KAAK,KAAK;QACjB,IAAI,CAAC,EAAE,KAAK,MAAM,EAClB,CAAC;QACD,SAAS;IACX,CAAC;IACD,YAAY,CAAC,GAAG,CAAC,GAAG,kBAAkB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AACpD,CAAC"}

package/dist/chunking/chunkBlocks.d.ts

@@ -1,9 +0,0 @@
-import type { LanguageConfig } from "./languageConfig.js";
-import type { BlockCandidate, ChunkMatch } from "./types.js";
-export type ChunkBlockGroups = {
-    mainBlocks: BlockCandidate[];
-    innerBlocks: BlockCandidate[];
-    comments: BlockCandidate[];
-};
-export declare function collectChunkBlockGroups(language: LanguageConfig, matches: ChunkMatch[]): ChunkBlockGroups;
-//# sourceMappingURL=chunkBlocks.d.ts.map

package/dist/chunking/chunkBlocks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunkBlocks.d.ts","sourceRoot":"","sources":["../../src/chunking/chunkBlocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAgB,UAAU,EAAE,MAAM,YAAY,CAAC;AAE3E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,gBAAgB,CAsEzG"}

package/dist/chunking/chunkBlocks.js

@@ -1,60 +0,0 @@
-export function collectChunkBlockGroups(language, matches) {
-    const mainBlocks = [];
-    const innerBlocks = [];
-    const comments = [];
-    for (const match of matches) {
-        let nameCapture;
-        let blockCapture;
-        let innerCapture;
-        let blockKind;
-        for (const capture of match.captures) {
-            const { name } = capture;
-            if (name === language.captures.name) {
-                nameCapture = capture;
-            }
-            if (language.captures.comments.includes(name)) {
-                comments.push({
-                    kind: name === "chunk.docstring" ? "docstring" : "comment",
-                    startByte: capture.startByte,
-                    endByte: capture.endByte,
-                    startLine: capture.startLine,
-                    endLine: capture.endLine,
-                });
-            }
-            if (name === language.captures.innerBlock) {
-                innerCapture = capture;
-            }
-            if (name.startsWith(language.captures.blockPrefix) && name !== language.captures.innerBlock) {
-                blockCapture = capture;
-                blockKind = name.slice(language.captures.blockPrefix.length) || capture.nodeType;
-            }
-        }
-        if (innerCapture) {
-            innerBlocks.push({
-                kind: "inner",
-                startByte: innerCapture.startByte,
-                endByte: innerCapture.endByte,
-                startLine: innerCapture.startLine,
-                endLine: innerCapture.endLine,
-            });
-        }
-        if (blockCapture) {
-            const candidate = {
-                kind: blockKind ?? "block",
-                startByte: blockCapture.startByte,
-                endByte: blockCapture.endByte,
-                startLine: blockCapture.startLine,
-                endLine: blockCapture.endLine,
-            };
-            if (nameCapture) {
-                candidate.name = nameCapture.text;
-            }
-            mainBlocks.push(candidate);
-        }
-    }
-    mainBlocks.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
-    innerBlocks.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
-    comments.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
-    return { mainBlocks, innerBlocks, comments };
-}
-//# sourceMappingURL=chunkBlocks.js.map

package/dist/chunking/chunkBlocks.js.map

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

package/dist/chunking/chunkFile.d.ts

@@ -1,39 +0,0 @@
-import type { LanguageConfig } from "./languageConfig.js";
-import type { Chunk, ChunkTokenizer } from "./types.js";
-export type { Chunk } from "./types.js";
-/**
- * Options for semantic code chunking.
- */
-export interface ChunkFileOptions {
-    /** Language configuration for parsing */
-    language: LanguageConfig;
-    /** Source code to chunk */
-    source: string;
-    /** Optional source file path for chunk IDs */
-    filePath?: string | undefined;
-    /** Minimum tokens per chunk (default: 150). Smaller chunks are merged. */
-    minTokens?: number;
-    /** Maximum tokens per chunk (default: 400). Larger chunks are split. */
-    maxTokens?: number;
-    /** Custom token counting function (default: whitespace-based) */
-    tokenizer?: ChunkTokenizer | undefined;
-}
-/**
- * Splits code into semantic chunks using Tree-sitter queries.
- * Nested declarations retain their hierarchical chunks: parents and children are
- * emitted independently. Every source byte is covered by at least one chunk, and
- * no individual chunk text repeats a source span internally.
- *
- * A parent that exceeds `maxTokens` is split at complete source-line boundaries,
- * while an individual oversized line is split at token boundaries. Child
- * declarations remain available as their own chunks.
- * @param opts Chunking options
- * @returns Array of semantic chunks
- */
-export type ChunkFileWithSymbolsResult = {
-    chunks: Chunk[];
-    symbolChunks: Chunk[];
-};
-export declare function chunkFileWithSymbols(opts: ChunkFileOptions): ChunkFileWithSymbolsResult;
-export declare function chunkFile(opts: ChunkFileOptions): Chunk[];
-//# sourceMappingURL=chunkFile.d.ts.map

package/dist/chunking/chunkFile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunkFile.d.ts","sourceRoot":"","sources":["../../src/chunking/chunkFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAO1D,OAAO,KAAK,EAAkB,KAAK,EAAE,cAAc,EAAe,MAAM,YAAY,CAAC;AAErF,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,QAAQ,EAAE,cAAc,CAAC;IACzB,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,SAAS,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CACxC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,YAAY,EAAE,KAAK,EAAE,CAAC;CACvB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,0BAA0B,CA8FvF;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,KAAK,EAAE,CAEzD"}