icu-minify 0.0.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,33 @@
+# `icu-minify`
+
+ICU message format compiler with a 650 bytes runtime ✨
+
+## Features
+
+1. **Build-time compilation** ⚡  
+   Converts ICU messages to a compact JSON intermediate representation
+2. **Minimal runtime** 📦  
+   650 bytes (minified + compressed) with zero runtime dependencies
+3. **Full ICU support** 🌍  
+   `{arguments}`, `plural`, `select`, `selectordinal`, `date`, `time`, `number` and `<tags>`
+
+## Usage
+
+```ts
+import compile from 'icu-minify/compile';
+import format from 'icu-minify/format';
+
+// At build time
+const compiled = compile('Hello {name}!');
+
+// At runtime
+format(compiled, 'en', {name: 'World'});
+```
+
+## Acknowledgments
+
+This library is heavily inspired by [`icu-to-json`](https://github.com/jantimon/icu-to-json) and [`@lingui/message-utils`](https://github.com/lingui/js-lingui/tree/main/packages/message-utils), which similarly use an array-based intermediate representation for compiled messages.
+
+## Design
+
+For detailed design rationale, motivation, tradeoffs, and implementation details, see [RFC: Ahead-of-time compilation of ICU messages](../../rfcs/002-icu-message-precompilation.md).

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,149 @@
+import { parse, TYPE } from '@formatjs/icu-messageformat-parser';
+import { T as TYPE_POUND, a as TYPE_NUMBER, b as TYPE_DATE, c as TYPE_TIME, d as TYPE_SELECT, e as TYPE_SELECTORDINAL, f as TYPE_PLURAL } from './types-Dl2aHte_.js';
+
+function compile(message) {
+  const ast = parse(message);
+  const compiled = compileNodes(ast);
+  if (compiled.length === 0) {
+    return '';
+  }
+  if (compiled.length === 1 && typeof compiled[0] === 'string') {
+    return compiled[0];
+  }
+  return compiled;
+}
+function compileNodes(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    const 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);
+    }
+  }
+  return result;
+}
+function compileNodesToNode(nodes) {
+  const compiled = compileNodes(nodes);
+  if (compiled.length === 0) {
+    return '';
+  }
+  if (compiled.length === 1) {
+    const 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 === TYPE_POUND) {
+      return node;
+    }
+  }
+  return compiled;
+}
+function compileNode(node) {
+  switch (node.type) {
+    case TYPE.literal:
+      return node.value;
+    case TYPE.argument:
+      return [node.value];
+    case TYPE.number:
+      return compileNumber(node);
+    case TYPE.date:
+      return compileDate(node);
+    case TYPE.time:
+      return compileTime(node);
+    case TYPE.select:
+      return compileSelect(node);
+    case TYPE.plural:
+      return compilePlural(node);
+    case TYPE.pound:
+      return TYPE_POUND;
+    case TYPE.tag:
+      return compileTag(node);
+    default:
+      throw new Error(`Unknown AST node type: ${node.type}`);
+  }
+}
+function compileNumber(node) {
+  const result = [node.value, TYPE_NUMBER];
+  const 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) {
+    const opts = style.parsedOptions;
+    return Object.keys(opts).length > 0 ? opts : undefined;
+  }
+  return undefined;
+}
+function compileDate(node) {
+  const result = [node.value, TYPE_DATE];
+  const style = compileDateTimeStyle(node.style);
+  if (style !== undefined) {
+    result.push(style);
+  }
+  return result;
+}
+function compileTime(node) {
+  const result = [node.value, TYPE_TIME];
+  const 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) {
+    const opts = style.parsedOptions;
+    return Object.keys(opts).length > 0 ? opts : undefined;
+  }
+  return undefined;
+}
+function compileSelect(node) {
+  const options = {};
+  for (const [key, option] of Object.entries(node.options)) {
+    options[key] = compileNodesToNode(option.value);
+  }
+  return [node.value, TYPE_SELECT, options];
+}
+
+// Plural offset is not supported
+function compilePlural(node) {
+  if (node.offset) {
+    throw new Error('Plural offsets are not supported');
+  }
+  const options = {};
+  for (const [key, option] of Object.entries(node.options)) {
+    options[key] = compileNodesToNode(option.value);
+  }
+  return [node.value, node.pluralType === 'ordinal' ? TYPE_SELECTORDINAL : TYPE_PLURAL, options];
+}
+function compileTag(node) {
+  const children = compileNodes(node.children);
+  const 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 {
+    result.push(...children);
+  }
+  return result;
+}
+
+export { compile as default };

package/dist/esm/development/format.js

@@ -0,0 +1,212 @@
+import { T as TYPE_POUND, c as TYPE_TIME, b as TYPE_DATE, a as TYPE_NUMBER, e as TYPE_SELECTORDINAL, f as TYPE_PLURAL, d as TYPE_SELECT } from './types-Dl2aHte_.js';
+
+// 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, values = {}, options) {
+  if (typeof message === 'string') {
+    return message;
+  }
+  const result = formatNodes(message, locale, values, options, undefined);
+  return optimizeResult(result);
+}
+function formatNodes(nodes, locale, values, options, pluralCtx) {
+  const result = [];
+  for (const node of nodes) {
+    const formatted = formatNode(node, locale, values, options, pluralCtx);
+    if (Array.isArray(formatted)) {
+      result.push(...formatted);
+    } else {
+      result.push(formatted);
+    }
+  }
+  return result;
+}
+function formatNode(node, locale, values, options, rawPluralCtx) {
+  if (typeof node === 'string') {
+    return node;
+  }
+  if (node === TYPE_POUND) {
+    if (!rawPluralCtx) {
+      throw new Error('# used outside of plural context');
+    }
+    const pluralCtx = rawPluralCtx;
+    return options.formatters.getNumberFormat(pluralCtx.locale).format(pluralCtx.value);
+  }
+  const [name, type, ...rest] = node;
+
+  // Simple argument: ["name"]
+  if (type === undefined) {
+    const value = getValue(values, name);
+    {
+      if (typeof value === 'boolean') {
+        throw new Error(`Invalid value for argument "${name}": Boolean values are not supported and should be converted to strings if needed.`);
+      }
+      if (value instanceof Date) {
+        throw new Error(`Invalid value for argument "${name}": Date values are not supported for plain parameters. Use date formatting instead (e.g. {${name}, date}).`);
+      }
+    }
+    return String(value);
+  }
+
+  // Tag: ["tagName", child1, child2, ...] - detected by non-number or pound marker
+  if (typeof type !== 'number' || type === TYPE_POUND) {
+    return formatTag(name, [type, ...rest], locale, values, options, rawPluralCtx);
+  }
+
+  // Typed nodes: ["name", TYPE, ...]
+  switch (type) {
+    case TYPE_SELECT:
+      return formatSelect(name, rest[0], locale, values, options, rawPluralCtx);
+    case TYPE_PLURAL:
+      return formatPlural(name, rest[0], locale, values, options, 'cardinal');
+    case TYPE_SELECTORDINAL:
+      return formatPlural(name, rest[0], locale, values, options, 'ordinal');
+    case TYPE_NUMBER:
+      return formatNumberValue(name, rest[0], locale, values, options);
+    case TYPE_DATE:
+      return formatDateTimeValue(name, rest[0], locale, values, options, 'date');
+    case TYPE_TIME:
+      return formatDateTimeValue(name, rest[0], locale, values, options, 'time');
+    default:
+      {
+        throw new Error(`Unknown compiled node type: ${type}`);
+      }
+  }
+}
+function getValue(values, name) {
+  if (!(name in values)) {
+    throw new Error(`Missing value for argument "${name}"`);
+  }
+  return values[name];
+}
+function formatSelect(name, options, locale, values, formatOptions, pluralCtx) {
+  const value = String(getValue(values, name));
+  const branch = options[value] ?? options.other;
+  if (!branch) {
+    throw new Error(`No matching branch for select "${name}" with value "${value}"`);
+  }
+  return formatBranch(branch, locale, values, formatOptions, pluralCtx);
+}
+function formatPlural(name, options, locale, values, formatOptions, pluralType) {
+  const rawValue = getValue(values, name);
+  if (typeof rawValue !== 'number') {
+    throw new Error(`Expected number for plural argument "${name}", got ${typeof rawValue}`);
+  }
+  const value = rawValue;
+  const exactKey = `=${value}`;
+  if (exactKey in options) {
+    return formatBranch(options[exactKey], locale, values, formatOptions, {
+      value,
+      locale
+    });
+  }
+  const category = formatOptions.formatters.getPluralRules(locale, {
+    type: pluralType
+  }).select(value);
+  const branch = options[category] ?? options.other;
+  if (!branch) {
+    throw new Error(`No matching branch for plural "${name}" with category "${category}"`);
+  }
+  return formatBranch(branch, locale, values, formatOptions, {
+    value,
+    locale
+  });
+}
+function formatBranch(branch, locale, values, formatOptions, pluralCtx) {
+  if (typeof branch === 'string') {
+    return branch;
+  }
+  if (branch === TYPE_POUND) {
+    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) {
+  const rawValue = getValue(values, name);
+  if (typeof rawValue !== 'number') {
+    throw new Error(`Expected number for argument "${name}", got ${typeof rawValue}`);
+  }
+  const value = rawValue;
+  const opts = getNumberFormatOptions(style, formatOptions);
+  return formatOptions.formatters.getNumberFormat(locale, opts).format(value);
+}
+function formatDateTimeValue(name, style, locale, values, formatOptions, type) {
+  const rawValue = getValue(values, name);
+  if (!(rawValue instanceof Date)) {
+    throw new Error(`Expected Date for argument "${name}", got ${typeof rawValue}`);
+  }
+  const date = rawValue;
+  const baseOpts = getDateTimeFormatOptions(style, type, formatOptions);
+
+  // Global time zone is used as default, but format-specific one takes precedence
+  const opts = {
+    ...baseOpts,
+    timeZone: baseOpts?.timeZone ?? formatOptions.timeZone
+  };
+  return formatOptions.formatters.getDateTimeFormat(locale, opts).format(date);
+}
+function getNumberFormatOptions(style, formatOptions) {
+  if (!style) return undefined;
+  if (typeof style === 'string') {
+    if (formatOptions.formats?.number?.[style]) {
+      return formatOptions.formats.number[style];
+    }
+    {
+      throw new Error(`Missing number format "${style}"`);
+    }
+  }
+  return style;
+}
+function getDateTimeFormatOptions(style, type, formatOptions) {
+  if (!style) return undefined;
+  if (typeof style === 'string') {
+    const resolved = formatOptions.formats?.dateTime?.[style];
+    if (!resolved) {
+      throw new Error(`Missing ${type} format "${style}"`);
+    }
+    return resolved;
+  }
+  return style;
+}
+function formatTag(name, children, locale, values, formatOptions, pluralCtx) {
+  const rawHandler = getValue(values, name);
+  if (typeof rawHandler !== 'function') {
+    throw new Error(`Expected function for tag handler "${name}"`);
+  }
+  const handler = rawHandler;
+  const formattedChildren = formatNodes(children, locale, values, formatOptions, pluralCtx);
+  const optimized = optimizeResult(formattedChildren);
+  const childArray = Array.isArray(optimized) ? optimized : [optimized];
+  return handler(childArray);
+}
+function optimizeResult(result) {
+  if (result.length === 0) {
+    return '';
+  }
+  const merged = [];
+  let currentString = '';
+  for (const item of result) {
+    if (typeof item === 'string') {
+      currentString += item;
+    } else {
+      if (currentString) {
+        merged.push(currentString);
+        currentString = '';
+      }
+      merged.push(item);
+    }
+  }
+  if (currentString) {
+    merged.push(currentString);
+  }
+  if (merged.length === 1) {
+    return merged[0];
+  }
+  return merged;
+}
+
+export { format as default };

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

@@ -0,0 +1,30 @@
+const TYPE_POUND = 0;
+const TYPE_SELECT = 1;
+const TYPE_PLURAL = 2;
+const TYPE_SELECTORDINAL = 3;
+const TYPE_NUMBER = 4;
+const TYPE_DATE = 5;
+const TYPE_TIME = 6;
+
+// Plain text literal
+
+// Simple argument reference: ["name"]
+
+// Pound sign (#) - represents the number in plural contexts
+
+// Select: ["name", TYPE_SELECT, {options}]
+
+// Plural: ["name", TYPE_PLURAL, {options}]
+
+// Select ordinal: ["name", TYPE_SELECTORDINAL, {options}]
+
+// Number format: ["name", TYPE_NUMBER, style?]
+
+// Date format: ["name", TYPE_DATE, style?]
+
+// Time format: ["name", TYPE_TIME, style?]
+
+// Tags have no type constant - detected at runtime by
+// format: ["tagName", child1, child2, ...]
+
+export { TYPE_POUND as T, TYPE_NUMBER as a, TYPE_DATE as b, TYPE_TIME as c, TYPE_SELECT as d, TYPE_SELECTORDINAL as e, TYPE_PLURAL as f };

package/dist/esm/production/compile.js

@@ -0,0 +1 @@
+import{parse as t,TYPE as n}from"@formatjs/icu-messageformat-parser";import{T as e,a as r,b as s,c as o,d as u,e as i,f as c}from"./types-DqTLNw7x.js";function a(n){const e=f(t(n));return 0===e.length?"":1===e.length&&"string"==typeof e[0]?e[0]:e}function f(t){const n=[];for(const e of t){const t=p(e);"string"==typeof t&&n.length>0&&"string"==typeof n[n.length-1]?n[n.length-1]+=t:n.push(t)}return n}function l(t){const n=f(t);if(0===n.length)return"";if(1===n.length){const t=n[0];if("string"==typeof t||t===e)return t}return n}function p(t){switch(t.type){case n.literal:return t.value;case n.argument:return[t.value];case n.number:return function(t){const n=[t.value,r],e=function(t){if(!t)return;if("string"==typeof t)return t;if("parsedOptions"in t){const n=t.parsedOptions;return Object.keys(n).length>0?n:void 0}return}(t.style);void 0!==e&&n.push(e);return n}(t);case n.date:return function(t){const n=[t.value,s],e=g(t.style);void 0!==e&&n.push(e);return n}(t);case n.time:return function(t){const n=[t.value,o],e=g(t.style);void 0!==e&&n.push(e);return n}(t);case n.select:return function(t){const n={};for(const[e,r]of Object.entries(t.options))n[e]=l(r.value);return[t.value,u,n]}(t);case n.plural:return function(t){const n={};for(const[e,r]of Object.entries(t.options))n[e]=l(r.value);return[t.value,"ordinal"===t.pluralType?i:c,n]}(t);case n.pound:return e;case n.tag:return function(t){const n=f(t.children),e=[t.value];0===n.length?e.push(""):e.push(...n);return e}(t);default:throw new Error(`Unknown AST node type: ${t.type}`)}}function g(t){if(t){if("string"==typeof t)return t;if("parsedOptions"in t){const n=t.parsedOptions;return Object.keys(n).length>0?n:void 0}}}export{a as default};

package/dist/esm/production/format.js

@@ -0,0 +1 @@
+import{T as t,c as r,b as n,a as e,e as o,f as u,d as s}from"./types-DqTLNw7x.js";function f(t,r,n={},e){if("string"==typeof t)return t;return g(i(t,r,n,e,void 0))}function i(t,r,n,e,o){const u=[];for(const s of t){const t=a(s,r,n,e,o);Array.isArray(t)?u.push(...t):u.push(t)}return u}function a(f,a,y,d,h){if("string"==typeof f)return f;if(f===t){const t=h;return d.formatters.getNumberFormat(t.locale).format(t.value)}const[b,v,...A]=f;if(void 0===v){const t=c(y,b);return String(t)}if("number"!=typeof v||v===t)return function(t,r,n,e,o,u){const s=c(e,t),f=s,a=i(r,n,e,o,u),m=g(a),l=Array.isArray(m)?m:[m];return f(l)}(b,[v,...A],a,y,d,h);switch(v){case s:return function(t,r,n,e,o,u){const s=String(c(e,t)),f=r[s]??r.other;return l(f,n,e,o,u)}(b,A[0],a,y,d,h);case u:return m(b,A[0],a,y,d,"cardinal");case o:return m(b,A[0],a,y,d,"ordinal");case e:return function(t,r,n,e,o){const u=c(e,t),s=u,f=function(t,r){if(!t)return;if("string"==typeof t)return r.formats?.number?.[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 n:return p(b,A[0],a,y,d,"date");case r: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){const s=c(e,t),f=`=${s}`;if(f in r)return l(r[f],n,e,o,{value:s,locale:n});return l(r[o.formatters.getPluralRules(n,{type:u}).select(s)]??r.other,n,e,o,{value:s,locale:n})}function l(r,n,e,o,u){return"string"==typeof r?r:r===t?a(r,n,e,o,u):i(r,n,e,o,u)}function p(t,r,n,e,o,u){const s=c(e,t),f=function(t,r,n){if(!t)return;if("string"==typeof t){const r=n.formats?.dateTime?.[t];return r}return t}(r,0,o),i={...f,timeZone:f?.timeZone??o.timeZone};return o.formatters.getDateTimeFormat(n,i).format(s)}function g(t){if(0===t.length)return"";const r=[];let n="";for(const e of t)"string"==typeof e?n+=e:(n&&(r.push(n),n=""),r.push(e));return n&&r.push(n),1===r.length?r[0]:r}export{f as default};

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

@@ -0,0 +1 @@
+const a=0,s=1,c=2,e=3,o=4,t=5,b=6;export{a as T,o as a,t as b,b as c,s as d,e,c as f};

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,67 @@
+{
+  "name": "icu-minify",
+  "version": "0.0.1",
+  "sideEffects": false,
+  "author": "Jan Amann <jan@amann.work>",
+  "description": "ICU message format compiler with a <1KB runtime bundle footprint",
+  "license": "MIT",
+  "homepage": "https://next-intl.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amannn/next-intl.git"
+  },
+  "type": "module",
+  "exports": {
+    "./compile": {
+      "types": "./dist/types/compile.d.ts",
+      "development": "./dist/esm/development/compile.js",
+      "default": "./dist/esm/production/compile.js"
+    },
+    "./format": {
+      "types": "./dist/types/format.d.ts",
+      "development": "./dist/esm/development/format.js",
+      "default": "./dist/esm/production/format.js"
+    }
+  },
+  "files": [
+    "dist",
+    "compile.d.ts",
+    "format.d.ts"
+  ],
+  "keywords": [
+    "icu",
+    "messageformat",
+    "i18n",
+    "internationalization",
+    "compiler",
+    "minify"
+  ],
+  "dependencies": {
+    "@formatjs/icu-messageformat-parser": "^3.4.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.4",
+    "@size-limit/preset-small-lib": "^11.2.0",
+    "@types/node": "^20.14.5",
+    "eslint": "9.11.1",
+    "eslint-config-molindo": "^8.0.0",
+    "intl-messageformat": "^11.1.0",
+    "prettier": "^3.3.3",
+    "publint": "^0.2.8",
+    "rollup": "^4.18.0",
+    "size-limit": "^11.2.0",
+    "typescript": "^5.5.3",
+    "vitest": "^3.0.8",
+    "tools": "^1.0.0"
+  },
+  "prettier": "eslint-config-molindo/.prettierrc.json",
+  "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"
+  }
+}