@tetral-ai/sdk 0.110.0-alpha.1

package/src/tools/memory/node.ts

@@ -0,0 +1,400 @@
+export { betaMemoryTool } from '../../helpers/beta/memory';
+export type { MemoryToolHandlers } from '../../helpers/beta/memory';
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { randomUUID } from 'crypto';
+import type { MemoryToolHandlers } from '../../helpers/beta/memory';
+import {
+  BetaMemoryTool20250818CreateCommand,
+  BetaMemoryTool20250818DeleteCommand,
+  BetaMemoryTool20250818InsertCommand,
+  BetaMemoryTool20250818RenameCommand,
+  BetaMemoryTool20250818StrReplaceCommand,
+  BetaMemoryTool20250818ViewCommand,
+} from '../../resources/beta';
+
+// Owner read/write only. Avoids the Node.js default of 0o666 which, in
+// environments with a permissive umask (e.g. Docker where umask is often
+// 0o000), would make memory files world-readable or even world-writable.
+const FILE_CREATE_MODE = 0o600;
+// fs.mkdir defaults to 0o777; restrict memory directories so they aren't
+// world-accessible in environments with permissive umasks.
+const DIR_CREATE_MODE = 0o700;
+
+async function exists(path: string) {
+  return await fs
+    .access(path)
+    .then(() => true)
+    .catch((err) => {
+      if (err.code === 'ENOENT') return false;
+      throw err;
+    });
+}
+
+/**
+ * Atomically writes content to a file by writing to a temporary file first and then renaming it.
+ * This ensures the target file is never in a partially written state, preventing data corruption
+ * if the process crashes or is interrupted during the write operation. The rename operation is
+ * atomic on most file systems, guaranteeing that readers will only ever see the complete old
+ * content or the complete new content, never a mix or partial state.
+ *
+ * @param targetPath - The path where the file should be written
+ * @param content - The content to write to the file
+ */
+async function atomicWriteFile(targetPath: string, content: string): Promise<void> {
+  const dir = path.dirname(targetPath);
+  const tempPath = path.join(dir, `.tmp-${process.pid}-${randomUUID()}`);
+
+  let handle: fs.FileHandle | undefined;
+  try {
+    handle = await fs.open(tempPath, 'wx', FILE_CREATE_MODE);
+    await handle.writeFile(content, 'utf-8');
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+
+    await fs.rename(tempPath, targetPath);
+  } catch (err) {
+    if (handle) {
+      await handle.close().catch(() => {});
+    }
+    await fs.unlink(tempPath).catch(() => {});
+    throw err;
+  }
+}
+
+/**
+ * Validates that a target path doesn't escape the memory root via symlinks.
+ *
+ * Prevents symlink attacks where a malicious symlink inside /memories points
+ * outside (e.g., /memories/foo -> /etc), which would allow operations like
+ * creating /memories/foo/passwd to actually write to /etc/passwd.
+ *
+ * Walks up from the target path to find the deepest existing ancestor,
+ * then resolves it to ensure the real path stays within memoryRoot.
+ */
+async function validateNoSymlinkEscape(targetPath: string, memoryRoot: string): Promise<void> {
+  const resolvedRoot = await fs.realpath(memoryRoot);
+
+  let current = targetPath;
+  while (true) {
+    try {
+      const resolved = await fs.realpath(current);
+      if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + path.sep)) {
+        throw new Error(`Path would escape /memories directory via symlink`);
+      }
+      return;
+    } catch (err: any) {
+      if (err.code !== 'ENOENT') throw err;
+      const parent = path.dirname(current);
+      if (parent === current || current === memoryRoot) {
+        return;
+      }
+      current = parent;
+    }
+  }
+}
+
+async function readFileContent(fullPath: string, memoryPath: string): Promise<string> {
+  try {
+    return await fs.readFile(fullPath, 'utf-8');
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      throw new Error(
+        `The file ${memoryPath} no longer exists (may have been deleted or renamed concurrently).`,
+      );
+    }
+    throw err;
+  }
+}
+
+function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0B';
+  const k = 1024;
+  const sizes = ['B', 'K', 'M', 'G'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const size = bytes / Math.pow(k, i);
+
+  return (size % 1 === 0 ? size.toString() : size.toFixed(1)) + sizes[i];
+}
+
+const MAX_LINES = 999999;
+const LINE_NUMBER_WIDTH = String(MAX_LINES).length;
+
+export class BetaLocalFilesystemMemoryTool implements MemoryToolHandlers {
+  private basePath: string;
+  private memoryRoot: string;
+
+  constructor(basePath: string = './memory') {
+    this.basePath = basePath;
+    this.memoryRoot = path.join(this.basePath, 'memories');
+  }
+
+  static async init(basePath: string = './memory'): Promise<BetaLocalFilesystemMemoryTool> {
+    const memory = new BetaLocalFilesystemMemoryTool(basePath);
+
+    await fs.mkdir(memory.memoryRoot, { recursive: true, mode: DIR_CREATE_MODE });
+
+    return memory;
+  }
+
+  private async validatePath(memoryPath: string): Promise<string> {
+    if (!memoryPath.startsWith('/memories')) {
+      throw new Error(`Path must start with /memories, got: ${memoryPath}`);
+    }
+
+    const relativePath = memoryPath.slice('/memories'.length).replace(/^\//, '');
+    const fullPath = relativePath ? path.join(this.memoryRoot, relativePath) : this.memoryRoot;
+
+    const resolvedPath = path.resolve(fullPath);
+    const resolvedRoot = path.resolve(this.memoryRoot);
+    if (resolvedPath !== resolvedRoot && !resolvedPath.startsWith(resolvedRoot + path.sep)) {
+      throw new Error(`Path ${memoryPath} would escape /memories directory`);
+    }
+
+    await validateNoSymlinkEscape(resolvedPath, this.memoryRoot);
+
+    return resolvedPath;
+  }
+
+  async view(command: BetaMemoryTool20250818ViewCommand): Promise<string> {
+    const fullPath = await this.validatePath(command.path);
+
+    let stat;
+    try {
+      stat = await fs.stat(fullPath);
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`The path ${command.path} does not exist. Please provide a valid path.`);
+      }
+      throw err;
+    }
+
+    if (stat.isDirectory()) {
+      const items: Array<{ size: string; path: string }> = [];
+
+      const collectItems = async (dirPath: string, relativePath: string, depth: number): Promise<void> => {
+        if (depth > 2) return;
+
+        const dirContents = await fs.readdir(dirPath);
+
+        for (const item of dirContents.sort()) {
+          if (item.startsWith('.') || item === 'node_modules') {
+            continue;
+          }
+          const itemPath = path.join(dirPath, item);
+          const itemRelativePath = relativePath ? `${relativePath}/${item}` : item;
+          let itemStat;
+          try {
+            itemStat = await fs.stat(itemPath);
+          } catch {
+            continue;
+          }
+
+          if (itemStat.isDirectory()) {
+            items.push({ size: formatFileSize(itemStat.size), path: `${itemRelativePath}/` });
+            if (depth < 2) {
+              await collectItems(itemPath, itemRelativePath, depth + 1);
+            }
+          } else if (itemStat.isFile()) {
+            items.push({ size: formatFileSize(itemStat.size), path: itemRelativePath });
+          }
+        }
+      };
+
+      await collectItems(fullPath, '', 1);
+
+      const header = `Here're the files and directories up to 2 levels deep in ${command.path}, excluding hidden items and node_modules:`;
+      const dirSize = formatFileSize(stat.size);
+      const lines = [
+        `${dirSize}\t${command.path}`,
+        ...items.map((item) => `${item.size}\t${command.path}/${item.path}`),
+      ];
+
+      return `${header}\n${lines.join('\n')}`;
+    } else if (stat.isFile()) {
+      const content = await readFileContent(fullPath, command.path);
+      const lines = content.split('\n');
+
+      if (lines.length > MAX_LINES) {
+        throw new Error(
+          `File ${command.path} has too many lines (${
+            lines.length
+          }). Maximum is ${MAX_LINES.toLocaleString()} lines.`,
+        );
+      }
+
+      let displayLines = lines;
+      let startNum = 1;
+
+      if (command.view_range && command.view_range.length === 2) {
+        const startLine = Math.max(1, command.view_range[0]!) - 1;
+        const endLine = command.view_range[1] === -1 ? lines.length : command.view_range[1];
+        displayLines = lines.slice(startLine, endLine);
+        startNum = startLine + 1;
+      }
+
+      const numberedLines = displayLines.map(
+        (line, i) => `${String(i + startNum).padStart(LINE_NUMBER_WIDTH, ' ')}\t${line}`,
+      );
+
+      return `Here's the content of ${command.path} with line numbers:\n${numberedLines.join('\n')}`;
+    } else {
+      throw new Error(`Unsupported file type for ${command.path}`);
+    }
+  }
+
+  async create(command: BetaMemoryTool20250818CreateCommand): Promise<string> {
+    const fullPath = await this.validatePath(command.path);
+
+    await fs.mkdir(path.dirname(fullPath), { recursive: true, mode: DIR_CREATE_MODE });
+
+    let handle: fs.FileHandle | undefined;
+    try {
+      handle = await fs.open(fullPath, 'wx', FILE_CREATE_MODE);
+      await handle.writeFile(command.file_text, 'utf-8');
+      await handle.sync();
+    } catch (err: any) {
+      if (err?.code === 'EEXIST') {
+        throw new Error(`File ${command.path} already exists`);
+      }
+      throw err;
+    } finally {
+      await handle?.close().catch(() => {});
+    }
+
+    return `File created successfully at: ${command.path}`;
+  }
+
+  async str_replace(command: BetaMemoryTool20250818StrReplaceCommand): Promise<string> {
+    const fullPath = await this.validatePath(command.path);
+
+    let stat;
+    try {
+      stat = await fs.stat(fullPath);
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`The path ${command.path} does not exist. Please provide a valid path.`);
+      }
+      throw err;
+    }
+
+    if (!stat.isFile()) {
+      throw new Error(`The path ${command.path} is not a file.`);
+    }
+
+    const content = await readFileContent(fullPath, command.path);
+    const lines = content.split('\n');
+
+    const matchingLines: number[] = [];
+    lines.forEach((line, index) => {
+      if (line.includes(command.old_str)) {
+        matchingLines.push(index + 1);
+      }
+    });
+
+    if (matchingLines.length === 0) {
+      throw new Error(
+        `No replacement was performed, old_str \`${command.old_str}\` did not appear verbatim in ${command.path}.`,
+      );
+    } else if (matchingLines.length > 1) {
+      throw new Error(
+        `No replacement was performed. Multiple occurrences of old_str \`${
+          command.old_str
+        }\` in lines: ${matchingLines.join(', ')}. Please ensure it is unique`,
+      );
+    }
+
+    const newContent = content.replace(command.old_str, command.new_str);
+    await atomicWriteFile(fullPath, newContent);
+
+    const newLines = newContent.split('\n');
+    const changedLineIndex = matchingLines[0]! - 1;
+    const contextStart = Math.max(0, changedLineIndex - 2);
+    const contextEnd = Math.min(newLines.length, changedLineIndex + 3);
+    const snippet = newLines.slice(contextStart, contextEnd).map((line, i) => {
+      const lineNum = contextStart + i + 1;
+      return `${String(lineNum).padStart(LINE_NUMBER_WIDTH, ' ')}\t${line}`;
+    });
+
+    return `The memory file has been edited. Here is the snippet showing the change (with line numbers):\n${snippet.join(
+      '\n',
+    )}`;
+  }
+
+  async insert(command: BetaMemoryTool20250818InsertCommand): Promise<string> {
+    const fullPath = await this.validatePath(command.path);
+
+    let stat;
+    try {
+      stat = await fs.stat(fullPath);
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`The path ${command.path} does not exist. Please provide a valid path.`);
+      }
+      throw err;
+    }
+
+    if (!stat.isFile()) {
+      throw new Error(`The path ${command.path} is not a file.`);
+    }
+
+    const content = await readFileContent(fullPath, command.path);
+    const lines = content.split('\n');
+
+    if (command.insert_line < 0 || command.insert_line > lines.length) {
+      throw new Error(
+        `Invalid \`insert_line\` parameter: ${command.insert_line}. It should be within the range of lines of the file: [0, ${lines.length}]`,
+      );
+    }
+
+    lines.splice(command.insert_line, 0, command.insert_text.replace(/\n$/, ''));
+    await atomicWriteFile(fullPath, lines.join('\n'));
+    return `The file ${command.path} has been edited.`;
+  }
+
+  async delete(command: BetaMemoryTool20250818DeleteCommand): Promise<string> {
+    const fullPath = await this.validatePath(command.path);
+
+    if (command.path === '/memories') {
+      throw new Error('Cannot delete the /memories directory itself');
+    }
+
+    try {
+      await fs.rm(fullPath, { recursive: true, force: false });
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`The path ${command.path} does not exist`);
+      }
+      throw err;
+    }
+
+    return `Successfully deleted ${command.path}`;
+  }
+
+  async rename(command: BetaMemoryTool20250818RenameCommand): Promise<string> {
+    const oldFullPath = await this.validatePath(command.old_path);
+    const newFullPath = await this.validatePath(command.new_path);
+
+    // POSIX rename() silently overwrites existing files without error,
+    // so we can't catch this atomically. Best-effort check to warn user.
+    if (await exists(newFullPath)) {
+      throw new Error(`The destination ${command.new_path} already exists`);
+    }
+
+    const newDir = path.dirname(newFullPath);
+    await fs.mkdir(newDir, { recursive: true, mode: DIR_CREATE_MODE });
+
+    try {
+      await fs.rename(oldFullPath, newFullPath);
+    } catch (err: any) {
+      if (err.code === 'ENOENT') {
+        throw new Error(`The path ${command.old_path} does not exist`);
+      }
+      throw err;
+    }
+
+    return `Successfully renamed ${command.old_path} to ${command.new_path}`;
+  }
+}

package/src/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  // this config is included in the published src directory to prevent TS errors
+  // from appearing when users go to source, and VSCode opens the source .ts file
+  // via declaration maps
+  "include": ["index.ts"],
+  "compilerOptions": {
+    "target": "ES2015",
+    "lib": ["DOM", "DOM.Iterable", "ES2018"],
+    "moduleResolution": "node"
+  }
+}

package/src/uploads.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/uploads instead */
+export * from './core/uploads';

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.110.0-alpha.1'; // x-release-please-version

package/streaming.d.mts

@@ -0,0 +1,3 @@
+/** @deprecated Import from ./core/streaming instead */
+export * from "./core/streaming.mjs";
+//# sourceMappingURL=streaming.d.mts.map

package/streaming.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.mts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,qCAAiC"}

package/streaming.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import from ./core/streaming instead */
+export * from "./core/streaming.js";
+//# sourceMappingURL=streaming.d.ts.map

package/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,oCAAiC"}

package/streaming.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("./internal/tslib.js");
+/** @deprecated Import from ./core/streaming instead */
+tslib_1.__exportStar(require("./core/streaming.js"), exports);
+//# sourceMappingURL=streaming.js.map

package/streaming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.js","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":";;;AAAA,uDAAuD;AACvD,8DAAiC"}

package/streaming.mjs

@@ -0,0 +1,3 @@
+/** @deprecated Import from ./core/streaming instead */
+export * from "./core/streaming.mjs";
+//# sourceMappingURL=streaming.mjs.map

package/streaming.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.mjs","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,qCAAiC"}

package/tools/agent-toolset/fs-util.d.mts

@@ -0,0 +1,50 @@
+/**
+ * Shared, Node-only filesystem helpers for the agent toolset's file tools:
+ * path confinement (symlink-aware), an atomic write, and language-independent
+ * error messages. Kept out of `node.ts` so the tool implementations stay focused
+ * and these helpers can be reused by every file tool.
+ */
+/** Mode for directories the file tools create — not world-writable under a 0 umask. */
+export declare const DIR_CREATE_MODE = 493;
+/** Mode for files the file tools create. */
+export declare const FILE_CREATE_MODE = 420;
+/**
+ * Fully resolve `abs`: `realpath` the longest existing ancestor and re-append
+ * the rest, but never re-append a component that is itself a symlink — read the
+ * link and continue from its target instead. This handles paths being created
+ * (write/edit) without letting a symlink leaf (e.g. a dangling one pointing
+ * outside a confinement root) slip through unresolved.
+ */
+export declare function canonicalize(abs: string): Promise<string>;
+/**
+ * Resolve `p` and confine it to `root`.
+ *
+ * Absolute and relative inputs go through the same canonicalise-then-contain
+ * check — an absolute path that lands inside `root` is permitted, only paths
+ * that resolve *outside* are rejected. Every symlink in `p` (including the
+ * leaf, even a dangling one) is resolved before the confinement check, and the
+ * resolved path is what the caller then operates on, so a symlink inside `root`
+ * that points outside it can neither pass the check nor be followed afterwards.
+ *
+ * Residual TOCTOU: a component could still be swapped for a symlink between this
+ * call and the eventual `fs` operation. Closing that fully needs per-component
+ * `O_NOFOLLOW`/`openat`, which Node does not expose ergonomically; this is why a
+ * sandbox is still recommended for the toolset as a whole.
+ */
+export declare function confineToRoot(root: string, p: string, opts?: {
+    allowOutside?: boolean;
+}): Promise<string>;
+/**
+ * Atomically write `content` to `targetPath`: write a sibling temp file, fsync
+ * it, then rename over the target. The rename is atomic on most filesystems, so
+ * a crash mid-write never leaves the target half-written.
+ */
+export declare function atomicWriteFile(targetPath: string, content: string): Promise<void>;
+/**
+ * Map a thrown filesystem error to a consistent, language-independent message,
+ * so the model sees the same wording regardless of the runtime (Node's raw
+ * `ENOENT: no such file...` text would otherwise leak through). Falls back to
+ * the raw error message for codes we don't special-case.
+ */
+export declare function fsErrorMessage(err: unknown, file: string): string;
+//# sourceMappingURL=fs-util.d.mts.map

package/tools/agent-toolset/fs-util.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-util.d.mts","sourceRoot":"","sources":["../../src/tools/agent-toolset/fs-util.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,uFAAuF;AACvF,eAAO,MAAM,eAAe,MAAQ,CAAC;AACrC,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB,MAAQ,CAAC;AAWtC;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkC/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EACT,IAAI,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GAChC,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBxF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAwBjE"}

package/tools/agent-toolset/fs-util.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared, Node-only filesystem helpers for the agent toolset's file tools:
+ * path confinement (symlink-aware), an atomic write, and language-independent
+ * error messages. Kept out of `node.ts` so the tool implementations stay focused
+ * and these helpers can be reused by every file tool.
+ */
+/** Mode for directories the file tools create — not world-writable under a 0 umask. */
+export declare const DIR_CREATE_MODE = 493;
+/** Mode for files the file tools create. */
+export declare const FILE_CREATE_MODE = 420;
+/**
+ * Fully resolve `abs`: `realpath` the longest existing ancestor and re-append
+ * the rest, but never re-append a component that is itself a symlink — read the
+ * link and continue from its target instead. This handles paths being created
+ * (write/edit) without letting a symlink leaf (e.g. a dangling one pointing
+ * outside a confinement root) slip through unresolved.
+ */
+export declare function canonicalize(abs: string): Promise<string>;
+/**
+ * Resolve `p` and confine it to `root`.
+ *
+ * Absolute and relative inputs go through the same canonicalise-then-contain
+ * check — an absolute path that lands inside `root` is permitted, only paths
+ * that resolve *outside* are rejected. Every symlink in `p` (including the
+ * leaf, even a dangling one) is resolved before the confinement check, and the
+ * resolved path is what the caller then operates on, so a symlink inside `root`
+ * that points outside it can neither pass the check nor be followed afterwards.
+ *
+ * Residual TOCTOU: a component could still be swapped for a symlink between this
+ * call and the eventual `fs` operation. Closing that fully needs per-component
+ * `O_NOFOLLOW`/`openat`, which Node does not expose ergonomically; this is why a
+ * sandbox is still recommended for the toolset as a whole.
+ */
+export declare function confineToRoot(root: string, p: string, opts?: {
+    allowOutside?: boolean;
+}): Promise<string>;
+/**
+ * Atomically write `content` to `targetPath`: write a sibling temp file, fsync
+ * it, then rename over the target. The rename is atomic on most filesystems, so
+ * a crash mid-write never leaves the target half-written.
+ */
+export declare function atomicWriteFile(targetPath: string, content: string): Promise<void>;
+/**
+ * Map a thrown filesystem error to a consistent, language-independent message,
+ * so the model sees the same wording regardless of the runtime (Node's raw
+ * `ENOENT: no such file...` text would otherwise leak through). Falls back to
+ * the raw error message for codes we don't special-case.
+ */
+export declare function fsErrorMessage(err: unknown, file: string): string;
+//# sourceMappingURL=fs-util.d.ts.map

package/tools/agent-toolset/fs-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-util.d.ts","sourceRoot":"","sources":["../../src/tools/agent-toolset/fs-util.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,uFAAuF;AACvF,eAAO,MAAM,eAAe,MAAQ,CAAC;AACrC,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB,MAAQ,CAAC;AAWtC;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkC/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,MAAM,EACT,IAAI,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GAChC,OAAO,CAAC,MAAM,CAAC,CAajB;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBxF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAwBjE"}