@controlium/utils 0.0.0

package/dist/esm/detokeniser/detokeniser.js

@@ -0,0 +1,1131 @@
+import { addDays, addHours, addMinutes, addMonths, addYears, format, secondsToHours, secondsToMinutes } from "date-fns";
+import { formatInTimeZone, getTimezoneOffset } from "date-fns-tz";
+import { JsonUtils, Log, LogLevels, StringUtils, Utils } from "../index";
+// ─── PublicHolidays stub ─────────────────────────────────────────────────────
+// TODO: Replace with a real import when a PublicHolidays module is provided by the consumer.
+//       The region string is an opaque identifier passed through by the caller (e.g. "us-east", "eu-london").
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var PublicHolidays;
+(function (PublicHolidays) {
+    function getIANAZone(_region) { throw new Error("PublicHolidays not yet implemented"); }
+    PublicHolidays.getIANAZone = getIANAZone;
+    async function isDatePublicHoliday(_date, _region) { throw new Error("PublicHolidays not yet implemented"); }
+    PublicHolidays.isDatePublicHoliday = isDatePublicHoliday;
+    async function getFirstPublicHolidayBetweenDates(_start, _end, _region) { throw new Error("PublicHolidays not yet implemented"); }
+    PublicHolidays.getFirstPublicHolidayBetweenDates = getFirstPublicHolidayBetweenDates;
+})(PublicHolidays || (PublicHolidays = {}));
+// ─── MockUtils stub ───────────────────────────────────────────────────────────
+// TODO: Replace with real import when MockUtils is brought into the package
+const MockUtils = {
+    interceptedRequests: undefined,
+};
+/**
+ * Processes strings containing tokens in the format `[[tokenType|expression|format]]`, replacing each
+ * token with its resolved value. Tokens can be nested — the innermost is always resolved first.
+ *
+ * ## Token syntax
+ * ```
+ * [[tokenType|expression|format]]
+ * ```
+ * - **tokenType** — identifies the built-in handler or is matched against registered callbacks
+ * - **expression** — what to compute (type-specific)
+ * - **format** — how to format the result (type-specific, often optional)
+ *
+ * The delimiter `|` and the `[[` / `]]` endstops are configurable via {@link Detokeniser.delimiter} and
+ * {@link Detokeniser.tokenStartEndChars}, but the defaults cover the vast majority of use cases.
+ *
+ * ---
+ * ## Built-in token types
+ *
+ * ### `random` — random data
+ * | Expression | Format | Example | Sample output |
+ * |---|---|---|---|
+ * | `digits` | count | `[[random\|digits\|6]]` | `482910` |
+ * | `letters` | count | `[[random\|letters\|4]]` | `xKpQ` |
+ * | `lowercaseletters` | count | `[[random\|lowercaseletters\|4]]` | `xkpq` |
+ * | `uppercaseletters` | count | `[[random\|uppercaseletters\|4]]` | `XKPQ` |
+ * | `alphanumerics` | count | `[[random\|alphanumerics\|8]]` | `a3Kx92Zp` |
+ * | `from(<chars>)` | count | `[[random\|from(aeiou)\|3]]` | `ioa` |
+ * | `float(min,max)` | decimal places | `[[random\|float(1.5,3.7)\|2]]` | `2.83` |
+ * | `date(fromEpoch,toEpoch)` | date format | `[[random\|date(0,1700000000000)\|yyyy-MM-dd]]` | `1994-07-12` |
+ *
+ * ### `date` / `date(<state>)` — date and time
+ * Format is a [date-fns format string](https://date-fns.org/docs/format), or the special values
+ * `epoch` (milliseconds since 1970-01-01) or `second-epoch`.
+ *
+ * | Expression | Example | Sample output |
+ * |---|---|---|
+ * | `today` / `now` | `[[date\|today\|dd-MM-yyyy]]` | `01-04-2026` |
+ * | `yesterday` | `[[date\|yesterday\|dd-MM-yyyy]]` | `31-03-2026` |
+ * | `tomorrow` | `[[date\|tomorrow\|dd-MM-yyyy]]` | `02-04-2026` |
+ * | `addYears(n)` | `[[date\|addYears(-1)\|yyyy]]` | `2025` |
+ * | `addMonths(n)` | `[[date\|addMonths(3)\|MMM yyyy]]` | `Jul 2026` |
+ * | `addDays(n)` | `[[date\|addDays(5)\|dd-MM-yyyy]]` | `06-04-2026` |
+ * | `addHours(n)` | `[[date\|addHours(2)\|HH:mm]]` | `14:30` |
+ * | `addMinutes(n)` | `[[date\|addMinutes(30)\|HH:mm]]` | `13:00` |
+ * | `random(fromEpoch,toEpoch)` | date format | `[[date\|random(0,1700000000000)\|yyyy-MM-dd]]` | random date |
+ * | `followingDay(epoch,dayName)` | date format | `[[date\|followingDay(1711929600000,wednesday)\|dd-MM-yyyy]]` | next Wednesday |
+ * | `yyyy-MM-dd` _(fixed date)_ | date format | `[[date\|2026-06-15\|EEEE]]` | `Monday` |
+ * | `timezoneOffset` _(with region)_ | _(none)_ | `[[date(us-east)\|timezoneOffset]]` | `-0500` |
+ *
+ * A region qualifier routes date formatting through the region's IANA timezone (resolved by the
+ * consumer-provided `PublicHolidays` module):
+ * ```
+ * [[date(eu-london)|today|HH:mm]]        ← formatted in London time
+ * [[date(us-east)|addDays(1)|dd-MM-yyyy]]
+ * ```
+ *
+ * The following expressions are **async-only** — use {@link Detokeniser.doAsync} with a region qualifier:
+ * - `addWorkingDays(n)` — adds business days, skipping weekends and public holidays
+ * - `followingWorkingDay(epoch,dayName)` — as `followingDay` but skips weekends and public holidays
+ * - `nextPublicHoliday(fromEpoch,maxDays)` — next public holiday within a search window
+ *
+ * ```typescript
+ * await Detokeniser.doAsync('[[date(us-east)|addWorkingDays(5)|dd-MM-yyyy]]');
+ * await Detokeniser.doAsync('[[date(eu-london)|nextPublicHoliday([[date|today|epoch]],90)|dd-MM-yyyy]]');
+ * ```
+ *
+ * ### `setting` — retrieve a configured value
+ * Parameters are given as JSON key/value pairs after the delimiter. Resolution order:
+ * process env → npm config → context parameters → default value.
+ * ```
+ * [[setting|processEnvName: "MY_VAR"]]
+ * [[setting|processEnvName: "MY_VAR", defaultValue: "fallback"]]
+ * [[setting|npmPackageConfigName: "myconfig"]]
+ * [[setting|profileParameterName: "myParam", defaultValue: "none"]]
+ * ```
+ *
+ * ### `base64` — encode or decode
+ * ```
+ * [[base64|encode|Hello World]]        →  SGVsbG8gV29ybGQ=
+ * [[base64|decode|SGVsbG8gV29ybGQ=]]   →  Hello World
+ * ```
+ *
+ * ### `jwt` — generate a signed JWT
+ * ```
+ * [[jwt|{"sub":"1234","name":"Test"}|MySecret]]
+ * [[jwt|{"sub":"1234"}|MySecret|{"algorithm":"HS256"}]]
+ * ```
+ *
+ * ### `mockintercepts` — harvest a value from intercepted mock requests
+ * ```
+ * [[mockintercepts|$.requests[0].body.userId]]
+ * ```
+ *
+ * ---
+ * ## Nesting
+ * Tokens are resolved innermost-first, so nested tokens compose naturally:
+ * ```typescript
+ * // Date N random days from now, where N is itself a random digit
+ * Detokeniser.do('[[date|addDays([[random|digits|1]])|dd-MM-yyyy]]');
+ *
+ * // Next NSW public holiday from today (async — needs doAsync)
+ * await Detokeniser.doAsync('[[date(eu-london)|nextPublicHoliday([[date|today|epoch]],90)|dd-MM-yyyy]]');
+ * ```
+ *
+ * ---
+ * ## Escaping
+ * The escape character is `/` (configurable via `EscapeChar`). Escaping applies both inside and
+ * outside tokens. A double escape `//` produces a literal `/`.
+ *
+ * | Input | Output | Notes |
+ * |---|---|---|
+ * | `/[[` | `[[` | Literal `[[` — not treated as token start |
+ * | `/]]` | `]]` | Literal `]]` — not treated as token end |
+ * | `//` | `/` | Literal escape char |
+ * | `[[random\|from(xyz/[[)\|3]]` | 3 chars from `xyz[[` | `/[[` inside `from()` = `/[` (→`[`) + `[` = two `[` (higher weight) |
+ * | `[[random\|from(abc/))\|2]]` | 2 chars from `abc)` | `/)` inside `from()` = literal `)` |
+ *
+ * ---
+ * ## Extending with callbacks
+ * Custom token types are registered via {@link Detokeniser.addCallbackSync} (for sync processing) or
+ * {@link Detokeniser.addCallbackAsync} (for async processing). Callbacks are tried in registration
+ * order; return `undefined` to pass to the next callback. If all callbacks return `undefined` and no
+ * built-in handler matched, an error is thrown.
+ *
+ * @see {@link Detokeniser.addCallbackSync}
+ * @see {@link Detokeniser.addCallbackAsync}
+ * @see {@link Detokeniser.do}
+ * @see {@link Detokeniser.doAsync}
+ */
+export class Detokeniser {
+    /**
+     * Gets the current single-character delimiter used to separate token parts.
+     * Default: `|`
+     */
+    static get delimiter() {
+        return this._delimiter;
+    }
+    /**
+     * Sets the single-character delimiter used to separate token parts.
+     * The new value applies to all subsequent {@link Detokeniser.do} / {@link Detokeniser.doAsync} calls.
+     * @param newDelimiter - Exactly one character
+     * @throws If `newDelimiter` is not exactly one character
+     * @example
+     * Detokeniser.delimiter = ':';
+     * Detokeniser.do('[[random:digits:6]]'); // → e.g. '482910'
+     * Detokeniser.reset();                   // restore default '|'
+     */
+    static set delimiter(newDelimiter) {
+        if (newDelimiter.length !== 1) {
+            const errTxt = `Invalid delimiter [${newDelimiter}].  Must be exactly 1 character!`;
+            Log.writeLine(LogLevels.Error, errTxt);
+            throw new Error(errTxt);
+        }
+        else {
+            this._delimiter = newDelimiter;
+        }
+    }
+    /**
+     * Sets the start and end token sequences.
+     * @param startEndChars - An even-length string whose first half is the start sequence and second half the end sequence.
+     * @example Detokeniser.tokenStartEndChars = "[[]]"; // start = "[[", end = "]]"
+     * @remarks Start and end sequences must differ. Minimum total length is 2 (one char each).
+     */
+    static set tokenStartEndChars(startEndChars) {
+        if (startEndChars.length < 2 || startEndChars.length % 2 !== 0) {
+            const errTxt = `Invalid start/end chars [${startEndChars}]. Must be an even number of characters (minimum 2) — first half as start sequence, second half as end sequence!`;
+            Log.writeLine(LogLevels.Error, errTxt);
+            throw new Error(errTxt);
+        }
+        const half = startEndChars.length / 2;
+        const start = startEndChars.substring(0, half);
+        const end = startEndChars.substring(half);
+        if (start === end) {
+            const errTxt = `Invalid start/end chars — start sequence [${start}] must differ from end sequence [${end}]!`;
+            Log.writeLine(LogLevels.Error, errTxt);
+            throw new Error(errTxt);
+        }
+        this._startTokenChar = start;
+        this._endTokenChar = end;
+    }
+    /**
+     * Gets the current token start/end sequences concatenated (e.g. `"[[]]"`).
+     */
+    static get tokenStartEndChars() {
+        return this._startTokenChar + this._endTokenChar;
+    }
+    /**
+     * Resets the Detokeniser to factory defaults:
+     * - Token endstops restored to `[[` / `]]`
+     * - Delimiter restored to `|`
+     * - Escape char restored to `/`
+     * - All registered sync and async callbacks cleared
+     *
+     * Call this in test teardown to guarantee a clean state between scenarios.
+     * @example
+     * afterEach(() => Detokeniser.reset());
+     */
+    static reset() {
+        this._endTokenChar = "]]";
+        this._startTokenChar = "[[";
+        this.EscapeChar = "/";
+        this._delimiter = "|";
+        if (this._syncCallbacks) {
+            this._syncCallbacks = [];
+        }
+        if (this._asyncCallbacks) {
+            this._asyncCallbacks = [];
+        }
+        this._asyncCallbacks = undefined;
+        this._syncCallbacks = undefined;
+    }
+    /**
+     * Registers a synchronous custom token handler.
+     *
+     * When {@link Detokeniser.do} encounters a token not handled by the built-in set, it invokes each
+     * registered sync callback in registration order. The first to return a non-`undefined` string wins.
+     * Return `undefined` to pass to the next callback. If all callbacks return `undefined`, an error is thrown.
+     *
+     * @param callback - `(delimiter: string, token: string) => string | undefined`
+     *   - `delimiter` — current delimiter character (default `|`)
+     *   - `token` — full token body without `[[` / `]]`, e.g. `"mytype|arg1|arg2"`
+     *
+     * @example
+     * // Handle [[env|VAR_NAME]] tokens
+     * Detokeniser.addCallbackSync((delimiter, token) => {
+     *   const [type, name] = token.split(delimiter);
+     *   if (type.toLowerCase() !== 'env') return undefined;
+     *   return process.env[name] ?? '';
+     * });
+     * Detokeniser.do('Path: [[env|HOME]]'); // → 'Path: /home/user'
+     *
+     * @example
+     * // Multiple callbacks — each handles one type, passes on the rest
+     * Detokeniser.addCallbackSync((delimiter, token) => {
+     *   const [type, value] = token.split(delimiter);
+     *   if (type === 'upper') return value.toUpperCase();
+     *   return undefined;
+     * });
+     * Detokeniser.addCallbackSync((delimiter, token) => {
+     *   const [type, value] = token.split(delimiter);
+     *   if (type === 'lower') return value.toLowerCase();
+     *   return undefined;
+     * });
+     * Detokeniser.do('[[upper|hello]] [[lower|WORLD]]'); // → 'HELLO world'
+     *
+     * @see {@link Detokeniser.resetSyncCallbacks} to remove all sync callbacks
+     * @see {@link Detokeniser.addCallbackAsync} for async token handlers
+     */
+    static addCallbackSync(callback) {
+        if (!this._syncCallbacks) {
+            this._syncCallbacks = new Array();
+        }
+        this._syncCallbacks.push(callback);
+    }
+    /**
+     * Registers an asynchronous custom token handler.
+     *
+     * Works identically to {@link Detokeniser.addCallbackSync} but is invoked by {@link Detokeniser.doAsync}.
+     * Async callbacks are tried in registration order; the first to return a non-`undefined` value wins.
+     * Return `undefined` to pass to the next callback.
+     *
+     * @param asyncCallback - `(delimiter: string, token: string) => Promise<string | undefined>`
+     *   - `delimiter` — current delimiter character (default `|`)
+     *   - `token` — full token body without `[[` / `]]`, e.g. `"mytype|arg1|arg2"`
+     *
+     * @example
+     * // Handle [[db|table|column|whereClause]] tokens
+     * Detokeniser.addCallbackAsync(async (delimiter, token) => {
+     *   const [type, table, column, where] = token.split(delimiter);
+     *   if (type.toLowerCase() !== 'db') return undefined;
+     *   const row = await db.query(`SELECT ${column} FROM ${table} WHERE ${where} LIMIT 1`);
+     *   return String(row[column]);
+     * });
+     * const result = await Detokeniser.doAsync('ID: [[db|users|id|active=1]]');
+     *
+     * @example
+     * // Combine with nested tokens — inner tokens resolve before the callback is called
+     * Detokeniser.addCallbackAsync(async (delimiter, token) => {
+     *   const [type, key] = token.split(delimiter);
+     *   if (type !== 'cache') return undefined;
+     *   return await redis.get(key);
+     * });
+     * // [[random|digits|8]] resolves first, then [[cache|...]] receives the result
+     * await Detokeniser.doAsync('Val: [[cache|prefix-[[random|digits|8]]]]');
+     *
+     * @see {@link Detokeniser.resetAsyncCallbacks} to remove all async callbacks
+     * @see {@link Detokeniser.addCallbackSync} for synchronous token handlers
+     */
+    static addCallbackAsync(asyncCallback) {
+        if (!this._asyncCallbacks) {
+            this._asyncCallbacks = new Array();
+        }
+        this._asyncCallbacks?.push(asyncCallback);
+    }
+    /**
+     * Removes all registered sync callbacks. Built-in token handlers are unaffected.
+     * Use between tests or scenarios to ensure callback isolation.
+     * @see {@link Detokeniser.reset} to also clear async callbacks and restore all defaults
+     */
+    static resetSyncCallbacks() {
+        if (this._syncCallbacks) {
+            this._syncCallbacks = [];
+        }
+    }
+    /**
+     * Removes all registered async callbacks. Built-in token handlers are unaffected.
+     * Use between tests or scenarios to ensure callback isolation.
+     * @see {@link Detokeniser.reset} to also clear sync callbacks and restore all defaults
+     */
+    static resetAsyncCallbacks() {
+        if (this._asyncCallbacks) {
+            this._asyncCallbacks = [];
+        }
+    }
+    /**
+     * Synchronously resolves all tokens in the given string and returns the result.
+     *
+     * Tokens are resolved innermost-first. Registered sync callbacks are invoked for token types not
+     * handled by the built-in set. Use {@link Detokeniser.doAsync} if you need async callbacks or any
+     * of the async-only date expressions (`addWorkingDays`, `followingWorkingDay`, `nextPublicHoliday`).
+     *
+     * @param tokenisedString - String potentially containing `[[...]]` tokens
+     * @param options - Optional processing options
+     * @returns The input string with all tokens replaced by their resolved values
+     * @throws If any token is malformed, unsupported, or a callback throws
+     *
+     * @example
+     * Detokeniser.do('Ref-[[random|digits|6]]');                        // → e.g. 'Ref-482910'
+     * Detokeniser.do('Expires [[date|addDays(30)|dd/MM/yyyy]]');        // → e.g. 'Expires 01/05/2026'
+     * Detokeniser.do('[[random|uppercaseletters|3]]-[[random|digits|4]]'); // → e.g. 'XKP-7391'
+     *
+     * @example
+     * // Nested tokens — innermost resolved first
+     * Detokeniser.do('[[date|addDays([[random|digits|1]])|dd-MM-yyyy]]');
+     *
+     * @example
+     * // Context parameters for [[setting|...]] tokens
+     * Detokeniser.do('Hello [[setting|profileParameterName: "username"]]', {
+     *   contextParameters: { username: 'Alice' }
+     * }); // → 'Hello Alice'
+     *
+     * @example
+     * // Escaping — produce literal [[ / ]] in output
+     * Detokeniser.do('Press /[[Enter/]] to continue'); // → 'Press [[Enter]] to continue'
+     */
+    static do(tokenisedString, options = {}) {
+        let deEscape = true;
+        try {
+            const runningString = this.doPreamble(tokenisedString);
+            // Loop until last token find found no tokens
+            while (runningString.currentToken.hasToken) {
+                // Process the last found token, prepend it to the text after the last found token then find any token in the resulting string
+                runningString.currentToken = new InnermostToken(this.doToken(runningString.currentToken.childToken.substring(this._startTokenChar.length), options) + runningString.currentToken.postamble, this._startTokenChar, this._endTokenChar, this.EscapeChar);
+                // Concatinate the last found tokens preable (or full text if none found) to the built string and recursivley call self to ensure full token resolution
+                runningString.outputString = this.do(runningString.outputString + runningString.currentToken.preamble);
+                deEscape = false;
+            }
+            //
+            // Okay, so there is a bug here.  But it shall remain unfixed as it requires time.
+            //
+            // The bug is that is the resolved token string contains a sequence of characters that makes doDeEscapesIfRequired think it sees an escaped special char
+            // the it will de-escape it!!  However, probablity of incidence is currently low.  When/If it does happen (impact could be high!) it can then be fixed.
+            //
+            // IE.
+            //  const encoded = Buffer.from('this/>escaped').toString('base64');
+            //  const decoded = Detokeniser.do(`<base64;decode;${encoded}>`);
+            //
+            //  decoded would now be "this>escaped".  Should be "this/>escaped".
+            //
+            runningString.outputString = this.doDeEscapesIfRequired(tokenisedString, deEscape, runningString.outputString);
+            return runningString.outputString;
+        }
+        catch (err) {
+            const errText = `Error processing [${tokenisedString}]: ${typeof err === "string" ? err : err instanceof Error ? err.message : "<unknown>"}`;
+            Log.writeLine(LogLevels.Error, errText);
+            throw Error(errText);
+        }
+    }
+    /**
+     * Asynchronously resolves all tokens in the given string and returns a Promise of the result.
+     *
+     * Functionally equivalent to {@link Detokeniser.do} but additionally supports:
+     * - Async callbacks registered via {@link Detokeniser.addCallbackAsync}
+     * - Async-only date expressions: `addWorkingDays`, `followingWorkingDay`, `nextPublicHoliday`
+     *
+     * Note: sync callbacks registered via {@link Detokeniser.addCallbackSync} are **not** invoked
+     * during async processing — re-register them with {@link Detokeniser.addCallbackAsync} if needed.
+     *
+     * @param tokenisedString - String potentially containing `[[...]]` tokens
+     * @returns Promise resolving to the input string with all tokens replaced
+     * @throws If any token is malformed, unsupported, or a callback throws
+     *
+     * @example
+     * // Async-only date expressions require doAsync and a region qualifier
+     * await Detokeniser.doAsync('[[date(us-east)|addWorkingDays(5)|dd-MM-yyyy]]');
+     * await Detokeniser.doAsync('[[date(eu-london)|nextPublicHoliday([[date|today|epoch]],90)|dd-MM-yyyy]]');
+     *
+     * @example
+     * // Async callback for database-driven tokens
+     * Detokeniser.addCallbackAsync(async (delim, token) => {
+     *   const [type, key] = token.split(delim);
+     *   if (type !== 'db') return undefined;
+     *   return await fetchFromDatabase(key);
+     * });
+     * await Detokeniser.doAsync('User: [[db|users.name.first]]');
+     */
+    static async doAsync(tokenisedString) {
+        let deEscape = true;
+        try {
+            const runningString = this.doPreamble(tokenisedString);
+            // Loop until last token find found no tokens
+            while (runningString.currentToken.hasToken) {
+                // Process the last found token, prepend it to the text after the last found token then find any token in the resulting string
+                runningString.currentToken = new InnermostToken((await this.asyncDoToken(runningString.currentToken.childToken.substring(this._startTokenChar.length))) +
+                    runningString.currentToken.postamble, this._startTokenChar, this._endTokenChar, this.EscapeChar);
+                const logToken = runningString.currentToken.hasToken ? runningString.currentToken.childToken : '<No Token>';
+                Log.writeLine(LogLevels.FrameworkDebug, `Preamble:[${runningString.currentToken.preamble}] Token:[${logToken}] Postamble:[${runningString.currentToken.postamble}]`);
+                // Concatinate the last found tokens preable (or full text if none found) to the built string and recursivley call self to ensure full token resolution
+                runningString.outputString = await this.doAsync(runningString.outputString + runningString.currentToken.preamble);
+                deEscape = false;
+            }
+            runningString.outputString = this.doDeEscapesIfRequired(tokenisedString, deEscape, runningString.outputString);
+            return runningString.outputString;
+        }
+        catch (err) {
+            const errText = `Error processing [${tokenisedString}]: ${typeof err === "string" ? err : err instanceof Error ? err.message : "<unknown>"}`;
+            Log.writeLine(LogLevels.Error, errText);
+            throw Error(errText);
+        }
+    }
+    static doDeEscapesIfRequired(tokenisedString, deEscape, stringToProcess) {
+        // After all tokens are resolved, remove escaping from any chars that were escaped to prevent token recognition.
+        // Uses a 3-pass approach to correctly handle escaped escape chars (e.g. //) adjacent to other escapes (e.g. /[):
+        //   Pass 1: replace // with \x00 placeholder
+        //   Pass 2: de-escape each char that makes up the start/end token sequences
+        //   Pass 3: restore \x00 back to the escape char
+        let processedString = stringToProcess;
+        if (deEscape && !StringUtils.isBlank(processedString)) {
+            const doubleEscapes = this.EscapeChar + this.EscapeChar;
+            processedString = StringUtils.replaceAll(processedString, doubleEscapes, "\x00");
+            const tokenChars = new Set([...this._startTokenChar, ...this._endTokenChar]);
+            for (const char of tokenChars) {
+                processedString = StringUtils.replaceAll(processedString, this.EscapeChar + char, char);
+            }
+            processedString = StringUtils.replaceAll(processedString, "\x00", this.EscapeChar);
+        }
+        if (tokenisedString !== processedString) {
+            Log.writeLine(LogLevels.FrameworkDebug, `Processed [${tokenisedString}]\nto [${processedString}]`);
+        }
+        return processedString;
+    }
+    static doPreamble(tokenisedString) {
+        // Drill down to the left-most deepest (if nested) token
+        const token = new InnermostToken(tokenisedString, this._startTokenChar, this._endTokenChar, this.EscapeChar);
+        // Get all text to the left of any token found in the string passed in.  If no token was found Preamble will contain all text from passed string
+        const outputString = token.preamble;
+        return { currentToken: token, outputString };
+    }
+    static doTokenMain(token, options = {}) {
+        const doTokenReturn = {};
+        doTokenReturn.processedToken = undefined;
+        if (!token || token === "") {
+            throw new Error("Empty token!  Token must be populated.");
+        }
+        const [tokenName, postAmble] = StringUtils.splitRemaining(token, this._delimiter, 2);
+        const loweredTokenName = tokenName.toLowerCase().trim();
+        const postAmbleDeEscaped = this.doDeEscapesIfRequired(postAmble, true, postAmble);
+        if (typeof doTokenReturn.processedToken === "undefined") {
+            switch (loweredTokenName) {
+                case "random":
+                    if (StringUtils.isBlank(postAmbleDeEscaped))
+                        throw new Error(`Random token [${token}] needs at least 2 parts (IE. {{random;type[;<length>]}} etc.)`);
+                    doTokenReturn.processedToken = this.doRandomToken(postAmbleDeEscaped);
+                    break;
+                case "setting":
+                    {
+                        if (StringUtils.isBlank(postAmbleDeEscaped))
+                            throw new Error(`Setting token [${token}] needs at least 2 parts (IE. {{setting;processEnvName: "TEST_LOG_TO_CONSOLE")`);
+                        doTokenReturn.processedToken = this.doSettingToken(postAmbleDeEscaped, options);
+                        break;
+                    }
+                case "mockintercepts":
+                    if (StringUtils.isBlank(postAmbleDeEscaped))
+                        throw new Error(`Request token [${token}] needs 2 parts {{mockintercepts;JSONPath}}`);
+                    doTokenReturn.processedToken = this.doMockRequests(postAmbleDeEscaped);
+                    break;
+                case "jwt":
+                    if (StringUtils.isBlank(postAmbleDeEscaped))
+                        throw new Error(`JWT token [${token}] needs at least 2 parts (IE. {{jwt;payload[;signature[;options]]}} etc.)`);
+                    doTokenReturn.processedToken = this.doJWTToken(postAmbleDeEscaped);
+                    break;
+                case "base64":
+                    // aha, we actuall need three parts <base64;encode|decode;<string>>
+                    if (!StringUtils.isBlank(postAmbleDeEscaped)) {
+                        const [direction, value] = StringUtils.splitRemaining(postAmbleDeEscaped, this._delimiter, 2);
+                        if (direction == "encode" || direction == "decode") {
+                            doTokenReturn.processedToken = this.doBase64(value, direction);
+                            break;
+                        }
+                    }
+                    throw new Error(`BASE64 token [${token}] needs 3 parts (IE. {{base64;encode|decode;value}})`);
+                default:
+                    if (loweredTokenName.startsWith("date")) {
+                        doTokenReturn.tokenBodyIfDateToken = postAmbleDeEscaped;
+                        if (loweredTokenName[4] === "(" && loweredTokenName.endsWith(")")) {
+                            if (StringUtils.isBlank(postAmbleDeEscaped)) {
+                                throw new Error(`Date token [${token}] needs 2 or 3 parts {{date(<state>);<offset>;<format>}} or {{date;timezone}}`);
+                            }
+                            else {
+                                const state = StringUtils.trimChar(StringUtils.splitRemaining(tokenName, "(", 2)[1], ")");
+                                const body = postAmbleDeEscaped;
+                                Log.writeLine(LogLevels.FrameworkDebug, `Calling doDateToken.  State = [${state}]. Body = [${body}]`);
+                                doTokenReturn.state = state;
+                            }
+                        }
+                    }
+            }
+        }
+        return doTokenReturn;
+    }
+    static doToken(token, options = {}) {
+        const doTokenReturn = this.doTokenMain(token, options);
+        let processedToken;
+        if (Utils.isNullOrUndefined(doTokenReturn.processedToken) && doTokenReturn.tokenBodyIfDateToken) {
+            processedToken = this.doDateToken(doTokenReturn.state, doTokenReturn.tokenBodyIfDateToken);
+        }
+        else {
+            processedToken = doTokenReturn.processedToken;
+        }
+        //
+        // If token still not been processed itterate through the callbacks, breaking as soon as it is processed
+        //
+        try {
+            if (Utils.isNullOrUndefined(processedToken)) {
+                if (typeof this._syncCallbacks != "undefined") {
+                    this._syncCallbacks.every((callback) => {
+                        processedToken = callback(this._delimiter, token);
+                        return Utils.isNullOrUndefined(processedToken);
+                    });
+                }
+            }
+        }
+        catch (e) {
+            throw new Error(`Error processing callback for [${token}]: ${e?.message ?? "<Unknown Error>"}}`);
+        }
+        if (Utils.isNullOrUndefined(processedToken)) {
+            throw new Error(`Unsupported token [${StringUtils.splitRemaining(token, this._delimiter, 2)[0]}]`);
+        }
+        else {
+            return processedToken;
+        }
+    }
+    static async asyncDoToken(token, options = {}) {
+        const doTokenReturn = this.doTokenMain(token, options);
+        let processedToken;
+        if (Utils.isNullOrUndefined(doTokenReturn.processedToken) && doTokenReturn.tokenBodyIfDateToken) {
+            processedToken = await this.asyncDoDateToken(doTokenReturn.state, doTokenReturn.tokenBodyIfDateToken);
+        }
+        else {
+            processedToken = doTokenReturn.processedToken;
+        }
+        //
+        // If token still not been processed itterate through the callbacks, breaking as soon as it is processed.  Dirty
+        // ucky loop. But it works....  If you know a sexier way of doing it please change!!
+        //
+        try {
+            if (Utils.isNullOrUndefined(processedToken)) {
+                if (typeof this._asyncCallbacks != "undefined") {
+                    for (let i = 0; i < this._asyncCallbacks.length; i++) {
+                        processedToken = await this._asyncCallbacks[i](this._delimiter, token);
+                        if (!Utils.isNullOrUndefined(processedToken))
+                            break;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            Log.writeLine(LogLevels.Error, `Error processing async callback (ignoring and setting response to undefined):${e?.message ?? "<Unknown Error>"}}`);
+            processedToken = undefined;
+        }
+        if (Utils.isNullOrUndefined(processedToken)) {
+            throw new Error(`Unsupported token [${StringUtils.splitRemaining(token, this._delimiter, 2)[0]}]`);
+        }
+        else {
+            return processedToken;
+        }
+    }
+    static doSettingToken(tokenBody, options = {}) {
+        const bodyJSON = `{${tokenBody}}`;
+        if (!JsonUtils.isJson(bodyJSON, true)) {
+            const errText = `Token 'Setting'.\nExpected: parameters in name: value format (IE. ${this._startTokenChar}setting;processEnvName: "MY_SETTING"${this._endTokenChar}\nToken was: ${this._startTokenChar}setting;${tokenBody}${this._endTokenChar}\n\nValid Setting parameters include;\n  processEnvName - Name of process env variable\n  npmPackageConfigName - Name of NPM config var\n  profileParameterName - Name of Cucumber profile parameter\n  defaultValue - default value if cannot be found`;
+            Log.writeLine(LogLevels.Error, errText);
+            throw new Error(errText);
+        }
+        const result = Utils.getSetting(LogLevels.TestInformation, "From Detokeniser", JsonUtils.parse(bodyJSON, true), options.contextParameters);
+        if (Utils.isNullOrUndefined(result)) {
+            return result;
+        }
+        else {
+            return typeof result === 'object' ? JSON.stringify(result) : String(result);
+        }
+    }
+    /**
+     * Base64-encodes or decodes a string.
+     *
+     * This is the underlying handler for `[[base64|encode|...]]` and `[[base64|decode|...]]` tokens
+     * but is also exposed for direct use.
+     *
+     * @param original - The string to encode or decode
+     * @param direction - `"encode"` to base64-encode; `"decode"` to base64-decode
+     * @returns The encoded or decoded string
+     * @throws If the conversion fails (e.g. invalid base64 input for decode)
+     *
+     * @example
+     * Detokeniser.doBase64('Hello World', 'encode');      // → 'SGVsbG8gV29ybGQ='
+     * Detokeniser.doBase64('SGVsbG8gV29ybGQ=', 'decode'); // → 'Hello World'
+     */
+    static doBase64(original, direction) {
+        try {
+            return direction == "encode" ? Buffer.from(original).toString("base64") : Buffer.from(original, "base64").toString();
+        }
+        catch (err) {
+            const errText = `Converting:\n[${original}]\n  ${direction == "encode" ? "to" : "from"} base64:\n {${err.message}}`;
+            Log.writeLine(LogLevels.Error, errText);
+            throw new Error(errText);
+        }
+    }
+    //
+    //  So, this has been created quickly with little/no checking/testing.  Lots and lots of error handling needs adding or testers will get
+    //  errors/fails they have no idea how to fix!!!!
+    //
+    static doJWTToken(tokenBody) {
+        Log.writeLine(LogLevels.FrameworkDebug, `JWT token [${tokenBody}]`);
+        const typeAndLengthOrFormat = StringUtils.splitRemaining(tokenBody, this._delimiter, 3);
+        if (typeAndLengthOrFormat.length == 3) {
+            return Utils.createJWT(typeAndLengthOrFormat[0], typeAndLengthOrFormat[1], typeAndLengthOrFormat[2]);
+        }
+        else if (typeAndLengthOrFormat.length == 2) {
+            return Utils.createJWT(typeAndLengthOrFormat[0], typeAndLengthOrFormat[1]);
+        }
+        else {
+            return Utils.createJWT(typeAndLengthOrFormat[0], "DummySignature");
+        }
+    }
+    static doMockRequests(jsonPath) {
+        //
+        // NOTE.  This is MockUtils only at the moment.  When playwright is brought in to the library this MUST be made generic so user can harvest from Mock intercepts,
+        // whether MSW OR Playwright.
+        //
+        if (!MockUtils.interceptedRequests || MockUtils.interceptedRequests.length <= 0) {
+            const errMessage = "No Mock Intercepted requests to harvest from!?";
+            Log.writeLine(LogLevels.Error, errMessage);
+            throw new Error(errMessage);
+        }
+        const jsonProperties = JsonUtils.getPropertiesMatchingPath(MockUtils.interceptedRequests, jsonPath);
+        if (jsonProperties.length != 1) {
+            throw new Error(`Expected path (${jsonPath}) to match exactly one JSON node.  However, path matched ${jsonProperties.length} nodes!`);
+        }
+        else {
+            return jsonProperties[0].value;
+        }
+    }
+    /**
+     * Extracts the content inside the first set of parentheses in `input`, respecting the escape char.
+     * An escaped `)` (i.e. `/)`) is treated as a literal `)` and does not end the content.
+     * @example parseParenContent("from(abc/))") → "abc)"
+     * @example parseParenContent("from(xyz/[[)") → "xyz[["  (with default escape char `/`)
+     */
+    static parseParenContent(input) {
+        const openParen = input.indexOf("(");
+        if (openParen === -1)
+            return "";
+        let result = "";
+        let i = openParen + 1;
+        while (i < input.length) {
+            if (input[i] === this.EscapeChar && i + 1 < input.length) {
+                result += input[i + 1];
+                i += 2;
+            }
+            else if (input[i] === ")") {
+                break;
+            }
+            else {
+                result += input[i];
+                i++;
+            }
+        }
+        return result;
+    }
+    static doRandomToken(tokenBody) {
+        const typeAndLengthOrFormat = StringUtils.splitRemaining(tokenBody, this._delimiter, 2);
+        let result = "";
+        let select = "";
+        const verb = typeAndLengthOrFormat[0].toLowerCase().trim();
+        if (verb.startsWith("date(")) {
+            const randomDate = this.doRandomDate(verb.substring(verb.indexOf("(") + 1, verb.indexOf(")")));
+            result = typeAndLengthOrFormat[1].toLowerCase() === "epoch" ? "" + randomDate : format(randomDate, typeAndLengthOrFormat[1]);
+        }
+        else if (verb.startsWith("float(")) {
+            // ToDo: Current format is only for number of decimals.  However in future could be precision,decimals if needed (IE. {random,float(4000,8000),3,4} precision 3 decimals 4...), defaulting
+            //       to decimal places if only a single number given (then change would be non-breaking)....
+            if (isNaN(parseInt(typeAndLengthOrFormat[1])))
+                throw `Invalid Float format. Expect {{random.float(min;max),<number of decimals>}}. Format was: [${typeAndLengthOrFormat[1]}]`;
+            const numberOfDecimalPlaces = parseInt(typeAndLengthOrFormat[1]);
+            const powerDPs = Math.pow(10, numberOfDecimalPlaces);
+            result = (Math.trunc(this.doRandomFloat(verb.substring(verb.indexOf("(") + 1, verb.indexOf(")"))) * powerDPs) / powerDPs).toFixed(numberOfDecimalPlaces);
+        }
+        else {
+            if (verb.startsWith("from(")) {
+                select = this.parseParenContent(typeAndLengthOrFormat[0]);
+            }
+            else {
+                switch (verb) {
+                    case "letters":
+                        select = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+                        break;
+                    case "lowercaseletters":
+                        select = "abcdefghijklmnopqrstuvwxyz";
+                        break;
+                    case "uppercaseletters":
+                        select = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+                        break;
+                    case "digits":
+                        select = "0123456789";
+                        break;
+                    case "alphanumerics":
+                        select = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890";
+                        break;
+                    default:
+                        throw `Unrecognised random Type [${typeAndLengthOrFormat[0]}] - Expect letters, lowercaseletters, uppercaseletters digits or alphanumerics`;
+                }
+            }
+            if (isNaN(parseInt(typeAndLengthOrFormat[1])) || parseInt(typeAndLengthOrFormat[1]) < 0)
+                throw `Invalid length part in Random token {{random;<type>;<length>}}. Length was: [${typeAndLengthOrFormat[1]}]`;
+            for (let count = 0; count < parseInt(typeAndLengthOrFormat[1]); count++) {
+                result += select[Utils.getRandomInt(0, select.length - 1)];
+            }
+        }
+        return result;
+    }
+    static doDateTokenPreamble(date, state, tokenBody) {
+        const offsetAndFormat = StringUtils.splitRemaining(tokenBody, this._delimiter, 2);
+        const stateIANAZone = state ? PublicHolidays.getIANAZone(state) : undefined;
+        Log.writeLine(LogLevels.FrameworkInformation, `Time now is [${date}] (Epoch) and we are in [${stateIANAZone ?? "<No state defined>"}]`);
+        if (offsetAndFormat.length != 2 && !(offsetAndFormat.length == 1 && offsetAndFormat[0] == "timezoneoffset"))
+            throw "Date token does not have a format parameter; example: {date;today;dd-MM-yyyy}";
+        return {
+            offsetAndFormat: offsetAndFormat,
+            verb: (offsetAndFormat[0].includes("(") && offsetAndFormat[0].endsWith(")") ? offsetAndFormat[0].split("(")[0] : offsetAndFormat[0]).toLowerCase().trim(),
+            params: offsetAndFormat[0].includes("(") && offsetAndFormat[0].endsWith(")")
+                ? ((x) => {
+                    return x.substring(0, x.length - 1);
+                })(offsetAndFormat[0].split("(")[1])
+                : undefined,
+            errParseDateOffset: "Invalid Active Date offset.  Expect AddYears(n) AddMonths(n) or AddDays(n)",
+            errInvalidEpoch: "Invalid Epoch offset.  Expect number of milliseconds since 1/1/1970",
+            errRandomParams: `Invalid Random params ([${offsetAndFormat[0]}]).  Expect Random(<start date>,<end date>).  Example: {date;random(1708990784000,1701360784000);yyy-MM-dd}`,
+            errFollowingDayParams: `FollowingDay requires epoch and day name.  IE. FollowingDay(123456,wednesday)  Got ${offsetAndFormat[0]}`,
+            errNextPublicHoldayParams: `Invalid Next Public Holiday Params.  Expect nextPublicHoliday(searchFromDateEpoch,maxDaysInFuture).  Got ${offsetAndFormat[0]}`,
+            errAddWorkingDaysParams: `Invalid Add Working Days Params.  Expect addWorkingDays(numberOfDaysToAdd,[state/s]). Got Got ${offsetAndFormat[0]}`,
+            errInvalidDateVerb: `Invalid date verb [${offsetAndFormat[0]}].  Need: Random, Today, Now, Yesterday, Tomorrow, AddYears(n) etc... EG {date;AddDays(5);yyyy-MM-dd}`,
+            stateIANAZone: stateIANAZone,
+        };
+    }
+    static doDateTokenPostamble(offsetAndFormat, date, stateIANAZone) {
+        if (offsetAndFormat[1].toLowerCase() === "epoch") {
+            return date.toString();
+        }
+        if (offsetAndFormat[1].toLowerCase() === "second-epoch") {
+            return Math.floor(date / 1000).toString();
+        }
+        try {
+            //date += await getEpochOffset(state);
+            const processedDate = stateIANAZone ? formatInTimeZone(date, stateIANAZone, offsetAndFormat[1]) : format(date, offsetAndFormat[1]);
+            Log.writeLine(LogLevels.FrameworkDebug, `Formatted [${offsetAndFormat[0]}] date [${date}] (Epoch) with [${offsetAndFormat[1]}] to: [${processedDate}]`);
+            return processedDate;
+        }
+        catch (err) {
+            const errorText = `Error formatting date [${date}] with format string[${offsetAndFormat[1]}]: ${err?.message ?? "<Unknown error>"}}`;
+            throw new Error(errorText + "/r" + (err?.stack ?? ""));
+        }
+    }
+    static doDateTokenNonAsyncVerbs(date, dateTokenPrep) {
+        let returnDate = date;
+        switch (dateTokenPrep.verb) {
+            case "random": {
+                if (Utils.isNullOrUndefined(dateTokenPrep.params)) {
+                    throw new Error(dateTokenPrep.errRandomParams);
+                }
+                else {
+                    returnDate = this.doRandomDate(dateTokenPrep.params);
+                }
+                break;
+            }
+            case "today":
+            case "now":
+                break;
+            case "yesterday":
+                returnDate = addDays(date, -1).getTime();
+                break;
+            case "tomorrow":
+                returnDate = addDays(date, 1).getTime();
+                break;
+            case "addyears":
+                returnDate = addYears(date, this.getParsedDateOffset(dateTokenPrep.params, dateTokenPrep.errParseDateOffset)).getTime();
+                break;
+            case "addmonths":
+                returnDate = addMonths(date, this.getParsedDateOffset(dateTokenPrep.params, dateTokenPrep.errParseDateOffset)).getTime();
+                break;
+            case "adddays":
+                returnDate = addDays(date, this.getParsedDateOffset(dateTokenPrep.params, dateTokenPrep.errParseDateOffset)).getTime();
+                break;
+            case "addhours":
+                returnDate = addHours(date, this.getParsedDateOffset(dateTokenPrep.params, dateTokenPrep.errParseDateOffset)).getTime();
+                break;
+            case "addMinutes":
+                returnDate = addMinutes(date, this.getParsedDateOffset(dateTokenPrep.params, dateTokenPrep.errParseDateOffset)).getTime();
+                break;
+            case "followingday": {
+                if (Utils.isNullOrUndefined(dateTokenPrep.params)) {
+                    throw new Error(dateTokenPrep.errFollowingDayParams);
+                }
+                else {
+                    const currentAndDay = dateTokenPrep.params.split(",");
+                    if (currentAndDay.length != 2)
+                        throw new Error(dateTokenPrep.errFollowingDayParams);
+                    returnDate = this.getFollowingDay(this.getParsedDateOffset(currentAndDay[0], dateTokenPrep.errInvalidEpoch), currentAndDay[1].toLowerCase(), dateTokenPrep.errFollowingDayParams).getTime();
+                }
+                break;
+            }
+            default:
+                if (/^\d{4}-\d{1,2}-\d{1,2}$/.test(dateTokenPrep.verb)) {
+                    // we have a fixed date.  User must be wanted to just format a date....
+                    const date = dateTokenPrep.verb.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
+                    const year = Number(date[1]) ?? 0;
+                    const month = (Number(date[2]) ?? 0) - 1;
+                    const day = Number(date[3]) ?? 0;
+                    Log.writeLine(LogLevels.FrameworkInformation, `Date got fixed date:- >>${year}<<>>${month}<<>>${day}<<`);
+                    const fullEpoch = new Date(Date.UTC(year, month, day, 0, 0, 0));
+                    Log.writeLine(LogLevels.FrameworkInformation, `... which is:- >>${fullEpoch}<<`);
+                    returnDate = fullEpoch.getTime();
+                }
+                else {
+                    throw dateTokenPrep.errInvalidDateVerb;
+                }
+        }
+        return returnDate;
+    }
+    static doDateToken(state, tokenBody) {
+        let date = new Date().getTime();
+        const dateTokenPrep = this.doDateTokenPreamble(date, state, tokenBody);
+        switch (dateTokenPrep.verb) {
+            case "timezoneoffset": {
+                return this.getOffset(state, date);
+            }
+            case "addworkingdays":
+            case "followingworkingday":
+            case "nextpublicholiday": {
+                const errorString = `${dateTokenPrep.verb} uses asynchoronous calls.  Use Detokenise.asyncDo`;
+                Log.writeLine(LogLevels.Error, errorString);
+                throw `Detokeniser: ${errorString}`;
+            }
+            default:
+                date = this.doDateTokenNonAsyncVerbs(date, dateTokenPrep);
+        }
+        return this.doDateTokenPostamble(dateTokenPrep.offsetAndFormat, date, dateTokenPrep.stateIANAZone);
+    }
+    static async asyncDoDateToken(state, tokenBody) {
+        let date = new Date().getTime();
+        Log.writeLine(LogLevels.FrameworkDebug, `asyncDoDateToken - Calling preAmble: Dates [${date}], State [${state}], Token Body [${tokenBody}]`);
+        const dateTokenPrep = this.doDateTokenPreamble(date, state, tokenBody);
+        Log.writeLine(LogLevels.FrameworkDebug, `asyncDoDateToken - Back from doDateTokenPreamble.  Verb ${dateTokenPrep.verb}`);
+        switch (dateTokenPrep.verb) {
+            case "timezoneoffset": {
+                return this.getOffset(state, date);
+            }
+            case "addworkingdays": {
+                // Adds days to current date not counting public holidays or weekends
+                try {
+                    if (Utils.isNullOrUndefined(dateTokenPrep.params)) {
+                        throw new Error(dateTokenPrep.errAddWorkingDaysParams);
+                    }
+                    const paramArray = dateTokenPrep.params.split(",");
+                    if (paramArray.length < 1) {
+                        throw new Error(dateTokenPrep.errAddWorkingDaysParams);
+                    }
+                    const numberOfDays = Number(paramArray[0]);
+                    const ascending = !(numberOfDays < 0);
+                    // Get the date not counting weekends
+                    const startDate = date;
+                    let endDate = startDate;
+                    let daysRemaining = numberOfDays;
+                    while (daysRemaining != 0) {
+                        endDate = addDays(endDate, ascending ? +1 : -1).getTime();
+                        while ((await PublicHolidays.isDatePublicHoliday(endDate, state)) ||
+                            Number(dateTokenPrep.stateIANAZone ? formatInTimeZone(endDate, dateTokenPrep.stateIANAZone, "e") : format(endDate, "e")) == 1 ||
+                            Number(dateTokenPrep.stateIANAZone ? formatInTimeZone(endDate, dateTokenPrep.stateIANAZone, "e") : format(endDate, "e")) == 7) {
+                            endDate = addDays(endDate, ascending ? +1 : -1).getTime();
+                        }
+                        daysRemaining += ascending ? -1 : 1;
+                    }
+                    date = endDate;
+                }
+                catch (err) {
+                    Log.writeLine(LogLevels.Error, `Error processing addworkingdays: ${err?.message ?? "<Unknown error>"}`);
+                }
+                break;
+            }
+            case "followingworkingday": {
+                if (Utils.isNullOrUndefined(dateTokenPrep.params)) {
+                    throw new Error(dateTokenPrep.errFollowingDayParams);
+                }
+                else {
+                    // So, first get the followingday...
+                    const body = `followingDay(${dateTokenPrep.params});epoch`;
+                    Log.writeLine(LogLevels.FrameworkDebug, `asyncDoDateToken - Calling doDateToken for followingDay.  State = [${state}]. Body = [${body}]`);
+                    let workingDate = Number(this.doDateToken(state, body));
+                    Log.writeLine(LogLevels.FrameworkDebug, `got from doDateToken followingDay.  workingDate = ${workingDate}`);
+                    // Then, check it is not a weekend or public holiday anywhere.  Move forward if it is...
+                    while (Number(dateTokenPrep.stateIANAZone ? formatInTimeZone(workingDate, dateTokenPrep.stateIANAZone, "e") : format(workingDate, "e")) == 7 ||
+                        Number(dateTokenPrep.stateIANAZone ? formatInTimeZone(workingDate, dateTokenPrep.stateIANAZone, "e") : format(workingDate, "e")) == 1 ||
+                        (await PublicHolidays.isDatePublicHoliday(workingDate, state))) {
+                        workingDate = addDays(workingDate, 1).getTime();
+                    }
+                    date = workingDate;
+                }
+                break;
+            }
+            case "nextpublicholiday": {
+                if (Utils.isNullOrUndefined(dateTokenPrep.params)) {
+                    throw new Error(dateTokenPrep.errNextPublicHoldayParams);
+                }
+                else {
+                    const paramArray = dateTokenPrep.params.split(",");
+                    if (paramArray.length != 2) {
+                        throw new Error(dateTokenPrep.errNextPublicHoldayParams);
+                    }
+                    else {
+                        date = (await this.getNextPublicHoliday(Number(paramArray[0]), state, Number(paramArray[1]))).getTime();
+                    }
+                }
+                break;
+            }
+            default:
+                date = this.doDateTokenNonAsyncVerbs(date, dateTokenPrep);
+        }
+        return this.doDateTokenPostamble(dateTokenPrep.offsetAndFormat, date, dateTokenPrep.stateIANAZone);
+    }
+    static async getNextPublicHoliday(dateEpoch, state, maxDaysAway) {
+        // So, to do this we get all public holidays upto maxDaysAway; first holiday is day we want!  easy!!!
+        if (state == undefined) {
+            const errMsg = "Cannot get next public holiday, State not defined (Use {Date(<state>);......})";
+            Log.writeLine(LogLevels.Error, errMsg);
+            throw new Error(errMsg);
+        }
+        const startDate = new Date(dateEpoch).getTime();
+        const endDate = addDays(startDate, maxDaysAway).getTime();
+        const stateIANAZone = PublicHolidays.getIANAZone(state);
+        const nextPublicHoliday = await PublicHolidays.getFirstPublicHolidayBetweenDates(startDate, endDate, state);
+        if (Utils.isNullOrUndefined(nextPublicHoliday)) {
+            throw new Error(`No public holiday found between ${formatInTimeZone(startDate, stateIANAZone, "YYYY-MM-dd")} and ${formatInTimeZone(startDate, stateIANAZone, "YYYY-MM-dd")} for State: ${state} (${stateIANAZone})`);
+        }
+        Log.writeLine(LogLevels.FrameworkInformation, `Found Public holiday: ${formatInTimeZone(nextPublicHoliday.date, stateIANAZone, "yyyy-MM-dd")} State: ${state} (${stateIANAZone})`);
+        return nextPublicHoliday.date;
+    }
+    static getFollowingDay(currentDateEpoch, requiredDayOfTheWeek, errorString) {
+        const dayName = requiredDayOfTheWeek.toLowerCase();
+        const requiredDayOfWeek = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"].findIndex((item) => {
+            if (item == dayName)
+                return true;
+            return false;
+        });
+        if (requiredDayOfWeek == -1)
+            throw new Error(errorString);
+        const actualDayOfWeek = new Date(currentDateEpoch).getUTCDay() - 1;
+        if (actualDayOfWeek < requiredDayOfWeek) {
+            return addDays(currentDateEpoch, requiredDayOfWeek - actualDayOfWeek);
+        }
+        else {
+            return addDays(currentDateEpoch, requiredDayOfWeek + 7 - actualDayOfWeek);
+        }
+    }
+    static getParsedDateOffset(numString, errorMessage) {
+        if (Utils.isNullOrUndefined(numString)) {
+            throw `${errorMessage} Got [No Params!]`;
+        }
+        else {
+            const offsetValue = parseInt(numString?.trim());
+            if (isNaN(offsetValue))
+                throw `${errorMessage} Got [${numString?.trim()}]`;
+            return offsetValue;
+        }
+    }
+    static doRandomDate(maxAndMinDates) {
+        const maxAndMin = maxAndMinDates.split(",");
+        if (maxAndMin.length != 2 || Number.isNaN(+maxAndMin[0]) || Number.isNaN(+maxAndMin[1]))
+            throw new Error(`Invalid Maximum and Minimum dates. Expect {random;date(fromEpoch,toEpoch);<format>}. Max/min was: [${maxAndMinDates}]`);
+        const minDate = Number(maxAndMin[0]);
+        const maxDate = Number(maxAndMin[1]);
+        if (minDate > maxDate)
+            throw new Error(`Minimum date greater than maximum!! Max/min was: [${maxAndMinDates}]`);
+        return minDate + Math.abs(Utils.getRandomInt(0, this.numberOfDays(minDate, maxDate) - 1)) * 1000 * 60 * 60 * 24;
+    }
+    static getOffset(state, dateOfOffset) {
+        if (state == undefined) {
+            const errMsg = "Unable to get timezone offset as no state provided.  Expect {Date(<state>);TimezoneOffset}";
+            Log.writeLine(LogLevels.Error, errMsg);
+            throw new Error(errMsg);
+        }
+        const offsetMilliseconds = getTimezoneOffset(PublicHolidays.getIANAZone(state), dateOfOffset);
+        const offsetSeconds = Math.floor(offsetMilliseconds / 1000);
+        const offsetHours = secondsToHours(offsetSeconds);
+        const offsetMinutes = secondsToMinutes(offsetSeconds - offsetHours * 3600);
+        const offset = (offsetSeconds < 0 ? "-" : "+") + Utils.pad(offsetHours, 2) + Utils.pad(offsetMinutes, 2);
+        Log.writeLine(LogLevels.FrameworkInformation, `Got current offset (${offset}) from UTC for [${state}]`);
+        return offset;
+    }
+    static numberOfDays(minDate, maxDate) {
+        Log.writeLine(LogLevels.FrameworkDebug, `Min date [${minDate}], Max date[${maxDate}]`);
+        const MS_PER_DAY = 1000 * 60 * 60 * 24;
+        const numberOfDays = Math.floor(Math.abs((minDate - maxDate) / MS_PER_DAY)) + 1;
+        Log.writeLine(LogLevels.FrameworkDebug, `Min date [${minDate}], Max date[${maxDate}].  Number of days [${numberOfDays}]`);
+        return numberOfDays;
+    }
+    static doRandomFloat(limits) {
+        const minimumAndMaximum = limits.split(",");
+        if (minimumAndMaximum.length != 2)
+            throw new Error(`Invalid Maximum and Minimum floats. Expect {{random.float(min;max),<format>}}. Max/min was: [${limits}]`);
+        const min = parseFloat(minimumAndMaximum[0]);
+        const max = parseFloat(minimumAndMaximum[1]);
+        if (isNaN(min))
+            throw new Error(`Invalid Minimum float. Expect {{random.float(min;max),<format>}}. Max/min was: [${limits}]`);
+        if (isNaN(max))
+            throw new Error(`Invalid Maximum float. Expect {{random.float(min;max),<format>}}. Max/min was: [${limits}]`);
+        return Utils.getRandomFloat(min, max);
+    }
+}
+Detokeniser._endTokenChar = "]]";
+Detokeniser._startTokenChar = "[[";
+Detokeniser.EscapeChar = "/";
+Detokeniser._delimiter = "|";
+Detokeniser._asyncCallbacks = undefined;
+Detokeniser._syncCallbacks = undefined;
+class InnermostToken {
+    constructor(inputString, StartTokenChar, EndTokenChar, EscapeChar) {
+        let startIndex = -1;
+        let endIndex = -1;
+        this.escapeChar = EscapeChar;
+        // Find the first (leftmost) non-escaped end token sequence. Because we search left-to-right this naturally
+        // gives us the innermost token when tokens are nested.
+        for (let index = 0; index <= inputString.length - EndTokenChar.length; index++) {
+            if (inputString.startsWith(EndTokenChar, index) && !this.isEscaped(inputString, index)) {
+                endIndex = index;
+                break;
+            }
+        }
+        // Now scan right-to-left from just before the end sequence to find the matching non-escaped start sequence.
+        if (endIndex !== -1) {
+            for (let index = endIndex - 1; index >= 0; index--) {
+                if (inputString.startsWith(StartTokenChar, index) && !this.isEscaped(inputString, index)) {
+                    startIndex = index;
+                    break;
+                }
+            }
+        }
+        if (startIndex !== -1 && endIndex !== -1) {
+            this.tokenPreamble = inputString.substring(0, startIndex);
+            this.tokenPostamble = inputString.substring(endIndex + EndTokenChar.length);
+            this._childToken = inputString.substring(startIndex, endIndex); // includes StartTokenChar, excludes EndTokenChar
+        }
+        else {
+            this.tokenPreamble = inputString;
+            this.tokenPostamble = "";
+            this._childToken = "";
+        }
+        this.foundToken = startIndex !== -1 && endIndex !== -1;
+    }
+    get preamble() {
+        return this.tokenPreamble;
+    }
+    get postamble() {
+        return this.tokenPostamble;
+    }
+    get childToken() {
+        return this._childToken;
+    }
+    get hasToken() {
+        return this.foundToken;
+    }
+    isEscaped(fullString, positionToTest) {
+        let index;
+        let escapeCharCount = 0;
+        let returnIsEscaped = false;
+        if (positionToTest > 0) {
+            index = positionToTest;
+            while (!(--index < 0)) {
+                if (fullString[index] == this.escapeChar) {
+                    escapeCharCount++;
+                }
+                else {
+                    break;
+                }
+            }
+            if (escapeCharCount % 2 == 1) {
+                returnIsEscaped = true;
+            }
+        }
+        return returnIsEscaped;
+    }
+}