@platforma-sdk/tengo-builder 1.14.11

package/dist/index.mjs

@@ -0,0 +1,851 @@
+var ge = Object.defineProperty;
+var he = (t, e, o) => e in t ? ge(t, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[e] = o;
+var d = (t, e, o) => he(t, typeof e != "symbol" ? e + "" : e, o);
+import { spawnSync as we, spawn as ye } from "node:child_process";
+import { Flags as T, Command as W } from "@oclif/core";
+import * as c from "node:path";
+import * as u from "node:fs";
+import { readFileSync as be } from "node:fs";
+import { gunzipSync as ve, gzipSync as $e } from "node:zlib";
+import Ee from "canonicalize";
+import A from "winston";
+import * as S from "node:fs/promises";
+import { TengoTesterBinaryPath as te } from "@milaboratories/tengo-tester";
+function k(t) {
+  throw new Error("Unexpected object: " + t);
+}
+function Ne() {
+  let t = process.cwd();
+  for (; t; ) {
+    const e = c.join(t, "node_modules");
+    if (u.existsSync(e)) return e;
+    const o = c.resolve(t, "..");
+    if (o === t) break;
+    t = o;
+  }
+  throw new Error("Unable to find node_modules directory.");
+}
+function v(t) {
+  try {
+    const e = u.statSync(t);
+    return e.isDirectory() ? "dir" : e.isFile() ? "file" : e.isSymbolicLink() ? "link" : "unknown";
+  } catch (e) {
+    if (e.code == "ENOENT") return "absent";
+    throw e;
+  }
+}
+function Z(t) {
+  return `${t.type}||${t.pkg}||${t.id}`;
+}
+function m(t) {
+  return `${t.type}:${t.pkg}:${t.id}:${t.version}`;
+}
+function g(t) {
+  return `${t.type}:${t.pkg}:${t.id}`;
+}
+function K(t, e) {
+  return t.type == e.type && t.pkg == e.pkg && t.id == e.id;
+}
+function y(t) {
+  return `${t.pkg}:${t.id}`;
+}
+function F(t) {
+  return { name: y(t), version: t.version };
+}
+function Se(t) {
+  const e = t.name.match(/^(?<pkg>[^:]*):(?<id>[^:]*)$/);
+  if (!e)
+    throw new Error(`malformed artifact name: ${t.name}`);
+  return { pkg: e.groups.pkg, id: e.groups.id, version: t.version };
+}
+function X(t) {
+  return `${t.pkg}:${t.id}:${t.version}`;
+}
+const ke = new TextDecoder(), Te = new TextEncoder();
+class re {
+  constructor(e, o, s) {
+    d(this, "data");
+    d(this, "content");
+    this.compileMode = e, this.fullName = o;
+    let { data: n, content: r } = s;
+    if (n === void 0 && r === void 0)
+      throw new Error("Neither data nor content is provided for template constructor");
+    if (n !== void 0 && r !== void 0)
+      throw new Error("Both data and content are provided for template constructor");
+    if (n === void 0 && (n = JSON.parse(ke.decode(ve(r))), n.type !== "pl.tengo-template.v2"))
+      throw new Error("malformed template");
+    r === void 0 && (r = $e(Te.encode(Ee(n))));
+    const i = Se(n);
+    if (i.pkg !== o.pkg || i.id !== o.id || i.version !== o.version)
+      throw new Error(`Compiled template name don't match it's package and file names: ${X(i)} != ${X(o)}`);
+    this.data = n, this.content = r;
+  }
+  toJSON() {
+    return { compileMode: this.compileMode, fullName: this.fullName, data: this.data };
+  }
+}
+class R {
+  constructor(e) {
+    d(this, "map", /* @__PURE__ */ new Map());
+    this.nameExtractor = e;
+  }
+  add(e, o = !0) {
+    const s = Z(this.nameExtractor(e)), n = this.map.get(s);
+    return n && !o || this.map.set(s, e), n;
+  }
+  get(e) {
+    return this.map.get(Z(e));
+  }
+  get array() {
+    const e = [];
+    return this.map.forEach((o) => e.push(o)), e;
+  }
+  forEach(e) {
+    this.map.forEach((o) => e(o, this.nameExtractor(o)));
+  }
+}
+function De() {
+  return new R((t) => t);
+}
+class x {
+  constructor(e) {
+    d(this, "dev");
+    d(this, "dist");
+    this.nameExtractor = e, this.dev = new R(e), this.dist = new R(e);
+  }
+  add(e, o, s = !0) {
+    switch (e) {
+      case "dist":
+        return this.dist.add(o, s);
+      default:
+        k(e);
+    }
+  }
+  get(e, o) {
+    switch (e) {
+      case "dist":
+        return this.dist.get(o);
+      default:
+        k(e);
+    }
+  }
+  array(e) {
+    const o = [];
+    return this.forEach(e, (s) => o.push(s)), o;
+  }
+  forEach(e, o) {
+    this.dist.forEach((s, n) => o(this.get(e, n) ?? s, n));
+  }
+}
+class Ae {
+  constructor(e) {
+    d(this, "libs", new x((e) => e.fullName));
+    d(this, "software", new x((e) => e.fullName));
+    d(this, "templates", new x((e) => e.fullName));
+    this.compileMode = e;
+  }
+  populateTemplateDataFromDependencies(e, o, s, n) {
+    for (const r of s)
+      switch (r.type) {
+        case "library":
+          const i = this.getLibOrError(r), a = n.indexOf(y(r));
+          if (a >= 0) {
+            let p = `library import recursion detected: ${n.slice(a).join(" -> ")} -> ${y(r)}`;
+            throw new Error(p);
+          }
+          o.libs[y(r)] = {
+            ...F(i.fullName),
+            src: i.src
+          }, this.populateTemplateDataFromDependencies(e, o, i.dependencies, [...n, y(r)]);
+          break;
+        case "software":
+          const l = this.getSoftwareOrError(r);
+          o.software[y(r)] = {
+            ...F(l.fullName),
+            src: l.src
+          };
+          break;
+        case "template":
+          if (K(e, r))
+            continue;
+          const f = this.getTemplateOrError(r);
+          o.templates[y(r)] = f.data;
+          break;
+        case "test":
+          throw new Error(
+            `dependencies tree error: tests should never be part of template: ${g(r)} is dependency of ${y(e)}`
+          );
+        default:
+          k(r.type);
+      }
+  }
+  /** This method assumes that all dependencies are already added to the compiler's context */
+  compileAndAddTemplate(e) {
+    if (e.fullName.type !== "template")
+      throw new Error("unexpected source type");
+    const o = {
+      type: "pl.tengo-template.v2",
+      ...F(e.fullName),
+      templates: {},
+      libs: {},
+      software: {},
+      src: e.src
+    };
+    this.populateTemplateDataFromDependencies(e.fullName, o, e.dependencies, []);
+    const s = new re(e.compileMode, e.fullName, { data: o });
+    return this.addTemplate(s), s;
+  }
+  addLib(e) {
+    const o = this.libs.add(e.compileMode, e, !1);
+    if (o)
+      throw new Error(
+        `compiler already contain such library: adding = ${m(e.fullName)}, contains = ${m(o.fullName)}`
+      );
+  }
+  allLibs() {
+    return this.libs.array(this.compileMode);
+  }
+  getLib(e) {
+    if (e.type !== "library")
+      throw new Error(`illegal artifact type: got ${e.type} instead of 'library`);
+    return this.libs.get(this.compileMode, e);
+  }
+  getLibOrError(e) {
+    const o = this.getLib(e);
+    if (!o)
+      throw new Error(`library not found: ${y(e)}`);
+    return o;
+  }
+  addSoftware(e) {
+    const o = this.software.add(e.compileMode, e, !1);
+    if (o)
+      throw new Error(
+        `compiler already contain info for software: adding = ${m(e.fullName)}, contains = ${m(o.fullName)}`
+      );
+  }
+  allSoftware() {
+    return this.software.array(this.compileMode);
+  }
+  getSoftware(e) {
+    if (e.type !== "software")
+      throw new Error(`illegal artifact type: got ${e.type} instead of 'software`);
+    return this.software.get(this.compileMode, e);
+  }
+  getSoftwareOrError(e) {
+    const o = this.getSoftware(e);
+    if (!o)
+      throw new Error(`software info not found: ${y(e)}`);
+    return o;
+  }
+  addTemplate(e) {
+    const o = this.templates.add(e.compileMode, e, !1);
+    if (o)
+      throw new Error(
+        `compiler already contain such template: adding = ${m(e.fullName)}, contains = ${m(o.fullName)}`
+      );
+  }
+  allTemplates() {
+    return this.templates.array(this.compileMode);
+  }
+  getTemplate(e) {
+    if (e.type !== "template")
+      throw new Error(`illegal artifact type: got ${e.type} instead of 'template`);
+    return this.templates.get(this.compileMode, e);
+  }
+  getTemplateOrError(e) {
+    const o = this.getTemplate(e);
+    if (!o)
+      throw new Error(`template not found: ${y(e)}`);
+    return o;
+  }
+  getArtefact(e) {
+    switch (e.type) {
+      case "template":
+        return this.getTemplate(e);
+      case "library":
+        return this.getLib(e);
+      case "software":
+        return this.getSoftware(e);
+      case "test":
+        return;
+      default:
+        k(e.type);
+    }
+  }
+  checkLibs() {
+    this.libs.forEach(this.compileMode, (e) => {
+      for (const o of e.dependencies) {
+        if (o.type === "test")
+          throw new Error(`test should never be dependency of production code: ${g(o)} test is dependency of ${m(e.fullName)}`);
+        if (!this.getArtefact(o))
+          throw new Error(`unresolved dependency ${g(o)} for ${m(e.fullName)}`);
+      }
+    });
+  }
+  compileAndAdd(e) {
+    const o = { templates: [], libs: [], software: [] };
+    let s = [];
+    for (const n of e)
+      n.fullName.type === "library" ? (this.addLib(n), o.libs.push(n)) : n.fullName.type === "software" ? (this.addSoftware(n), o.software.push(n)) : s.push(n);
+    for (; s.length > 0; ) {
+      const n = [];
+      for (const r of s) {
+        const i = r.dependencies.filter(
+          (a) => !this.getArtefact(a) && // allow self reference for templates
+          !(r.fullName.type === "template" && K(r.fullName, a))
+        );
+        if (i.length > 0) {
+          let a = `Unsatisfied dependencies in ${m(r.fullName)}:
+`;
+          for (const l of i)
+            a += `  - ${g(l)}
+`;
+          n.push({ src: r, err: Error(a) });
+          continue;
+        }
+        switch (r.fullName.type) {
+          case "library":
+            this.addLib(r), o.libs.push(r);
+            break;
+          case "software":
+            this.addSoftware(r), o.software.push(r);
+            break;
+          case "template":
+            try {
+              const a = this.compileAndAddTemplate(r);
+              o.templates.push(a);
+            } catch (a) {
+              let l = `Unsatisfied dependencies in ${m(r.fullName)}:
+`;
+              l += `  - ${a.message}
+`, n.push({ src: r, err: Error(l) });
+            }
+            break;
+          case "test":
+            break;
+          default:
+            k(r.fullName.type);
+        }
+      }
+      if (s.length === n.length) {
+        let r = "";
+        for (const i of n)
+          r += `
+${i.err.message}`;
+        throw new Error(r);
+      }
+      s = n.map(({ src: r }) => r);
+    }
+    return o;
+  }
+}
+const H = "[_a-zA-Z][_a-zA-Z0-9]*", D = (t, e) => new RegExp(
+  `\\b${t}\\.(?<fnCall>(?<fnName>` + e + ')\\s*\\(\\s*"(?<templateName>[^"]+)"\\s*\\))'
+), Fe = (t) => D(t, "getTemplateId"), xe = (t) => D(t, "getSoftwareInfo"), Q = (t) => D(t, "importTemplate"), Y = (t) => D(t, "importSoftware"), Re = /^\s*(\/\/)|(\/\*.*\*\/)/, Me = /^\s*\/\*/, je = /\*\//, oe = /\s*:=\s*import\s*\(\s*"(?<moduleName>[^"]+)"\s*\)/, Le = new RegExp(
+  `\\b(?<importName>${H}(\\.${H})*)${oe.source}`
+), Oe = /(?<pkgName>[^"]+)?:(?<depID>[^"]+)/;
+class se {
+  constructor(e, o, s, n, r) {
+    this.compileMode = e, this.fullName = o, this.src = s, this.srcName = n, this.dependencies = r;
+  }
+}
+function ne(t, e, o, s) {
+  const n = be(e).toString(), { deps: r, normalized: i } = Ie(n, o, s);
+  return new se(t, o, i, e, r.array);
+}
+function Ie(t, e, o) {
+  const s = De(), n = t.split(`
+`), r = [];
+  let i = {
+    isInCommentBlock: !1,
+    tplDepREs: /* @__PURE__ */ new Map()
+  }, a = 0;
+  for (const l of n) {
+    a++;
+    try {
+      const f = Ce(
+        l,
+        i,
+        e.pkg,
+        o
+      );
+      r.push(f.line), i = f.context, f.artifact && s.add(f.artifact);
+    } catch (f) {
+      throw new Error(`[line ${a}]: ${f.message}
+	${l}`);
+    }
+  }
+  return {
+    normalized: r.join(`
+`),
+    deps: s
+  };
+}
+function Ce(t, e, o, s) {
+  if (e.isInCommentBlock)
+    return je.exec(t) && (e.isInCommentBlock = !1), { line: t, context: e, artifact: void 0 };
+  if (Re.exec(t))
+    return { line: t, context: e, artifact: void 0 };
+  if (Me.exec(t))
+    return e.isInCommentBlock = !0, { line: t, context: e, artifact: void 0 };
+  const n = oe.exec(t);
+  if (n) {
+    const r = Ge(t);
+    if (r.module === "plapi")
+      return e.tplDepREs.has(r.module) || e.tplDepREs.set(r.module, [
+        ["template", Fe(r.alias)],
+        ["software", xe(r.alias)]
+      ]), { line: t, context: e, artifact: void 0 };
+    (r.module === "@milaboratory/tengo-sdk:ll" || r.module === "@platforma-sdk/workflow-tengo:ll" || (o === "@milaboratory/tengo-sdk" || o === "@platforma-sdk/workflow-tengo") && r.module === ":ll") && (e.tplDepREs.has(r.module) || e.tplDepREs.set(r.module, [
+      ["template", Q(r.alias)],
+      ["software", Y(r.alias)]
+    ])), (r.module === "@milaboratory/tengo-sdk:assets" || r.module === "@platforma-sdk/workflow-tengo:assets" || (o === "@milaboratory/tengo-sdk" || o === "@platforma-sdk/workflow-tengo") && r.module === ":assets") && (e.tplDepREs.has(r.module) || e.tplDepREs.set(r.module, [
+      ["template", Q(r.alias)],
+      ["software", Y(r.alias)]
+    ]));
+    const i = _(r.module, "library", o);
+    return i ? (t = t.replace(n[0], ` := import("${i.pkg}:${i.id}")`), { line: t, context: e, artifact: i }) : { line: t, context: e, artifact: void 0 };
+  }
+  if (e.tplDepREs.size > 0)
+    for (const [r, i] of e.tplDepREs)
+      for (const [a, l] of i) {
+        const f = l.exec(t);
+        if (!f || !f.groups)
+          continue;
+        const { fnCall: p, templateName: b, fnName: h } = f.groups;
+        if (!p || !b || !h)
+          throw Error("failed to parse template import statement");
+        const w = _(b, a, o);
+        if (!w)
+          throw Error(`failed to parse artifact name in ${h} import statement`);
+        return t = t.replace(p, `${h}("${w.pkg}:${w.id}")`), { line: t, context: e, artifact: w };
+      }
+  return { line: t, context: e, artifact: void 0 };
+}
+function Ge(t) {
+  const e = Le.exec(t);
+  if (!e || !e.groups)
+    throw Error("failed to parse 'import' statement");
+  const { importName: o, moduleName: s } = e.groups;
+  if (!o || !s)
+    throw Error("failed to parse 'import' statement");
+  return {
+    module: s,
+    alias: o
+  };
+}
+function _(t, e, o) {
+  const s = Oe.exec(t);
+  if (!s)
+    return;
+  if (!s.groups)
+    throw Error(
+      "failed to parse dependency name inside 'import' statement. The dependency name should have format '<package>:<templateName>'"
+    );
+  const { pkgName: n, depID: r } = s.groups;
+  if (!r)
+    throw Error(
+      "failed to parse dependency name inside 'import' statement. The dependency name should have format '<package>:<templateName>'"
+    );
+  return { type: e, pkg: n ?? o, id: r };
+}
+const M = ".plj.gz", j = ".lib.tengo", L = ".sw.json", ee = ".test.tengo", O = ".tpl.tengo", I = ".lib.tengo", C = ".sw.json", ze = [I, O, C];
+function J(t = "debug") {
+  return A.createLogger({
+    level: t,
+    format: A.format.printf(({ level: e, message: o }) => `${e.padStart(6, " ")}: ${o}`),
+    transports: [
+      new A.transports.Console({
+        stderrLevels: ["error", "warn", "info", "debug"],
+        handleExceptions: !0
+      })
+    ]
+  });
+}
+function U() {
+  return JSON.parse(u.readFileSync("package.json").toString());
+}
+function ie(t, e) {
+  return c.resolve(e, t, "tengo", "lib");
+}
+function ae(t, e) {
+  return c.resolve(e, t, "tengo", "tpl");
+}
+function le(t, e) {
+  return c.resolve(e, t, "tengo", "software");
+}
+function ce(t, e, o, s, n = !1) {
+  const r = c.resolve(s, "package.json");
+  if (v(r) !== "file") {
+    for (const w of u.readdirSync(s)) {
+      const me = v(c.join(s, w)) === "link", V = c.resolve(s, w);
+      v(V) === "dir" && ce(t, e, o, V, me);
+    }
+    return;
+  }
+  const i = ie("dist", s), a = ae("dist", s), l = le("dist", s), f = v(i) === "dir", p = v(a) === "dir", b = v(l) === "dir";
+  if (!f && !p && !b)
+    return;
+  const h = JSON.parse(u.readFileSync(r).toString());
+  if (h.name !== o.name) {
+    if (v(c.resolve(s, "node_modules")) === "dir" && n)
+      throw new Error(
+        `nested node_modules is a sign of library dependencies version incompatibility in ${s}`
+      );
+    f && Pe(t, h, "dist", i, e), p && We(t, h, "dist", a, e), b && Je(t, h, "dist", l, e);
+  }
+}
+function Pe(t, e, o, s, n) {
+  for (const r of u.readdirSync(s)) {
+    const i = c.resolve(s, r);
+    if (!r.endsWith(j)) throw new Error(`unexpected file in 'lib' folder: ${i}`);
+    const a = {
+      type: "library",
+      pkg: e.name,
+      id: r.slice(0, r.length - j.length),
+      version: e.version
+    }, l = ne(o, i, a, !0);
+    if (n.addLib(l), t.debug(`Adding dependency ${m(a)} from ${i}`), l.dependencies.length > 0) {
+      t.debug("Dependencies:");
+      for (const f of l.dependencies) t.debug(`  - ${g(f)}`);
+    }
+  }
+}
+function We(t, e, o, s, n) {
+  for (const r of u.readdirSync(s)) {
+    const i = c.resolve(s, r);
+    if (!r.endsWith(M)) throw new Error(`unexpected file in 'tpl' folder: ${i}`);
+    const a = {
+      type: "template",
+      pkg: e.name,
+      id: r.slice(0, r.length - M.length),
+      version: e.version
+    }, l = new re(o, a, { content: u.readFileSync(i) });
+    n.addTemplate(l), t.debug(`Adding dependency ${m(a)} from ${i}`);
+  }
+}
+function Je(t, e, o, s, n) {
+  for (const r of u.readdirSync(s)) {
+    const i = c.resolve(s, r);
+    if (!r.endsWith(L))
+      throw new Error(`unexpected file in 'software' folder: ${i}`);
+    const a = {
+      type: "software",
+      pkg: e.name,
+      id: r.slice(0, r.length - L.length),
+      version: e.version
+    }, l = new se(o, a, u.readFileSync(i).toString(), i, []);
+    n.addSoftware(l), t.debug(`Adding dependency ${m(a)} from ${i}`);
+  }
+}
+function q(t, e, o, s, n) {
+  const r = [];
+  for (const i of u.readdirSync(c.join(s, n))) {
+    const a = c.join(n, i), l = c.join(s, a);
+    if (v(l) === "dir") {
+      const w = q(t, e, o, s, a);
+      r.push(...w);
+      continue;
+    }
+    const f = i === "index.lib.tengo" ? `${c.basename(n)}.lib.tengo` : a, p = Ue(e, f.replaceAll(c.sep, "."));
+    if (!p)
+      continue;
+    const b = c.resolve(s, a);
+    t.debug(`Parsing ${m(p)} from ${b}`);
+    const h = ne(o, b, p, !0);
+    if (h.dependencies.length > 0) {
+      t.debug("Detected dependencies:");
+      for (const w of h.dependencies) t.debug(`  - ${g(w)}`);
+    }
+    r.push(h);
+  }
+  return r;
+}
+function fe(t, e, o) {
+  const s = new Ae(o);
+  return ce(t, s, e, Ne()), s;
+}
+function Ue(t, e) {
+  const o = { pkg: t.name, version: t.version };
+  return e.endsWith(I) ? {
+    ...o,
+    id: e.substring(0, e.length - I.length),
+    type: "library"
+  } : e.endsWith(O) ? {
+    ...o,
+    id: e.substring(0, e.length - O.length),
+    type: "template"
+  } : e.endsWith(C) ? {
+    ...o,
+    id: e.substring(0, e.length - C.length),
+    type: "software"
+  } : e.endsWith(ee) ? {
+    ...o,
+    id: e.substring(0, e.length - ee.length),
+    type: "test"
+  } : null;
+}
+function qe(t, e) {
+  const o = U(), s = fe(t, o, e), n = q(t, o, e, "src", "");
+  if (n.length === 0) {
+    const i = [];
+    for (const a of ze)
+      i.push(`*${a}`);
+    t.error(`Nothing to compile. Looked for ${i.join(", ")}`), process.exit(1);
+  }
+  t.info(`Compiling '${e}'...`);
+  const r = s.compileAndAdd(n);
+  return t.debug("Done."), r;
+}
+function Be(t, e, o) {
+  if (e.libs.length > 0) {
+    const s = ie(o, ".");
+    u.mkdirSync(s, { recursive: !0 });
+    for (const n of e.libs) {
+      const r = c.resolve(s, n.fullName.id + j);
+      t.info(`  - writing ${r}`), u.writeFileSync(r, n.src);
+    }
+  }
+  if (e.templates.length > 0) {
+    const s = ae(o, ".");
+    u.mkdirSync(s, { recursive: !0 });
+    for (const n of e.templates) {
+      const r = c.resolve(s, n.fullName.id + M);
+      t.info(`  - writing ${r}`), u.writeFileSync(r, n.content);
+    }
+  }
+  if (e.software.length > 0) {
+    const s = le(o, ".");
+    u.mkdirSync(s, { recursive: !0 });
+    for (const n of e.software) {
+      const r = c.resolve(s, n.fullName.id + L);
+      t.info(`  - writing ${r}`), u.writeFileSync(r, n.src);
+    }
+  }
+}
+const B = {
+  "log-level": T.string({
+    description: "logging level",
+    default: "info",
+    options: ["error", "warn", "info", "debug"]
+  })
+}, Ve = {
+  "generate-tags": T.boolean({
+    description: "generate tags, default false",
+    default: !1
+  }),
+  "tags-file": T.file({
+    description: 'where to put ".tags" file, it should be a root of VS Code project',
+    default: "../../.tags"
+    // usually a user opens a directory with all blocks
+  }),
+  "tags-additional-args": T.string({
+    description: "additional flags for universal-ctags command: e.g. -e for emacs",
+    default: [],
+    multiple: !0,
+    delimiter: ","
+  })
+}, N = class N extends W {
+  async run() {
+    const { flags: e } = await this.parse(N), o = J(e["log-level"]), s = U(), n = qe(o, "dist");
+    Be(o, n, "dist"), o.info("");
+    let r = `declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
+`;
+    r += `declare type TplName = ${n.templates.map((p) => '"' + p.fullName.id + '"').join(" | ")};
+`, r += `declare const Templates: Record<TplName, TemplateFromFile>;
+`, r += `export { Templates };
+`;
+    let i = `module.exports = { Templates: {
+`, a = `import { resolve } from 'node:path';
+export const Templates = {
+`;
+    const l = n.templates.map(
+      (p) => `  '${p.fullName.id}': { type: 'from-file', path: require.resolve('./tengo/tpl/${p.fullName.id}.plj.gz') }`
+    ).join(`,
+`), f = n.templates.map(
+      (p) => `  '${p.fullName.id}': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/${p.fullName.id}.plj.gz') }`
+    ).join(`,
+`);
+    i += l, a += f, i += `
+}};
+`, a += `
+};
+`, await S.writeFile("dist/index.d.ts", r), s.type === "module" ? (await S.writeFile("dist/index.cjs", i), await S.writeFile("dist/index.js", a)) : (await S.writeFile("dist/index.js", i), await S.writeFile("dist/index.mjs", a)), Ze(e), e["generate-tags"] && Ke(o, e), o.info("Template Pack build done.");
+  }
+};
+d(N, "description", "build tengo sources into single distributable pack file"), d(N, "examples", ["<%= config.bin %> <%= command.id %>"]), d(N, "flags", {
+  ...B,
+  ...Ve
+});
+let G = N;
+function Ze(t) {
+  process.env.GENERATE_TAGS != null && (t["generate-tags"] = process.env.GENERATE_TAGS == "true"), process.env.TAGS_FILE != null && (t["tags-file"] = process.env.TAGS_FILE), process.env.TAGS_ADDITIONAL_ARGS != null && (t["tags-additional-args"] = process.env.TAGS_ADDITIONAL_ARGS.split(","));
+}
+function Ke(t, e) {
+  var a;
+  const o = c.resolve(e["tags-file"]), s = c.dirname(o), n = e["tags-additional-args"], r = Xe(s);
+  t.info(
+    `Generating tags for tengo autocompletion from "${s}" in "${o}", additional arguments: "${n}".
+Found ${r.length} tengo files...`
+  );
+  const i = we(
+    "ctags",
+    [
+      "-f",
+      o,
+      ...n,
+      "--langdef=tengo",
+      "--map-tengo=+.tengo",
+      "--kinddef-tengo=f,function,function",
+      "--regex-tengo=/^\\s*(.*)(:| :=| =) ?func.*/\\1/f/",
+      "--kinddef-tengo=c,constant,constant",
+      '--regex-tengo=/^\\s*(.*) := ("|\\{).*/\\1/c/',
+      "-R",
+      ...r
+    ],
+    {
+      env: process.env,
+      stdio: "inherit",
+      cwd: s
+    }
+  );
+  if ((a = i.error) != null && a.message.includes("ENOENT")) {
+    console.log(`
+pl-tengo can create tags for tengo autocompletion,
+but the program should be installed
+with "brew install universal-ctags" on OSX
+or "sudo apt install universal-ctags" on Ubuntu.
+
+For vscode, you should also install ctags extension:
+https://marketplace.visualstudio.com/items?itemName=jaydenlin.ctags-support`);
+    return;
+  }
+  He(i, "failed to generate ctags"), t.info("Generation of tags is done.");
+}
+function Xe(t) {
+  const e = u.readdirSync(t, { withFileTypes: !0, recursive: !0 }), o = [];
+  return e.forEach((s) => {
+    if (!s.isDirectory() && s.name.endsWith(".tengo")) {
+      const n = c.join(s.parentPath, s.name).replace(t, ".");
+      o.push(n);
+    }
+  }), o;
+}
+function He(t, e) {
+  t.error && console.log(t.error);
+  const o = e;
+  t.status !== 0 && console.log(`WARN: ${o} the build will continue as-is`);
+}
+function de(t, e) {
+  const o = U(), s = q(t, o, "dist", "src", ""), n = fe(t, o, "dist");
+  for (const r of n.allLibs())
+    t.debug(
+      `Dumping to pl-tester: ${g(r.fullName)}`
+    ), e.write(JSON.stringify(r) + `
+`);
+  for (const r of s)
+    r.fullName.type === "library" && (t.debug(
+      `Dumping to pl-tester: ${g(r.fullName)}`
+    ), e.write(JSON.stringify(r) + `
+`));
+  for (const r of n.allTemplates())
+    t.debug(
+      `Dumping to pl-tester: ${g(r.fullName)}`
+    ), e.write(JSON.stringify(r) + `
+`);
+  for (const r of s)
+    r.fullName.type === "template" && (t.debug(
+      `Dumping to pl-tester: ${g(r.fullName)} ${r.srcName}`
+    ), e.write(JSON.stringify(r) + `
+`));
+  for (const r of n.allSoftware())
+    t.debug(
+      `Dumping to pl-tester: ${g(r.fullName)}`
+    ), e.write(JSON.stringify(r) + `
+`);
+  for (const r of s)
+    r.fullName.type === "software" && (t.debug(
+      `Dumping to pl-tester: ${g(r.fullName)}`
+    ), e.write(JSON.stringify(r) + `
+`));
+  for (const r of s)
+    r.fullName.type === "test" && (t.debug(
+      `Dumping to pl-tester: ${g(r.fullName)} ${r.srcName}`
+    ), e.write(JSON.stringify(r) + `
+`));
+}
+function pe(t, ...e) {
+  const o = ye(t, e, { stdio: ["pipe", "inherit", "inherit"] });
+  return o.stdin.on("error", (s) => {
+    s.code;
+  }), o;
+}
+function ue(t) {
+  return new Promise((e, o) => {
+    t.on("close", (s) => {
+      e(s);
+    }), t.on("error", (s) => {
+      o(s);
+    });
+  });
+}
+const $ = class $ extends W {
+  async run() {
+    const { flags: e, argv: o } = await this.parse($), s = J(e["log-level"]), n = o.length == 0 ? ["./src"] : o, r = pe(
+      te,
+      "check",
+      "--log-level",
+      e["log-level"],
+      "--artifacts",
+      "-",
+      ...n
+    );
+    try {
+      de(s, r.stdin);
+    } catch (i) {
+      s.error(i);
+    } finally {
+      r.stdin.end();
+      const i = await ue(r);
+      process.exit(i);
+    }
+  }
+};
+d($, "description", "check tengo sources for language processor an"), // static override args = {
+//   "log-level": Args.string({description: 'logging level'}),
+// }
+d($, "strict", !1), d($, "flags", { ...B }), d($, "examples", ["<%= config.bin %> <%= command.id %>"]);
+let z = $;
+const E = class E extends W {
+  async run() {
+    const { flags: e } = await this.parse(E), o = J(e["log-level"]), s = this.argv.length == 0 ? ["./src"] : this.argv, n = pe(
+      te,
+      "run",
+      "--log-level",
+      e["log-level"],
+      "--artifacts",
+      "-",
+      ...s
+    );
+    try {
+      de(o, n.stdin);
+    } catch (r) {
+      o.error(r);
+    } finally {
+      n.stdin.end();
+      const r = await ue(n);
+      process.exit(r);
+    }
+  }
+};
+d(E, "description", "run tengo unit tests (.test.tengo)"), d(E, "strict", !1), d(E, "flags", { ...B }), d(E, "examples", ["<%= config.bin %> <%= command.id %>"]);
+let P = E;
+const it = {
+  build: G,
+  check: z,
+  test: P
+};
+export {
+  it as COMMANDS
+};
+//# sourceMappingURL=index.mjs.map