gulp-mu-gulp-api 0.3.5 → 0.3.8

package/src/i18x-hyphen.mjs

@@ -0,0 +1,166 @@
+// ===========================================
+// i18x-hyphen.mjs — TeX-style hyphenation (µLib / i18xe-compatible)
+// © 2026 Meinolf Amekudzi
+// ===========================================
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const HYPHEN_CHAR = '\xAD'; // U+00AD soft hyphen
+const hyphenData = {};
+const hyphenCache = {};
+
+/** Directory holding hyphen rule files: env override or `<cwd>/i18x/prod`. */
+function _HyphenDir() {
+	return process.env.MICROGULP_I18X_HYPHEN_DIR || join(process.cwd(), 'i18x', 'prod');
+}
+
+/**
+ * Loads hyphen rules for a localization id from `<dir>/<lid>.hyphen.json`.
+ * Missing or broken files yield a no-op catalog (`{ exist: false }`).
+ * @param {string} _lid
+ * @returns {object}
+ */
+export function LoadHyphenData(_lid) {
+	if (hyphenData[_lid]) return hyphenData[_lid];
+	let data = { exist: false };
+	try {
+		let filePath = join(_HyphenDir(), _lid + '.hyphen.json');
+		if (existsSync(filePath)) data = JSON.parse(readFileSync(filePath, 'utf8'));
+	} catch {
+		// Malformed hyphen data must not break the build — fall back to no-op.
+	}
+	if (!data || typeof data !== 'object') data = { exist: false };
+	hyphenData[_lid] = data;
+	hyphenCache[_lid] = {};
+	return data;
+}
+
+/**
+ * Hyphenates a single word; returns the original when no rules exist.
+ * @param {string} _word
+ * @param {string} _lid
+ * @returns {string}
+ */
+export function WordHyphenation(_word, _lid) {
+	let word = String(_word);
+	let data = LoadHyphenData(_lid);
+	if (!data.exist) return word;
+	if (!hyphenCache[_lid]) hyphenCache[_lid] = {};
+	if (hyphenCache[_lid][word]) return hyphenCache[_lid][word];
+
+	let lower = word.toLowerCase();
+	let ret = word;
+
+	if (!data.exceptions?.[lower]) {
+		let sylbs = data.sylbs;
+		let minSylbs = data.minSylbs;
+		let maxSylbs = data.maxSylbs;
+		let l = word.length + 1;
+		let myword = '.' + lower;
+		let vals = new Array(l + 1).fill(0);
+		for (let i = 0; i < l; i++) {
+			let sylb = '';
+			for (let j = 0; (i + j) < l; j++) {
+				sylb += myword.charAt(i + j);
+				if (j >= minSylbs && j <= maxSylbs) {
+					if (Object.prototype.hasOwnProperty.call(sylbs, sylb)) {
+						let sylbVals = sylbs[sylb];
+						let sl = sylb.length;
+						for (let k = -1; k <= sl; k++) vals[i + k] = Math.max(sylbVals[k + 1], vals[i + k]);
+					}
+				} else if (j > maxSylbs) break;
+			}
+		}
+		ret = '';
+		let k = l - 3;
+		let m = 2;
+		l--;
+		for (let i = 0; i < l; i++) {
+			if ((vals[i] % 2) === 1 && i > m && i < k) ret += HYPHEN_CHAR;
+			ret += word.charAt(i);
+		}
+	} else {
+		let w = data.exceptions[lower];
+		let j = 0;
+		for (let i = 0; i < w.length; i++) {
+			if (w.charAt(i) === HYPHEN_CHAR) {
+				ret += word.charAt(j++);
+			} else {
+				ret += w.charAt(i);
+			}
+		}
+	}
+
+	hyphenCache[_lid][word] = ret;
+	return ret;
+}
+
+/**
+ * Hyphenates every word in a text; preserves HTML/XML tags.
+ * @param {string} _text
+ * @param {string} _lid
+ * @returns {string}
+ */
+export function Hyphenation(_text, _lid) {
+	let txts = String(_text);
+	let ret = [];
+
+	if (txts.indexOf('<') >= 0 && txts.indexOf('>') >= 0) {
+		let tags = {};
+		let matches = txts.match(/(<[^>]+>)/g);
+		if (matches != null) {
+			for (let i = 0; i < matches.length; i++) {
+				tags[matches[i]] = '\x7F' + i + '\x7F';
+				txts = txts.replace(matches[i], tags[matches[i]]);
+			}
+		}
+		let words = txts.split(' ');
+		for (let i = 0; i < words.length; i++) {
+			let t = words[i].trim();
+			ret.push(t ? WordHyphenation(t, _lid) : t);
+		}
+		txts = ret.join(' ');
+		if (matches != null) {
+			for (let i = 0; i < matches.length; i++) txts = txts.replace(tags[matches[i]], matches[i]);
+		}
+		return txts;
+	}
+
+	let words = txts.split(' ');
+	for (let i = 0; i < words.length; i++) {
+		let t = words[i].trim();
+		ret.push(t ? WordHyphenation(t, _lid) : t);
+	}
+	return ret.join(' ');
+}
+
+/** @param {string} _target @param {string} _name @param {Function} _value */
+function _DefinePrototype(_target, _name, _value) {
+	if (typeof _target[_name] !== 'function') {
+		Object.defineProperty(_target, _name, { value: _value, writable: true, configurable: true });
+	}
+}
+
+/**
+ * Installs µLib- and i18xe-compatible String hyphenation prototypes.
+ * @param {function(): string} [_resolveLid] defaults to empty string when omitted
+ */
+export function InstallHyphenPrototypes(_resolveLid) {
+	function _ResolveLid(_lid) {
+		if (_lid) return _lid;
+		try {
+			return _resolveLid?.() ?? '';
+		} catch {
+			return '';
+		}
+	}
+	let wordFn = function (_lid = '') { return WordHyphenation(String(this), _ResolveLid(_lid)); };
+	let textFn = function (_lid = '') { return Hyphenation(String(this), _ResolveLid(_lid)); };
+	_DefinePrototype(String.prototype, 'WordHyphenation', wordFn);
+	_DefinePrototype(String.prototype, 'Hyphenation', textFn);
+	_DefinePrototype(String.prototype, 'wordHyphenation', wordFn);
+	_DefinePrototype(String.prototype, 'hyphenation', textFn);
+}
+
+export default { HYPHEN_CHAR, LoadHyphenData, WordHyphenation, Hyphenation, InstallHyphenPrototypes };

package/src/i18x.mjs

@@ -31,6 +31,8 @@
 
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { Trans as EngineTrans, FormatValue as EngineFormatValue, RegisterFormat } from './i18x-engine.mjs';
+import { InstallHyphenPrototypes as _InstallHyphenPrototypes } from './i18x-hyphen.mjs';
 
 const DEFAULT_LID = 'en-US';
 
@@ -51,6 +53,7 @@ const LIDS_MAIN_CULTURES = {
 
 let dictionaryCache = new Map();
 let formatDefinitionCache = new Map();
+let formatRegistryCache = new Map();
 let availableLids = null;
 let activeLid = null;
 const timeZoneFormatters = {};
@@ -90,6 +93,22 @@ export function DateInTimeZone(_date, _timeZone) {
 	}
 }
 
+/**
+ * Offset in minutes (UTC minus wall-clock, same sign as Date.getTimezoneOffset).
+ * @param {Date|number} _date
+ * @param {string} [_timeZone]
+ * @returns {number}
+ */
+export function TimeZoneOffset(_date, _timeZone) {
+	let date = _date instanceof Date ? _date : new Date(Number(_date) || 0);
+	let shifted = DateInTimeZone(date, _timeZone);
+	let wallAsUTC = Date.UTC(
+		shifted.getFullYear(), shifted.getMonth(), shifted.getDate(),
+		shifted.getHours(), shifted.getMinutes(), shifted.getSeconds(), shifted.getMilliseconds(),
+	);
+	return Math.round((date.getTime() - wallAsUTC) / 60000);
+}
+
 /** Normalizes casing: language lower, 2-letter region upper, 4-letter script Title. */
 function _NormalizeLid(_lid) {
 	if (!_lid) return '';
@@ -177,6 +196,7 @@ export function GetLid() {
 export function SetLid(_lid) {
 	activeLid = _lid ? _BestAvailableLid(_lid, _AvailableLids()) : null;
 	formatDefinitionCache.clear();
+	formatRegistryCache.clear();
 }
 
 /** Loads and caches `<dir>/<lid>.json`; a missing/broken file yields source text. */
@@ -215,101 +235,58 @@ function _LoadFormatDefinitions(_lid) {
 	return formats;
 }
 
-/** Formats milliseconds as M:SS or H:MM:SS (progress bar durations). */
-function _FormatDuration(_ms) {
-	let ms = Math.max(0, Number(_ms) || 0);
-	let totalSeconds = Math.round(ms / 1000);
-	let seconds = totalSeconds % 60;
-	let minutes = Math.floor(totalSeconds / 60) % 60;
-	let hours = Math.floor(totalSeconds / 3600);
-	let pad = (_n) => String(_n).padStart(2, '0');
-	return hours > 0 ? hours + ':' + pad(minutes) + ':' + pad(seconds) : minutes + ':' + pad(seconds);
+/** Builds (and caches) the name→parsed-definition format registry for a language. */
+function _FormatRegistry(_lid) {
+	if (formatRegistryCache.has(_lid)) return formatRegistryCache.get(_lid);
+	let registry = Object.create(null);
+	let definitions = _LoadFormatDefinitions(_lid);
+	for (let xml of Object.values(definitions)) RegisterFormat(registry, xml, false);
+	formatRegistryCache.set(_lid, registry);
+	return registry;
+}
+
+/** Assembles the engine render context (language, timezone, format registry). */
+function _RenderContext(_lid, _timeZone) {
+	let lid = _lid ?? GetLid();
+	return { lid, timeZone: _timeZone ?? GetTimeZone(), formats: _FormatRegistry(lid) };
 }
 
 /**
- * Formats a numeric value with a named i18xe format definition from the
- * project's i18x/gulp dictionaries (synced from i18xe prod).
+ * Formats a numeric/date value with a named i18xe format definition from the
+ * project's i18x/gulp dictionaries (synced from i18xe prod). Delegates to the
+ * eval-free i18x engine, so the full i18x notation (fill/padding, `if`
+ * conditions, nested formats, expressions, enumerations, date parts) is honored.
+ * Date/time formats interpret the value as milliseconds since the Unix epoch.
  * @param {number|string} _value
- * @param {string} _formatName e.g. 'int', 'floatFix2', 'byteSize'
+ * @param {string} _formatName e.g. 'int', 'floatFix2', 'byteSize', 'stdDateTime'
  * @param {string} [_lid]
+ * @param {string} [_timeZone] IANA timezone id (defaults to GetTimeZone())
  * @returns {string}
  */
-export function FormatValue(_value, _formatName, _lid) {
-	let lid = _lid ?? GetLid();
-	let tz = GetTimeZone();
-	if (_formatName === 'progressDuration') return _FormatDuration(Number(_value));
-	if (_formatName === 'stdTime') {
-		let date = new Date(Number(_value) || 0);
-		try {
-			return new Intl.DateTimeFormat(lid, { hour: '2-digit', minute: '2-digit', timeZone: tz }).format(date);
-		} catch {
-			return date.toISOString();
-		}
-	}
-	if (_formatName === 'stdDateTime' || _formatName === 'fullDateTime') {
-		let date = new Date(Number(_value) || 0);
-		try {
-			return new Intl.DateTimeFormat(lid, {
-				year: 'numeric', month: '2-digit', day: '2-digit',
-				hour: '2-digit', minute: '2-digit', timeZone: tz,
-			}).format(date);
-		} catch {
-			return date.toISOString();
-		}
-	}
-	if (_formatName === 'byteSize') {
-		let bytes = Number(_value);
-		if (!Number.isFinite(bytes)) return String(_value);
-		if (bytes >= 1073741824) return FormatValue(bytes / 1073741824, 'floatFix2', lid) + ' GB';
-		if (bytes >= 1048576) return FormatValue(bytes / 1048576, 'floatFix2', lid) + ' MB';
-		if (bytes >= 1024) return FormatValue(bytes / 1024, 'floatFix2', lid) + ' KB';
-		return FormatValue(bytes, 'int', lid) + ' Bytes';
-	}
-	let number = Number(_value);
-	if (!Number.isFinite(number)) return String(_value);
-	let definition = _LoadFormatDefinitions(lid)[_formatName];
-	if (!definition) return String(_value);
-	let groupSeparator = definition.match(/<xa if="1000\|1000\+">([^<]*)<\/xa>/)?.[1] ?? ',';
-	let decimalSeparator = definition.match(/if="0~">([^<]*)<m0\/>/)?.[1]
-		?? definition.match(/<\/xa>([^<]*)<f0\/>/)?.[1] ?? '.';
-	let fractionDigits = _formatName === 'floatFix1' ? 1
-		: (_formatName.startsWith('floatFix') ? 2 : 0);
-	if (_formatName === 'int') number = Math.round(number);
-	let negative = number < 0;
-	let absolute = Math.abs(number);
-	let integerPart = String(Math.trunc(fractionDigits ? absolute : Math.round(absolute)));
-	let grouped = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
-	let fraction = fractionDigits ? decimalSeparator + absolute.toFixed(fractionDigits).split('.')[1] : '';
-	return (negative ? '-' : '') + grouped + fraction;
-}
-
-/** Substitutes `<name/>` placeholders; honors `format="…"` via FormatValue. */
-function _ApplyPlaceholders(_text, _values) {
-	let text = String(_text);
-	let lid = GetLid();
-	for (let key of Object.keys(_values ?? {})) {
-		let pattern = new RegExp('<' + key + '(?:\\s+format="([^"]*)")?\\s*/>', 'g');
-		text = text.replace(pattern, (_match, _formatName) =>
-			_formatName ? FormatValue(_values[key], _formatName, lid) : String(_values[key]));
-	}
-	return text.replace(/<[^>]*>/g, '');
+export function FormatValue(_value, _formatName, _lid, _timeZone) {
+	let context = _RenderContext(_lid, _timeZone);
+	if (!Object.prototype.hasOwnProperty.call(context.formats, _formatName)) return String(_value);
+	return EngineFormatValue(_value, _formatName, context);
 }
 
 /**
  * Translates a source phrase (including its context tag) into the active
- * language and resolves placeholders. Unknown phrases fall back to the en-US
- * source text with its tags stripped.
+ * language and renders it through the i18x engine (placeholders, `format="…"`,
+ * `if` conditions, …). Unknown phrases fall back to the en-US source text.
  * @param {string} _text source phrase, e.g. 'Build ready<context="task log"/>'
  * @param {object} [_values] placeholder values for `<name/>` tags
+ * @param {string} [_timeZone] IANA timezone id (defaults to GetTimeZone())
  * @returns {string}
  */
-export function Translate(_text, _values) {
+export function Translate(_text, _values, _timeZone) {
 	if (_text == null) return '';
 	let source = String(_text);
 	let lid = GetLid();
 	let dictionary = lid === DEFAULT_LID ? null : _LoadDictionary(lid);
 	let translated = (dictionary && Object.prototype.hasOwnProperty.call(dictionary, source)) ? dictionary[source] : source;
-	return _ApplyPlaceholders(translated, _values);
+	// The context tag is part of the dictionary key only; strip it before rendering.
+	translated = translated.replace(/<context=[^>]*>/g, '');
+	return EngineTrans(translated, _values ?? {}, _RenderContext(lid, _timeZone));
 }
 
 /**
@@ -351,7 +328,7 @@ export function LogError(_text, _values) {
 export function InstallStringExtensions() {
 	if (typeof String.prototype.I18xTrans !== 'function') {
 		Object.defineProperty(String.prototype, 'I18xTrans', {
-			value: function (_values) { return Translate(String(this), _values); },
+			value: function (_values, _timeZone) { return Translate(String(this), _values, _timeZone); },
 			writable: true, configurable: true,
 		});
 	}
@@ -373,11 +350,73 @@ export function InstallStringExtensions() {
 			writable: true, configurable: true,
 		});
 	}
+	InstallFormatPrototypes();
+	InstallHyphenPrototypes();
+}
+
+/**
+ * Installs String hyphenation prototypes (µLib + i18xe aliases). Called from
+ * InstallStringExtensions (auto-run on import); also exported for explicit control.
+ */
+export function InstallHyphenPrototypes() {
+	_InstallHyphenPrototypes(GetLid);
+}
+
+// .NET ticks are 100-nanosecond intervals since 0001-01-01; this offset is the
+// tick count at the Unix epoch (1970-01-01), so ms = (ticks - offset) / 10000.
+const TICKS_EPOCH_OFFSET = 621355968000000000;
+const TICKS_PER_MILLISECOND = 10000;
+
+/** @param {string} _name @param {Function} _value install a prototype method only if absent (µLib wins) */
+function _DefinePrototype(_target, _name, _value) {
+	if (typeof _target[_name] !== 'function') {
+		Object.defineProperty(_target, _name, { value: _value, writable: true, configurable: true });
+	}
+}
+
+/**
+ * µLib-compatible Number/Date/String `Format` prototypes for gulpfiles that
+ * prefer `(1536).Format('byteSize')` or `new Date().Format('stdDateTime')`
+ * over the FormatValue() helper. Date/time formats interpret their value as
+ * milliseconds since the Unix epoch (µGulp convention), except FormatTicks
+ * which takes .NET ticks. Never overwrites an implementation already provided
+ * by µLib (µLib wins when both are loaded). Called from InstallStringExtensions
+ * (auto-run on import); also exported for explicit control.
+ */
+export function InstallFormatPrototypes() {
+	// Number.prototype.Format — number formats use the value directly, date
+	// formats interpret it as milliseconds since the Unix epoch.
+	_DefinePrototype(Number.prototype, 'Format', function (_format, _lid, _timeZone) {
+		return FormatValue(this.valueOf(), _format, _lid, _timeZone);
+	});
+	// Number.prototype.FormatTimestamp — an explicit Unix millisecond timestamp.
+	_DefinePrototype(Number.prototype, 'FormatTimestamp', function (_format, _lid, _timeZone) {
+		return FormatValue(this.valueOf(), _format, _lid, _timeZone);
+	});
+	// Number.prototype.FormatTicks — a .NET tick count, converted to ms first.
+	_DefinePrototype(Number.prototype, 'FormatTicks', function (_format, _lid, _timeZone) {
+		let ms = (this.valueOf() - TICKS_EPOCH_OFFSET) / TICKS_PER_MILLISECOND;
+		return FormatValue(ms, _format, _lid, _timeZone);
+	});
+	// i18xe-sync lowercase aliases.
+	_DefinePrototype(Number.prototype, 'format', Number.prototype.Format);
+	_DefinePrototype(Number.prototype, 'formatTimestamp', Number.prototype.FormatTimestamp);
+	_DefinePrototype(Number.prototype, 'formatTicks', Number.prototype.FormatTicks);
+	// Date.prototype.Format — formats via the date's millisecond timestamp.
+	_DefinePrototype(Date.prototype, 'Format', function (_format, _lid, _timeZone) {
+		return FormatValue(this.getTime(), _format, _lid, _timeZone);
+	});
+	_DefinePrototype(Date.prototype, 'format', Date.prototype.Format);
+	// String.prototype.Format — µLib parity: a string has no numeric format.
+	_DefinePrototype(String.prototype, 'Format', function () {
+		return this.valueOf();
+	});
 }
 
 InstallStringExtensions();
 
 export default {
-	GetLid, SetLid, GetTimeZone, DateInTimeZone,
-	Translate, FormatValue, Log, Warn, LogError, InstallStringExtensions,
+	GetLid, SetLid, GetTimeZone, DateInTimeZone, TimeZoneOffset,
+	Translate, FormatValue, Log, Warn, LogError,
+	InstallStringExtensions, InstallFormatPrototypes, InstallHyphenPrototypes,
 };

package/src/index.mjs

@@ -30,7 +30,8 @@
 
 // Localized console output (i18x). Re-exported so tasks import everything
 // from one place: `import { Log, Warn, ReportProgress } from 'gulp-mu-gulp-api'`.
-export { Log, Warn, LogError, Translate, FormatValue, GetLid, SetLid, GetTimeZone, DateInTimeZone, InstallStringExtensions } from './i18x.mjs';
+export { Log, Warn, LogError, Translate, FormatValue, GetLid, SetLid, GetTimeZone, DateInTimeZone, TimeZoneOffset, InstallStringExtensions, InstallFormatPrototypes, InstallHyphenPrototypes } from './i18x.mjs';
+export { WordHyphenation, Hyphenation, LoadHyphenData } from './i18x-hyphen.mjs';
 import * as I18x from './i18x.mjs';
 
 let uiRequestCounter = 0;
@@ -207,6 +208,77 @@ export function LogBuildDebugReport(_report, _options = {}) {
 	});
 }
 
+/**
+ * Sends a highlighted callout box (info/success/warning/error) to the dashboard
+ * log pane. The payload is JSON: `{ variant, title?, message }`.
+ * CLI fallback: a bracketed line on stdout.
+ *
+ * @param {object} _spec `{ variant?: 'info'|'success'|'warning'|'error', title?, message }`
+ */
+export function LogCallout(_spec) {
+	let payload = _NormalizeCalloutSpec(_spec);
+	if (_SendStructuredLog('callout', payload)) return;
+	let head = payload.variant.toUpperCase() + (payload.title ? ': ' + payload.title : '');
+	console.log('[' + head + '] ' + payload.message);
+}
+
+/**
+ * Sends a key/value list (metrics, build summary, environment) to the dashboard
+ * log pane. The payload is JSON: `{ title?, items: {key, value}[] }`.
+ * CLI fallback: aligned `key: value` lines on stdout.
+ *
+ * @param {object} _spec `{ title?, items: Array<{key, value}> | Record<string, any> }`
+ */
+export function LogKeyValue(_spec) {
+	let payload = _NormalizeKeyValueSpec(_spec);
+	if (_SendStructuredLog('key-value', payload)) return;
+	if (payload.title) console.log(payload.title);
+	let width = payload.items.reduce((_max, _item) => Math.max(_max, _item.key.length), 0);
+	for (let item of payload.items) console.log('  ' + item.key.padEnd(width) + '  ' + item.value);
+}
+
+/**
+ * Sends a row of status badges/chips to the dashboard log pane. The payload is
+ * JSON: `{ title?, items: {label, variant?}[] }`.
+ * CLI fallback: bracketed labels on one stdout line.
+ *
+ * @param {object} _spec `{ title?, items: Array<string|{label, variant?}> }`
+ */
+export function LogBadges(_spec) {
+	let payload = _NormalizeBadgesSpec(_spec);
+	if (_SendStructuredLog('badges', payload)) return;
+	let chips = payload.items.map((_item) => '[' + _item.label + ']').join(' ');
+	console.log((payload.title ? payload.title + ' ' : '') + chips);
+}
+
+/**
+ * Sends a code block (monospace, preserved whitespace) to the dashboard log
+ * pane. The payload is JSON: `{ title?, language?, code }`.
+ * CLI fallback: the code printed verbatim on stdout.
+ *
+ * @param {object} _spec `{ title?, language?, code }`
+ */
+export function LogCode(_spec) {
+	let payload = _NormalizeCodeSpec(_spec);
+	if (_SendStructuredLog('code', payload)) return;
+	if (payload.title) console.log(payload.title + (payload.language ? ' (' + payload.language + ')' : ''));
+	console.log(payload.code);
+}
+
+/**
+ * Sends a bar chart to the dashboard log pane, rendered as inline SVG (no
+ * scripts — Content-Security-Policy safe). The payload is JSON:
+ * `{ title?, type?: 'bar', series: {label, value, color?}[], max?, unit? }`.
+ * CLI fallback: an ASCII bar chart on stdout.
+ *
+ * @param {object} _spec `{ title?, type?, series: Array<{label, value, color?}>, max?, unit? }`
+ */
+export function LogChart(_spec) {
+	let payload = _NormalizeChartSpec(_spec);
+	if (_SendStructuredLog('chart', payload)) return;
+	for (let line of _AsciiChart(payload)) console.log(line);
+}
+
 // -------------------------------------------------
 // sound & speech
 // -------------------------------------------------
@@ -553,6 +625,98 @@ function _AsciiGallery(_payload) {
 	return lines.join('\n');
 }
 
+const CALLOUT_VARIANTS = new Set(['info', 'success', 'warning', 'error']);
+
+function _NormalizeCalloutSpec(_spec) {
+	let variant = String(_spec?.variant ?? 'info').toLowerCase();
+	if (!CALLOUT_VARIANTS.has(variant)) variant = 'info';
+	return {
+		variant,
+		title: _spec?.title != null ? String(_spec.title) : '',
+		message: String(_spec?.message ?? _spec?.text ?? ''),
+	};
+}
+
+function _NormalizeKeyValueSpec(_spec) {
+	let rawItems = _spec?.items ?? _spec ?? [];
+	let items = [];
+	if (Array.isArray(rawItems)) {
+		for (let item of rawItems) {
+			if (item == null) continue;
+			if (typeof item === 'object' && !Array.isArray(item)) {
+				items.push({ key: String(item.key ?? ''), value: String(item.value ?? '') });
+			} else if (Array.isArray(item)) {
+				items.push({ key: String(item[0] ?? ''), value: String(item[1] ?? '') });
+			}
+		}
+	} else if (rawItems && typeof rawItems === 'object') {
+		for (let [key, value] of Object.entries(rawItems)) {
+			if (key === 'title') continue;
+			items.push({ key: String(key), value: String(value) });
+		}
+	}
+	return { title: _spec?.title != null ? String(_spec.title) : '', items };
+}
+
+const BADGE_VARIANTS = new Set(['neutral', 'info', 'success', 'warning', 'error']);
+
+function _NormalizeBadgesSpec(_spec) {
+	let items = (_spec?.items ?? []).map((_item) => {
+		if (_item == null) return null;
+		if (typeof _item === 'object') {
+			let variant = String(_item.variant ?? 'neutral').toLowerCase();
+			return { label: String(_item.label ?? _item.value ?? ''), variant: BADGE_VARIANTS.has(variant) ? variant : 'neutral' };
+		}
+		return { label: String(_item), variant: 'neutral' };
+	}).filter((_item) => _item && _item.label);
+	return { title: _spec?.title != null ? String(_spec.title) : '', items };
+}
+
+function _NormalizeCodeSpec(_spec) {
+	return {
+		title: _spec?.title != null ? String(_spec.title) : '',
+		language: _spec?.language != null ? String(_spec.language) : '',
+		code: String(_spec?.code ?? _spec?.text ?? ''),
+	};
+}
+
+function _NormalizeChartSpec(_spec) {
+	let series = (_spec?.series ?? _spec?.data ?? []).map((_entry) => {
+		if (_entry == null) return null;
+		if (typeof _entry === 'object' && !Array.isArray(_entry)) {
+			return {
+				label: String(_entry.label ?? ''),
+				value: Number(_entry.value) || 0,
+				color: _entry.color != null ? String(_entry.color) : '',
+			};
+		}
+		if (Array.isArray(_entry)) return { label: String(_entry[0] ?? ''), value: Number(_entry[1]) || 0, color: '' };
+		return { label: '', value: Number(_entry) || 0, color: '' };
+	}).filter(Boolean);
+	let explicitMax = Number(_spec?.max);
+	let dataMax = series.reduce((_max, _entry) => Math.max(_max, _entry.value), 0);
+	return {
+		title: _spec?.title != null ? String(_spec.title) : '',
+		type: 'bar',
+		unit: _spec?.unit != null ? String(_spec.unit) : '',
+		max: Number.isFinite(explicitMax) && explicitMax > 0 ? explicitMax : (dataMax || 1),
+		series,
+	};
+}
+
+function _AsciiChart(_payload) {
+	let lines = [];
+	if (_payload.title) lines.push(_payload.title);
+	let labelWidth = _payload.series.reduce((_max, _entry) => Math.max(_max, _entry.label.length), 0);
+	const BAR_WIDTH = 24;
+	for (let entry of _payload.series) {
+		let filled = _payload.max > 0 ? Math.round((entry.value / _payload.max) * BAR_WIDTH) : 0;
+		let bar = '\u2588'.repeat(filled) + '\u00b7'.repeat(Math.max(0, BAR_WIDTH - filled));
+		lines.push('  ' + entry.label.padEnd(labelWidth) + '  ' + bar + '  ' + entry.value + (_payload.unit ? ' ' + _payload.unit : ''));
+	}
+	return lines;
+}
+
 export default {
 	IsMicroGulp,
 	IsµGulp,
@@ -576,10 +740,18 @@ export default {
 	SetLid: I18x.SetLid,
 	GetTimeZone: I18x.GetTimeZone,
 	DateInTimeZone: I18x.DateInTimeZone,
+	TimeZoneOffset: I18x.TimeZoneOffset,
 	InstallStringExtensions: I18x.InstallStringExtensions,
+	InstallFormatPrototypes: I18x.InstallFormatPrototypes,
+	InstallHyphenPrototypes: I18x.InstallHyphenPrototypes,
 	LogTable,
 	LogTree,
 	LogGallery,
 	LogAssetPreviews,
 	LogBuildDebugReport,
+	LogCallout,
+	LogKeyValue,
+	LogBadges,
+	LogCode,
+	LogChart,
 };