@clarigen/cli 4.0.1 → 4.0.2-alpha.1

package/dist/index.js

@@ -1,1291 +0,0 @@
-// src/docs/markdown.ts
-import { getContractName as getContractName2, getTypeString } from "@clarigen/core";
-
-// src/logger.ts
-import { pino } from "pino";
-import pinoPretty from "pino-pretty";
-var colorizedClarigen = `\x1B[33m[Clarigen]\x1B[0m`;
-var logger = pino(
-  pinoPretty({
-    colorize: true,
-    ignore: "pid,hostname,time",
-    messageFormat: `${colorizedClarigen} {msg}`,
-    minimumLevel: "debug"
-  })
-);
-logger.level = "info";
-var log = logger;
-
-// src/docs/index.ts
-import { spawn } from "child_process";
-var FN_TYPES = ["read-only", "public", "private"];
-var VAR_TYPES = ["map", "data-var", "constant"];
-function createContractDocInfo({
-  contractSrc,
-  abi
-}) {
-  const lines = contractSrc.split("\n");
-  let comments = [];
-  let parensCount = 0;
-  let currentFn;
-  const contract = {
-    comments: [],
-    functions: [],
-    variables: [],
-    maps: []
-  };
-  lines.forEach((line, lineNumber) => {
-    if (currentFn) {
-      currentFn.source.push(line);
-      parensCount = traceParens(line, parensCount);
-      if (parensCount === 0) {
-        pushItem(contract, currentFn);
-        currentFn = void 0;
-      }
-      return;
-    }
-    if (isComment(line)) {
-      const comment = line.replace(/^\s*;;\s*/g, "");
-      if (contract.comments.length === lineNumber) {
-        contract.comments.push(comment);
-      } else {
-        comments.push(comment);
-      }
-      return;
-    }
-    const name = findItemNameFromLine(line);
-    if (typeof name === "undefined") {
-      comments = [];
-    } else {
-      const abiFn = findAbiItemByName(abi, name);
-      if (!abiFn) {
-        console.debug(`[claridoc]: Unable to find ABI for function \`${name}\`. Probably a bug.`);
-        return;
-      }
-      parensCount = traceParens(line, 0);
-      const metaComments = parseComments(comments, abiFn);
-      currentFn = {
-        abi: abiFn,
-        comments: metaComments,
-        startLine: lineNumber,
-        source: [line]
-      };
-      if (parensCount === 0) {
-        pushItem(contract, currentFn);
-        currentFn = void 0;
-      }
-      comments = [];
-    }
-  });
-  return contract;
-}
-function pushItem(contract, item) {
-  if ("args" in item.abi) {
-    contract.functions.push(item);
-  } else if ("key" in item.abi) {
-    contract.maps.push(item);
-  } else if ("access" in item.abi) {
-    contract.variables.push(item);
-  }
-}
-function clarityNameMatcher(line) {
-  return /[\w|\-|\?|\!]+/.exec(line);
-}
-function findItemNameFromLine(line) {
-  const fnType = FN_TYPES.find((type3) => {
-    return line.startsWith(`(define-${type3}`);
-  });
-  if (fnType) {
-    const prefix = `(define-${fnType} (`;
-    const startString = line.slice(prefix.length);
-    const match = clarityNameMatcher(startString);
-    if (!match) {
-      console.debug(`[claridocs]: Unable to determine function name from line:
-  \`${line}\``);
-      return;
-    }
-    return match[0];
-  }
-  for (const type3 of VAR_TYPES) {
-    const prefix = `(define-${type3} `;
-    if (!line.startsWith(prefix)) continue;
-    const startString = line.slice(prefix.length);
-    const match = clarityNameMatcher(startString);
-    if (!match) {
-      console.debug(`[claridocs]: Unable to determine ${type3} name from line:
-  \`${line}\``);
-      return;
-    }
-    return match[0];
-  }
-  return void 0;
-}
-function findAbiItemByName(abi, name) {
-  const fn = abi.functions.find((fn2) => {
-    return fn2.name === name;
-  });
-  if (fn) return fn;
-  const map = abi.maps.find((m) => m.name === name);
-  if (map) return map;
-  const v = abi.variables.find((v2) => v2.name === name);
-  return v;
-}
-function isComment(line) {
-  return line.startsWith(";;");
-}
-function getFnName(line) {
-  const fnType = FN_TYPES.find((type3) => {
-    return line.startsWith(`(define-${type3}`);
-  });
-  if (typeof fnType === "undefined") return;
-  const prefix = `(define-${fnType} (`;
-  const startString = line.slice(prefix.length);
-  const match = clarityNameMatcher(startString);
-  if (!match) {
-    console.debug(`[claridocs]: Unable to determine function name from line:
-  \`${line}\``);
-    return;
-  }
-  return match[0];
-}
-function traceParens(line, count) {
-  let newCount = count;
-  line.split("").forEach((char) => {
-    if (char === "(") newCount++;
-    if (char === ")") newCount--;
-  });
-  return newCount;
-}
-function parseComments(comments, abi) {
-  let curParam;
-  const parsed = {
-    text: [],
-    params: {}
-  };
-  comments.forEach((line) => {
-    const paramMatches = /\s*@param\s([\w|\-]+)([;|-|\s]*)(.*)/.exec(line);
-    if (paramMatches === null) {
-      if (!curParam || line.trim() === "") {
-        curParam = void 0;
-        parsed.text.push(line);
-      } else {
-        parsed.params[curParam].comments.push(line);
-      }
-      return;
-    }
-    if (!("args" in abi)) return;
-    const [_full, name, _separator, rest] = paramMatches;
-    const arg = abi.args.find((arg2) => arg2.name === name);
-    if (!arg) {
-      console.debug(`[claridocs]: Unable to find ABI for @param ${name}`);
-      return;
-    }
-    curParam = name;
-    parsed.params[curParam] = {
-      abi: arg,
-      comments: [rest]
-    };
-  });
-  if ("args" in abi) {
-    abi.args.forEach((arg) => {
-      if (!parsed.params[arg.name]) {
-        parsed.params[arg.name] = {
-          abi: arg,
-          comments: []
-        };
-      }
-    });
-  }
-  return parsed;
-}
-async function afterDocs(config) {
-  var _a;
-  const command = (_a = config.docs) == null ? void 0 : _a.after;
-  if (!command) return;
-  logger.debug(`Running after docs command: ${command}`);
-  const parts = command.split(" ");
-  const [cmd, ...args] = parts;
-  return new Promise((resolve3, reject) => {
-    const child = spawn(cmd, args, {
-      cwd: config.cwd,
-      stdio: "inherit"
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve3();
-      } else {
-        reject(new Error(`Command failed with code ${code ?? "unknown"}`));
-      }
-    });
-  });
-}
-
-// src/docs/markdown.ts
-import { basename } from "path";
-
-// src/utils.ts
-import { getContractName, toCamelCase } from "@clarigen/core";
-import { stat, mkdir, writeFile as fsWriteFile } from "fs/promises";
-import { dirname, relative } from "path";
-function encodeVariableName(name) {
-  if (/^[A-Z\-_]*$/.test(name)) return name.replaceAll("-", "_");
-  return toCamelCase(name);
-}
-async function fileExists(filename) {
-  try {
-    await stat(filename);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-async function writeFile(path, contents) {
-  const dir = dirname(path);
-  await mkdir(dir, { recursive: true });
-  await fsWriteFile(path, contents, "utf-8");
-  return path;
-}
-function cwdRelative(path) {
-  return relative(process.cwd(), path);
-}
-function sortContracts(contracts) {
-  const nameSorted = [...contracts].sort((a, b) => {
-    if (getContractName(a.contract_id, false) < getContractName(b.contract_id, false)) {
-      return -1;
-    }
-    return 1;
-  });
-  return nameSorted;
-}
-
-// src/docs/markdown.ts
-function generateMarkdown({
-  contract,
-  contractFile,
-  withToc = true
-}) {
-  const contractName = getContractName2(contract.contract_id, false);
-  const doc = createContractDocInfo({
-    contractSrc: contract.source,
-    abi: contract.contract_interface
-  });
-  const functions = doc.functions.map((fn) => markdownFunction(fn, contractFile));
-  const maps = doc.maps.map((map) => markdownMap(map, contractFile));
-  const vars = doc.variables.filter((v) => v.abi.access === "variable").map((v) => markdownVar(v, contractFile));
-  const constants = doc.variables.filter((v) => v.abi.access === "constant").map((v) => markdownVar(v, contractFile));
-  let fileLine = "";
-  if (contractFile) {
-    const fileName = basename(contractFile);
-    fileLine = `
-[\`${fileName}\`](${contractFile})`;
-  }
-  return `
-# ${contractName}
-${fileLine}
-
-${doc.comments.join("\n\n")}
-
-${withToc ? markdownTOC(doc) : ""}
-
-## Functions
-
-${functions.join("\n\n")}
-
-## Maps
-
-${maps.join("\n\n")}
-
-## Variables
-
-${vars.join("\n\n")}
-
-## Constants
-
-${constants.join("\n\n")}
-  `;
-}
-function markdownFunction(fn, contractFile) {
-  const params = mdParams(fn);
-  const returnType = getTypeString(fn.abi.outputs.type);
-  const paramSigs = fn.abi.args.map((arg) => {
-    return `(${arg.name} ${getTypeString(arg.type)})`;
-  });
-  const startLine = fn.startLine + 1;
-  let link = "";
-  if (contractFile) {
-    link = `[View in file](${contractFile}#L${startLine})`;
-  }
-  const source = `<details>
-  <summary>Source code:</summary>
-
-\`\`\`clarity
-${fn.source.join("\n")}
-\`\`\`
-</details>
-`;
-  const sig = `(define-${fn.abi.access.replace("_", "-")} (${fn.abi.name} (${paramSigs.join(
-    " "
-  )}) ${returnType})`;
-  return `### ${fn.abi.name}
-
-${link}
-
-\`${sig}\`
-
-${fn.comments.text.join("\n")}
-
-${source}
-
-${params}`;
-}
-function mdParams(fn) {
-  if (fn.abi.args.length === 0) return "";
-  const hasDescription = Object.values(fn.comments.params).some((p) => p.comments.length > 0);
-  const params = Object.values(fn.comments.params).map((p) => markdownParam(p, hasDescription));
-  return `**Parameters:**
-
-| Name | Type | ${hasDescription ? "Description |" : ""}
-| --- | --- | ${hasDescription ? "--- |" : ""}
-${params.join("\n")}`;
-}
-function markdownParam(param, withDescription) {
-  const typeString = getTypeString(param.abi.type);
-  const base = `| ${param.abi.name} | ${typeString} |`;
-  if (!withDescription) return base;
-  return `${base} ${param.comments.join(" ")} |`;
-}
-function markdownMap(map, contractFile) {
-  const startLine = map.startLine + 1;
-  let link = "";
-  if (contractFile) {
-    link = `[View in file](${contractFile}#L${startLine})`;
-  }
-  return `### ${map.abi.name}
-
-${map.comments.text.join("\n")}
-
-\`\`\`clarity
-${map.source.join("\n")}
-\`\`\`
-
-${link}`;
-}
-function markdownVar(variable, contractFile) {
-  const startLine = variable.startLine + 1;
-  let link = "";
-  if (contractFile) {
-    link = `[View in file](${contractFile}#L${startLine})`;
-  }
-  const sig = variable.abi.access === "variable" ? getTypeString(variable.abi.type) : "";
-  return `### ${variable.abi.name}
-
-${sig}
-
-${variable.comments.text.join("\n")}
-
-\`\`\`clarity
-${variable.source.join("\n")}
-\`\`\`
-
-${link}`;
-}
-function markdownTOC(contract) {
-  const publics = contract.functions.filter((fn) => fn.abi.access === "public");
-  const readOnly = contract.functions.filter((fn) => fn.abi.access === "read_only");
-  const privates = contract.functions.filter((fn) => fn.abi.access === "private");
-  const maps = contract.maps;
-  const constants = contract.variables.filter((v) => v.abi.access === "constant");
-  const vars = contract.variables.filter((v) => v.abi.access === "variable");
-  function tocLine(fn) {
-    const name = fn.abi.name;
-    return `- [\`${name}\`](#${name.toLowerCase().replaceAll("?", "")})`;
-  }
-  return `**Public functions:**
-
-${publics.map(tocLine).join("\n")}
-
-**Read-only functions:**
-
-${readOnly.map(tocLine).join("\n")}
-
-**Private functions:**
-
-${privates.map(tocLine).join("\n")}
-
-**Maps**
-
-${maps.map(tocLine).join("\n")}
-
-**Variables**
-
-${vars.map(tocLine).join("\n")}
-
-**Constants**
-
-${constants.map(tocLine).join("\n")}
-`;
-}
-function generateReadme(session, excluded) {
-  const contractLines = [];
-  sortContracts(session.contracts).forEach((contract) => {
-    const name = getContractName2(contract.contract_id, false);
-    if (excluded[name]) return;
-    const fileName = `${name}.md`;
-    const line = `- [\`${name}\`](${fileName})`;
-    contractLines.push(line);
-  });
-  const fileContents = `# Contracts
-
-${contractLines.join("\n")}
-  `;
-  return fileContents;
-}
-
-// src/config.ts
-import { type as type2 } from "arktype";
-
-// src/clarinet-config.ts
-import { type } from "arktype";
-import { readFile } from "fs/promises";
-import { parse } from "@iarna/toml";
-var ClarinetConfig = type({
-  project: type({
-    requirements: type({
-      contract_id: type("string").describe("Contract ID")
-    }).array().describe("Project requirements").optional(),
-    cache_location: type({
-      path: type("string").describe("Cache location path")
-    }).optional()
-  }),
-  contracts: type({
-    "[string]": type({
-      path: type("string").describe("Contract path")
-    })
-  }).optional()
-});
-async function getClarinetConfig(path) {
-  const file = await readFile(path, "utf-8");
-  const config = ClarinetConfig.assert(parse(file));
-  return config;
-}
-
-// src/config.ts
-import { dirname as dirname2, join, relative as relative2, resolve as resolve2 } from "path";
-import { stringify, parse as parse2 } from "@iarna/toml";
-import { readFile as readFile2 } from "fs/promises";
-var CONFIG_FILE = "Clarigen.toml";
-var OutputType = /* @__PURE__ */ ((OutputType2) => {
-  OutputType2["ESM"] = "types";
-  OutputType2["ESM_OLD"] = "esm";
-  OutputType2["Docs"] = "docs";
-  return OutputType2;
-})(OutputType || {});
-var typesSchema = type2({
-  "output?": type2("string").describe("Path to the output file"),
-  "outputs?": type2("string[]").describe("Paths to the output files"),
-  "include_accounts?": type2("boolean").describe("Include accounts in the output"),
-  "after?": type2("string").describe("Script to run after the output is generated"),
-  "include_boot_contracts?": type2("boolean").describe("Include boot contracts in the output"),
-  "watch_folders?": type2("string[]").describe("Folders to watch for changes")
-}).optional();
-var ConfigFile = type2({
-  clarinet: type2("string").describe("Path to the Clarinet config file"),
-  ["types" /* ESM */]: typesSchema,
-  ["esm" /* ESM_OLD */]: typesSchema,
-  ["docs" /* Docs */]: type2({
-    "output?": type2("string").describe("Path to docs output folder. Defaults to ./docs"),
-    "outputs?": type2("string[]").describe("Paths to docs output folders"),
-    "exclude?": type2("string[]").describe("Contracts to exclude from docs generation"),
-    "after?": type2("string").describe("Script to run after docs are generated")
-  }).optional()
-});
-var defaultConfigFile = {
-  clarinet: "./Clarinet.toml"
-};
-var Config = class {
-  configFile;
-  clarinet;
-  cwd;
-  constructor(config, clarinet, cwd) {
-    this.configFile = config;
-    this.clarinet = clarinet;
-    this.cwd = cwd ?? process.cwd();
-  }
-  static async load(cwd) {
-    const config = await getConfig(cwd);
-    if (config["esm" /* ESM_OLD */]) {
-      config["types" /* ESM */] = config["esm" /* ESM_OLD */];
-      delete config["esm" /* ESM_OLD */];
-    }
-    const clarinet = await getClarinetConfig(resolve2(cwd ?? "", config.clarinet));
-    return new this(config, clarinet, cwd);
-  }
-  getOutputs(type3) {
-    var _a, _b;
-    const singlePath = (_a = this.configFile[type3]) == null ? void 0 : _a.output;
-    const multiPath = ((_b = this.configFile[type3]) == null ? void 0 : _b.outputs) || [];
-    if (singlePath !== void 0) return [singlePath];
-    return multiPath;
-  }
-  outputResolve(type3, filePath) {
-    const outputs = this.getOutputs(type3);
-    if (!this.supports(type3)) return null;
-    return outputs.map((path) => {
-      return resolve2(this.cwd, path, filePath || "");
-    });
-  }
-  async writeOutput(type3, contents, filePath) {
-    const paths = this.outputResolve(type3, filePath);
-    if (paths === null) return null;
-    await Promise.all(
-      paths.map(async (path) => {
-        await writeFile(path, contents);
-        log.debug(`Generated ${type3} file at ${relative2(this.cwd, path)}`);
-      })
-    );
-    return paths;
-  }
-  supports(type3) {
-    return this.getOutputs(type3).length > 0;
-  }
-  type(type3) {
-    return this.configFile[type3];
-  }
-  get esm() {
-    return this.configFile["types" /* ESM */];
-  }
-  get docs() {
-    return this.configFile["docs" /* Docs */];
-  }
-  clarinetFile() {
-    return resolve2(this.cwd, this.configFile.clarinet);
-  }
-  joinFromClarinet(filePath) {
-    const baseDir = dirname2(this.clarinetFile());
-    return join(baseDir, filePath);
-  }
-};
-function configFilePath(cwd) {
-  return resolve2(cwd ?? process.cwd(), CONFIG_FILE);
-}
-async function saveConfig(config) {
-  const configToml = stringify({ ...config });
-  await writeFile(configFilePath(), configToml);
-}
-var sessionConfig;
-async function getConfig(cwd) {
-  if (typeof sessionConfig !== "undefined") return sessionConfig;
-  const path = configFilePath(cwd);
-  if (await fileExists(path)) {
-    const toml = await readFile2(path, "utf-8");
-    const parsedToml = parse2(toml);
-    const parsed = ConfigFile(parsedToml);
-    if (parsed instanceof type2.errors) {
-      logger.error(`Error parsing Clarigen config: ${parsed.summary}`);
-      throw new Error(`Error parsing Clarigen config: ${parsed.summary}`);
-    }
-    sessionConfig = parsed;
-  } else {
-    sessionConfig = defaultConfigFile;
-  }
-  return sessionConfig;
-}
-
-// src/files/docs.ts
-import { getContractName as getContractName3 } from "@clarigen/core";
-import { relative as relative3, extname } from "path";
-async function generateDocs({
-  session,
-  config
-}) {
-  const docs = config.configFile["docs" /* Docs */];
-  const docsBase = docs == null ? void 0 : docs.output;
-  if (!docsBase) {
-    warnNoDocs();
-    return;
-  }
-  const docsPathExt = extname(docsBase);
-  if (docsPathExt) {
-    log.warn(`Docs output path ('${docsBase}') looks like a file - it needs to be a directory.`);
-  }
-  const excluded = Object.fromEntries(
-    (docs.exclude || []).map((e) => {
-      return [e, true];
-    })
-  );
-  log.debug(`Generating docs at path \`${docsBase}\``);
-  const docsBaseFolder = config.outputResolve("docs" /* Docs */, "./")[0];
-  const paths = await Promise.all(
-    session.contracts.map(async (contract) => {
-      var _a, _b;
-      const name = getContractName3(contract.contract_id, false);
-      if (excluded[name]) return null;
-      const docFile = `${name}.md`;
-      const contractPathDef = (_b = (_a = config.clarinet.contracts) == null ? void 0 : _a[name]) == null ? void 0 : _b.path;
-      let contractFile;
-      if (contractPathDef) {
-        const contractPathFull = config.joinFromClarinet(contractPathDef);
-        contractFile = relative3(docsBaseFolder, contractPathFull);
-      } else {
-        log.debug(`Couldn't find contract file from Clarinet.toml for contract ${name}`);
-      }
-      const md = generateMarkdown({ contract, contractFile });
-      const path = await config.writeOutput("docs" /* Docs */, md, docFile);
-      return path[0];
-    })
-  );
-  const readme = generateReadme(session, excluded);
-  paths.push((await config.writeOutput("docs" /* Docs */, readme, "README.md"))[0]);
-  await afterDocs(config);
-}
-function warnNoDocs() {
-  log.warn(
-    `
-Clarigen config file doesn't include an output directory for docs.
-
-To generate docs, specify 'docs.output' in your config file:
-
-[docs]
-output = "docs/"
-  `.trimEnd()
-  );
-}
-
-// src/files/variables.ts
-import {
-  cvToValue,
-  getContractName as getContractName5
-} from "@clarigen/core";
-
-// src/declaration.ts
-import {
-  isClarityAbiBuffer,
-  isClarityAbiList,
-  isClarityAbiOptional,
-  isClarityAbiPrimitive,
-  isClarityAbiResponse,
-  isClarityAbiStringAscii,
-  isClarityAbiStringUtf8,
-  isClarityAbiTuple,
-  isClarityAbiTraitReference
-} from "@clarigen/core";
-import { toCamelCase as toCamelCase2 } from "@clarigen/core";
-var jsTypeFromAbiType = (val, isArgument = false) => {
-  if (isClarityAbiPrimitive(val)) {
-    if (val === "uint128") {
-      if (isArgument) return "number | bigint";
-      return "bigint";
-    } else if (val === "int128") {
-      if (isArgument) return "number | bigint";
-      return "bigint";
-    } else if (val === "bool") {
-      return "boolean";
-    } else if (val === "principal") {
-      return "string";
-    } else if (val === "none") {
-      return "null";
-    } else if (val === "trait_reference") {
-      return "string";
-    } else {
-      throw new Error(`Unexpected Clarity ABI type primitive: ${JSON.stringify(val)}`);
-    }
-  } else if (isClarityAbiBuffer(val)) {
-    return "Uint8Array";
-  } else if (isClarityAbiResponse(val)) {
-    const ok = jsTypeFromAbiType(val.response.ok, isArgument);
-    const err = jsTypeFromAbiType(val.response.error, isArgument);
-    return `Response<${ok}, ${err}>`;
-  } else if (isClarityAbiOptional(val)) {
-    const innerType = jsTypeFromAbiType(val.optional, isArgument);
-    return `${innerType} | null`;
-  } else if (isClarityAbiTuple(val)) {
-    const tupleDefs = [];
-    val.tuple.forEach(({ name, type: type3 }) => {
-      const camelName = toCamelCase2(name);
-      const innerType = jsTypeFromAbiType(type3, isArgument);
-      tupleDefs.push(`"${camelName}": ${innerType};`);
-    });
-    return `{
-  ${tupleDefs.join("\n  ")}
-}`;
-  } else if (isClarityAbiList(val)) {
-    const innerType = jsTypeFromAbiType(val.list.type, isArgument);
-    return `${innerType}[]`;
-  } else if (isClarityAbiStringAscii(val)) {
-    return "string";
-  } else if (isClarityAbiStringUtf8(val)) {
-    return "string";
-  } else if (isClarityAbiTraitReference(val)) {
-    return "string";
-  } else {
-    throw new Error(`Unexpected Clarity ABI type: ${JSON.stringify(val)}`);
-  }
-};
-function abiArgType(arg) {
-  const nativeType = jsTypeFromAbiType(arg.type, true);
-  const argName = getArgName(arg.name);
-  return `${argName}: TypedAbiArg<${nativeType}, "${argName}">`;
-}
-function abiFunctionType(abiFunction) {
-  const args = abiFunction.args.map(abiArgType);
-  const retType = jsTypeFromAbiType(abiFunction.outputs.type);
-  const argsTuple = `[${args.join(", ")}]`;
-  return `TypedAbiFunction<${argsTuple}, ${retType}>`;
-}
-function getArgName(name) {
-  const camel = toCamelCase2(name);
-  const prefix = RESERVED[camel] ? "_" : "";
-  return `${prefix}${camel}`;
-}
-function _hash(...words) {
-  const h = {};
-  for (const word of words) {
-    h[word] = true;
-  }
-  return h;
-}
-var RESERVED = _hash(
-  // Keywords, ES6 11.6.2.1, http://www.ecma-international.org/ecma-262/6.0/index.html#sec-keywords
-  "break",
-  "do",
-  "in",
-  "typeof",
-  "case",
-  "else",
-  "instanceof",
-  "var",
-  "catch",
-  "export",
-  "new",
-  "void",
-  "class",
-  "extends",
-  "return",
-  "while",
-  "const",
-  "finally",
-  "super",
-  "with",
-  "continue",
-  "for",
-  "switch",
-  "yield",
-  "debugger",
-  "function",
-  "this",
-  "default",
-  "if",
-  "throw",
-  "delete",
-  "import",
-  "try",
-  // Future Reserved Words, ES6 11.6.2.2
-  // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-future-reserved-words
-  "enum",
-  "await",
-  // NullLiteral & BooleanLiteral
-  "null",
-  "true",
-  "false"
-);
-
-// src/files/base.ts
-import { toCamelCase as toCamelCase3 } from "@clarigen/core";
-
-// src/files/accounts.ts
-function generateAccountsCode(accounts) {
-  const sortedAccounts = sortAccounts(accounts);
-  const namedAccounts = Object.fromEntries(
-    sortedAccounts.map((a) => {
-      const { name, ...rest } = a;
-      return [name, rest];
-    })
-  );
-  return JSON.stringify(namedAccounts);
-}
-function sortAccounts(accounts) {
-  const nameSorted = [...accounts].sort((a, b) => {
-    if (a.name < b.name) {
-      return -1;
-    }
-    return 1;
-  });
-  return nameSorted;
-}
-
-// src/files/identifiers.ts
-import { getContractName as getContractName4 } from "@clarigen/core";
-function generateIdentifiers(session) {
-  const identifiers = Object.fromEntries(
-    sortContracts(session.contracts).map((c) => {
-      const contractName = getContractName4(c.contract_id);
-      return [contractName, c.contract_id];
-    })
-  );
-  return identifiers;
-}
-function generateIdentifiersCode(session) {
-  const identifiers = generateIdentifiers(session);
-  return `export const identifiers = ${JSON.stringify(identifiers)} as const`;
-}
-
-// src/files/base.ts
-import { inspect } from "util";
-function generateContractMeta(contract, constants) {
-  const abi = contract.contract_interface;
-  const functionLines = [];
-  const { functions, maps, variables, non_fungible_tokens, ...rest } = abi;
-  functions.forEach((func) => {
-    let functionLine = `${toCamelCase3(func.name)}: `;
-    const funcDef = JSON.stringify(func);
-    functionLine += funcDef;
-    const functionType = abiFunctionType(func);
-    functionLine += ` as ${functionType}`;
-    functionLines.push(functionLine);
-  });
-  const mapLines = maps.map((map) => {
-    let mapLine = `${toCamelCase3(map.name)}: `;
-    const keyType = jsTypeFromAbiType(map.key, true);
-    const valType = jsTypeFromAbiType(map.value);
-    mapLine += JSON.stringify(map);
-    mapLine += ` as TypedAbiMap<${keyType}, ${valType}>`;
-    return mapLine;
-  });
-  const otherAbi = JSON.stringify(rest);
-  const contractName = contract.contract_id.split(".")[1];
-  const variableLines = encodeVariables(variables);
-  const nftLines = non_fungible_tokens.map((nft) => {
-    return JSON.stringify(nft);
-  });
-  return `{
-  ${serializeLines("functions", functionLines)}
-  ${serializeLines("maps", mapLines)}
-  ${serializeLines("variables", variableLines)}
-  constants: ${constants},
-  ${serializeArray("non_fungible_tokens", nftLines)}
-  ${otherAbi.slice(1, -1)},
-  contractName: '${contractName}',
-  }`;
-}
-var TYPE_IMPORTS = `import type { TypedAbiArg, TypedAbiFunction, TypedAbiMap, TypedAbiVariable, Response } from '@clarigen/core';`;
-function generateBaseFile(session) {
-  const combined = session.contracts.map((c, i) => ({
-    ...c,
-    constants: session.variables[i]
-  }));
-  const contractDefs = sortContracts(combined).map((contract) => {
-    const meta = generateContractMeta(contract, contract.constants);
-    const id = contract.contract_id.split(".")[1];
-    const keyName = toCamelCase3(id);
-    return `${keyName}: ${meta}`;
-  });
-  const file = `
-${TYPE_IMPORTS}
-
-export const contracts = {
-  ${contractDefs.join(",\n")}
-} as const;
-
-export const accounts = ${generateAccountsCode(session.accounts)} as const;
-
-${generateIdentifiersCode(session)}
-
-export const simnet = {
-  accounts,
-  contracts,
-  identifiers,
-} as const;
-
-`;
-  return file;
-}
-function encodeVariables(variables) {
-  return variables.map((v) => {
-    let varLine = `${encodeVariableName(v.name)}: `;
-    const type3 = jsTypeFromAbiType(v.type);
-    const varJSON = serialize(v);
-    varLine += `${varJSON} as TypedAbiVariable<${type3}>`;
-    return varLine;
-  });
-}
-Uint8Array.prototype[inspect.custom] = function(depth, options) {
-  return `Uint8Array.from([${this.join(",")}])`;
-};
-function serialize(obj) {
-  return inspect(obj, {
-    // showHidden: false,
-    // depth: 100,
-    // colors: false,
-    showHidden: false,
-    // iterableLimit: 100000,
-    compact: false,
-    // trailingComma: true,
-    depth: 100,
-    colors: false,
-    maxArrayLength: Infinity,
-    maxStringLength: Infinity,
-    breakLength: Infinity,
-    numericSeparator: true
-    // strAbbreviateSize: 100000,
-  });
-}
-function serializeLines(key, lines) {
-  return `"${key}": {
-    ${lines.join(",\n    ")}
-  },`;
-}
-function serializeArray(key, lines) {
-  return `"${key}": [
-    ${lines.join(",\n    ")}
-  ],`;
-}
-
-// src/files/variables.ts
-function clarityVersionForContract(contract) {
-  switch (contract.contract_interface.clarity_version) {
-    case "Clarity1":
-      return 1;
-    case "Clarity2":
-      return 2;
-    case "Clarity3":
-      return 3;
-    case "Clarity4":
-      return 4;
-    default:
-      return 3;
-  }
-}
-function getVariablesV2(contract, simnet, verbose) {
-  const [deployer] = contract.contract_id.split(".");
-  const fakeId = `${getContractName5(contract.contract_id)}-vars`;
-  logger.debug(`Deploying ${contract.contract_id} for variables.`);
-  if (!contract.source) {
-    logger.debug(
-      `Contract ${getContractName5(contract.contract_id)} has no source. Skipping variables.`
-    );
-    return {};
-  }
-  if (contract.contract_interface.variables.length === 0) {
-    logger.info(`Contract ${getContractName5(contract.contract_id, false)} has no variables`);
-    return {};
-  }
-  let varFn = `{
-`;
-  const varLines = contract.contract_interface.variables.map((variable) => {
-    let varLine = `${variable.name}: `;
-    if (variable.access === "constant") {
-      varLine += `${variable.name}`;
-    } else {
-      varLine += `(var-get ${variable.name})`;
-    }
-    return varLine;
-  });
-  varFn += varLines.map((l) => ` ${l},`).join("\n");
-  varFn += "\n}";
-  const fullSrc = contract.source + `
-
-${varFn}`;
-  try {
-    const receipt = simnet.deployContract(
-      fakeId,
-      fullSrc,
-      {
-        clarityVersion: clarityVersionForContract(contract)
-      },
-      deployer
-    );
-    const result = receipt.result;
-    const varsAbi = {
-      tuple: []
-    };
-    contract.contract_interface.variables.forEach((v) => {
-      const _v = v;
-      varsAbi.tuple.push({
-        type: _v.type,
-        name: _v.name
-      });
-    });
-    if (verbose) {
-      logger.info(cvToValue(result, true));
-    }
-    return cvToValue(result, true);
-  } catch (error) {
-    logger.warn(
-      { err: error },
-      `Error getting variables for ${getContractName5(contract.contract_id, false)}`
-    );
-    return {};
-  }
-}
-function mapVariables(session, simnet) {
-  return session.contracts.map((contract) => {
-    const vars = getVariablesV2(contract, simnet);
-    return serialize(vars);
-  });
-}
-
-// src/files/esm.ts
-import { readFile as readFile3 } from "fs/promises";
-import { join as join2, dirname as dirname3, relative as relative4 } from "path";
-import { parse as parse3 } from "yaml";
-
-// src/deployments.ts
-function flatBatch(batches) {
-  const txs = [];
-  batches.forEach((batch) => txs.push(...batch.transactions));
-  return txs;
-}
-function getContractTxs(batches) {
-  const txs = flatBatch(batches);
-  return txs.filter(isContractTx);
-}
-function getDeploymentContract(contractName, deployment) {
-  const txs = flatBatch(deployment.plan.batches);
-  for (const tx of txs) {
-    if (!isContractTx(tx)) continue;
-    if ("requirement-publish" in tx) {
-      const [_, name] = tx["requirement-publish"]["contract-id"].split(".");
-      if (name === contractName) {
-        return tx;
-      }
-    } else if ("emulated-contract-publish" in tx) {
-      if (tx["emulated-contract-publish"]["contract-name"] === contractName) {
-        return tx;
-      }
-    } else if ("contract-publish" in tx) {
-      const contract = tx["contract-publish"];
-      if (contract["contract-name"] === contractName) {
-        return tx;
-      }
-    }
-  }
-  throw new Error(`Unable to find deployment tx for contract '${contractName}'`);
-}
-function getDeploymentTxPath(tx) {
-  if (!isContractTx(tx)) {
-    throw new Error("Unable to get path for tx type.");
-  }
-  if ("requirement-publish" in tx) {
-    return tx["requirement-publish"].path;
-  } else if ("emulated-contract-publish" in tx) {
-    const contract = tx["emulated-contract-publish"];
-    return contract.path;
-  } else if ("contract-publish" in tx) {
-    const contract = tx["contract-publish"];
-    return contract.path;
-  }
-  throw new Error("Couldnt get path for deployment tx.");
-}
-function getIdentifier(tx) {
-  if (!isContractTx(tx)) {
-    throw new Error("Unable to get ID for tx type.");
-  }
-  if ("requirement-publish" in tx) {
-    const spec = tx["requirement-publish"];
-    const [_, name] = spec["contract-id"].split(".");
-    return `${spec["remap-sender"]}.${name}`;
-  } else if ("emulated-contract-publish" in tx) {
-    const contract = tx["emulated-contract-publish"];
-    return `${contract["emulated-sender"]}.${contract["contract-name"]}`;
-  } else if ("contract-publish" in tx) {
-    const contract = tx["contract-publish"];
-    return `${contract["expected-sender"]}.${contract["contract-name"]}`;
-  }
-  throw new Error(`Unable to find ID for contract.`);
-}
-function isContractTx(tx) {
-  if ("contract-call" in tx) return false;
-  if ("btc-transfer" in tx) return false;
-  if ("emulated-contract-call" in tx) return false;
-  return true;
-}
-
-// src/files/esm.ts
-import { getContractName as getContractName6 } from "@clarigen/core";
-import { spawn as spawn2 } from "child_process";
-async function parseDeployment(path) {
-  const contents = await readFile3(path, "utf-8");
-  const parsed = parse3(contents);
-  return parsed;
-}
-var DEPLOYMENT_NETWORKS = ["devnet", "simnet", "testnet", "mainnet"];
-async function getDeployments(config) {
-  const entries = await Promise.all(
-    DEPLOYMENT_NETWORKS.map(async (network) => {
-      const file = `default.${network}-plan.yaml`;
-      const path = join2(dirname3(config.clarinetFile()), "deployments", file);
-      let plan;
-      try {
-        plan = await parseDeployment(path);
-      } catch (_) {
-      }
-      return [network, plan];
-    })
-  );
-  return Object.fromEntries(entries);
-}
-async function generateESMFile({
-  baseFile,
-  session,
-  config
-}) {
-  const deployments = await getDeployments(config);
-  const contractDeployments = collectContractDeployments(session, deployments, config);
-  const simnet = generateSimnetCode(config, deployments, session);
-  return `${baseFile}
-export const deployments = ${JSON.stringify(contractDeployments)} as const;
-${simnet}
-export const project = {
-  contracts,
-  deployments,
-} as const;
-  `;
-}
-function insertNetworkId(deployments, identifier, network) {
-  const name = getContractName6(identifier);
-  if (!deployments[name]) {
-    return;
-  }
-  if (deployments[name][network] === null) {
-    deployments[name][network] = identifier;
-  }
-}
-function collectContractDeployments(session, deployments, config) {
-  var _a;
-  const full = Object.fromEntries(
-    sortContracts(session.contracts).map((contract) => {
-      const contractName = getContractName6(contract.contract_id);
-      const contractDeployments = Object.fromEntries(
-        DEPLOYMENT_NETWORKS.map((network) => {
-          const deployment = deployments[network];
-          if (typeof deployment === "undefined") {
-            return [network, null];
-          }
-          try {
-            const contractName2 = contract.contract_id.split(".")[1];
-            const tx = getDeploymentContract(contractName2, deployment);
-            const id = getIdentifier(tx);
-            return [network, id];
-          } catch (_) {
-            return [network, null];
-          }
-        })
-      );
-      return [contractName, contractDeployments];
-    })
-  );
-  const deployer = session.accounts.find((a) => a.name === "deployer");
-  (_a = config.clarinet.project.requirements) == null ? void 0 : _a.forEach(({ contract_id }) => {
-    insertNetworkId(full, contract_id, "mainnet");
-    const contractName = contract_id.split(".")[1];
-    if (deployer) {
-      const devnetId = `${deployer.address}.${contractName}`;
-      insertNetworkId(full, devnetId, "devnet");
-    }
-  });
-  session.contracts.forEach((contract) => {
-    insertNetworkId(full, contract.contract_id, "devnet");
-    insertNetworkId(full, contract.contract_id, "simnet");
-  });
-  return full;
-}
-function collectDeploymentFiles(deployments, clarinetFolder, cwd) {
-  if (!deployments.simnet) return [];
-  const simnet = deployments.simnet;
-  const txs = getContractTxs(simnet.plan.batches);
-  const entries = txs.map((tx) => {
-    const id = getIdentifier(tx);
-    const contractFile = getDeploymentTxPath(tx);
-    return {
-      identifier: id,
-      file: relative4(cwd, join2(clarinetFolder, contractFile))
-    };
-  });
-  return entries;
-}
-function generateSimnetCode(config, deployments, _session) {
-  var _a;
-  if (!((_a = config.esm) == null ? void 0 : _a.include_accounts)) return "";
-  const clarinetFolder = dirname3(config.clarinetFile());
-  const files = collectDeploymentFiles(deployments, clarinetFolder, config.cwd);
-  return `
-export const simnetDeployment = ${JSON.stringify(files)};
-`;
-}
-async function afterESM(config) {
-  var _a;
-  const command = (_a = config.esm) == null ? void 0 : _a.after;
-  if (!command) return;
-  logger.debug(`Running after ESM command: ${command}`);
-  const parts = command.split(" ");
-  const [cmd, ...args] = parts;
-  return new Promise((resolve3, reject) => {
-    const child = spawn2(cmd, args, {
-      cwd: config.cwd,
-      stdio: "inherit"
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve3();
-      } else {
-        reject(new Error(`Command failed with code ${code ?? "unknown"}`));
-      }
-    });
-  });
-}
-export {
-  CONFIG_FILE,
-  ClarinetConfig,
-  Config,
-  ConfigFile,
-  DEPLOYMENT_NETWORKS,
-  FN_TYPES,
-  OutputType,
-  TYPE_IMPORTS,
-  VAR_TYPES,
-  abiArgType,
-  abiFunctionType,
-  afterDocs,
-  afterESM,
-  collectContractDeployments,
-  collectDeploymentFiles,
-  configFilePath,
-  createContractDocInfo,
-  cwdRelative,
-  defaultConfigFile,
-  encodeVariableName,
-  encodeVariables,
-  fileExists,
-  flatBatch,
-  generateBaseFile,
-  generateContractMeta,
-  generateDocs,
-  generateESMFile,
-  generateMarkdown,
-  generateReadme,
-  getArgName,
-  getClarinetConfig,
-  getConfig,
-  getContractTxs,
-  getDeploymentContract,
-  getDeploymentTxPath,
-  getDeployments,
-  getFnName,
-  getIdentifier,
-  getVariablesV2,
-  isComment,
-  isContractTx,
-  jsTypeFromAbiType,
-  mapVariables,
-  markdownFunction,
-  parseComments,
-  parseDeployment,
-  saveConfig,
-  serialize,
-  sortContracts,
-  traceParens,
-  writeFile
-};
-//# sourceMappingURL=index.js.map