@accordproject/template-engine 2.1.1 → 2.3.0

package/dist/index.js

@@ -1,21 +1,739 @@
-"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 vfs = require('@typescript/vfs');
+var twoslash = require('@typescript/twoslash');
+var concertoCodegen = require('@accordproject/concerto-codegen');
+var concertoUtil = require('@accordproject/concerto-util');
+var markdownTemplate = require('@accordproject/markdown-template');
+var fs = require('fs');
+var lzstring = require('lz-string');
+
+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);
+
+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 ensureDirSync(path) {
+  !fs.existsSync(path) && fs.mkdirSync(path, { recursive: true });
+}
+function removeSync(path) {
+  fs.rmSync(path, { recursive: true, force: 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);
+  });
+}
+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 || {});
+
+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);
+  }
+}
+
+exports.TemplateMarkInterpreter = TemplateMarkInterpreter;
+exports.ensureDirSync = ensureDirSync;
+exports.getTemplateClassDeclaration = getTemplateClassDeclaration;
+exports.nameUserCode = nameUserCode;
+exports.removeSync = removeSync;
+exports.writeFunctionToString = writeFunctionToString;
+//# sourceMappingURL=index.js.map