@common.js/formatjs__icu-messageformat-parser 3.5.12

package/no-parser.js

@@ -0,0 +1,261 @@
+//#region packages/icu-messageformat-parser/types.ts
+"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, {
+    SKELETON_TYPE: function() {
+        return SKELETON_TYPE;
+    },
+    TYPE: function() {
+        return TYPE;
+    },
+    "_Parser": function() {
+        return _Parser;
+    },
+    createLiteralElement: function() {
+        return createLiteralElement;
+    },
+    createNumberElement: function() {
+        return createNumberElement;
+    },
+    isArgumentElement: function() {
+        return isArgumentElement;
+    },
+    isDateElement: function() {
+        return isDateElement;
+    },
+    isDateTimeSkeleton: function() {
+        return isDateTimeSkeleton;
+    },
+    isLiteralElement: function() {
+        return isLiteralElement;
+    },
+    isNumberElement: function() {
+        return isNumberElement;
+    },
+    isNumberSkeleton: function() {
+        return isNumberSkeleton;
+    },
+    isPluralElement: function() {
+        return isPluralElement;
+    },
+    isPoundElement: function() {
+        return isPoundElement;
+    },
+    isSelectElement: function() {
+        return isSelectElement;
+    },
+    isStructurallySame: function() {
+        return isStructurallySame;
+    },
+    isTagElement: function() {
+        return isTagElement;
+    },
+    isTimeElement: function() {
+        return isTimeElement;
+    },
+    parse: function() {
+        return parse;
+    }
+});
+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 _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 _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+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);
+}
+var TYPE = /* @__PURE__ */ function(TYPE) {
+    /**
+	* Raw text
+	*/ TYPE[TYPE["literal"] = 0] = "literal";
+    /**
+	* Variable w/o any format, e.g `var` in `this is a {var}`
+	*/ TYPE[TYPE["argument"] = 1] = "argument";
+    /**
+	* Variable w/ number format
+	*/ TYPE[TYPE["number"] = 2] = "number";
+    /**
+	* Variable w/ date format
+	*/ TYPE[TYPE["date"] = 3] = "date";
+    /**
+	* Variable w/ time format
+	*/ TYPE[TYPE["time"] = 4] = "time";
+    /**
+	* Variable w/ select format
+	*/ TYPE[TYPE["select"] = 5] = "select";
+    /**
+	* Variable w/ plural format
+	*/ TYPE[TYPE["plural"] = 6] = "plural";
+    /**
+	* Only possible within plural argument.
+	* This is the `#` symbol that will be substituted with the count.
+	*/ TYPE[TYPE["pound"] = 7] = "pound";
+    /**
+	* XML-like tag
+	*/ TYPE[TYPE["tag"] = 8] = "tag";
+    return TYPE;
+}({});
+var SKELETON_TYPE = /* @__PURE__ */ function(SKELETON_TYPE) {
+    SKELETON_TYPE[SKELETON_TYPE["number"] = 0] = "number";
+    SKELETON_TYPE[SKELETON_TYPE["dateTime"] = 1] = "dateTime";
+    return SKELETON_TYPE;
+}({});
+/**
+* Type Guards
+*/ function isLiteralElement(el) {
+    return el.type === 0;
+}
+function isArgumentElement(el) {
+    return el.type === 1;
+}
+function isNumberElement(el) {
+    return el.type === 2;
+}
+function isDateElement(el) {
+    return el.type === 3;
+}
+function isTimeElement(el) {
+    return el.type === 4;
+}
+function isSelectElement(el) {
+    return el.type === 5;
+}
+function isPluralElement(el) {
+    return el.type === 6;
+}
+function isPoundElement(el) {
+    return el.type === 7;
+}
+function isTagElement(el) {
+    return el.type === 8;
+}
+function isNumberSkeleton(el) {
+    return !!(el && typeof el === "object" && el.type === 0);
+}
+function isDateTimeSkeleton(el) {
+    return !!(el && typeof el === "object" && el.type === 1);
+}
+function createLiteralElement(value) {
+    return {
+        type: 0,
+        value: value
+    };
+}
+function createNumberElement(value, style) {
+    return {
+        type: 2,
+        value: value,
+        style: style
+    };
+}
+//#endregion
+//#region packages/icu-messageformat-parser/manipulator.ts
+/**
+* Collect all variables in an AST to Record<string, TYPE>
+* @param ast AST to collect variables from
+* @param vars Record of variable name to variable type
+*/ function collectVariables(ast) {
+    var vars = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : /* @__PURE__ */ new Map();
+    ast.forEach(function(el) {
+        if (isArgumentElement(el) || isDateElement(el) || isTimeElement(el) || isNumberElement(el)) if (vars.has(el.value)) {
+            var existingType = vars.get(el.value);
+            if (existingType !== el.type && existingType !== 6 && existingType !== 5) throw new Error("Variable ".concat(el.value, " has conflicting types"));
+        } else vars.set(el.value, el.type);
+        if (isPluralElement(el) || isSelectElement(el)) {
+            vars.set(el.value, el.type);
+            Object.keys(el.options).forEach(function(k) {
+                collectVariables(el.options[k].value, vars);
+            });
+        }
+        if (isTagElement(el)) {
+            vars.set(el.value, el.type);
+            collectVariables(el.children, vars);
+        }
+    });
+}
+/**
+* Check if 2 ASTs are structurally the same. This primarily means that
+* they have the same variables with the same type
+* @param a
+* @param b
+* @returns
+*/ function isStructurallySame(a, b) {
+    var aVars = /* @__PURE__ */ new Map();
+    var bVars = /* @__PURE__ */ new Map();
+    collectVariables(a, aVars);
+    collectVariables(b, bVars);
+    if (aVars.size !== bVars.size) return {
+        success: false,
+        error: /* @__PURE__ */ new Error("Different number of variables: [".concat(Array.from(aVars.keys()).join(", "), "] vs [").concat(Array.from(bVars.keys()).join(", "), "]"))
+    };
+    return Array.from(aVars.entries()).reduce(function(result, param) {
+        var _param = _slicedToArray(param, 2), key = _param[0], type = _param[1];
+        if (!result.success) return result;
+        var bType = bVars.get(key);
+        if (bType == null) return {
+            success: false,
+            error: /* @__PURE__ */ new Error("Missing variable ".concat(key, " in message"))
+        };
+        if (bType !== type) return {
+            success: false,
+            error: /* @__PURE__ */ new Error("Variable ".concat(key, " has conflicting types: ").concat(TYPE[type], " vs ").concat(TYPE[bType]))
+        };
+        return result;
+    }, {
+        success: true
+    });
+}
+//#endregion
+//#region packages/icu-messageformat-parser/no-parser.ts
+function parse() {
+    throw new Error("You're trying to format an uncompiled message with react-intl without parser, please import from 'react-intl' instead");
+}
+var _Parser = void 0;
+ //# sourceMappingURL=no-parser.js.map

package/no-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-parser.js","names":[],"sources":["../types.ts","../manipulator.ts","../no-parser.ts"],"sourcesContent":["import type {NumberFormatOptions} from '#packages/ecma402-abstract/types/number.js'\nimport {type NumberSkeletonToken} from '@formatjs/icu-skeleton-parser'\n\nexport interface ExtendedNumberFormatOptions extends NumberFormatOptions {\n  scale?: number\n}\n\nexport enum TYPE {\n  /**\n   * Raw text\n   */\n  literal,\n  /**\n   * Variable w/o any format, e.g `var` in `this is a {var}`\n   */\n  argument,\n  /**\n   * Variable w/ number format\n   */\n  number,\n  /**\n   * Variable w/ date format\n   */\n  date,\n  /**\n   * Variable w/ time format\n   */\n  time,\n  /**\n   * Variable w/ select format\n   */\n  select,\n  /**\n   * Variable w/ plural format\n   */\n  plural,\n  /**\n   * Only possible within plural argument.\n   * This is the `#` symbol that will be substituted with the count.\n   */\n  pound,\n  /**\n   * XML-like tag\n   */\n  tag,\n}\n\nexport enum SKELETON_TYPE {\n  number,\n  dateTime,\n}\n\nexport interface LocationDetails {\n  offset: number\n  line: number\n  column: number\n}\nexport interface Location {\n  start: LocationDetails\n  end: LocationDetails\n}\n\nexport interface BaseElement<T extends TYPE> {\n  type: T\n  value: string\n  location?: Location\n}\n\nexport type LiteralElement = BaseElement<TYPE.literal>\nexport type ArgumentElement = BaseElement<TYPE.argument>\nexport interface TagElement extends BaseElement<TYPE.tag> {\n  children: MessageFormatElement[]\n}\n\nexport interface SimpleFormatElement<\n  T extends TYPE,\n  S extends Skeleton,\n> extends BaseElement<T> {\n  style?: string | S | null\n}\n\nexport type NumberElement = SimpleFormatElement<TYPE.number, NumberSkeleton>\nexport type DateElement = SimpleFormatElement<TYPE.date, DateTimeSkeleton>\nexport type TimeElement = SimpleFormatElement<TYPE.time, DateTimeSkeleton>\n\nexport type ValidPluralRule =\n  | 'zero'\n  | 'one'\n  | 'two'\n  | 'few'\n  | 'many'\n  | 'other'\n  | string\n\nexport interface PluralOrSelectOption {\n  value: MessageFormatElement[]\n  location?: Location\n}\n\nexport interface SelectElement extends BaseElement<TYPE.select> {\n  options: Record<string, PluralOrSelectOption>\n}\n\nexport interface PluralElement extends BaseElement<TYPE.plural> {\n  options: Record<ValidPluralRule, PluralOrSelectOption>\n  offset: number\n  pluralType: Intl.PluralRulesOptions['type']\n}\n\nexport interface PoundElement {\n  type: TYPE.pound\n  location?: Location\n}\n\nexport type MessageFormatElement =\n  | ArgumentElement\n  | DateElement\n  | LiteralElement\n  | NumberElement\n  | PluralElement\n  | PoundElement\n  | SelectElement\n  | TagElement\n  | TimeElement\n\nexport interface NumberSkeleton {\n  type: SKELETON_TYPE.number\n  tokens: NumberSkeletonToken[]\n  location?: Location\n  parsedOptions: ExtendedNumberFormatOptions\n}\n\nexport interface DateTimeSkeleton {\n  type: SKELETON_TYPE.dateTime\n  pattern: string\n  location?: Location\n  parsedOptions: Intl.DateTimeFormatOptions\n}\n\nexport type Skeleton = NumberSkeleton | DateTimeSkeleton\n\n/**\n * Type Guards\n */\nexport function isLiteralElement(\n  el: MessageFormatElement\n): el is LiteralElement {\n  return el.type === TYPE.literal\n}\nexport function isArgumentElement(\n  el: MessageFormatElement\n): el is ArgumentElement {\n  return el.type === TYPE.argument\n}\nexport function isNumberElement(el: MessageFormatElement): el is NumberElement {\n  return el.type === TYPE.number\n}\nexport function isDateElement(el: MessageFormatElement): el is DateElement {\n  return el.type === TYPE.date\n}\nexport function isTimeElement(el: MessageFormatElement): el is TimeElement {\n  return el.type === TYPE.time\n}\nexport function isSelectElement(el: MessageFormatElement): el is SelectElement {\n  return el.type === TYPE.select\n}\nexport function isPluralElement(el: MessageFormatElement): el is PluralElement {\n  return el.type === TYPE.plural\n}\nexport function isPoundElement(el: MessageFormatElement): el is PoundElement {\n  return el.type === TYPE.pound\n}\nexport function isTagElement(el: MessageFormatElement): el is TagElement {\n  return el.type === TYPE.tag\n}\nexport function isNumberSkeleton(\n  el: NumberElement['style'] | Skeleton\n): el is NumberSkeleton {\n  return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.number)\n}\nexport function isDateTimeSkeleton(\n  el?: DateElement['style'] | TimeElement['style'] | Skeleton\n): el is DateTimeSkeleton {\n  return !!(el && typeof el === 'object' && el.type === SKELETON_TYPE.dateTime)\n}\n\nexport function createLiteralElement(value: string): LiteralElement {\n  return {\n    type: TYPE.literal,\n    value,\n  }\n}\n\nexport function createNumberElement(\n  value: string,\n  style?: string | null\n): NumberElement {\n  return {\n    type: TYPE.number,\n    value,\n    style,\n  }\n}\n","import {\n  isArgumentElement,\n  isDateElement,\n  isNumberElement,\n  isPluralElement,\n  isPoundElement,\n  isSelectElement,\n  isTagElement,\n  isTimeElement,\n  type MessageFormatElement,\n  type PluralElement,\n  type PluralOrSelectOption,\n  type SelectElement,\n  TYPE,\n} from '#packages/icu-messageformat-parser/types.js'\n\nfunction cloneDeep<T>(obj: T): T {\n  if (Array.isArray(obj)) {\n    // @ts-expect-error meh\n    return obj.map(cloneDeep)\n  }\n  if (obj !== null && typeof obj === 'object') {\n    // @ts-expect-error meh\n    return Object.keys(obj).reduce((cloned, k) => {\n      // @ts-expect-error meh\n      cloned[k] = cloneDeep(obj[k])\n      return cloned\n    }, {})\n  }\n  return obj\n}\n\n/**\n * Replace pound elements with number elements referencing the given variable.\n * This is needed when nesting plurals - the # in the outer plural should become\n * an explicit variable reference when nested inside another plural.\n * GH #4202\n */\nfunction replacePoundWithArgument(\n  ast: MessageFormatElement[],\n  variableName: string\n): MessageFormatElement[] {\n  return ast.map(el => {\n    if (isPoundElement(el)) {\n      // Replace # with {variableName, number}\n      return {\n        type: TYPE.number,\n        value: variableName,\n        style: null,\n        location: el.location,\n      }\n    }\n    if (isPluralElement(el) || isSelectElement(el)) {\n      // Recursively process options\n      const newOptions: Record<string, PluralOrSelectOption> = {}\n      for (const key of Object.keys(el.options)) {\n        newOptions[key] = {\n          value: replacePoundWithArgument(el.options[key].value, variableName),\n        }\n      }\n      return {...el, options: newOptions}\n    }\n    if (isTagElement(el)) {\n      return {\n        ...el,\n        children: replacePoundWithArgument(el.children, variableName),\n      }\n    }\n    return el\n  })\n}\n\nfunction hoistPluralOrSelectElement(\n  ast: MessageFormatElement[],\n  el: PluralElement | SelectElement,\n  positionToInject: number\n) {\n  // pull this out of the ast and move it to the top\n  const cloned = cloneDeep(el)\n  const {options} = cloned\n\n  // GH #4202: Check if there are other plural/select elements after this one\n  const afterElements = ast.slice(positionToInject + 1)\n  const hasSubsequentPluralOrSelect = afterElements.some(\n    isPluralOrSelectElement\n  )\n\n  cloned.options = Object.keys(options).reduce(\n    (all: Record<string, PluralOrSelectOption>, k) => {\n      let optionValue = options[k].value\n\n      // GH #4202: If there are subsequent plurals/selects and this is a plural,\n      // replace # with explicit variable reference to avoid ambiguity\n      if (hasSubsequentPluralOrSelect && isPluralElement(el)) {\n        optionValue = replacePoundWithArgument(optionValue, el.value)\n      }\n\n      const newValue = hoistSelectors([\n        ...ast.slice(0, positionToInject),\n        ...optionValue,\n        ...afterElements,\n      ])\n      all[k] = {\n        value: newValue,\n      }\n      return all\n    },\n    {}\n  )\n  return cloned\n}\n\nfunction isPluralOrSelectElement(\n  el: MessageFormatElement\n): el is PluralElement | SelectElement {\n  return isPluralElement(el) || isSelectElement(el)\n}\n\nfunction findPluralOrSelectElement(ast: MessageFormatElement[]): boolean {\n  return !!ast.find(el => {\n    if (isPluralOrSelectElement(el)) {\n      return true\n    }\n    if (isTagElement(el)) {\n      return findPluralOrSelectElement(el.children)\n    }\n    return false\n  })\n}\n\n/**\n * Hoist all selectors to the beginning of the AST & flatten the\n * resulting options. E.g:\n * \"I have {count, plural, one{a dog} other{many dogs}}\"\n * becomes \"{count, plural, one{I have a dog} other{I have many dogs}}\".\n * If there are multiple selectors, the order of which one is hoisted 1st\n * is non-deterministic.\n * The goal is to provide as many full sentences as possible since fragmented\n * sentences are not translator-friendly\n * @param ast AST\n */\nexport function hoistSelectors(\n  ast: MessageFormatElement[]\n): MessageFormatElement[] {\n  for (let i = 0; i < ast.length; i++) {\n    const el = ast[i]\n    if (isPluralOrSelectElement(el)) {\n      return [hoistPluralOrSelectElement(ast, el, i)]\n    }\n    if (isTagElement(el) && findPluralOrSelectElement([el])) {\n      throw new Error(\n        'Cannot hoist plural/select within a tag element. Please put the tag element inside each plural/select option'\n      )\n    }\n  }\n  return ast\n}\n\n/**\n * Collect all variables in an AST to Record<string, TYPE>\n * @param ast AST to collect variables from\n * @param vars Record of variable name to variable type\n */\nfunction collectVariables(\n  ast: MessageFormatElement[],\n  vars: Map<string, TYPE> = new Map<string, TYPE>()\n): void {\n  ast.forEach(el => {\n    if (\n      isArgumentElement(el) ||\n      isDateElement(el) ||\n      isTimeElement(el) ||\n      isNumberElement(el)\n    ) {\n      // If the variable was already registered as a plural/select, it's normal\n      // for it to also appear inside as number/date/time/argument — not a conflict.\n      if (vars.has(el.value)) {\n        const existingType = vars.get(el.value)!\n        if (\n          existingType !== el.type &&\n          existingType !== TYPE.plural &&\n          existingType !== TYPE.select\n        ) {\n          throw new Error(`Variable ${el.value} has conflicting types`)\n        }\n      } else {\n        vars.set(el.value, el.type)\n      }\n    }\n\n    if (isPluralElement(el) || isSelectElement(el)) {\n      vars.set(el.value, el.type)\n      Object.keys(el.options).forEach(k => {\n        collectVariables(el.options[k].value, vars)\n      })\n    }\n\n    if (isTagElement(el)) {\n      vars.set(el.value, el.type)\n      collectVariables(el.children, vars)\n    }\n  })\n}\n\ninterface IsStructurallySameResult {\n  error?: Error\n  success: boolean\n}\n\n/**\n * Check if 2 ASTs are structurally the same. This primarily means that\n * they have the same variables with the same type\n * @param a\n * @param b\n * @returns\n */\nexport function isStructurallySame(\n  a: MessageFormatElement[],\n  b: MessageFormatElement[]\n): IsStructurallySameResult {\n  const aVars = new Map<string, TYPE>()\n  const bVars = new Map<string, TYPE>()\n  collectVariables(a, aVars)\n  collectVariables(b, bVars)\n\n  if (aVars.size !== bVars.size) {\n    return {\n      success: false,\n      error: new Error(\n        `Different number of variables: [${Array.from(aVars.keys()).join(', ')}] vs [${Array.from(bVars.keys()).join(', ')}]`\n      ),\n    }\n  }\n\n  return Array.from(aVars.entries()).reduce<IsStructurallySameResult>(\n    (result, [key, type]) => {\n      if (!result.success) {\n        return result\n      }\n      const bType = bVars.get(key)\n      if (bType == null) {\n        return {\n          success: false,\n          error: new Error(`Missing variable ${key} in message`),\n        }\n      }\n      if (bType !== type) {\n        return {\n          success: false,\n          error: new Error(\n            `Variable ${key} has conflicting types: ${TYPE[type]} vs ${TYPE[bType]}`\n          ),\n        }\n      }\n      return result\n    },\n    {success: true}\n  )\n}\n","export function parse(): void {\n  throw new Error(\n    \"You're trying to format an uncompiled message with react-intl without parser, please import from 'react-intl' instead\"\n  )\n}\nexport * from '#packages/icu-messageformat-parser/types.js'\nexport const _Parser = undefined\nexport {isStructurallySame} from '#packages/icu-messageformat-parser/manipulator.js'\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@common.js/formatjs__icu-messageformat-parser",
+  "version": "3.5.12",
+  "license": "MIT",
+  "repository": "etienne-martin/common.js",
+  "type": "commonjs",
+  "types": "index.d.ts",
+  "dependencies": {
+    "@common.js/formatjs__icu-skeleton-parser": "2.1.10"
+  },
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "description": "@formatjs/icu-messageformat-parser package exported as CommonJS modules",
+  "scripts": {},
+  "main": "./index.js"
+}

package/printer.d.ts

@@ -0,0 +1,156 @@
+import { NumberSkeletonToken } from "@formatjs/icu-skeleton-parser";
+
+//#region packages/ecma402-abstract/types/number.d.ts
+type NumberFormatNotation = "standard" | "scientific" | "engineering" | "compact";
+type RoundingPriorityType = "auto" | "morePrecision" | "lessPrecision";
+type RoundingModeType = "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven";
+type UseGroupingType = "min2" | "auto" | "always" | boolean;
+interface NumberFormatDigitOptions {
+  minimumIntegerDigits?: number;
+  minimumSignificantDigits?: number;
+  maximumSignificantDigits?: number;
+  minimumFractionDigits?: number;
+  maximumFractionDigits?: number;
+  roundingPriority?: RoundingPriorityType;
+  roundingIncrement?: number;
+  roundingMode?: RoundingModeType;
+  trailingZeroDisplay?: TrailingZeroDisplay;
+}
+type NumberFormatOptionsLocaleMatcher = "lookup" | "best fit";
+type NumberFormatOptionsStyle = "decimal" | "percent" | "currency" | "unit";
+type NumberFormatOptionsCompactDisplay = "short" | "long";
+type NumberFormatOptionsCurrencyDisplay = "symbol" | "code" | "name" | "narrowSymbol";
+type NumberFormatOptionsCurrencySign = "standard" | "accounting";
+type NumberFormatOptionsNotation = NumberFormatNotation;
+type NumberFormatOptionsSignDisplay = "auto" | "always" | "never" | "exceptZero" | "negative";
+type NumberFormatOptionsUnitDisplay = "long" | "short" | "narrow";
+type TrailingZeroDisplay = "auto" | "stripIfInteger";
+type NumberFormatOptions = Omit<Intl.NumberFormatOptions, "signDisplay" | "useGrouping"> & NumberFormatDigitOptions & {
+  localeMatcher?: NumberFormatOptionsLocaleMatcher;
+  style?: NumberFormatOptionsStyle;
+  compactDisplay?: NumberFormatOptionsCompactDisplay;
+  currencyDisplay?: NumberFormatOptionsCurrencyDisplay;
+  currencySign?: NumberFormatOptionsCurrencySign;
+  notation?: NumberFormatOptionsNotation;
+  signDisplay?: NumberFormatOptionsSignDisplay;
+  unit?: string;
+  unitDisplay?: NumberFormatOptionsUnitDisplay;
+  numberingSystem?: string;
+  trailingZeroDisplay?: TrailingZeroDisplay;
+  roundingPriority?: RoundingPriorityType;
+  roundingIncrement?: number;
+  roundingMode?: RoundingModeType;
+  useGrouping?: UseGroupingType;
+};
+//#endregion
+//#region packages/icu-messageformat-parser/types.d.ts
+interface ExtendedNumberFormatOptions extends NumberFormatOptions {
+  scale?: number;
+}
+declare enum TYPE {
+  /**
+  * Raw text
+  */
+  literal = 0,
+  /**
+  * Variable w/o any format, e.g `var` in `this is a {var}`
+  */
+  argument = 1,
+  /**
+  * Variable w/ number format
+  */
+  number = 2,
+  /**
+  * Variable w/ date format
+  */
+  date = 3,
+  /**
+  * Variable w/ time format
+  */
+  time = 4,
+  /**
+  * Variable w/ select format
+  */
+  select = 5,
+  /**
+  * Variable w/ plural format
+  */
+  plural = 6,
+  /**
+  * Only possible within plural argument.
+  * This is the `#` symbol that will be substituted with the count.
+  */
+  pound = 7,
+  /**
+  * XML-like tag
+  */
+  tag = 8
+}
+declare enum SKELETON_TYPE {
+  number = 0,
+  dateTime = 1
+}
+interface LocationDetails {
+  offset: number;
+  line: number;
+  column: number;
+}
+interface Location {
+  start: LocationDetails;
+  end: LocationDetails;
+}
+interface BaseElement<T extends TYPE> {
+  type: T;
+  value: string;
+  location?: Location;
+}
+type LiteralElement = BaseElement<TYPE.literal>;
+type ArgumentElement = BaseElement<TYPE.argument>;
+interface TagElement extends BaseElement<TYPE.tag> {
+  children: MessageFormatElement[];
+}
+interface SimpleFormatElement<T extends TYPE, S extends Skeleton> extends BaseElement<T> {
+  style?: string | S | null;
+}
+type NumberElement = SimpleFormatElement<TYPE.number, NumberSkeleton>;
+type DateElement = SimpleFormatElement<TYPE.date, DateTimeSkeleton>;
+type TimeElement = SimpleFormatElement<TYPE.time, DateTimeSkeleton>;
+type ValidPluralRule = "zero" | "one" | "two" | "few" | "many" | "other" | string;
+interface PluralOrSelectOption {
+  value: MessageFormatElement[];
+  location?: Location;
+}
+interface SelectElement extends BaseElement<TYPE.select> {
+  options: Record<string, PluralOrSelectOption>;
+}
+interface PluralElement extends BaseElement<TYPE.plural> {
+  options: Record<ValidPluralRule, PluralOrSelectOption>;
+  offset: number;
+  pluralType: Intl.PluralRulesOptions["type"];
+}
+interface PoundElement {
+  type: TYPE.pound;
+  location?: Location;
+}
+type MessageFormatElement = ArgumentElement | DateElement | LiteralElement | NumberElement | PluralElement | PoundElement | SelectElement | TagElement | TimeElement;
+interface NumberSkeleton {
+  type: SKELETON_TYPE.number;
+  tokens: NumberSkeletonToken[];
+  location?: Location;
+  parsedOptions: ExtendedNumberFormatOptions;
+}
+interface DateTimeSkeleton {
+  type: SKELETON_TYPE.dateTime;
+  pattern: string;
+  location?: Location;
+  parsedOptions: Intl.DateTimeFormatOptions;
+}
+type Skeleton = NumberSkeleton | DateTimeSkeleton;
+//#endregion
+//#region packages/icu-messageformat-parser/printer.d.ts
+declare function printAST(ast: MessageFormatElement[]): string;
+declare function doPrintAST(ast: MessageFormatElement[], isInPlural: boolean): string;
+declare function printDateTimeSkeleton(style: DateTimeSkeleton): string;
+//#endregion
+export { doPrintAST, printAST, printDateTimeSkeleton };
+//# sourceMappingURL=printer.d.ts.map