@accordproject/template-engine 2.0.3 → 2.2.0

package/dist/index.js

@@ -1,21 +1,1437 @@
-"use strict";
-/*
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateMarkToTypeScriptCompiler = exports.TemplateMarkInterpreter = void 0;
-var TemplateMarkInterpreter_1 = require("./TemplateMarkInterpreter");
-Object.defineProperty(exports, "TemplateMarkInterpreter", { enumerable: true, get: function () { return TemplateMarkInterpreter_1.TemplateMarkInterpreter; } });
-var TemplateMarkToTypeScriptCompiler_1 = require("./TemplateMarkToTypeScriptCompiler");
-Object.defineProperty(exports, "TemplateMarkToTypeScriptCompiler", { enumerable: true, get: function () { return TemplateMarkToTypeScriptCompiler_1.TemplateMarkToTypeScriptCompiler; } });
-//# sourceMappingURL=index.js.map
+'use strict';
+
+var jp = require('jsonpath');
+var traverse = require('traverse');
+var concertoCore = require('@accordproject/concerto-core');
+var dayjs = require('dayjs');
+var utc = require('dayjs/plugin/utc');
+var markdownCommon = require('@accordproject/markdown-common');
+var markdownTemplate = require('@accordproject/markdown-template');
+var vfs = require('@typescript/vfs');
+var twoslash = require('@typescript/twoslash');
+var concertoCodegen = require('@accordproject/concerto-codegen');
+var concertoUtil = require('@accordproject/concerto-util');
+var lzstring = require('lz-string');
+var fs = require('fs');
+var tar = require('tar');
+var stream = require('stream');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var lzstring__namespace = /*#__PURE__*/_interopNamespaceDefault(lzstring);
+var tar__namespace = /*#__PURE__*/_interopNamespaceDefault(tar);
+
+function booleanDrafter(value) {
+  if (value) {
+    return "true";
+  } else {
+    return "false";
+  }
+}
+
+dayjs.extend(utc);
+function dateTimeDrafter(value, format) {
+  const f = format ? format : "MM/DD/YYYY";
+  return dayjs.utc(value).format(f);
+}
+
+function draftDoubleIEEE(value) {
+  if (Math.floor(value) === value) {
+    return new Number(value).toFixed(1);
+  } else {
+    return "" + value;
+  }
+}
+function draftDoubleFormat(value, format) {
+  return format.replace(/0(.)0((.)(0+))?/gi, function(_a, sep1, _b, sep2, digits) {
+    const len = digits ? digits.length : 0;
+    const vs = value.toFixed(len);
+    let res = "";
+    if (sep2) {
+      const d = vs.substring(vs.length - len);
+      res += sep2 + d;
+    }
+    let i = vs.substring(0, vs.length - (len === 0 ? 0 : len + 1));
+    while (i.length > 3) {
+      res = sep1 + i.substring(i.length - 3) + res;
+      i = i.substring(0, i.length - 3);
+    }
+    return i + res;
+  });
+}
+
+function doubleDrafter(value, format) {
+  if (format) {
+    return draftDoubleFormat(value, format);
+  } else {
+    return draftDoubleIEEE(value);
+  }
+}
+
+function draftInteger(value) {
+  return "" + value;
+}
+function draftIntegerFormat(value, format) {
+  return format.replace(/0(.)0/gi, function(_a, sep1) {
+    const vs = value.toFixed(0);
+    let res = "";
+    let i = vs.substring(0, vs.length);
+    while (i.length > 3) {
+      res = sep1 + i.substring(i.length - 3) + res;
+      i = i.substring(0, i.length - 3);
+    }
+    return i + res;
+  });
+}
+
+function integerDrafter(value, format) {
+  if (format) {
+    return draftIntegerFormat(value, format);
+  } else {
+    return draftInteger(value);
+  }
+}
+
+function longDrafter(value, format) {
+  if (format) {
+    return draftIntegerFormat(value, format);
+  } else {
+    return draftInteger(value);
+  }
+}
+
+var CurrencyCode = /* @__PURE__ */ ((CurrencyCode2) => {
+  CurrencyCode2["USD"] = "$";
+  CurrencyCode2["EUR"] = "\u20AC";
+  CurrencyCode2["JPY"] = "\xA5";
+  CurrencyCode2["GBP"] = "\xA3";
+  CurrencyCode2["AUD"] = "A$";
+  CurrencyCode2["CAD"] = "C$";
+  CurrencyCode2["CHF"] = "CHF";
+  CurrencyCode2["CNY"] = "\u5143";
+  CurrencyCode2["HKD"] = "HK$";
+  CurrencyCode2["NZD"] = "NZ$";
+  CurrencyCode2["KRW"] = "\u20A9";
+  CurrencyCode2["SGD"] = "S$";
+  CurrencyCode2["MXN"] = "MEX$";
+  CurrencyCode2["INR"] = "\u20B9";
+  CurrencyCode2["RUB"] = "\u20BD";
+  CurrencyCode2["ZAR"] = "R";
+  CurrencyCode2["TRY"] = "\u20BA";
+  CurrencyCode2["BRL"] = "R$";
+  CurrencyCode2["TWD"] = "NT$";
+  CurrencyCode2["PLN"] = "z\u0142";
+  CurrencyCode2["THB"] = "\u0E3F";
+  CurrencyCode2["IDR"] = "Rp";
+  CurrencyCode2["HUF"] = "Ft";
+  CurrencyCode2["CZK"] = "K\u010D";
+  CurrencyCode2["ILS"] = "\u20AA";
+  CurrencyCode2["CLP"] = "CLP$";
+  CurrencyCode2["PHP"] = "\u20B1";
+  CurrencyCode2["AED"] = "\u062F.\u0625";
+  CurrencyCode2["COP"] = "COL$";
+  CurrencyCode2["SAR"] = "\uFDFC";
+  CurrencyCode2["MYR"] = "RM";
+  CurrencyCode2["RON"] = "L";
+  CurrencyCode2["BGN"] = "\u043B\u0432.";
+  return CurrencyCode2;
+})(CurrencyCode || {});
+
+function monetaryAmountDefaultDrafter(value) {
+  return "" + draftDoubleIEEE(value.doubleValue) + " " + value.currencyCode;
+}
+function codeSymbol(c) {
+  const index = Object.keys(CurrencyCode).indexOf(c);
+  if (index >= 0) {
+    return Object.values(CurrencyCode)[index];
+  } else {
+    return c;
+  }
+}
+function monetaryAmountFormatDrafter(value, format) {
+  return draftDoubleFormat(
+    value.doubleValue,
+    format.replace(/K/gi, codeSymbol(value.currencyCode)).replace(/CCC/gi, value.currencyCode)
+  );
+}
+function monetaryAmountDrafter(value, format) {
+  if (format) {
+    return monetaryAmountFormatDrafter(value, format);
+  } else {
+    return monetaryAmountDefaultDrafter(value);
+  }
+}
+
+function stringDrafter(value) {
+  return value;
+}
+
+function getDrafter(typeName) {
+  switch (typeName) {
+    case "Boolean":
+      return booleanDrafter;
+    case "DateTime":
+      return dateTimeDrafter;
+    case "Double":
+      return doubleDrafter;
+    case "Integer":
+      return integerDrafter;
+    case "Long":
+      return longDrafter;
+    case "org.accordproject.money@0.3.0.MonetaryAmount":
+      return monetaryAmountDrafter;
+    case "String":
+      return stringDrafter;
+    default:
+      return null;
+  }
+}
+
+const TEMPLATEMARK_RE = /^(org\.accordproject\.templatemark)@(.+)\.(\w+)Definition$/;
+const FORMULA_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.FormulaDefinition$/;
+const VARIABLE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.VariableDefinition$/;
+const CONDITIONAL_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ConditionalDefinition$/;
+const ENUM_VARIABLE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.EnumVariableDefinition$/;
+const FORMATTED_VARIABLE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.FormattedVariableDefinition$/;
+const WITH_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.WithDefinition$/;
+const LISTBLOCK_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ListBlockDefinition$/;
+const JOIN_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.JoinDefinition$/;
+const OPTIONAL_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.OptionalDefinition$/;
+const CLAUSE_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ClauseDefinition$/;
+const CONTRACT_DEFINITION_RE = /^(org\.accordproject\.templatemark)@(.+)\.ContractDefinition$/;
+const NAVIGATION_NODES = [
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.ListBlockDefinition`,
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.WithDefinition`,
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.JoinDefinition`,
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.OptionalDefinition`,
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.ClauseDefinition`
+];
+function getTemplateClassDeclaration(modelManager, templateConceptFqn) {
+  const introspector = new concertoCore.Introspector(modelManager);
+  try {
+    return markdownTemplate.templatemarkutil.findTemplateConcept(introspector, "clause", templateConceptFqn);
+  } catch (err) {
+    console.log(err);
+    throw err;
+  }
+}
+
+class TypeScriptCompilationContext {
+  modelManager;
+  templateClass;
+  constructor(modelManager, templateConceptFqn) {
+    this.modelManager = modelManager;
+    this.templateClass = getTemplateClassDeclaration(this.modelManager, templateConceptFqn);
+  }
+  getTypeScriptFiles() {
+    const result = {};
+    const visitor = new concertoCodegen.CodeGen.TypescriptVisitor();
+    const writer = new concertoUtil.InMemoryWriter();
+    const params = {
+      fileWriter: writer
+    };
+    this.modelManager.accept(visitor, params);
+    writer.getFilesInMemory().forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  getCompilationContext() {
+    const files = this.getTypeScriptFiles();
+    let result = "";
+    Object.keys(files).forEach((key) => {
+      const content = files[key];
+      result += `
+// @filename: ${key}
+${content}
+`;
+    });
+    result += `
+// @filename: code.ts
+import * as TemplateModel from './${this.templateClass.getNamespace()}';
+import dayjs from 'dayjs';
+import jp from 'jsonpath';
+
+type GenerationOptions = {
+    now?:string,
+    locale?:string
+}
+`;
+    return result;
+  }
+}
+
+const DAYJS_BASE64 = "/// <reference path="./locale/index.d.ts" />

export = dayjs;

declare function dayjs (date?: dayjs.ConfigType): dayjs.Dayjs

declare function dayjs (date?: dayjs.ConfigType, format?: dayjs.OptionType, strict?: boolean): dayjs.Dayjs

declare function dayjs (date?: dayjs.ConfigType, format?: dayjs.OptionType, locale?: string, strict?: boolean): dayjs.Dayjs

declare namespace dayjs {
  interface ConfigTypeMap {
    default: string | number | Date | Dayjs | null | undefined
  }

  export type ConfigType = ConfigTypeMap[keyof ConfigTypeMap]

  export interface FormatObject { locale?: string, format?: string, utc?: boolean }

  export type OptionType = FormatObject | string | string[]

  export type UnitTypeShort = 'd' | 'D' | 'M' | 'y' | 'h' | 'm' | 's' | 'ms'

  export type UnitTypeLong = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year' | 'date'

  export type UnitTypeLongPlural = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'months' | 'years' | 'dates'
  
  export type UnitType = UnitTypeLong | UnitTypeLongPlural | UnitTypeShort;

  export type OpUnitType = UnitType | "week" | "weeks" | 'w';
  export type QUnitType = UnitType | "quarter" | "quarters" | 'Q';
  export type ManipulateType = Exclude<OpUnitType, 'date' | 'dates'>;
  class Dayjs {
    constructor (config?: ConfigType)
    /**
     * All Day.js objects are immutable. Still, `dayjs#clone` can create a clone of the current object if you need one.
     * ```
     * dayjs().clone()// => Dayjs
     * dayjs(dayjs('2019-01-25')) // passing a Dayjs object to a constructor will also clone it
     * ```
     * Docs: https://day.js.org/docs/en/parse/dayjs-clone
     */
    clone(): Dayjs
    /**
     * This returns a `boolean` indicating whether the Day.js object contains a valid date or not.
     * ```
     * dayjs().isValid()// => boolean
     * ```
     * Docs: https://day.js.org/docs/en/parse/is-valid
     */
    isValid(): boolean
    /**
     * Get the year.
     * ```
     * dayjs().year()// => 2020
     * ```
     * Docs: https://day.js.org/docs/en/get-set/year
     */
    year(): number
    /**
     * Set the year.
     * ```
     * dayjs().year(2000)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/year
     */
    year(value: number): Dayjs
    /**
     * Get the month.
     *
     * Months are zero indexed, so January is month 0.
     * ```
     * dayjs().month()// => 0-11
     * ```
     * Docs: https://day.js.org/docs/en/get-set/month
     */
    month(): number
    /**
     * Set the month.
     *
     * Months are zero indexed, so January is month 0.
     *
     * Accepts numbers from 0 to 11. If the range is exceeded, it will bubble up to the next year.
     * ```
     * dayjs().month(0)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/month
     */
    month(value: number): Dayjs
    /**
     * Get the date of the month.
     * ```
     * dayjs().date()// => 1-31
     * ```
     * Docs: https://day.js.org/docs/en/get-set/date
     */
    date(): number
    /**
     * Set the date of the month.
     *
     * Accepts numbers from 1 to 31. If the range is exceeded, it will bubble up to the next months.
     * ```
     * dayjs().date(1)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/date
     */
    date(value: number): Dayjs
    /**
     * Get the day of the week.
     *
     * Returns numbers from 0 (Sunday) to 6 (Saturday).
     * ```
     * dayjs().day()// 0-6
     * ```
     * Docs: https://day.js.org/docs/en/get-set/day
     */
    day(): number
    /**
     * Set the day of the week.
     *
     * Accepts numbers from 0 (Sunday) to 6 (Saturday). If the range is exceeded, it will bubble up to next weeks.
     * ```
     * dayjs().day(0)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/day
     */
    day(value: number): Dayjs
    /**
     * Get the hour.
     * ```
     * dayjs().hour()// => 0-23
     * ```
     * Docs: https://day.js.org/docs/en/get-set/hour
     */
    hour(): number
    /**
     * Set the hour.
     *
     * Accepts numbers from 0 to 23. If the range is exceeded, it will bubble up to the next day.
     * ```
     * dayjs().hour(12)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/hour
     */
    hour(value: number): Dayjs
    /**
     * Get the minutes.
     * ```
     * dayjs().minute()// => 0-59
     * ```
     * Docs: https://day.js.org/docs/en/get-set/minute
     */
    minute(): number
    /**
     * Set the minutes.
     *
     * Accepts numbers from 0 to 59. If the range is exceeded, it will bubble up to the next hour.
     * ```
     * dayjs().minute(59)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/minute
     */
    minute(value: number): Dayjs
    /**
     * Get the seconds.
     * ```
     * dayjs().second()// => 0-59
     * ```
     * Docs: https://day.js.org/docs/en/get-set/second
     */
    second(): number
    /**
     * Set the seconds.
     *
     * Accepts numbers from 0 to 59. If the range is exceeded, it will bubble up to the next minutes.
     * ```
     * dayjs().second(1)// Dayjs
     * ```
     */
    second(value: number): Dayjs
    /**
     * Get the milliseconds.
     * ```
     * dayjs().millisecond()// => 0-999
     * ```
     * Docs: https://day.js.org/docs/en/get-set/millisecond
     */
    millisecond(): number
    /**
     * Set the milliseconds.
     *
     * Accepts numbers from 0 to 999. If the range is exceeded, it will bubble up to the next seconds.
     * ```
     * dayjs().millisecond(1)// => Dayjs
     * ```
     * Docs: https://day.js.org/docs/en/get-set/millisecond
     */
    millisecond(value: number): Dayjs
    /**
     * Generic setter, accepting unit as first argument, and value as second, returns a new instance with the applied changes.
     *
     * In general:
     * ```
     * dayjs().set(unit, value) === dayjs()[unit](value)
     * ```
     * Units are case insensitive, and support plural and short forms.
     * ```
     * dayjs().set('date', 1)
     * dayjs().set('month', 3) // April
     * dayjs().set('second', 30)
     * ```
     * Docs: https://day.js.org/docs/en/get-set/set
     */
    set(unit: UnitType, value: number): Dayjs
    /**
     * String getter, returns the corresponding information getting from Day.js object.
     *
     * In general:
     * ```
     * dayjs().get(unit) === dayjs()[unit]()
     * ```
     * Units are case insensitive, and support plural and short forms.
     * ```
     * dayjs().get('year')
     * dayjs().get('month') // start 0
     * dayjs().get('date')
     * ```
     * Docs: https://day.js.org/docs/en/get-set/get
     */
    get(unit: UnitType): number
    /**
     * Returns a cloned Day.js object with a specified amount of time added.
     * ```
     * dayjs().add(7, 'day')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/add
     */
    add(value: number, unit?: ManipulateType): Dayjs
    /**
     * Returns a cloned Day.js object with a specified amount of time subtracted.
     * ```
     * dayjs().subtract(7, 'year')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/subtract
     */
    subtract(value: number, unit?: ManipulateType): Dayjs
    /**
     * Returns a cloned Day.js object and set it to the start of a unit of time.
     * ```
     * dayjs().startOf('year')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/start-of
     */
    startOf(unit: OpUnitType): Dayjs
    /**
     * Returns a cloned Day.js object and set it to the end of a unit of time.
     * ```
     * dayjs().endOf('month')// => Dayjs
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/manipulate/end-of
     */
    endOf(unit: OpUnitType): Dayjs
    /**
     * Get the formatted date according to the string of tokens passed in.
     *
     * To escape characters, wrap them in square brackets (e.g. [MM]).
     * ```
     * dayjs().format()// => current date in ISO8601, without fraction seconds e.g. '2020-04-02T08:02:17-05:00'
     * dayjs('2019-01-25').format('[YYYYescape] YYYY-MM-DDTHH:mm:ssZ[Z]')// 'YYYYescape 2019-01-25T00:00:00-02:00Z'
     * dayjs('2019-01-25').format('DD/MM/YYYY') // '25/01/2019'
     * ```
     * Docs: https://day.js.org/docs/en/display/format
     */
    format(template?: string): string
    /**
     * This indicates the difference between two date-time in the specified unit.
     *
     * To get the difference in milliseconds, use `dayjs#diff`
     * ```
     * const date1 = dayjs('2019-01-25')
     * const date2 = dayjs('2018-06-05')
     * date1.diff(date2) // 20214000000 default milliseconds
     * date1.diff() // milliseconds to current time
     * ```
     *
     * To get the difference in another unit of measurement, pass that measurement as the second argument.
     * ```
     * const date1 = dayjs('2019-01-25')
     * date1.diff('2018-06-05', 'month') // 7
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/display/difference
     */
    diff(date?: ConfigType, unit?: QUnitType | OpUnitType, float?: boolean): number
    /**
     * This returns the number of **milliseconds** since the Unix Epoch of the Day.js object.
     * ```
     * dayjs('2019-01-25').valueOf() // 1548381600000
     * +dayjs(1548381600000) // 1548381600000
     * ```
     * To get a Unix timestamp (the number of seconds since the epoch) from a Day.js object, you should use Unix Timestamp `dayjs#unix()`.
     *
     * Docs: https://day.js.org/docs/en/display/unix-timestamp-milliseconds
     */
    valueOf(): number
    /**
     * This returns the Unix timestamp (the number of **seconds** since the Unix Epoch) of the Day.js object.
     * ```
     * dayjs('2019-01-25').unix() // 1548381600
     * ```
     * This value is floored to the nearest second, and does not include a milliseconds component.
     *
     * Docs: https://day.js.org/docs/en/display/unix-timestamp
     */
    unix(): number
    /**
     * Get the number of days in the current month.
     * ```
     * dayjs('2019-01-25').daysInMonth() // 31
     * ```
     * Docs: https://day.js.org/docs/en/display/days-in-month
     */
    daysInMonth(): number
    /**
     * To get a copy of the native `Date` object parsed from the Day.js object use `dayjs#toDate`.
     * ```
     * dayjs('2019-01-25').toDate()// => Date
     * ```
     */
    toDate(): Date
    /**
     * To serialize as an ISO 8601 string.
     * ```
     * dayjs('2019-01-25').toJSON() // '2019-01-25T02:00:00.000Z'
     * ```
     * Docs: https://day.js.org/docs/en/display/as-json
     */
    toJSON(): string
    /**
     * To format as an ISO 8601 string.
     * ```
     * dayjs('2019-01-25').toISOString() // '2019-01-25T02:00:00.000Z'
     * ```
     * Docs: https://day.js.org/docs/en/display/as-iso-string
     */
    toISOString(): string
    /**
     * Returns a string representation of the date.
     * ```
     * dayjs('2019-01-25').toString() // 'Fri, 25 Jan 2019 02:00:00 GMT'
     * ```
     * Docs: https://day.js.org/docs/en/display/as-string
     */
    toString(): string
    /**
     * Get the UTC offset in minutes.
     * ```
     * dayjs().utcOffset()
     * ```
     * Docs: https://day.js.org/docs/en/manipulate/utc-offset
     */
    utcOffset(): number
    /**
     * This indicates whether the Day.js object is before the other supplied date-time.
     * ```
     * dayjs().isBefore(dayjs('2011-01-01')) // default milliseconds
     * ```
     * If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.
     * ```
     * dayjs().isBefore('2011-01-01', 'year')// => boolean
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/query/is-before
     */
    isBefore(date: ConfigType, unit?: OpUnitType): boolean
    /**
     * This indicates whether the Day.js object is the same as the other supplied date-time.
     * ```
     * dayjs().isSame(dayjs('2011-01-01')) // default milliseconds
     * ```
     * If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.
     * ```
     * dayjs().isSame('2011-01-01', 'year')// => boolean
     * ```
     * Docs: https://day.js.org/docs/en/query/is-same
     */
    isSame(date: ConfigType, unit?: OpUnitType): boolean
    /**
     * This indicates whether the Day.js object is after the other supplied date-time.
     * ```
     * dayjs().isAfter(dayjs('2011-01-01')) // default milliseconds
     * ```
     * If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.
     * ```
     * dayjs().isAfter('2011-01-01', 'year')// => boolean
     * ```
     * Units are case insensitive, and support plural and short forms.
     *
     * Docs: https://day.js.org/docs/en/query/is-after
     */
    isAfter(date: ConfigType, unit?: OpUnitType): boolean

    locale(): string

    locale(preset: string | ILocale, object?: Partial<ILocale>): Dayjs
  }

  export type PluginFunc<T = unknown> = (option: T, c: typeof Dayjs, d: typeof dayjs) => void

  export function extend<T = unknown>(plugin: PluginFunc<T>, option?: T): Dayjs

  export function locale(preset?: string | ILocale, object?: Partial<ILocale>, isLocal?: boolean): string

  export function isDayjs(d: any): d is Dayjs

  export function unix(t: number): Dayjs

  const Ls : { [key: string] :  ILocale }
}
";
+const JSONPATH_BASE64 = "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";
+
+class TypeScriptToJavaScriptCompiler {
+  context;
+  fsMap;
+  ts;
+  constructor(modelManager, templateConceptFqn) {
+    this.context = new TypeScriptCompilationContext(modelManager, templateConceptFqn).getCompilationContext();
+  }
+  async initialize() {
+    if (typeof window === "undefined") {
+      this.ts = await import('typescript');
+      this.fsMap = vfs.createDefaultMapFromNodeModules({
+        target: this.ts.ScriptTarget.ES2020
+      });
+    } else {
+      this.ts = (await import('https://cdn.jsdelivr.net/npm/typescript@4.8.4/+esm')).default;
+      if (!this.ts) {
+        throw new Error("Failed to dynamically load typescript");
+      }
+      this.fsMap = await vfs.createDefaultMapFromCDN({ target: this.ts.ScriptTarget.ES2020 }, this.ts.version, false, this.ts);
+    }
+    this.fsMap.set("/node_modules/@types/dayjs/index.d.ts", Buffer.from(DAYJS_BASE64, "base64").toString());
+    this.fsMap.set("/node_modules/@types/jsonpath/index.d.ts", Buffer.from(JSONPATH_BASE64, "base64").toString());
+  }
+  compile(typescript) {
+    if (!this.fsMap) {
+      throw new Error("initialize must be awaited before compile is called.");
+    }
+    const twoSlashCode = `
+${this.context}
+${typescript}
+`;
+    const options = {
+      fsMap: this.fsMap,
+      tsModule: this.ts,
+      lzstringModule: lzstring__namespace,
+      defaultOptions: {
+        showEmit: true,
+        noErrorValidation: true,
+        showEmittedFile: "code.js"
+      }
+    };
+    const result = twoslash.twoslasher(twoSlashCode, "ts", options);
+    return result;
+  }
+}
+
+var CodeType = /* @__PURE__ */ ((CodeType2) => {
+  CodeType2["TYPESCRIPT"] = "TYPESCRIPT";
+  CodeType2["ES_2020"] = "ES_2020";
+  return CodeType2;
+})(CodeType || {});
+
+function ensureDirSync(path) {
+  !fs.existsSync(path) && fs.mkdirSync(path, { recursive: true });
+}
+function writeFunctionToString(templateClass, functionName, returnType, code) {
+  let result = "";
+  result += "/// ---cut---\n";
+  result += `export function ${functionName}(data:TemplateModel.I${templateClass.getName()}, library:any, options:GenerationOptions) : ${returnType} {
+`;
+  result += "   const now = dayjs(options?.now);\n";
+  result += "   const locale = options?.locale;\n";
+  templateClass.getProperties().forEach((p) => {
+    result += `   const ${p.getName()} = data.${p.getName()};
+`;
+  });
+  result += "   " + code.trim() + "\n";
+  result += "}\n";
+  result += "\n";
+  return result;
+}
+function nameUserCode(templateMarkDom) {
+  return traverse(templateMarkDom).map(function(x) {
+    if (x && (x.$class === `${markdownCommon.TemplateMarkModel.NAMESPACE}.ConditionalDefinition` && x.condition || `${markdownCommon.TemplateMarkModel.NAMESPACE}.ClauseDefinition` && x.condition)) {
+      x.functionName = `condition_${this.path.join("_")}`;
+    }
+    this.update(x);
+  });
+}
+
+const CODE_NODES = [
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.FormulaDefinition`,
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.ConditionalDefinition`,
+  `${markdownCommon.TemplateMarkModel.NAMESPACE}.ClauseDefinition`
+];
+function checkCode$1(code) {
+  if (code.type !== CodeType.TYPESCRIPT) {
+    throw new Error(`Cannot compile ${code.contents} as it is not Typescript.`);
+  }
+}
+class TemplateMarkToJavaScriptCompiler {
+  modelManager;
+  compiler;
+  templateClass;
+  constructor(modelManager, templateConceptFqn) {
+    this.modelManager = modelManager;
+    this.compiler = new TypeScriptToJavaScriptCompiler(modelManager, templateConceptFqn);
+    this.templateClass = getTemplateClassDeclaration(modelManager, templateConceptFqn);
+  }
+  async initialize() {
+    await this.compiler.initialize();
+  }
+  compile(templateJson) {
+    const namedTemplateMark = nameUserCode(templateJson);
+    const that = this;
+    const errors = Array();
+    const compiled = traverse(namedTemplateMark).map(function(x) {
+      if (x && CODE_NODES.includes(x.$class)) {
+        if (x.code) {
+          checkCode$1(x.code);
+          const result = that.compiler.compile(writeFunctionToString(that.templateClass, x.name, "any", x.code.contents));
+          if (result.errors.length === 0) {
+            x.code.contents = result.code;
+            x.code.type = CodeType.ES_2020;
+            this.update(x);
+          } else {
+            errors.push({
+              nodeId: x.name,
+              code: x.code.contents,
+              errors: result.errors
+            });
+          }
+        } else if (x.condition) {
+          checkCode$1(x.condition);
+          const result = that.compiler.compile(writeFunctionToString(that.templateClass, x.functionName, "boolean", x.condition.contents));
+          if (result.errors.length === 0) {
+            x.condition.contents = result.code;
+            x.condition.type = CodeType.ES_2020;
+            this.update(x);
+          } else {
+            errors.push({
+              nodeId: x.functionName,
+              code: x.condition.contents,
+              errors: result.errors
+            });
+          }
+        }
+      }
+    });
+    if (errors.length === 0) {
+      return compiled;
+    } else {
+      throw errors;
+    }
+  }
+}
+
+function joinList(data, joinDef, options) {
+  if (joinDef.separator) {
+    return data.join(joinDef.separator);
+  } else {
+    const formatter = new Intl.ListFormat(
+      joinDef.locale ? joinDef.locale : options?.locale,
+      {
+        style: joinDef.style,
+        type: joinDef.type
+      }
+    );
+    return formatter.format(data);
+  }
+}
+
+function checkCode(code) {
+  if (code.type !== CodeType.ES_2020) {
+    throw new Error(`Cannot run ${code.contents} as it is not ES_2020 JavaScript.`);
+  }
+}
+function evaluateJavaScript(clauseLibrary, data, fn, options) {
+  if (!data || !fn) {
+    throw new Error(`Cannot evaluate JS ${fn} against ${data}`);
+  }
+  const functionArgNames = new Array();
+  functionArgNames.push("data");
+  functionArgNames.push("library");
+  functionArgNames.push("options");
+  functionArgNames.push("dayjs");
+  functionArgNames.push("jp");
+  const functionArgValues = new Array();
+  functionArgValues.push(data);
+  functionArgValues.push(clauseLibrary);
+  functionArgValues.push(options);
+  functionArgValues.push(dayjs);
+  functionArgValues.push(jp);
+  const expression = fn.substring(fn.indexOf("{") + 1, fn.lastIndexOf("}"));
+  if (expression.trim().length === 0) {
+    throw new Error("Empty expression");
+  }
+  try {
+    const fun = new Function(...functionArgNames, expression);
+    const result = fun(...functionArgValues);
+    return result;
+  } catch (err) {
+    throw new Error(`Caught error ${err} evaluating ${expression} with arguments ${functionArgValues}`);
+  }
+}
+function getJsonPath(rootData, currentNode, paths) {
+  if (!currentNode) {
+    throw new Error("Node must be supplied");
+  }
+  if (!currentNode.name) {
+    throw new Error(`Node must have a name: ${JSON.stringify(currentNode)}`);
+  }
+  if (currentNode.name.indexOf(".") >= 0) {
+    throw new Error(`Invalid name property ${currentNode.name}`);
+  }
+  if (!paths || !paths.length || paths.length < 1) {
+    throw new Error("Paths must be supplied");
+  }
+  const withPath = [];
+  for (let n = 1; n < paths.length; n++) {
+    const sub = paths.slice(0, n);
+    const obj = traverse.get(rootData, sub);
+    if (obj && obj.$class) {
+      if (NAVIGATION_NODES.indexOf(obj.$class) >= 0) {
+        withPath.push(`['${obj.name}']`);
+      }
+    }
+  }
+  if (currentNode.name !== "this") {
+    withPath.push(`['${currentNode.name}']`);
+  }
+  return withPath.length > 0 ? `$${withPath.join("")}` : "$";
+}
+function generateAgreement(modelManager, clauseLibrary, templateMark, data, options) {
+  const introspector = new concertoCore.Introspector(modelManager);
+  return traverse(templateMark).map(function(context) {
+    let stopHere = false;
+    if (typeof context === "object" && context.$class && typeof context.$class === "string") {
+      const nodeClass = context.$class;
+      const match = nodeClass.match(TEMPLATEMARK_RE);
+      if (match && match.length > 1) {
+        context.$class = `${markdownCommon.CiceroMarkModel.NAMESPACE}.${match[3]}`;
+      }
+      if (CONTRACT_DEFINITION_RE.test(nodeClass)) {
+        context.$class = `${markdownCommon.CommonMarkModel.NAMESPACE}.Paragraph`;
+        delete context.name;
+        delete context.elementType;
+      }
+      if (WITH_DEFINITION_RE.test(nodeClass)) {
+        context.$class = `${markdownCommon.CommonMarkModel.NAMESPACE}.Paragraph`;
+        delete context.name;
+        delete context.elementType;
+      } else if (FORMULA_DEFINITION_RE.test(nodeClass)) {
+        if (context.code) {
+          checkCode(context.code);
+          const result = evaluateJavaScript(clauseLibrary, data, context.code.contents, options);
+          if (result === null) {
+            context.value = "<null>";
+          } else if (typeof result === "string") {
+            context.value = result;
+          } else {
+            context.value = JSON.stringify(result);
+          }
+          delete context.code;
+        } else {
+          throw new Error("Formula node is missing code.");
+        }
+      } else if (LISTBLOCK_DEFINITION_RE.test(nodeClass)) {
+        const path = getJsonPath(templateMark, context, this.path);
+        const variableValues = jp.query(data, path, 1);
+        if (variableValues.length === 0) {
+          throw new Error(`No values found for path '${path}' in data ${data}.`);
+        } else {
+          const arrayData = variableValues[0];
+          if (!Array.isArray(arrayData)) {
+            throw new Error(`Values found for path '${path}' in data ${data} is not an array: ${arrayData}.`);
+          } else {
+            context.$class = `${markdownCommon.CommonMarkModel.NAMESPACE}.List`;
+            delete context.elementType;
+            delete context.name;
+            context.nodes = arrayData.map((arrayItem) => {
+              const subResult = generateAgreement(modelManager, clauseLibrary, context.nodes[0].nodes[0], arrayItem);
+              return {
+                $class: `${markdownCommon.CommonMarkModel.NAMESPACE}.Item`,
+                nodes: subResult.nodes ? subResult.nodes : []
+              };
+            });
+            stopHere = true;
+          }
+        }
+      } else if (JOIN_DEFINITION_RE.test(nodeClass)) {
+        const path = getJsonPath(templateMark, context, this.path);
+        const variableValues = jp.query(data, path, 1);
+        if (variableValues.length === 0) {
+          throw new Error(`No values found for path '${path}' in data ${data}.`);
+        } else {
+          const arrayData = variableValues[0];
+          if (!Array.isArray(arrayData)) {
+            throw new Error(`Values found for path '${path}' in data ${data} is not an array: ${arrayData}.`);
+          } else {
+            context.$class = `${markdownCommon.CommonMarkModel.NAMESPACE}.Text`;
+            const drafter = getDrafter(context.elementType);
+            context.text = joinList(arrayData.map((arrayItem) => {
+              return drafter ? drafter(arrayItem, context.format) : arrayItem;
+            }), context, options);
+            delete context.elementType;
+            delete context.name;
+            delete context.separator;
+            delete context.locale;
+            delete context.type;
+            delete context.style;
+            delete context.nodes;
+            stopHere = true;
+          }
+        }
+      } else if (VARIABLE_DEFINITION_RE.test(nodeClass) || ENUM_VARIABLE_DEFINITION_RE.test(nodeClass) || FORMATTED_VARIABLE_DEFINITION_RE.test(nodeClass)) {
+        if (typeof data === "object") {
+          const path = getJsonPath(templateMark, context, this.path);
+          const variableValues = jp.query(data, path, 1);
+          if (variableValues.length === 0) {
+            throw new Error(`No values found for path '${path}' in data ${data}.`);
+          } else {
+            const variableValue = variableValues[0];
+            const type = concertoCore.ModelUtil.isPrimitiveType(context.elementType) ? null : introspector.getClassDeclaration(context.elementType);
+            const drafter = getDrafter(type && type.isEnum() ? "String" : context.elementType);
+            context.value = drafter ? drafter(variableValue, context.format) : JSON.stringify(variableValue);
+          }
+        } else {
+          const variableValue = data;
+          const type = concertoCore.ModelUtil.isPrimitiveType(context.elementType) ? null : introspector.getClassDeclaration(context.elementType);
+          const drafter = getDrafter(type && type.isEnum() ? "String" : context.elementType);
+          context.value = drafter ? drafter(variableValue, context.format) : JSON.stringify(variableValue);
+        }
+      } else if (CONDITIONAL_DEFINITION_RE.test(nodeClass)) {
+        if (context.condition) {
+          checkCode(context.condition);
+          context.isTrue = !!evaluateJavaScript(clauseLibrary, data, context.condition.contents, options);
+        } else {
+          const path = getJsonPath(templateMark, context, this.path);
+          const variableValues = jp.query(data, path, 1);
+          if (variableValues && variableValues.length) {
+            if (variableValues.length === 1) {
+              context.isTrue = !!variableValues[0];
+            } else {
+              throw new Error(`Multiple values found for path '${path}' in data ${data}.`);
+            }
+          } else {
+            context.isTrue = false;
+          }
+        }
+        context.nodes = context.isTrue ? context.whenTrue : context.whenFalse;
+        delete context.condition;
+        delete context.dependencies;
+        delete context.functionName;
+      } else if (CLAUSE_DEFINITION_RE.test(nodeClass)) {
+        if (context.condition) {
+          checkCode(context.condition);
+          const result = !!evaluateJavaScript(clauseLibrary, data, context.condition.contents, options);
+          if (!result) {
+            delete context.nodes;
+            stopHere = true;
+          }
+        }
+        delete context.condition;
+        delete context.functionName;
+      } else if (OPTIONAL_DEFINITION_RE.test(nodeClass)) {
+        const path = getJsonPath(templateMark, context, this.path);
+        const variableValues = jp.query(data, path, 1);
+        if (variableValues && variableValues.length) {
+          if (variableValues.length === 1) {
+            context.hasSome = true;
+            context.whenNone = [];
+          } else {
+            throw new Error(`Multiple values found for path '${path}' in data ${data}.`);
+          }
+        } else {
+          context.hasSome = false;
+          context.whenSome = [];
+        }
+        context.nodes = context.hasSome ? context.whenSome : context.whenNone;
+      }
+    }
+    this.update(context, stopHere);
+  });
+}
+class TemplateMarkInterpreter {
+  modelManager;
+  templateClass;
+  clauseLibrary;
+  constructor(modelManager, clauseLibrary, templateConceptFqn) {
+    this.modelManager = modelManager;
+    this.clauseLibrary = clauseLibrary;
+    this.templateClass = getTemplateClassDeclaration(this.modelManager, templateConceptFqn);
+  }
+  /**
+   * Checks that a TemplateMark JSON document is valid with respect to the
+   * TemplateMark model, as well as the template model.
+   *
+   * Checks:
+   * 1. Variable names are valid properties in the template model
+   * 2. Optional properties have guards
+   * @param {*} templateMark the TemplateMark JSON object
+   * @returns {*} TemplateMark JSON that has been typed checked and has type metadata added
+   * @throws {Error} if the templateMark document is invalid
+   */
+  checkTypes(templateMark) {
+    const modelManager = new concertoCore.ModelManager({ strict: true });
+    modelManager.addCTOModel(markdownCommon.ConcertoMetaModel.MODEL, "concertometamodel.cto");
+    modelManager.addCTOModel(markdownCommon.CommonMarkModel.MODEL, "commonmark.cto");
+    modelManager.addCTOModel(markdownCommon.TemplateMarkModel.MODEL, "templatemark.cto");
+    const factory = new concertoCore.Factory(modelManager);
+    const serializer = new concertoCore.Serializer(factory, modelManager);
+    try {
+      serializer.fromJSON(templateMark);
+      return templateMark;
+    } catch (err) {
+      throw new Error(`Generated invalid agreement: ${err}: ${JSON.stringify(templateMark, null, 2)}`);
+    }
+  }
+  /**
+   * Compiles the code nodes containing TS to code nodes containing JS.
+   * @param {*} templateMark the TemplateMark JSON object
+   * @returns {*} TemplateMark JSON with JS nodes
+   * @throws {Error} if the templateMark document is invalid
+   */
+  async compileTypeScriptToJavaScript(templateMark) {
+    const templateConcept = templateMark.nodes[0].elementType;
+    if (!templateConcept) {
+      throw new Error("TemplateMark is not typed");
+    }
+    const compiler = new TemplateMarkToJavaScriptCompiler(this.modelManager, templateConcept);
+    await compiler.initialize();
+    return compiler.compile(templateMark);
+  }
+  validateCiceroMark(ciceroMark) {
+    const modelManager = new concertoCore.ModelManager({ strict: true });
+    modelManager.addCTOModel(markdownCommon.ConcertoMetaModel.MODEL, "concertometamodel.cto");
+    modelManager.addCTOModel(markdownCommon.CommonMarkModel.MODEL, "commonmark.cto");
+    modelManager.addCTOModel(markdownCommon.CiceroMarkModel.MODEL, "ciceromark.cto");
+    const factory = new concertoCore.Factory(modelManager);
+    const serializer = new concertoCore.Serializer(factory, modelManager);
+    try {
+      return serializer.fromJSON(ciceroMark);
+    } catch (err) {
+      throw new Error(`Generated invalid agreement: ${err}: ${JSON.stringify(ciceroMark, null, 2)}`);
+    }
+  }
+  async generate(templateMark, data, options) {
+    const factory = new concertoCore.Factory(this.modelManager);
+    const serializer = new concertoCore.Serializer(factory, this.modelManager);
+    const templateData = serializer.fromJSON(data);
+    if (templateData.getFullyQualifiedType() !== this.templateClass.getFullyQualifiedName()) {
+      throw new Error(`Template data must be of type '${this.templateClass.getFullyQualifiedName()}'.`);
+    }
+    const typedTemplateMark = this.checkTypes(templateMark);
+    const jsTemplateMark = await this.compileTypeScriptToJavaScript(typedTemplateMark);
+    const ciceroMark = generateAgreement(this.modelManager, this.clauseLibrary, jsTemplateMark, data, options);
+    return this.validateCiceroMark(ciceroMark);
+  }
+}
+
+function writeDebug(fw, level, concept) {
+  fw.writeLine(level, `// ${concertoCore.ModelUtil.getShortName(concept.$class)} ${concept.name ? `(${concept.name})` : ""}`);
+}
+const RUNTIME_DIR = "runtime";
+function writeImports(fw, level, templateClass) {
+  fw.writeLine(level, `import * as CommonMark from './${markdownCommon.CommonMarkModel.NAMESPACE}';`);
+  fw.writeLine(level, `import * as CiceroMark from './${markdownCommon.CiceroMarkModel.NAMESPACE}';`);
+  fw.writeLine(level, `import * as TemplateModel from './${templateClass.getNamespace()}';`);
+  fw.writeLine(level, "import * as UserCode from './usercode';");
+  fw.writeLine(level, `import { getDrafter as $getDrafter } from './${RUNTIME_DIR}/drafting';`);
+  fw.writeLine(level, `import * as Runtime from './${RUNTIME_DIR}/TypeScriptRuntime';`);
+}
+function writeProlog(fw, level, templateClass) {
+  fw.writeLine(level, `export function generator(data:TemplateModel.I${templateClass.getName()}, library:any, options:Runtime.GenerationOptions) : CommonMark.IDocument {`);
+  fw.writeLine(level, `const docNode = {$class: '${markdownCommon.CommonMarkModel.NAMESPACE}.Document', xmlns: '${markdownCommon.CommonMarkModel.NAMESPACE}', nodes: []} as CommonMark.INode;`);
+  fw.writeLine(level, "const $nodes:CommonMark.INode[] = [];");
+  fw.writeLine(level, "const $data:any[] = [];");
+  fw.writeLine(level, "let $result:any = docNode;");
+  fw.writeLine(level, "Runtime.push($data, data);");
+}
+function writeEpilog(fw, level) {
+  fw.writeLine(level, "return $result as CommonMark.IDocument;");
+  fw.writeLine(level, "}");
+}
+function writeOpenGenerateScope(fw, level) {
+  fw.writeLine(level, "$result = (() => {");
+}
+function writeCloseGenerateScope(fw, level) {
+  fw.writeLine(level, "})();");
+  fw.writeLine(level, "Runtime.addChild($nodes, $result);");
+}
+function writeOpenNodeScope(fw, level) {
+  fw.writeLine(level, "Runtime.push($nodes, $result);");
+}
+function writeCloseNodeScope(fw, level) {
+  fw.writeLine(level, "$result = Runtime.pop($nodes);");
+}
+function writeOpenDataScope(fw, level, name, allowUndefined = false) {
+  fw.writeLine(level, `Runtime.push($data, Runtime.peekProperty($data, '${name}', ${allowUndefined}));`);
+}
+function writeCloseDataScope(fw, level) {
+  fw.writeLine(level, "Runtime.pop($data);");
+}
+function getTypeScriptType(ctoFqn) {
+  const ns = concertoCore.ModelUtil.getNamespace(ctoFqn);
+  const type = concertoCore.ModelUtil.getShortName(ctoFqn);
+  if (ns === markdownCommon.CommonMarkModel.NAMESPACE) {
+    return `CommonMark.I${type}`;
+  } else if (ns === markdownCommon.CiceroMarkModel.NAMESPACE) {
+    return `CiceroMark.I${type}`;
+  } else if (ns === markdownCommon.TemplateMarkModel.NAMESPACE) {
+    return `CiceroMark.I${type.substring(0, type.length - "Definition".length)}`;
+  } else {
+    throw new Error(`No type mapping for ${ctoFqn}`);
+  }
+}
+function makeCiceroMark(templateMarkNode, deep = false) {
+  if (!templateMarkNode.$class) {
+    throw new Error("Not a concerto type.");
+  }
+  const json = JSON.parse(JSON.stringify(templateMarkNode));
+  delete json.elementType;
+  if (!deep) {
+    delete json.nodes;
+  } else {
+    if (json.nodes) {
+      json.nodes = json.nodes.map((n) => makeCiceroMark(n, deep));
+    }
+  }
+  const ns = concertoCore.ModelUtil.getNamespace(json.$class);
+  const type = concertoCore.ModelUtil.getShortName(json.$class);
+  if (ns === markdownCommon.TemplateMarkModel.NAMESPACE) {
+    json.$class = `${markdownCommon.CiceroMarkModel.NAMESPACE}.${type.substring(0, type.length - "Definition".length)}`;
+  }
+  return json;
+}
+class AbstractComplexCompiler {
+  leaf;
+  constructor(leaf) {
+    this.leaf = leaf;
+  }
+  isLeaf() {
+    return this.leaf;
+  }
+  enter(fw, level, templateMarkNode) {
+    writeDebug(fw, level, templateMarkNode);
+    writeOpenNodeScope(fw, level);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  exit(fw, level) {
+    writeCloseNodeScope(fw, level);
+  }
+}
+class AbstractSimpleCompiler extends AbstractComplexCompiler {
+  constructor(leaf) {
+    super(leaf);
+  }
+  generate(fw, level, templateMarkNode) {
+    const node = this.getNode(templateMarkNode);
+    if (this.isLeaf()) {
+      node.nodes = [];
+    }
+    writeOpenGenerateScope(fw, level);
+    fw.writeLine(level, `return ${JSON.stringify(node)} as ${getTypeScriptType(node.$class)};`);
+    writeCloseGenerateScope(fw, level);
+  }
+}
+class PassThrough extends AbstractSimpleCompiler {
+  constructor(leaf) {
+    super(leaf);
+  }
+  getNode(templateMarkNode) {
+    return makeCiceroMark(templateMarkNode);
+  }
+}
+class Ignore {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  enter(fw, level, templateMarkNode) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  generate(fw, level, templateMarkNode) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  exit(fw, level, templateMarkNode) {
+  }
+}
+
+class Clause extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.ClauseDefinition`;
+  constructor() {
+    super(false);
+  }
+  enter(fw, level, templateMarkNode) {
+    writeDebug(fw, level, templateMarkNode);
+    writeOpenNodeScope(fw, level);
+    writeOpenDataScope(fw, level, templateMarkNode.name);
+  }
+  generate(fw, level, templateMarkNode) {
+    const clone = makeCiceroMark(templateMarkNode);
+    delete clone.condition;
+    delete clone.functionName;
+    const para = { $class: `${markdownCommon.CommonMarkModel.NAMESPACE}.Paragraph` };
+    writeOpenGenerateScope(fw, level);
+    if (templateMarkNode.condition) {
+      fw.writeLine(level, `const isTrue:boolean = UserCode.${templateMarkNode.functionName}(data,library,options)`);
+    } else {
+      fw.writeLine(level, "const isTrue:boolean = true;");
+    }
+    fw.writeLine(level, "if(isTrue) {");
+    fw.writeLine(level, `return ${JSON.stringify(clone)} as ${getTypeScriptType(clone.$class)};`);
+    fw.writeLine(level, "}");
+    fw.writeLine(level, "else {");
+    fw.writeLine(level, `return ${JSON.stringify(para)} as ${getTypeScriptType(para.$class)};`);
+    fw.writeLine(level, "}");
+    writeCloseGenerateScope(fw, level);
+    delete templateMarkNode.condition;
+  }
+  exit(fw, level) {
+    writeCloseDataScope(fw, level);
+    writeCloseNodeScope(fw, level);
+  }
+}
+
+class Conditional extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.ConditionalDefinition`;
+  constructor() {
+    super(false);
+  }
+  generate(fw, level, templateMarkNode) {
+    const clone = makeCiceroMark(templateMarkNode, true);
+    delete clone.condition;
+    delete clone.dependencies;
+    delete clone.functionName;
+    clone.isTrue = true;
+    writeOpenGenerateScope(fw, level);
+    if (templateMarkNode.condition) {
+      fw.writeLine(level, `const isTrue:boolean = UserCode.${templateMarkNode.functionName}(data,library,options)`);
+    } else {
+      writeOpenDataScope(fw, level, templateMarkNode.name);
+      fw.writeLine(level, "const isTrue:boolean = Runtime.peek($data);");
+      writeCloseDataScope(fw, level);
+    }
+    fw.writeLine(level, `const curNode = ${JSON.stringify(clone)} as ${getTypeScriptType(templateMarkNode.$class)};`);
+    fw.writeLine(level, "(curNode as CiceroMark.IConditional).isTrue = isTrue;");
+    fw.writeLine(level, "return curNode;");
+    writeCloseGenerateScope(fw, level);
+    delete templateMarkNode.condition;
+    delete templateMarkNode.whenTrue;
+    delete templateMarkNode.whenFalse;
+  }
+}
+
+class ContractDefinition extends AbstractSimpleCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.ContractDefinition`;
+  constructor() {
+    super(false);
+  }
+  getNode(templateMarkNode) {
+    return {
+      $class: `${markdownCommon.CiceroMarkModel.NAMESPACE}.Contract`,
+      name: templateMarkNode.name,
+      nodes: []
+    };
+  }
+}
+
+class FormattedVariable extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.FormattedVariableDefinition`;
+  constructor() {
+    super(true);
+  }
+  generate(fw, level, templateMarkNode) {
+    const clone = makeCiceroMark(templateMarkNode);
+    writeOpenGenerateScope(fw, level);
+    if (templateMarkNode.name !== "this") {
+      writeOpenDataScope(fw, level, templateMarkNode.name);
+    }
+    fw.writeLine(level, `const drafter = $getDrafter('${templateMarkNode.elementType}');`);
+    fw.writeLine(level, `const text = drafter ? drafter(Runtime.peek($data), '${templateMarkNode.format}') : JSON.stringify(Runtime.peek($data)) as string;`);
+    if (templateMarkNode.name !== "this") {
+      writeCloseDataScope(fw, level);
+    }
+    fw.writeLine(level, `const variable:any = ${JSON.stringify(clone)};`);
+    fw.writeLine(level, "variable.value = text;");
+    fw.writeLine(level, `return variable as ${getTypeScriptType(clone.$class)};`);
+    writeCloseGenerateScope(fw, level);
+  }
+}
+
+class Formula extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.FormulaDefinition`;
+  constructor() {
+    super(true);
+  }
+  generate(fw, level, templateMarkNode) {
+    const clone = makeCiceroMark(templateMarkNode);
+    writeOpenGenerateScope(fw, level);
+    fw.writeLine(level, `const formulaResult = UserCode.${templateMarkNode.name}(data,library,options);`);
+    fw.writeLine(level, "const text = JSON.stringify(formulaResult);");
+    fw.writeLine(level, `const formula:any = ${JSON.stringify(clone)};`);
+    fw.writeLine(level, "formula.value = text;");
+    fw.writeLine(level, `formula.code = ${JSON.stringify(templateMarkNode.code.contents)};`);
+    fw.writeLine(level, `return formula as ${getTypeScriptType(clone.$class)};`);
+    writeCloseGenerateScope(fw, level);
+  }
+}
+
+class Join extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.JoinDefinition`;
+  constructor() {
+    super(true);
+  }
+  generate(fw, level, templateMarkNode) {
+    writeOpenGenerateScope(fw, level);
+    writeOpenDataScope(fw, level, templateMarkNode.name);
+    fw.writeLine(level, `const joinDef = ${JSON.stringify(templateMarkNode)};`);
+    fw.writeLine(level, "const text = Runtime.joinList(Runtime.peek($data), joinDef, options);");
+    writeCloseDataScope(fw, level);
+    fw.writeLine(level, `return { $class: '${markdownCommon.CommonMarkModel.NAMESPACE}.Text', text: text } as ${getTypeScriptType(markdownCommon.CommonMarkModel.NAMESPACE + ".Text")};`);
+    writeCloseGenerateScope(fw, level);
+    delete templateMarkNode.nodes;
+  }
+}
+
+class ListBlock extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.ListBlockDefinition`;
+  constructor() {
+    super(false);
+  }
+  enter(fw, level, templateMarkNode) {
+    writeDebug(fw, level, templateMarkNode);
+    writeOpenNodeScope(fw, level);
+    writeOpenDataScope(fw, level, templateMarkNode.name);
+  }
+  generate(fw, level, templateMarkNode, doIt) {
+    if (templateMarkNode?.nodes?.[0]) {
+      const clone = makeCiceroMark(templateMarkNode?.nodes?.[0]);
+      writeOpenGenerateScope(fw, level);
+      fw.writeLine(level, `const result = ${JSON.stringify(clone)} as ${getTypeScriptType(templateMarkNode.$class)};`);
+      fw.writeLine(level, "Runtime.peek($data).forEach( (item:any) => {");
+      fw.writeLine(level, "Runtime.push($data,item);");
+      if (templateMarkNode.nodes?.[0].nodes?.[0]) {
+        doIt(fw, level + 1, templateMarkNode.nodes[0].nodes[0]);
+        delete templateMarkNode.nodes;
+      }
+      fw.writeLine(level, "Runtime.pop($data);");
+      fw.writeLine(level, "});");
+      fw.writeLine(level, "return result;");
+      writeCloseGenerateScope(fw, level);
+    }
+  }
+  exit(fw, level) {
+    writeCloseDataScope(fw, level);
+    writeCloseNodeScope(fw, level);
+  }
+}
+
+class Optional extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.OptionalDefinition`;
+  constructor() {
+    super(false);
+  }
+  enter(fw, level, templateMarkNode) {
+    writeDebug(fw, level, templateMarkNode);
+    writeOpenNodeScope(fw, level);
+    writeOpenDataScope(fw, level, templateMarkNode.name, true);
+  }
+  generate(fw, level, templateMarkNode, doIt) {
+    const clone = makeCiceroMark(templateMarkNode);
+    delete clone.nodes;
+    delete clone.whenSome;
+    delete clone.whenNone;
+    writeOpenGenerateScope(fw, level);
+    fw.writeLine(level, `const result = ${JSON.stringify(clone)} as ${getTypeScriptType(templateMarkNode.$class)};`);
+    fw.writeLine(level, "const hasSome:boolean = !(Runtime.peek($data) === null || Runtime.peek($data) === undefined);");
+    fw.writeLine(level, "(result as CiceroMark.IOptional).hasSome = hasSome;");
+    fw.writeLine(level, "if(hasSome) {");
+    doIt(fw, level + 1, { $class: `${markdownCommon.CommonMarkModel.NAMESPACE}.Paragraph`, nodes: templateMarkNode.whenSome });
+    fw.writeLine(level, "(result as CiceroMark.IOptional).whenSome = $result.nodes[0];");
+    fw.writeLine(level, "(result as CiceroMark.IOptional).whenNone = $result.nodes[0];");
+    fw.writeLine(level, "return result;");
+    fw.writeLine(level, "}");
+    fw.writeLine(level, "else {");
+    doIt(fw, level + 1, { $class: `${markdownCommon.CommonMarkModel.NAMESPACE}.Paragraph`, nodes: templateMarkNode.whenNone });
+    fw.writeLine(level, "(result as CiceroMark.IOptional).whenNone = $result.nodes[0];");
+    fw.writeLine(level, "(result as CiceroMark.IOptional).whenSome = $result.nodes[0];");
+    fw.writeLine(level, "return result;");
+    fw.writeLine(level, "}");
+    writeCloseGenerateScope(fw, level);
+    delete templateMarkNode.nodes;
+    delete templateMarkNode.whenSome;
+    delete templateMarkNode.whenNone;
+  }
+  exit(fw, level) {
+    writeCloseDataScope(fw, level);
+    writeCloseNodeScope(fw, level);
+  }
+}
+
+class Variable extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.VariableDefinition`;
+  constructor() {
+    super(true);
+  }
+  generate(fw, level, templateMarkNode) {
+    const clone = makeCiceroMark(templateMarkNode);
+    writeOpenGenerateScope(fw, level);
+    if (templateMarkNode.name !== "this") {
+      writeOpenDataScope(fw, level, templateMarkNode.name);
+    }
+    fw.writeLine(level, "const text = JSON.stringify(Runtime.peek($data)) as string;");
+    if (templateMarkNode.name !== "this") {
+      writeCloseDataScope(fw, level);
+    }
+    fw.writeLine(level, `const variable:any = ${JSON.stringify(clone)};`);
+    fw.writeLine(level, "variable.value = text;");
+    fw.writeLine(level, `return variable as ${getTypeScriptType(clone.$class)};`);
+    writeCloseGenerateScope(fw, level);
+  }
+}
+
+class With extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.WithDefinition`;
+  constructor() {
+    super(false);
+  }
+  enter(fw, level, templateMarkNode) {
+    writeDebug(fw, level, templateMarkNode);
+    writeOpenDataScope(fw, level, templateMarkNode.name);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
+  generate(fw, level, templateMarkNode) {
+  }
+  exit(fw, level) {
+    writeCloseDataScope(fw, level);
+  }
+}
+
+class EnumVariable extends AbstractComplexCompiler {
+  static TYPE = `${markdownCommon.TemplateMarkModel.NAMESPACE}.EnumVariableDefinition`;
+  constructor() {
+    super(true);
+  }
+  generate(fw, level, templateMarkNode) {
+    const clone = makeCiceroMark(templateMarkNode);
+    writeOpenGenerateScope(fw, level);
+    if (templateMarkNode.name !== "this") {
+      writeOpenDataScope(fw, level, templateMarkNode.name);
+    }
+    fw.writeLine(level, "const text = JSON.stringify(Runtime.peek($data)) as string;");
+    if (templateMarkNode.name !== "this") {
+      writeCloseDataScope(fw, level);
+    }
+    fw.writeLine(level, `const variable:any = ${JSON.stringify(clone)};`);
+    fw.writeLine(level, "variable.value = text;");
+    fw.writeLine(level, `return variable as ${getTypeScriptType(clone.$class)};`);
+    writeCloseGenerateScope(fw, level);
+  }
+}
+
+const NODE_COMPILERS = {};
+NODE_COMPILERS[ContractDefinition.TYPE] = new ContractDefinition();
+NODE_COMPILERS[Variable.TYPE] = new Variable();
+NODE_COMPILERS[EnumVariable.TYPE] = new EnumVariable();
+NODE_COMPILERS[FormattedVariable.TYPE] = new FormattedVariable();
+NODE_COMPILERS[Formula.TYPE] = new Formula();
+NODE_COMPILERS[Conditional.TYPE] = new Conditional();
+NODE_COMPILERS[Join.TYPE] = new Join();
+NODE_COMPILERS[With.TYPE] = new With();
+NODE_COMPILERS[Clause.TYPE] = new Clause();
+NODE_COMPILERS[Optional.TYPE] = new Optional();
+NODE_COMPILERS[ListBlock.TYPE] = new ListBlock();
+NODE_COMPILERS[`${markdownCommon.TemplateMarkModel.NAMESPACE}.Code`] = new Ignore();
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Document`] = new Ignore();
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Paragraph`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Text`] = new PassThrough(true);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Attribute`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.TagInfo`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.CodeBlock`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Code`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.HtmlInline`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.HtmlBlock`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Emph`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Strong`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.BlockQuote`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Heading`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.ThematicBreak`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Softbreak`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Linebreak`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Link`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Image`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.List`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Item`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.Table`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.TableHead`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.TableBody`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.TableRow`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.TableRow`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.HeaderCell`] = new PassThrough(false);
+NODE_COMPILERS[`${markdownCommon.CommonMarkModel.NAMESPACE}.TableCell`] = new PassThrough(false);
+function getCompiler(fqn) {
+  const compiler = NODE_COMPILERS[fqn];
+  if (!compiler) {
+    throw new Error(`No compiler found for node ${fqn}`);
+  }
+  return compiler;
+}
+
+const RUNTIME_TGZ_BASE64 = "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";
+
+class TemplateMarkToTypeScriptCompiler {
+  modelManager;
+  templateClass;
+  constructor(modelManager, templateConceptFqn) {
+    this.modelManager = modelManager;
+    this.templateClass = getTemplateClassDeclaration(this.modelManager, templateConceptFqn);
+  }
+  writeFunction(fw, functionName, returnType, code) {
+    fw.writeLine(0, writeFunctionToString(this.templateClass, functionName, returnType, code));
+  }
+  /**
+   * Get a model manager with templatemark model
+   * @param {string} outputDir the output directory
+   * @returns {ModelManager} the model manager
+   */
+  getTemplateMarkModelManager() {
+    const modelManager = new concertoCore.ModelManager({ strict: true });
+    modelManager.addCTOModel(markdownCommon.ConcertoMetaModel.MODEL, "concertometamodel.cto");
+    modelManager.addCTOModel(markdownCommon.CommonMarkModel.MODEL, "commonmark.cto");
+    modelManager.addCTOModel(markdownCommon.TemplateMarkModel.MODEL, "templatemark.cto");
+    return modelManager;
+  }
+  /**
+   * Get a model manager with templatemark model
+   * @param {string} outputDir the output directory
+   * @returns {ModelManager} the model manager
+   */
+  getCiceroMarkModelManager() {
+    const modelManager = new concertoCore.ModelManager({ strict: true });
+    modelManager.addCTOModel(markdownCommon.ConcertoMetaModel.MODEL, "concertometamodel.cto");
+    modelManager.addCTOModel(markdownCommon.CommonMarkModel.MODEL, "commonmark.cto");
+    modelManager.addCTOModel(markdownCommon.CiceroMarkModel.MODEL, "ciceromark.cto");
+    return modelManager;
+  }
+  generateTypeScript(modelManager, outputDir) {
+    const tsVisitor = new concertoCodegen.CodeGen.TypescriptVisitor();
+    const parameters = {
+      fileWriter: new concertoUtil.FileWriter(outputDir)
+    };
+    modelManager.accept(tsVisitor, parameters);
+  }
+  generateSampleData(modelManager, outputDir) {
+    const factory = new concertoCore.Factory(modelManager);
+    const instance = factory.newResource(
+      this.templateClass.getNamespace(),
+      this.templateClass.getName(),
+      this.templateClass.isIdentified() ? "sample" : void 0,
+      { generate: "sample", includeOptionalFields: true }
+    );
+    fs.writeFileSync(`${outputDir}/sample.json`, JSON.stringify(instance, null, 2));
+  }
+  /**
+   * The main iteration function over templatemark. This function
+   * looks up an INodeCompiler that can handle each templatemark node
+   * and delegates to it for code generation.
+   * Note that the result of code generation (a CiceroMark node) is left in
+   * the $result global varianble.
+   * @param {FileWriter} fw  the file writer to use
+   * @param {number} level the indentation level
+   * @param {object} templateMark the templatemark node to iterate over
+   */
+  static doIt(fw, level, templateMark) {
+    fw.writeLine(level, `// start processing ${concertoCore.ModelUtil.getShortName(templateMark.$class)}`);
+    traverse(templateMark).forEach(function(context) {
+      if (typeof context === "object" && context.$class && typeof context.$class === "string") {
+        const nodeClass = context.$class;
+        const compiler = getCompiler(nodeClass);
+        const sourceLevel = level + 1;
+        this.before(() => {
+          compiler.enter(fw, sourceLevel, context);
+          compiler.generate(fw, sourceLevel, context, TemplateMarkToTypeScriptCompiler.doIt);
+        });
+        this.after(() => {
+          compiler.exit(fw, sourceLevel, context);
+        });
+      }
+    });
+    fw.writeLine(level, `// end processing ${concertoCore.ModelUtil.getShortName(templateMark.$class)}`);
+  }
+  /**
+   * Converts a TemplateMark document to typescript code that is parameterised
+   * by the 'data' argument.
+   *
+   * The strategy is to traverse the template mark json, converting each node into
+   * typescript statements that add an equivalent ciceromark node. Variables will
+   * pull values from 'data'.
+   *
+   * Conditionals and formulae will call the functions produced by
+   * compileUserCode.
+   *
+   * Note that code generation process is itself recursive, for example, when
+   * a list definition node is encountered the list must be iterated over
+   * based on a variable value coming from data, and code must be
+   * generated to produce each list item.
+   *
+   * All internal variables are prefixed with '$' to ensure (?)
+   * that they cannot collide with end user variable names.
+   *
+   * @param {IDocument} templateMark the TemplateMark Concerto resource
+   * @param {string} outputDir the output directory for code
+   */
+  compileGenerator(templateMark, outputDir) {
+    const fw = new concertoUtil.FileWriter(outputDir);
+    fw.openFile("index.ts");
+    fw.writeLine(0, "// generated code");
+    fw.writeLine(0, "import { readFileSync } from 'fs';");
+    fw.writeLine(0, "import { generator } from './generator';");
+    fw.writeLine(0, "if(process.argv.length === 3) {");
+    fw.writeLine(1, "const result = generator( JSON.parse(readFileSync(process.argv[2], 'utf-8')), {}, {});");
+    fw.writeLine(1, "console.log(JSON.stringify(result, null, 2));");
+    fw.writeLine(0, "}");
+    fw.writeLine(0, "else {");
+    fw.writeLine(1, "console.log('First argument is path to JSON data file');");
+    fw.writeLine(0, "}");
+    fw.closeFile();
+    fw.openFile("generator.ts");
+    fw.writeLine(0, "// generated code, do not modify");
+    fw.writeLine(0, "");
+    fw.writeLine(0, "// IMPORTS");
+    writeImports(fw, 0, this.templateClass);
+    fw.writeLine(0, "");
+    fw.writeLine(0, "// GENERATOR");
+    writeProlog(fw, 0, this.templateClass);
+    TemplateMarkToTypeScriptCompiler.doIt(fw, 1, templateMark);
+    writeEpilog(fw, 0);
+    fw.closeFile();
+  }
+  /**
+   * Decompresses the base64 zipped runtime into an output folder.
+   * @param {string} outputDir the output directory to copy the runtime to
+   */
+  copyRuntime(outputDir) {
+    ensureDirSync(`${outputDir}/${RUNTIME_DIR}`);
+    const runtimeBuffer = Buffer.from(RUNTIME_TGZ_BASE64, "base64");
+    const s = new stream.Readable();
+    s.push(runtimeBuffer);
+    s.push(null);
+    s.pipe(
+      tar__namespace.x({
+        strip: 2,
+        C: `${outputDir}/${RUNTIME_DIR}`
+      })
+    );
+  }
+  /**
+   * Create package.json for the generated code
+   * @param {string} outputDir the output directory to copy the runtime to
+   */
+  createPackage(outputDir) {
+    const packageJson = {
+      "name": "generated",
+      "version": "1.0.0",
+      "description": "TypeScript code generated from TemplateMark",
+      "engines": {
+        "node": ">=14",
+        "npm": ">=6"
+      },
+      "keywords": [
+        "accord project",
+        "template",
+        "templatemark"
+      ],
+      "dependencies": {
+        "dayjs": "1.11.7",
+        "jsonpath": "^1.1.1"
+      },
+      "devDependencies": {
+        "@types/node": "^20.2.0",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.0.2",
+        "@types/jsonpath": "^0.2.0"
+      },
+      "scripts": {
+        "start": "ts-node index.ts sample.json"
+      }
+    };
+    fs.writeFileSync(`${outputDir}/package.json`, JSON.stringify(packageJson, null, 2));
+  }
+  compile(templateMark, outputDir, options) {
+    ensureDirSync(outputDir);
+    this.generateSampleData(this.modelManager, outputDir);
+    this.generateTypeScript(this.modelManager, outputDir);
+    this.generateTypeScript(this.getTemplateMarkModelManager(), outputDir);
+    this.generateTypeScript(this.getCiceroMarkModelManager(), outputDir);
+    const namedTemplateMark = nameUserCode(templateMark.toJSON ? templateMark.toJSON() : templateMark);
+    this.compileUserCode(namedTemplateMark, outputDir);
+    if (!options?.skipCopyRuntime) {
+      this.copyRuntime(outputDir);
+    }
+    if (!options?.skipGenerator) {
+      this.createPackage(outputDir);
+      this.compileGenerator(namedTemplateMark, outputDir);
+    }
+  }
+  compileUserCode(templateMark, outputDir) {
+    const fw = new concertoUtil.FileWriter(outputDir);
+    fw.openFile("usercode.ts");
+    fw.writeLine(0, "// generated code, do not modify");
+    fw.writeLine(0, "");
+    fw.writeLine(0, "// IMPORTS");
+    fw.writeLine(0, `import * as TemplateModel from './${this.templateClass.getNamespace()}';`);
+    fw.writeLine(0, "import dayjs from 'dayjs';");
+    fw.writeLine(0, "import jp from 'jsonpath';");
+    fw.writeLine(0, "import {GenerationOptions} from './runtime/TypeScriptRuntime';");
+    fw.writeLine(0, "");
+    const templateMarkDom = templateMark;
+    const functionNodes = traverse(templateMarkDom).reduce(function(acc, x) {
+      if (x && x.$class === `${markdownCommon.TemplateMarkModel.NAMESPACE}.FormulaDefinition`) {
+        acc.push({
+          name: x.name,
+          code: x.code
+        });
+      }
+      return acc;
+    }, []);
+    const conditionalNodes = traverse(templateMarkDom).reduce(function(acc, x) {
+      if (x && x.$class === `${markdownCommon.TemplateMarkModel.NAMESPACE}.ConditionalDefinition` && x.condition) {
+        acc.push({
+          name: x.functionName,
+          code: x.condition
+        });
+      }
+      return acc;
+    }, []);
+    const clauseNodes = traverse(templateMarkDom).reduce(function(acc, x) {
+      if (x && x.$class === `${markdownCommon.TemplateMarkModel.NAMESPACE}.ClauseDefinition` && x.condition) {
+        acc.push({
+          name: x.functionName,
+          code: x.condition
+        });
+      }
+      return acc;
+    }, []);
+    fw.writeLine(0, "// FORMULAE");
+    functionNodes.forEach((fun) => {
+      this.writeFunction(fw, `${fun.name}`, "any", fun.code.contents);
+    });
+    fw.writeLine(0, "");
+    fw.writeLine(0, "// CONDITIONALS");
+    conditionalNodes.forEach((fun) => {
+      this.writeFunction(fw, `${fun.name}`, "boolean", fun.code.contents);
+    });
+    fw.writeLine(0, "");
+    fw.writeLine(0, "// CLAUSES");
+    clauseNodes.forEach((fun) => {
+      this.writeFunction(fw, `${fun.name}`, "boolean", fun.code.contents);
+    });
+    fw.writeLine(0, "");
+    fw.closeFile();
+  }
+}
+
+exports.TemplateMarkInterpreter = TemplateMarkInterpreter;
+exports.TemplateMarkToTypeScriptCompiler = TemplateMarkToTypeScriptCompiler;
+//# sourceMappingURL=index.js.map