@facetlayer/docs-tool 0.1.0

package/dist/cli.js

@@ -0,0 +1,549 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/index.ts
+import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join3, basename, relative } from "path";
+
+// src/browseLocalLibrary.ts
+import { resolve, join } from "path";
+import { existsSync } from "fs";
+function browseLocalLibrary(targetPath) {
+  const resolvedPath = resolve(targetPath);
+  const docsPath = join(resolvedPath, "docs");
+  const hasDocsFolder = existsSync(docsPath);
+  const dirs = [resolvedPath];
+  if (hasDocsFolder) {
+    dirs.push(docsPath);
+  }
+  const helper = new DocFilesHelper({
+    dirs,
+    overrideGetSubcommand: `show ${targetPath}`
+  });
+  return {
+    libraryPath: resolvedPath,
+    helper,
+    hasDocsFolder
+  };
+}
+
+// src/browseNpmLibrary.ts
+import { readFileSync, readdirSync, existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir } from "os";
+import { runShellCommand } from "@facetlayer/subprocess-wrapper";
+function findExactMatch(nodeModulesPath, libraryName) {
+  if (libraryName.startsWith("@")) {
+    const [scope, pkgName] = libraryName.split("/");
+    const scopePath = join2(nodeModulesPath, scope);
+    if (pkgName && existsSync2(scopePath)) {
+      const fullPath2 = join2(scopePath, pkgName);
+      if (existsSync2(fullPath2) && existsSync2(join2(fullPath2, "package.json"))) {
+        return fullPath2;
+      }
+    }
+    return null;
+  }
+  const fullPath = join2(nodeModulesPath, libraryName);
+  if (existsSync2(fullPath) && existsSync2(join2(fullPath, "package.json"))) {
+    return fullPath;
+  }
+  return null;
+}
+function findPartialMatches(nodeModulesPath, partialName) {
+  const matches = [];
+  const lowerPartial = partialName.toLowerCase();
+  if (!existsSync2(nodeModulesPath)) {
+    return matches;
+  }
+  const entries = readdirSync(nodeModulesPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith("@")) {
+      const scopePath = join2(nodeModulesPath, entry.name);
+      const scopedEntries = readdirSync(scopePath, { withFileTypes: true });
+      for (const scopedEntry of scopedEntries) {
+        if (!scopedEntry.isDirectory()) continue;
+        const fullName = `${entry.name}/${scopedEntry.name}`;
+        if (fullName.toLowerCase().includes(lowerPartial)) {
+          const fullPath = join2(scopePath, scopedEntry.name);
+          if (existsSync2(join2(fullPath, "package.json"))) {
+            matches.push({
+              libraryPath: fullPath,
+              libraryName: fullName,
+              matchType: "partial"
+            });
+          }
+        }
+      }
+    } else {
+      if (entry.name.toLowerCase().includes(lowerPartial)) {
+        const fullPath = join2(nodeModulesPath, entry.name);
+        if (existsSync2(join2(fullPath, "package.json"))) {
+          matches.push({
+            libraryPath: fullPath,
+            libraryName: entry.name,
+            matchType: "partial"
+          });
+        }
+      }
+    }
+  }
+  return matches;
+}
+function getNodeModulesPaths(startDir) {
+  const paths = [];
+  let currentDir = startDir;
+  while (true) {
+    const nodeModulesPath = join2(currentDir, "node_modules");
+    if (existsSync2(nodeModulesPath)) {
+      paths.push(nodeModulesPath);
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return paths;
+}
+function findLibraryInNodeModules(libraryName, startDir) {
+  const cwd = startDir || process.cwd();
+  const nodeModulesPaths = getNodeModulesPaths(cwd);
+  for (const nodeModulesPath of nodeModulesPaths) {
+    const exactPath = findExactMatch(nodeModulesPath, libraryName);
+    if (exactPath) {
+      return {
+        libraryPath: exactPath,
+        libraryName,
+        matchType: "exact"
+      };
+    }
+  }
+  for (const nodeModulesPath of nodeModulesPaths) {
+    const partialMatches = findPartialMatches(nodeModulesPath, libraryName);
+    if (partialMatches.length === 1) {
+      return partialMatches[0];
+    }
+    if (partialMatches.length > 1) {
+      console.warn(`Multiple partial matches found for "${libraryName}":`);
+      for (const match of partialMatches) {
+        console.warn(`  - ${match.libraryName}`);
+      }
+      console.warn(`Using: ${partialMatches[0].libraryName}`);
+      return partialMatches[0];
+    }
+  }
+  return null;
+}
+function getInstallationDirectory() {
+  const stateDir = join2(homedir(), ".cache", "docs-tool");
+  const installDir = join2(stateDir, "installed-packages");
+  if (!existsSync2(installDir)) {
+    mkdirSync(installDir, { recursive: true });
+  }
+  return installDir;
+}
+function ensureInstallDirInitialized(installDir) {
+  const packageJsonPath = join2(installDir, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    const packageJson2 = {
+      name: "docs-tool-installed-packages",
+      version: "1.0.0",
+      private: true,
+      description: "Packages installed by docs-tool for documentation viewing"
+    };
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson2, null, 2));
+  }
+}
+function findInInstallDir(installDir, libraryName) {
+  const nodeModulesPath = join2(installDir, "node_modules");
+  if (!existsSync2(nodeModulesPath)) {
+    return null;
+  }
+  const exactPath = findExactMatch(nodeModulesPath, libraryName);
+  if (exactPath) {
+    return {
+      libraryPath: exactPath,
+      libraryName,
+      matchType: "exact"
+    };
+  }
+  const partialMatches = findPartialMatches(nodeModulesPath, libraryName);
+  if (partialMatches.length >= 1) {
+    return partialMatches[0];
+  }
+  return null;
+}
+async function getLatestVersion(libraryName) {
+  var _a;
+  try {
+    const result = await runShellCommand("npm", ["view", libraryName, "version"]);
+    if (result.failed() || !result.stdout) {
+      return null;
+    }
+    return ((_a = result.stdout[0]) == null ? void 0 : _a.trim()) || null;
+  } catch {
+    return null;
+  }
+}
+function getInstalledVersion(libraryPath) {
+  try {
+    const packageJsonPath = join2(libraryPath, "package.json");
+    const packageJson2 = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson2.version || null;
+  } catch {
+    return null;
+  }
+}
+async function installLibrary(installDir, libraryName) {
+  ensureInstallDirInitialized(installDir);
+  console.log(`Installing ${libraryName}...`);
+  const result = await runShellCommand("npm", ["install", libraryName, "--ignore-scripts"], {
+    cwd: installDir
+  });
+  if (result.failed()) {
+    throw new Error(`Failed to install ${libraryName}: ${result.stderrAsString()}`);
+  }
+  console.log(`Successfully installed ${libraryName}`);
+}
+async function updateLibrary(installDir, libraryName) {
+  console.log(`Updating ${libraryName} to latest version...`);
+  const result = await runShellCommand("npm", ["update", libraryName, "--ignore-scripts"], {
+    cwd: installDir
+  });
+  if (result.failed()) {
+    console.warn(`Warning: Failed to update ${libraryName}: ${result.stderrAsString()}`);
+  } else {
+    console.log(`Successfully updated ${libraryName}`);
+  }
+}
+async function findLibrary(libraryName, options) {
+  const localResult = findLibraryInNodeModules(libraryName);
+  if (localResult) {
+    return localResult;
+  }
+  if (options == null ? void 0 : options.skipInstall) {
+    return null;
+  }
+  const installDir = getInstallationDirectory();
+  let installedResult = findInInstallDir(installDir, libraryName);
+  if (installedResult) {
+    const installedVersion = getInstalledVersion(installedResult.libraryPath);
+    const latestVersion = await getLatestVersion(installedResult.libraryName);
+    if (installedVersion && latestVersion && installedVersion !== latestVersion) {
+      console.log(`Found ${installedResult.libraryName}@${installedVersion}, latest is ${latestVersion}`);
+      await updateLibrary(installDir, installedResult.libraryName);
+      installedResult = findInInstallDir(installDir, libraryName);
+    }
+    return installedResult;
+  }
+  await installLibrary(installDir, libraryName);
+  return findInInstallDir(installDir, libraryName);
+}
+function getLibraryDocs(libraryPath, libraryName) {
+  const dirs = [];
+  const files = [];
+  const readmePath = join2(libraryPath, "README.md");
+  const docsPath = join2(libraryPath, "docs");
+  const hasReadme = existsSync2(readmePath);
+  const hasDocsFolder = existsSync2(docsPath);
+  if (hasReadme) {
+    files.push(readmePath);
+  }
+  if (hasDocsFolder) {
+    dirs.push(docsPath);
+  }
+  const helper = new DocFilesHelper({
+    dirs,
+    files,
+    overrideGetSubcommand: `show ${libraryName}`
+  });
+  return {
+    libraryName,
+    libraryPath,
+    helper,
+    hasReadme,
+    hasDocsFolder
+  };
+}
+async function browseNpmLibrary(libraryName, options) {
+  const location = await findLibrary(libraryName, options);
+  if (!location) {
+    return null;
+  }
+  return getLibraryDocs(location.libraryPath, location.libraryName);
+}
+
+// src/index.ts
+function parseFrontmatter(text) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+  const match = text.match(frontmatterRegex);
+  if (!match) {
+    return {
+      frontmatter: {},
+      content: text
+    };
+  }
+  const [, frontmatterBlock, content] = match;
+  const frontmatter = {};
+  for (const line of frontmatterBlock.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    frontmatter[key] = value;
+  }
+  return {
+    frontmatter,
+    content: content.trim()
+  };
+}
+var DocFilesHelper = class {
+  constructor(options) {
+    this.options = options;
+    this.fileMap = /* @__PURE__ */ new Map();
+    if (options.dirs) {
+      for (const dir of options.dirs) {
+        const files = readdirSync2(dir);
+        for (const file of files) {
+          if (!file.endsWith(".md")) continue;
+          this.fileMap.set(file, join3(dir, file));
+        }
+      }
+    }
+    if (options.files) {
+      for (const filePath of options.files) {
+        const baseFilename = basename(filePath);
+        this.fileMap.set(baseFilename, filePath);
+      }
+    }
+  }
+  formatGetDocCommand(filename) {
+    const script = relative(process.cwd(), process.argv[1]);
+    const binName = basename(script);
+    const subcommand = this.options.overrideGetSubcommand || "show";
+    if (binName === "." || binName.endsWith(".js") || binName.endsWith(".mjs") || binName.endsWith(".ts")) {
+      return `node ${script} ${subcommand} ${filename}`;
+    }
+    return `${binName} ${subcommand} ${filename}`;
+  }
+  /**
+   * List all doc files, returning their metadata from frontmatter.
+   * Files that don't exist are silently skipped.
+   */
+  listDocs() {
+    const docs = [];
+    for (const [baseFilename, fullPath] of this.fileMap) {
+      let rawContent;
+      try {
+        rawContent = readFileSync2(fullPath, "utf-8");
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          continue;
+        }
+        throw err;
+      }
+      const { frontmatter } = parseFrontmatter(rawContent);
+      docs.push({
+        name: frontmatter.name || basename(baseFilename, ".md"),
+        description: frontmatter.description || "",
+        filename: baseFilename
+      });
+    }
+    return docs;
+  }
+  /**
+   * Get the contents of a specific doc file by name.
+   * If the exact filename doesn't exist, looks for a partial match.
+   * Throws an error if the doc file is not found or if multiple matches are found.
+   */
+  getDoc(name) {
+    const baseName = name.endsWith(".md") ? name.slice(0, -3) : name;
+    const filename = `${baseName}.md`;
+    const fullPath = this.fileMap.get(filename);
+    if (fullPath) {
+      const rawContent2 = readFileSync2(fullPath, "utf-8");
+      const { frontmatter: frontmatter2, content: content2 } = parseFrontmatter(rawContent2);
+      return {
+        name: frontmatter2.name || baseName,
+        description: frontmatter2.description || "",
+        filename,
+        content: content2,
+        rawContent: rawContent2,
+        fullPath
+      };
+    }
+    const docs = this.listDocs();
+    const matches = docs.filter(
+      (doc) => doc.filename.toLowerCase().includes(baseName.toLowerCase()) || doc.name.toLowerCase().includes(baseName.toLowerCase())
+    );
+    if (matches.length === 0) {
+      throw new Error(`Doc file not found: ${baseName}`);
+    }
+    if (matches.length > 1) {
+      const matchNames = matches.map((m) => m.filename).join(", ");
+      throw new Error(
+        `Multiple docs match "${baseName}": ${matchNames}. Please be more specific.`
+      );
+    }
+    const matchedFilename = matches[0].filename;
+    const matchedPath = this.fileMap.get(matchedFilename);
+    const rawContent = readFileSync2(matchedPath, "utf-8");
+    const { frontmatter, content } = parseFrontmatter(rawContent);
+    return {
+      name: frontmatter.name || basename(matchedFilename, ".md"),
+      description: frontmatter.description || "",
+      filename: matchedFilename,
+      content,
+      rawContent,
+      fullPath: matchedPath
+    };
+  }
+  /**
+   * Print a formatted list of all doc files to stdout.
+   * Used by the 'list-docs' command.
+   */
+  printDocFileList() {
+    const docs = this.listDocs();
+    console.log("Available doc files:\n");
+    for (const doc of docs) {
+      if (doc.description) {
+        console.log(`  ${doc.name} (${this.formatGetDocCommand(doc.filename)}):`);
+        console.log(`    ${doc.description}
+`);
+      } else {
+        console.log(`  ${doc.name} (${this.formatGetDocCommand(doc.filename)})
+`);
+      }
+    }
+  }
+  /**
+   * Print the raw contents of a specific doc file to stdout.
+   *
+   * Used by the 'get-doc' command.
+   */
+  printDocFileContents(name) {
+    try {
+      const doc = this.getDoc(name);
+      console.log(doc.rawContent);
+      console.log(`
+(File source: ${doc.fullPath})`);
+    } catch {
+      console.error(`Doc file not found: ${name}`);
+      console.error('Run with "list-docs" or "list" command to see available docs.');
+      process.exit(1);
+    }
+  }
+  yargsSetup(yargs2) {
+    yargs2.command(
+      "list-docs",
+      "List available documentation files",
+      {},
+      async () => this.printDocFileList()
+    ).command(
+      "get-doc <name>",
+      "Display the contents of a documentation file",
+      (yargs3) => {
+        return yargs3.positional("name", {
+          type: "string",
+          describe: "Name of the doc file",
+          demandOption: true
+        });
+      },
+      async (argv) => this.printDocFileContents(argv.name)
+    );
+  }
+};
+function parseTarget(target) {
+  if (target.startsWith(".") || target.startsWith("/")) {
+    return { type: "directory", value: target };
+  }
+  return { type: "npm", value: target };
+}
+
+// src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+var packageJson = JSON.parse(
+  readFileSync3(join4(__dirname, "../package.json"), "utf-8")
+);
+async function main() {
+  await yargs(hideBin(process.argv)).command(
+    "list <target>",
+    "List available doc files in a directory or NPM package",
+    (yargs2) => {
+      return yargs2.positional("target", {
+        type: "string",
+        describe: "Directory path (starts with . or /) or NPM package name",
+        demandOption: true
+      });
+    },
+    async (argv) => {
+      const target = argv.target;
+      const parsed = parseTarget(target);
+      if (parsed.type === "directory") {
+        const local = browseLocalLibrary(parsed.value);
+        local.helper.printDocFileList();
+      } else {
+        const docs = await browseNpmLibrary(parsed.value);
+        if (!docs) {
+          console.error(`Could not find library: ${parsed.value}`);
+          process.exit(1);
+        }
+        console.log(`
+Library: ${docs.libraryName}`);
+        console.log(`Path: ${docs.libraryPath}
+`);
+        if (!docs.hasReadme && !docs.hasDocsFolder) {
+          console.log("No documentation found for this library.");
+          console.log("(No README.md or docs/ folder exists)");
+          return;
+        }
+        docs.helper.printDocFileList();
+      }
+    }
+  ).command(
+    "show <target> [name]",
+    "Get the contents of one doc file",
+    (yargs2) => {
+      return yargs2.positional("target", {
+        type: "string",
+        describe: "Directory path (starts with . or /) or NPM package name",
+        demandOption: true
+      }).positional("name", {
+        type: "string",
+        describe: "Name of the doc file (defaults to README)",
+        default: "README"
+      });
+    },
+    async (argv) => {
+      const target = argv.target;
+      const name = argv.name;
+      const parsed = parseTarget(target);
+      if (parsed.type === "directory") {
+        const local = browseLocalLibrary(parsed.value);
+        local.helper.printDocFileContents(name);
+      } else {
+        const docs = await browseNpmLibrary(parsed.value);
+        if (!docs) {
+          console.error(`Could not find library: ${parsed.value}`);
+          process.exit(1);
+        }
+        docs.helper.printDocFileContents(name);
+      }
+    }
+  ).strictCommands().demandCommand(1, "You must specify a command").help().alias("help", "h").version(packageJson.version).alias("version", "v").example([
+    ["$0 list ./docs", "List all doc files in ./docs directory"],
+    ["$0 list lodash", "List all doc files for the lodash NPM package"],
+    ["$0 show ./docs project-setup", "Display the project-setup doc from ./docs"],
+    ["$0 show lodash", "Display the README for the lodash NPM package"]
+  ]).parse();
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+export { browseLocalLibrary, type LocalLibraryDocs } from './browseLocalLibrary.ts';
+export { browseNpmLibrary, findLibrary, findLibraryInNodeModules, getInstallationDirectory, getLibraryDocs, type LibraryLocation, type NpmLibraryDocs, } from './browseNpmLibrary.ts';
+export interface Frontmatter {
+    name?: string;
+    description?: string;
+    [key: string]: string | undefined;
+}
+export interface ParsedDocument {
+    frontmatter: Frontmatter;
+    content: string;
+}
+export interface DocInfo {
+    name: string;
+    description: string;
+    filename: string;
+}
+export interface DocContent extends DocInfo {
+    content: string;
+    rawContent: string;
+    fullPath: string;
+}
+export interface DocFilesHelperOptions {
+    dirs?: string[];
+    files?: string[];
+    overrideGetSubcommand?: string;
+}
+/**
+ * Parse YAML frontmatter from a markdown document.
+ * Frontmatter is delimited by --- at the start of the file.
+ */
+export declare function parseFrontmatter(text: string): ParsedDocument;
+/**
+ * Helper class for working with doc files.
+ */
+export declare class DocFilesHelper {
+    options: DocFilesHelperOptions;
+    private fileMap;
+    constructor(options: DocFilesHelperOptions);
+    formatGetDocCommand(filename: string): string;
+    /**
+     * List all doc files, returning their metadata from frontmatter.
+     * Files that don't exist are silently skipped.
+     */
+    listDocs(): DocInfo[];
+    /**
+     * Get the contents of a specific doc file by name.
+     * If the exact filename doesn't exist, looks for a partial match.
+     * Throws an error if the doc file is not found or if multiple matches are found.
+     */
+    getDoc(name: string): DocContent;
+    /**
+     * Print a formatted list of all doc files to stdout.
+     * Used by the 'list-docs' command.
+     */
+    printDocFileList(): void;
+    /**
+     * Print the raw contents of a specific doc file to stdout.
+     *
+     * Used by the 'get-doc' command.
+     */
+    printDocFileContents(name: string): void;
+    yargsSetup(yargs: any): void;
+}
+export type ParsedTarget = {
+    type: 'directory';
+    value: string;
+} | {
+    type: 'npm';
+    value: string;
+};
+/**
+ * Determine if a target string is a directory path or an NPM package name.
+ * Returns 'directory' if it starts with '.' or '/', otherwise 'npm'.
+ */
+export declare function parseTarget(target: string): ParsedTarget;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACpF,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,wBAAwB,EACxB,wBAAwB,EACxB,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAW,SAAQ,OAAO;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IAEpC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAGhB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAIjB,qBAAqB,CAAC,EAAE,MAAM,CAAA;CAC/B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CA2B7D;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,EAAE,qBAAqB,CAAA;IAG9B,OAAO,CAAC,OAAO,CAAsB;gBAEzB,OAAO,EAAE,qBAAqB;IAwB1C,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAW7C;;;OAGG;IACH,QAAQ,IAAI,OAAO,EAAE;IA0BrB;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAsDhC;;;OAGG;IACH,gBAAgB,IAAI,IAAI;IAaxB;;;;OAIG;IACH,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAYxC,UAAU,CAAC,KAAK,EAAE,GAAG;CAsBtB;AAED,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnC;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAKxD"}