@common.js/icu-minify 4.13.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jan Amann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @common.js/icu-minify
+
+The [icu-minify](https://www.npmjs.com/package/icu-minify) package exported as CommonJS modules.
+
+Exported from [icu-minify@4.13.1](https://www.npmjs.com/package/icu-minify/v/4.13.1) using https://github.com/etienne-martin/common.js.

package/compile.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export {default} from './dist/types/compile.d.ts';

package/dist/esm/development/compile.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return compile;
+    }
+});
+var _icuMessageformatParser = require("@formatjs/icu-messageformat-parser");
+var _typesDl2AHteJs = require("./types-Dl2aHte_.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function compile(message) {
+    var ast = (0, _icuMessageformatParser.parse)(message);
+    var compiled = compileNodes(ast);
+    if (compiled.length === 0) {
+        return "";
+    }
+    if (compiled.length === 1 && typeof compiled[0] === "string") {
+        return compiled[0];
+    }
+    return compiled;
+}
+function compileNodes(nodes) {
+    var result = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var node = _step.value;
+            var compiled = compileNode(node);
+            if (typeof compiled === "string" && result.length > 0 && typeof result[result.length - 1] === "string") {
+                result[result.length - 1] += compiled;
+            } else {
+                result.push(compiled);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+function compileNodesToNode(nodes) {
+    var compiled = compileNodes(nodes);
+    if (compiled.length === 0) {
+        return "";
+    }
+    if (compiled.length === 1) {
+        var node = compiled[0];
+        // Only unwrap strings and pound signs, not array-based nodes (tags, typed nodes)
+        // This preserves structure for formatBranch to correctly identify single nodes vs arrays
+        if (typeof node === "string" || node === _typesDl2AHteJs.T) {
+            return node;
+        }
+    }
+    return compiled;
+}
+function compileNode(node) {
+    switch(node.type){
+        case _icuMessageformatParser.TYPE.literal:
+            return node.value;
+        case _icuMessageformatParser.TYPE.argument:
+            return [
+                node.value
+            ];
+        case _icuMessageformatParser.TYPE.number:
+            return compileNumber(node);
+        case _icuMessageformatParser.TYPE.date:
+            return compileDate(node);
+        case _icuMessageformatParser.TYPE.time:
+            return compileTime(node);
+        case _icuMessageformatParser.TYPE.select:
+            return compileSelect(node);
+        case _icuMessageformatParser.TYPE.plural:
+            return compilePlural(node);
+        case _icuMessageformatParser.TYPE.pound:
+            return _typesDl2AHteJs.T;
+        case _icuMessageformatParser.TYPE.tag:
+            return compileTag(node);
+        default:
+            throw new Error("Unknown AST node type: ".concat(node.type));
+    }
+}
+function compileNumber(node) {
+    var result = [
+        node.value,
+        _typesDl2AHteJs.a
+    ];
+    var style = compileNumberStyle(node.style);
+    if (style !== undefined) {
+        result.push(style);
+    }
+    return result;
+}
+function compileNumberStyle(style) {
+    if (!style) {
+        return undefined;
+    }
+    if (typeof style === "string") {
+        return style;
+    }
+    if ("parsedOptions" in style) {
+        var opts = style.parsedOptions;
+        return Object.keys(opts).length > 0 ? opts : undefined;
+    }
+    return undefined;
+}
+function compileDate(node) {
+    var result = [
+        node.value,
+        _typesDl2AHteJs.b
+    ];
+    var style = compileDateTimeStyle(node.style);
+    if (style !== undefined) {
+        result.push(style);
+    }
+    return result;
+}
+function compileTime(node) {
+    var result = [
+        node.value,
+        _typesDl2AHteJs.c
+    ];
+    var style = compileDateTimeStyle(node.style);
+    if (style !== undefined) {
+        result.push(style);
+    }
+    return result;
+}
+function compileDateTimeStyle(style) {
+    if (!style) {
+        return undefined;
+    }
+    if (typeof style === "string") {
+        return style;
+    }
+    if ("parsedOptions" in style) {
+        var opts = style.parsedOptions;
+        return Object.keys(opts).length > 0 ? opts : undefined;
+    }
+    return undefined;
+}
+function compileSelect(node) {
+    var options = Object.create(null);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(node.options)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], option = _value[1];
+            options[key] = compileNodesToNode(option.value);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return [
+        node.value,
+        _typesDl2AHteJs.d,
+        options
+    ];
+}
+// Plural offset is not supported
+function compilePlural(node) {
+    if (node.offset) {
+        throw new Error("Plural offsets are not supported");
+    }
+    var options = Object.create(null);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(node.options)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], option = _value[1];
+            options[key] = compileNodesToNode(option.value);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return [
+        node.value,
+        node.pluralType === "ordinal" ? _typesDl2AHteJs.e : _typesDl2AHteJs.f,
+        options
+    ];
+}
+function compileTag(node) {
+    var children = compileNodes(node.children);
+    var result = [
+        node.value
+    ];
+    // Tags have no type number - detected at runtime by typeof node[1] !== 'number'
+    // Empty tags get an empty string child to distinguish from simple arguments
+    if (children.length === 0) {
+        result.push("");
+    } else {
+        var _result;
+        (_result = result).push.apply(_result, _toConsumableArray(children));
+    }
+    return result;
+}

package/dist/esm/development/format.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return format;
+    }
+});
+var _typesDl2AHteJs = require("./types-Dl2aHte_.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i1 = 0, arr2 = new Array(len); i1 < len; i1++)arr2[i1] = arr[i1];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i1 = 1; i1 < arguments.length; i1++){
+        var source = arguments[i1] != null ? arguments[i1] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _toArray(arr) {
+    return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+// Re-export CompiledMessage type for consumers
+// Could potentially share this with `use-intl` if we had a shared package for both
+function format(message, locale) {
+    var values = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, options = arguments.length > 3 ? arguments[3] : void 0;
+    // Hot path for plain strings
+    if (typeof message === "string") {
+        return message;
+    }
+    var result = formatNodes(message, locale, values, options, undefined);
+    return optimizeResult(result);
+}
+function formatNodes(nodes, locale, values, options, pluralCtx) {
+    var result = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = nodes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var node = _step.value;
+            var formatted = formatNode(node, locale, values, options, pluralCtx);
+            if (Array.isArray(formatted)) {
+                var _result;
+                (_result = result).push.apply(_result, _toConsumableArray(formatted));
+            } else {
+                result.push(formatted);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+function formatNode(node, locale, values, options, rawPluralCtx) {
+    if (typeof node === "string") {
+        return node;
+    }
+    if (node === _typesDl2AHteJs.T) {
+        if (!rawPluralCtx) {
+            throw new Error("# used outside of plural context");
+        }
+        var pluralCtx = rawPluralCtx;
+        return options.formatters.getNumberFormat(pluralCtx.locale).format(pluralCtx.value);
+    }
+    var _node = _toArray(node), name = _node[0], type = _node[1], rest = _node.slice(2);
+    // Simple argument: ["name"]
+    if (type === undefined) {
+        var value = getValue(values, name);
+        {
+            if (typeof value === "boolean") {
+                throw new Error('Invalid value for argument "'.concat(name, '": Boolean values are not supported and should be converted to strings if needed.'));
+            }
+            if (_instanceof(value, Date)) {
+                throw new Error('Invalid value for argument "'.concat(name, '": Date values are not supported for plain parameters. Use date formatting instead (e.g. {').concat(name, ", date})."));
+            }
+        }
+        return String(value);
+    }
+    // Tag: ["tagName", child1, child2, ...] - detected by non-number or pound marker
+    if (typeof type !== "number" || type === _typesDl2AHteJs.T) {
+        return formatTag(name, [
+            type
+        ].concat(_toConsumableArray(rest)), locale, values, options, rawPluralCtx);
+    }
+    // Typed nodes: ["name", TYPE, ...]
+    switch(type){
+        case _typesDl2AHteJs.d:
+            return formatSelect(name, rest[0], locale, values, options, rawPluralCtx);
+        case _typesDl2AHteJs.f:
+            return formatPlural(name, rest[0], locale, values, options, "cardinal");
+        case _typesDl2AHteJs.e:
+            return formatPlural(name, rest[0], locale, values, options, "ordinal");
+        case _typesDl2AHteJs.a:
+            return formatNumberValue(name, rest[0], locale, values, options);
+        case _typesDl2AHteJs.b:
+            return formatDateTimeValue(name, rest[0], locale, values, options, "date");
+        case _typesDl2AHteJs.c:
+            return formatDateTimeValue(name, rest[0], locale, values, options, "time");
+        default:
+            {
+                throw new Error("Unknown compiled node type: ".concat(type));
+            }
+    }
+}
+function getValue(values, name) {
+    if (!(name in values)) {
+        throw new Error('Missing value for argument "'.concat(name, '"'));
+    }
+    return values[name];
+}
+function formatSelect(name, options, locale, values, formatOptions, pluralCtx) {
+    var value = String(getValue(values, name));
+    var _value;
+    var branch = (_value = options[value]) !== null && _value !== void 0 ? _value : options.other;
+    if (!branch) {
+        throw new Error('No matching branch for select "'.concat(name, '" with value "').concat(value, '"'));
+    }
+    return formatBranch(branch, locale, values, formatOptions, pluralCtx);
+}
+function formatPlural(name, options, locale, values, formatOptions, pluralType) {
+    var rawValue = getValue(values, name);
+    if (typeof rawValue !== "number") {
+        throw new Error('Expected number for plural argument "'.concat(name, '", got ').concat(typeof rawValue === "undefined" ? "undefined" : _typeof(rawValue)));
+    }
+    var value = rawValue;
+    var exactKey = "=".concat(value);
+    if (exactKey in options) {
+        return formatBranch(options[exactKey], locale, values, formatOptions, {
+            value: value,
+            locale: locale
+        });
+    }
+    var category = formatOptions.formatters.getPluralRules(locale, {
+        type: pluralType
+    }).select(value);
+    var _category;
+    var branch = (_category = options[category]) !== null && _category !== void 0 ? _category : options.other;
+    if (!branch) {
+        throw new Error('No matching branch for plural "'.concat(name, '" with category "').concat(category, '"'));
+    }
+    return formatBranch(branch, locale, values, formatOptions, {
+        value: value,
+        locale: locale
+    });
+}
+function formatBranch(branch, locale, values, formatOptions, pluralCtx) {
+    if (typeof branch === "string") {
+        return branch;
+    }
+    if (branch === _typesDl2AHteJs.T) {
+        return formatNode(branch, locale, values, formatOptions, pluralCtx);
+    }
+    // Branch is an array - either a single complex node wrapped in array, or multiple nodes
+    // formatNodes handles both correctly via formatNode's tag detection
+    return formatNodes(branch, locale, values, formatOptions, pluralCtx);
+}
+function formatNumberValue(name, style, locale, values, formatOptions) {
+    var rawValue = getValue(values, name);
+    if (typeof rawValue !== "number") {
+        throw new Error('Expected number for argument "'.concat(name, '", got ').concat(typeof rawValue === "undefined" ? "undefined" : _typeof(rawValue)));
+    }
+    var value = rawValue;
+    var opts = getNumberFormatOptions(style, formatOptions);
+    return formatOptions.formatters.getNumberFormat(locale, opts).format(value);
+}
+function formatDateTimeValue(name, style, locale, values, formatOptions, type) {
+    var rawValue = getValue(values, name);
+    if (!_instanceof(rawValue, Date)) {
+        throw new Error('Expected Date for argument "'.concat(name, '", got ').concat(typeof rawValue === "undefined" ? "undefined" : _typeof(rawValue)));
+    }
+    var date = rawValue;
+    var baseOpts = getDateTimeFormatOptions(style, type, formatOptions);
+    var ref;
+    // Global time zone is used as default, but format-specific one takes precedence
+    var opts = _objectSpreadProps(_objectSpread({}, baseOpts), {
+        timeZone: (ref = baseOpts === null || baseOpts === void 0 ? void 0 : baseOpts.timeZone) !== null && ref !== void 0 ? ref : formatOptions.timeZone
+    });
+    return formatOptions.formatters.getDateTimeFormat(locale, opts).format(date);
+}
+function getNumberFormatOptions(style, formatOptions) {
+    if (!style) return undefined;
+    if (typeof style === "string") {
+        var ref, ref1;
+        if ((ref = formatOptions.formats) === null || ref === void 0 ? void 0 : (ref1 = ref.number) === null || ref1 === void 0 ? void 0 : ref1[style]) {
+            return formatOptions.formats.number[style];
+        }
+        {
+            throw new Error('Missing number format "'.concat(style, '"'));
+        }
+    }
+    return style;
+}
+function getDateTimeFormatOptions(style, type, formatOptions) {
+    if (!style) return undefined;
+    if (typeof style === "string") {
+        var ref, ref1;
+        var resolved = (ref = formatOptions.formats) === null || ref === void 0 ? void 0 : (ref1 = ref.dateTime) === null || ref1 === void 0 ? void 0 : ref1[style];
+        if (!resolved) {
+            throw new Error("Missing ".concat(type, ' format "').concat(style, '"'));
+        }
+        return resolved;
+    }
+    return style;
+}
+function formatTag(name, children, locale, values, formatOptions, pluralCtx) {
+    var rawHandler = getValue(values, name);
+    if (typeof rawHandler !== "function") {
+        throw new Error('Expected function for tag handler "'.concat(name, '"'));
+    }
+    var handler = rawHandler;
+    var formattedChildren = formatNodes(children, locale, values, formatOptions, pluralCtx);
+    var optimized = optimizeResult(formattedChildren);
+    var childArray = Array.isArray(optimized) ? optimized : [
+        optimized
+    ];
+    return handler(childArray);
+}
+function optimizeResult(result) {
+    if (result.length === 0) {
+        return "";
+    }
+    var merged = [];
+    var currentString = "";
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = result[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var item = _step.value;
+            if (typeof item === "string") {
+                currentString += item;
+            } else {
+                if (currentString) {
+                    merged.push(currentString);
+                    currentString = "";
+                }
+                merged.push(item);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (currentString) {
+        merged.push(currentString);
+    }
+    if (merged.length === 1) {
+        return merged[0];
+    }
+    return merged;
+}

package/dist/esm/development/types-Dl2aHte_.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    T: function() {
+        return TYPE_POUND;
+    },
+    a: function() {
+        return TYPE_NUMBER;
+    },
+    b: function() {
+        return TYPE_DATE;
+    },
+    c: function() {
+        return TYPE_TIME;
+    },
+    d: function() {
+        return TYPE_SELECT;
+    },
+    e: function() {
+        return TYPE_SELECTORDINAL;
+    },
+    f: function() {
+        return TYPE_PLURAL;
+    }
+});
+var TYPE_POUND = 0;
+var TYPE_SELECT = 1;
+var TYPE_PLURAL = 2;
+var TYPE_SELECTORDINAL = 3;
+var TYPE_NUMBER = 4;
+var TYPE_DATE = 5;
+var TYPE_TIME = 6;

package/dist/esm/production/compile.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return a;
+    }
+});
+var _icuMessageformatParser = require("@formatjs/icu-messageformat-parser");
+var _typesDqTLNw7XJs = require("./types-DqTLNw7x.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function a(e) {
+    var n = f((0, _icuMessageformatParser.parse)(e));
+    return 0 === n.length ? "" : 1 === n.length && "string" == typeof n[0] ? n[0] : n;
+}
+function f(t) {
+    var e = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = t[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var n = _step.value;
+            var _$t = p(n);
+            "string" == typeof _$t && e.length > 0 && "string" == typeof e[e.length - 1] ? e[e.length - 1] += _$t : e.push(_$t);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return e;
+}
+function l(t) {
+    var e = f(t);
+    if (0 === e.length) return "";
+    if (1 === e.length) {
+        var _$t = e[0];
+        if ("string" == typeof _$t || _$t === _typesDqTLNw7XJs.T) return _$t;
+    }
+    return e;
+}
+function p(t) {
+    switch(t.type){
+        case _icuMessageformatParser.TYPE.literal:
+            return t.value;
+        case _icuMessageformatParser.TYPE.argument:
+            return [
+                t.value
+            ];
+        case _icuMessageformatParser.TYPE.number:
+            return function(t) {
+                var _$e = [
+                    t.value,
+                    _typesDqTLNw7XJs.a
+                ], _$n = function(t) {
+                    if (!t) return;
+                    if ("string" == typeof t) return t;
+                    if ("parsedOptions" in t) {
+                        var _$e = t.parsedOptions;
+                        return Object.keys(_$e).length > 0 ? _$e : void 0;
+                    }
+                    return;
+                }(t.style);
+                void 0 !== _$n && _$e.push(_$n);
+                return _$e;
+            }(t);
+        case _icuMessageformatParser.TYPE.date:
+            return function(t) {
+                var _$e = [
+                    t.value,
+                    _typesDqTLNw7XJs.b
+                ], _$n = g(t.style);
+                void 0 !== _$n && _$e.push(_$n);
+                return _$e;
+            }(t);
+        case _icuMessageformatParser.TYPE.time:
+            return function(t) {
+                var _$e = [
+                    t.value,
+                    _typesDqTLNw7XJs.c
+                ], _$n = g(t.style);
+                void 0 !== _$n && _$e.push(_$n);
+                return _$e;
+            }(t);
+        case _icuMessageformatParser.TYPE.select:
+            return function(t) {
+                var _$e = Object.create(null);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Object.entries(t.options)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), _$n = _value[0], r = _value[1];
+                        _$e[_$n] = l(r.value);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return [
+                    t.value,
+                    _typesDqTLNw7XJs.d,
+                    _$e
+                ];
+            }(t);
+        case _icuMessageformatParser.TYPE.plural:
+            return function(t) {
+                var _$e = Object.create(null);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Object.entries(t.options)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), _$n = _value[0], r = _value[1];
+                        _$e[_$n] = l(r.value);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return [
+                    t.value,
+                    "ordinal" === t.pluralType ? _typesDqTLNw7XJs.e : _typesDqTLNw7XJs.f,
+                    _$e
+                ];
+            }(t);
+        case _icuMessageformatParser.TYPE.pound:
+            return _typesDqTLNw7XJs.T;
+        case _icuMessageformatParser.TYPE.tag:
+            return function(t) {
+                var _n;
+                var _$e = f(t.children), _$n = [
+                    t.value
+                ];
+                0 === _$e.length ? _$n.push("") : (_n = _$n).push.apply(_n, _toConsumableArray(_$e));
+                return _$n;
+            }(t);
+        default:
+            throw new Error("Unknown AST node type: ".concat(t.type));
+    }
+}
+function g(t) {
+    if (t) {
+        if ("string" == typeof t) return t;
+        if ("parsedOptions" in t) {
+            var e = t.parsedOptions;
+            return Object.keys(e).length > 0 ? e : void 0;
+        }
+    }
+}

package/dist/esm/production/format.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return f;
+    }
+});
+var _typesDqTLNw7XJs = require("./types-DqTLNw7x.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i1 = 0, arr2 = new Array(len); i1 < len; i1++)arr2[i1] = arr[i1];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i1 = 1; i1 < arguments.length; i1++){
+        var source = arguments[i1] != null ? arguments[i1] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _toArray(arr) {
+    return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function f(t, r) {
+    var n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, e = arguments.length > 3 ? arguments[3] : void 0;
+    if ("string" == typeof t) return t;
+    return g(i1(t, r, n, e, void 0));
+}
+function i1(t, r, n, e, o) {
+    var u = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = t[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var s = _step.value;
+            var _u;
+            var _$t = a(s, r, n, e, o);
+            Array.isArray(_$t) ? (_u = u).push.apply(_u, _toConsumableArray(_$t)) : u.push(_$t);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return u;
+}
+function a(f, a, y, d, h) {
+    if ("string" == typeof f) return f;
+    if (f === _typesDqTLNw7XJs.T) {
+        var _$t = h;
+        return d.formatters.getNumberFormat(_$t.locale).format(_$t.value);
+    }
+    var _f = _toArray(f), b = _f[0], v = _f[1], A = _f.slice(2);
+    if (void 0 === v) {
+        var _$t1 = c(y, b);
+        return String(_$t1);
+    }
+    if ("number" != typeof v || v === _typesDqTLNw7XJs.T) return function(t, r, n, e, o, u) {
+        var _$s = c(e, t), _$f = _$s, _$a = i1(r, n, e, o, u), _$m = g(_$a), l = Array.isArray(_$m) ? _$m : [
+            _$m
+        ];
+        return _$f(l);
+    }(b, [
+        v
+    ].concat(_toConsumableArray(A)), a, y, d, h);
+    switch(v){
+        case _typesDqTLNw7XJs.d:
+            return function(t, r, n, e, o, u) {
+                var _s;
+                var _$s = String(c(e, t)), _$f = (_s = r[_$s]) !== null && _s !== void 0 ? _s : r.other;
+                return l(_$f, n, e, o, u);
+            }(b, A[0], a, y, d, h);
+        case _typesDqTLNw7XJs.f:
+            return m(b, A[0], a, y, d, "cardinal");
+        case _typesDqTLNw7XJs.e:
+            return m(b, A[0], a, y, d, "ordinal");
+        case _typesDqTLNw7XJs.a:
+            return function(t, r, n, e, o) {
+                var _$u = c(e, t), _$s = _$u, _$f = function(t, r) {
+                    var ref, ref1;
+                    if (!t) return;
+                    if ("string" == typeof t) return ((ref = r.formats) === null || ref === void 0 ? void 0 : (ref1 = ref.number) === null || ref1 === void 0 ? void 0 : ref1[t]) ? r.formats.number[t] : void 0;
+                    return t;
+                }(r, o);
+                return o.formatters.getNumberFormat(n, _$f).format(_$s);
+            }(b, A[0], a, y, d);
+        case _typesDqTLNw7XJs.b:
+            return p(b, A[0], a, y, d, "date");
+        case _typesDqTLNw7XJs.c:
+            return p(b, A[0], a, y, d, "time");
+        default:
+            return "";
+    }
+}
+function c(t, r) {
+    return t[r];
+}
+function m(t, r, n, e, o, u) {
+    var s = c(e, t), f = "=".concat(s);
+    if (f in r) return l(r[f], n, e, o, {
+        value: s,
+        locale: n
+    });
+    var ref;
+    return l((ref = r[o.formatters.getPluralRules(n, {
+        type: u
+    }).select(s)]) !== null && ref !== void 0 ? ref : r.other, n, e, o, {
+        value: s,
+        locale: n
+    });
+}
+function l(r, n, e, o, u) {
+    return "string" == typeof r ? r : r === _typesDqTLNw7XJs.T ? a(r, n, e, o, u) : i1(r, n, e, o, u);
+}
+function p(t, r, n, e, o, u) {
+    var ref;
+    var s = c(e, t), f = function(t, r, n) {
+        if (!t) return;
+        if ("string" == typeof t) {
+            var ref, ref1;
+            var _$r = (ref = n.formats) === null || ref === void 0 ? void 0 : (ref1 = ref.dateTime) === null || ref1 === void 0 ? void 0 : ref1[t];
+            return _$r;
+        }
+        return t;
+    }(r, 0, o), i1 = _objectSpreadProps(_objectSpread({}, f), {
+        timeZone: (ref = f === null || f === void 0 ? void 0 : f.timeZone) !== null && ref !== void 0 ? ref : o.timeZone
+    });
+    return o.formatters.getDateTimeFormat(n, i1).format(s);
+}
+function g(t) {
+    if (0 === t.length) return "";
+    var r = [];
+    var n = "";
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = t[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var e = _step.value;
+            "string" == typeof e ? n += e : (n && (r.push(n), n = ""), r.push(e));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return n && r.push(n), 1 === r.length ? r[0] : r;
+}

package/dist/esm/production/types-DqTLNw7x.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    T: function() {
+        return a;
+    },
+    a: function() {
+        return o;
+    },
+    b: function() {
+        return t;
+    },
+    c: function() {
+        return b;
+    },
+    d: function() {
+        return s;
+    },
+    e: function() {
+        return e;
+    },
+    f: function() {
+        return c;
+    }
+});
+var a = 0, s = 1, c = 2, e = 3, o = 4, t = 5, b = 6;

package/dist/types/compile.d.ts

@@ -0,0 +1,2 @@
+import { type CompiledMessage } from './types.js';
+export default function compile(message: string): CompiledMessage;

package/dist/types/format.d.ts

@@ -0,0 +1,17 @@
+import { type CompiledMessage } from './types.js';
+export type { CompiledMessage } from './types.js';
+export type FormatValues<RichTextElement = unknown> = Record<string, string | number | boolean | Date | ((chunks: Array<string | RichTextElement>) => RichTextElement)>;
+export type Formats = {
+    dateTime?: Record<string, Intl.DateTimeFormatOptions>;
+    number?: Record<string, Intl.NumberFormatOptions>;
+};
+export type FormatOptions = {
+    formats?: Formats;
+    formatters: {
+        getDateTimeFormat(...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
+        getNumberFormat(...args: ConstructorParameters<typeof Intl.NumberFormat>): Intl.NumberFormat;
+        getPluralRules(...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
+    };
+    timeZone?: string;
+};
+export default function format<RichTextElement = string>(message: CompiledMessage, locale: string, values: FormatValues<RichTextElement> | undefined, options: FormatOptions): string | RichTextElement | Array<string | RichTextElement>;

package/dist/types/types.d.ts

@@ -0,0 +1,29 @@
+export declare const TYPE_POUND = 0;
+export declare const TYPE_SELECT = 1;
+export declare const TYPE_PLURAL = 2;
+export declare const TYPE_SELECTORDINAL = 3;
+export declare const TYPE_NUMBER = 4;
+export declare const TYPE_DATE = 5;
+export declare const TYPE_TIME = 6;
+export type NumberStyleOptions = Intl.NumberFormatOptions;
+export type NumberStyle = string | NumberStyleOptions;
+export type DateTimeStyleOptions = Intl.DateTimeFormatOptions;
+export type DateTimeStyle = string | DateTimeStyleOptions;
+export type PluralOptions = Record<string, CompiledNode>;
+export type SelectOptions = Record<string, CompiledNode>;
+export type CompiledPlainTextNode = string;
+export type CompiledSimpleArgNode = [string];
+export type CompiledPoundNode = typeof TYPE_POUND;
+export type CompiledSelectNode = [string, typeof TYPE_SELECT, SelectOptions];
+export type CompiledPluralNode = [string, typeof TYPE_PLURAL, PluralOptions];
+export type CompiledSelectOrdinalNode = [
+    string,
+    typeof TYPE_SELECTORDINAL,
+    PluralOptions
+];
+export type CompiledNumberNode = [string, typeof TYPE_NUMBER, NumberStyle?];
+export type CompiledDateNode = [string, typeof TYPE_DATE, DateTimeStyle?];
+export type CompiledTimeNode = [string, typeof TYPE_TIME, DateTimeStyle?];
+export type CompiledTagNode = [string, unknown, ...Array<unknown>];
+export type CompiledNode = CompiledPlainTextNode | CompiledSimpleArgNode | CompiledPoundNode | CompiledSelectNode | CompiledPluralNode | CompiledSelectOrdinalNode | CompiledNumberNode | CompiledDateNode | CompiledTimeNode | CompiledTagNode;
+export type CompiledMessage = string | Array<CompiledNode>;

package/format.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export {default} from './dist/types/format.d.ts';

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@common.js/icu-minify",
+  "version": "4.13.1",
+  "sideEffects": false,
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://github.com/sponsors/amannn"
+    }
+  ],
+  "description": "icu-minify package exported as CommonJS modules",
+  "license": "MIT",
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "repository": "etienne-martin/common.js",
+  "scripts": {
+    "build": "rm -rf dist && rollup -c",
+    "test": "TZ=Europe/Berlin vitest",
+    "lint": "pnpm run lint:source && pnpm run lint:package",
+    "lint:source": "eslint src test && tsc --noEmit && pnpm run lint:prettier",
+    "lint:package": "publint && attw --pack --ignore-rules=cjs-resolves-to-esm",
+    "lint:prettier": "prettier src --check",
+    "size": "size-limit"
+  },
+  "type": "commonjs",
+  "files": [
+    "dist",
+    "compile.d.ts",
+    "format.d.ts"
+  ],
+  "dependencies": {
+    "@common.js/formatjs__icu-messageformat-parser": "^3.4.0"
+  },
+  "gitHead": "976ca1f83a6e06b5646865b87c4fb461cbf84374"
+}