10-6

libs/i18n/lang/cn.json

@@ -18,6 +18,35 @@
 		"a4": "日均收益率",
 		"a5": "立即加入"
 	},
+	"homeingor":{
+		"m1":"互娱玩法介绍",
+		"m0":"互娱游戏推广计划",
+		"m2":"互娱游戏举例",
+		"m4": "项目亮点"
+	},
+	"zy":{
+		"a1": "单笔上限",
+		"m0":"日均收益率",
+		"m1":"限投份额",
+		"m2":"托管过期",
+		"m3": "单笔上限",
+		"m4": "起投金额",
+		"m5": "收益过程",
+		"m6": "申请提交",
+		"m7": "今日",
+		"m8": "每日返利",
+		"m9": "24小时后",
+		"m10": "申请提现",
+		"m11": "24小时之内到账",
+		"m12": "加入后不可撤销",
+		"m13": "产品到期选择复投，收益不断",
+		"m14": "收益公式",
+		"m15": "收益结算",
+		"m16": "加入金额(元)",
+		"m17": "余额",
+		"m18": "当前可用",
+		"m19": "立即加入"
+	},
 	"user":{
 		"c1": "余额",
 		"a4": "累計",
@@ -35,6 +64,71 @@
 		"b7":"交易密码",
 		"b8":"退出登录"
 	},
+	"myple": {
+		"u1": "质押数",
+		"u2": "进行中",
+		"u3": "已结束",
+		"u4": "质押金额",
+		"u5": "累计收益",
+		"u6": "质押期限",
+		"u7": "购买时间",
+		"u8": "到期时间"
+	},
+	"userinfo": {
+		"u1": "收款地址",
+		"u2": "保存相冊",
+		"u3": "复制地址",
+		"u4": "链名称",
+		"u5": "提示：充值大于5000U，请先充值一笔小额的，到zhang之后再进行大额充值。充值地址每个人都是唯一的！请一定要仔细确认避免充错！",
+		"u6": "提币网络",
+		"u7": "提币地址",
+		"u8": "提币数量",
+		"u9": "提现须知",
+		"u10": "使用步骤",
+		"u11": "输入您要提现的币种、网络、地址、数量，点击“下一步”",
+		"u12": "确认资讯无误后输入资金密码完成验证，点击“确认提现”",
+		"u13": "每日提现上限2次;",
+		"u14": "提现成功后，提现地址将自动保存以便于下次使用；",
+		"u15": "请注意每个人的地址都是唯一的，请一定要仔细确认避免提错！",
+		"u16": "确认提币"
+	},
+	"money": {
+		"a1": "钱包",
+		"a2": "我的余额",
+		"a3": "充值",
+		"a4": "提现",
+		"a5": "累计收入",
+		"a6": "累计支出",
+		"a7": "历史充值",
+		"a8": "历史提现"
+	},
+	"gameList": {
+		"a1": "待开奖",
+		"a2": "k线类型",
+		"a3": "5分线",
+		"a4": "互娱金额",
+		"a5": "开奖时间"
+	},
+	"huiyuan": {
+		"a1": "直推人数",
+		"a2": "团队人数",
+		"a3": "账户总数",
+		"a4": "有效账户",
+		"a5": "详情",
+		"a6": "互娱金额",
+		"a7": "推广数"
+	},
+	"password": {
+		"a1": "修改交易密码",
+		"a2": "新密码",
+		"a3": "请输入新密码",
+		"a4": "重复密码",
+		"a5": "请重复输入密码",
+		"a6": "验证码",
+		"a7": "请输入验证码",
+		"a8": "确认"
+	},
+	
 	"add": {
 		"kt": "Airdrop",
 		"ck": "deposit",
@@ -645,8 +739,8 @@
 		"a2": "分类"
 	},
 	"login": {
-		"a0": "邮箱号",
-		"a1": "请输入邮箱号",
+		"a0": "互娱共享",
+		"a1": "请输入手机号/邮箱",
 		"a2": "密码",
 		"a3": "请输入密码",
 		"a4": "登录",
@@ -655,7 +749,12 @@
 		"a7": "立即注册",
 		"a8": "手机",
 		"a9": "邮箱",
-		"b0": "完成"
+		"b0": "完成",
+		"b2": "忘记密码?",
+		"b3": "请输入交易密码",
+		"b4": "请输入邀请码",
+		"b5": "发送验证码",
+		"b6": "请输入验证码"
 	},
 	"contract": {
 		"title": "合约",

libs/i18n/lang/en.json

@@ -18,6 +18,99 @@
 		"a4": "Daily profit",
 		"a5": "Buy"
 	},
+	"zy":{
+		"m0":"Daily return",
+		"m1":"Limited",
+		"m2":"Expire",
+		"m3": "Upper limit",
+		"m4": "Sum money",
+		"m5": "Return process",
+		"m6": "Submit ",
+		"m7": "Today",
+		"m8": "Daily rebate",
+		"m9": "After 24 hours",
+		"m10": "Withdrawal",
+		"m11": "Received within 24 hours",
+		"m12": "Not revocable after joining",
+		"m13": "Mature reinvestment with continuous returns",
+		"m14": "Income formula",
+		"m15": "Income settlement",
+		"m16": "Amount added(yuan)",
+		"m17": "Balance",
+		"m18": "Total",
+		"m19": "Join Now"
+	},
+	"homeinformation":{
+		"m1":"Game Introduction",
+		"m0":"Promotion Plan",
+		"m2":"Examples of games",
+		"m4": "Project Highlights"
+	},
+	"userinfo": {
+		"u1": "Collection",
+		"u2": "Save",
+		"u3": "Copy",
+		"u4": "Name",
+		"u5": " Note: If the recharge amount is greater than 5000U, please recharge a small amount first, and then proceed with the large amount recharge after it is credited. The recharge address is unique for each person! Please be sure to double-check and avoid recharging to the wrong address!",
+	    "u6": "Cash withdrawal network",
+	    "u7": "Cash withdrawal address",
+	    "u8": "Cash withdrawal count",
+		
+		"u9": "Withdrawal Notice",
+		"u10": "Usage steps",
+		"u11": "Enter the currency, network, address, and amount you want to withdraw, then click Next",
+		"u12": "After confirming the information is correct, enter your fund password for verification, and click Confirm Withdrawal",
+		"u13": "Daily withdrawal limit: 2 times;",
+		"u14": "After successful withdrawal, the withdrawal address will be automatically saved for future use",
+		"u15": "Please note that each person’s address is unique. Please be sure to double-check and avoid withdrawing to the wrong address!",
+		"u16": "Confirm"
+	},	
+	"myple": {
+		"u1": "Number of pledges",
+		"u2": "in progress",
+		"u3": "Ended",
+		"u4": "Amount",
+		"u5": "Income",
+		"u6": "Term",
+		"u7": "Buying",
+		"u8": "Expiration"
+	},
+	"money": {
+		"a1": "wallet",
+		"a2": "My Balance",
+		"a3": "Recharge",
+		"a4": "Withdrawal",
+		"a5": "Accumulated income",
+		"a6": "Accumulated expenses",
+		"a7": "Historical recharge",
+		"a8": "Historical withdrawal"
+	},	
+	"gameList": {
+		"a1": "Await",
+		"a2": "k types",
+		"a3": "5-point line",
+		"a4": "Game amount",
+		"a5": "Lottery opening time"
+	},
+	"huiyuan": {
+		"a1": "Recommends",
+		"a2": "Teams",
+		"a3": "Total accounts",
+		"a4": "Valid Account",
+		"a5": "Details",
+		"a6": "amount",
+		"a7": "Promotions"
+	},
+	"password": {
+		"a1": "Change transaction password",
+		"a2": "New password",
+		"a3": "New password",
+		"a4": "Repeat ",
+		"a5": "Repeat the password",
+		"a6": "Code",
+		"a7": "Please enter code",
+		"a8": "Confirm"
+	},
 	"user":{
 		"c1": "Balance",
 		"a4": "All ",
@@ -35,6 +128,7 @@
 		"b7":"Transaction password",
 		"b8":"Exit"
 	},
+	
 	"add": {
 		"kt": "Airdrop",
 		"ck": "deposit",
@@ -701,8 +795,8 @@
 		"h6": "Purchase Tutorial"
 	},
 	"login": {
-		"a0": "Email",
-		"a1": "Please enter your email number",
+		"a0": "Game",
+		"a1": "Please enter phone number/email",
 		"a2": "Password",
 		"a3": "Please enter a password",
 		"a4": "Login",
@@ -711,7 +805,12 @@
 		"a7": "Register Now",
 		"a8": "Mobile",
 		"a9": "Email",
-		"b0": "Done"
+		"b0": "Done",
+		"b2": "Fotgot password?",
+		"b3": "Please enter a transaction password",
+		"b4": "Please enter a invitation code",
+		"b5": "Send code",
+		"b6": "Please enter code"
 	},
 	"contract": {
 		"title": "TXT Futures",

libs/i18n/lang/tw.json

@@ -18,6 +18,34 @@
 		"a4": "日均收益率",
 		"a5": "立即加入"
 	},
+	"homeingor":{
+		"m1":"互娛遊戲玩法介紹",
+		"m0":"互娛遊戲推廣計劃",
+		"m2":"互娛遊戲舉例",
+		"m4": "項目亮點"
+	},
+	"zy":{
+		"m0":"日均收益率",
+		"m1":"限投份額",
+		"m2":"託管週期",
+		"m3": "單筆上限",
+		"m4": "起投金額",
+		"m5": "收益過程",
+		"m6": "申請提交",
+		"m7": "今日",
+		"m8": "每日返利",
+		"m9": "24小時後",
+		"m10": "申請提現",
+		"m11": "24小時之內到賬",
+		"m12": "買入後不可撤銷",
+		"m13": "产品到期选择复投，收益不断",
+		"m14": "收益公式",
+		"m15": "收益結算",
+		"m16": "買入金額(元)",
+		"m17": "餘額",
+		"m18": "當前可用",
+		"m19": "立即加入"
+	},
 	"user":{
 		"c1": "餘額",
 		"a4": "累計",
@@ -33,8 +61,72 @@
 		"b5":"分享鏈接",
 		"b6":"在線留言",
 		"b7":"交易密碼",
-		"b8":"退出登錄"
-		
+		"b8":"退出登錄",
+		"ck": "存款"
+	},
+	"myple": {
+		"u1": "質押數",
+		"u2": "进行中",
+		"u3": "已结束",
+		"u4": "質押金額",
+		"u5": "累計收益",
+		"u6": "質押期限",
+		"u7": "購買時間",
+		"u8": "到期時間"
+	},
+	"userinfo": {
+		"u1": "收款地址",
+		"u2": "保存相冊",
+		"u3": "複製地址",
+		"u4": "鏈名稱",
+		"u5": "提示：充值大於5000U，請先充值一筆小額的，到賬之後再進行大額充值。充值地址每個人都是唯一的！請一定要仔細確認避免充錯！",
+		"u6": "提幣網絡",
+		"u7": "提幣地址",
+		"u8": "提幣數量",
+		"u9": "提現須知",
+		"u10": "使用步驟",
+		"u11": "輸入您要提現的幣種、網絡、地址、數量，點擊“下一步”",
+		"u12": "確認資訊無誤後輸入資金密碼完成驗證，點擊“確認提現”",
+		"u13": "每日提現上限2次;",
+		"u14": "提現成功後，提現地址將自動保存以便於下次使用；",
+		"u15": "請注意每個人的地址都是唯一的，請一定要仔細確認避免提錯！",
+		"u16": "確認提幣"
+	},
+	"money": {
+		"a1": "錢包",
+		"a2": "我的餘額",
+		"a3": "充值",
+		"a4": "提現",
+		"a5": "累计收入",
+		"a6": "累计支出",
+		"a7": "历史充值",
+		"a8": "历史提現"
+	},
+	"gameList": {
+		"a1": "待開獎",
+		"a2": "k線類型",
+		"a3": "5分線",
+		"a4": "互娛金額",
+		"a5": "開獎時間"
+	},
+	"huiyuan": {
+		"a1": "直推人數",
+		"a2": "團隊人數",
+		"a3": "賬戶總數",
+		"a4": "有效賬戶",
+		"a5": "詳情",
+		"a6": "互娛金額",
+		"a7": "推廣數"
+	},
+	"password": {
+		"a1": "修改交易密碼",
+		"a2": "新密碼",
+		"a3": "請輸入新密碼",
+		"a4": "重復密碼",
+		"a5": "請重復輸入密碼",
+		"a6": "驗證碼",
+		"a7": "請輸入驗證碼",
+		"a8": "確認"
 	},
 	"add": {
 		"ck": "存款",
@@ -645,8 +737,8 @@
 		"a2": "分類"
 	},
 	"login": {
-		"a0": "郵箱號",
-		"a1": "請輸入郵箱號",
+		"a0": "互娛共享",
+		"a1": "請输入手機號/郵箱",
 		"a2": "密碼",
 		"a3": "請輸入密碼",
 		"a4": "登錄",
@@ -655,7 +747,12 @@
 		"a7": "立即註冊",
 		"a8": "手機",
 		"a9": "郵箱",
-		"b0": "完成"
+		"b0": "完成",
+		"b2": "忘记密码?",
+		"b3": "請輸入交易密碼",
+		"b4": "請輸入邀請碼",
+		"b5": "发送驗證碼",
+		"b6": "請輸入驗證碼"
 	},
 	"contract": {
 		"title": "合約",

node_modules/.bin/mustache

@@ -0,0 +1,12 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../mustache/bin/mustache" "$@"
+else 
+  exec node  "$basedir/../mustache/bin/mustache" "$@"
+fi

node_modules/.bin/mustache.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\mustache\bin\mustache" %*

node_modules/.bin/mustache.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../mustache/bin/mustache" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../mustache/bin/mustache" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../mustache/bin/mustache" $args
+  } else {
+    & "node$exe"  "$basedir/../mustache/bin/mustache" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/nanoid

@@ -0,0 +1,12 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
+else 
+  exec node  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
+fi

node_modules/.bin/nanoid.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\nanoid\bin\nanoid.cjs" %*

node_modules/.bin/nanoid.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  } else {
+    & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.bin/parser

@@ -0,0 +1,12 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
+else 
+  exec node  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
+fi

node_modules/.bin/parser.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\@babel\parser\bin\babel-parser.js" %*

node_modules/.bin/parser.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  } else {
+    & "node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

node_modules/.package-lock.json

@@ -3,6 +3,239 @@
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
+    "node_modules/@babel/parser": {
+      "version": "7.23.0",
+      "resolved": "https://registry.npmmirror.com/@babel/parser/-/parser-7.23.0.tgz",
+      "integrity": "sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==",
+      "peer": true,
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@intlify/core-base": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmmirror.com/@intlify/core-base/-/core-base-9.5.0.tgz",
+      "integrity": "sha512-y3ufM1RJbI/DSmJf3lYs9ACq3S/iRvaSsE3rPIk0MGH7fp+JxU6rdryv/EYcwfcr3Y1aHFlCBir6S391hRZ57w==",
+      "dependencies": {
+        "@intlify/message-compiler": "9.5.0",
+        "@intlify/shared": "9.5.0"
+      },
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/@intlify/message-compiler": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmmirror.com/@intlify/message-compiler/-/message-compiler-9.5.0.tgz",
+      "integrity": "sha512-CAhVNfEZcOVFg0/5MNyt+OFjvs4J/ARjCj2b+54/FvFP0EDJI5lIqMTSDBE7k0atMROSP0SvWCkwu/AZ5xkK1g==",
+      "dependencies": {
+        "@intlify/shared": "9.5.0",
+        "source-map-js": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/@intlify/shared": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmmirror.com/@intlify/shared/-/shared-9.5.0.tgz",
+      "integrity": "sha512-tAxV14LMXZDZbu32XzLMTsowNlgJNmLwWHYzvMUl6L8gvQeoYiZONjY7AUsqZW8TOZDX9lfvF6adPkk9FSRdDA==",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.4.15",
+      "resolved": "https://registry.npmmirror.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
+      "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==",
+      "peer": true
+    },
+    "node_modules/@messageformat/core": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmmirror.com/@messageformat/core/-/core-3.2.0.tgz",
+      "integrity": "sha512-ppbb/7OYqg/t4WdFk8VAfZEV2sNUq3+7VeBAo5sKFhmF786sh6gB7fUeXa2qLTDIcTHS49HivTBN7QNOU5OFTg==",
+      "dependencies": {
+        "@messageformat/date-skeleton": "^1.0.0",
+        "@messageformat/number-skeleton": "^1.0.0",
+        "@messageformat/parser": "^5.1.0",
+        "@messageformat/runtime": "^3.0.1",
+        "make-plural": "^7.0.0",
+        "safe-identifier": "^0.4.1"
+      }
+    },
+    "node_modules/@messageformat/date-skeleton": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/@messageformat/date-skeleton/-/date-skeleton-1.0.1.tgz",
+      "integrity": "sha512-jPXy8fg+WMPIgmGjxSlnGJn68h/2InfT0TNSkVx0IGXgp4ynnvYkbZ51dGWmGySEK+pBiYUttbQdu5XEqX5CRg=="
+    },
+    "node_modules/@messageformat/number-skeleton": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/@messageformat/number-skeleton/-/number-skeleton-1.2.0.tgz",
+      "integrity": "sha512-xsgwcL7J7WhlHJ3RNbaVgssaIwcEyFkBqxHdcdaiJzwTZAWEOD8BuUFxnxV9k5S0qHN3v/KzUpq0IUpjH1seRg=="
+    },
+    "node_modules/@messageformat/parser": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmmirror.com/@messageformat/parser/-/parser-5.1.0.tgz",
+      "integrity": "sha512-jKlkls3Gewgw6qMjKZ9SFfHUpdzEVdovKFtW1qRhJ3WI4FW5R/NnGDqr8SDGz+krWDO3ki94boMmQvGke1HwUQ==",
+      "dependencies": {
+        "moo": "^0.5.1"
+      }
+    },
+    "node_modules/@messageformat/runtime": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmmirror.com/@messageformat/runtime/-/runtime-3.0.1.tgz",
+      "integrity": "sha512-6RU5ol2lDtO8bD9Yxe6CZkl0DArdv0qkuoZC+ZwowU+cdRlVE1157wjCmlA5Rsf1Xc/brACnsZa5PZpEDfTFFg==",
+      "dependencies": {
+        "make-plural": "^7.0.0"
+      }
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/compiler-core/-/compiler-core-3.3.4.tgz",
+      "integrity": "sha512-cquyDNvZ6jTbf/+x+AgM2Arrp6G4Dzbb0R64jiG804HRMfRiFXWI6kqUVqZ6ZR0bQhIoQjB4+2bhNtVwndW15g==",
+      "peer": true,
+      "dependencies": {
+        "@babel/parser": "^7.21.3",
+        "@vue/shared": "3.3.4",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.0.2"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/compiler-dom/-/compiler-dom-3.3.4.tgz",
+      "integrity": "sha512-wyM+OjOVpuUukIq6p5+nwHYtj9cFroz9cwkfmP9O1nzH68BenTTv0u7/ndggT8cIQlnBeOo6sUT/gvHcIkLA5w==",
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-core": "3.3.4",
+        "@vue/shared": "3.3.4"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/compiler-sfc/-/compiler-sfc-3.3.4.tgz",
+      "integrity": "sha512-6y/d8uw+5TkCuzBkgLS0v3lSM3hJDntFEiUORM11pQ/hKvkhSKZrXW6i69UyXlJQisJxuUEJKAWEqWbWsLeNKQ==",
+      "peer": true,
+      "dependencies": {
+        "@babel/parser": "^7.20.15",
+        "@vue/compiler-core": "3.3.4",
+        "@vue/compiler-dom": "3.3.4",
+        "@vue/compiler-ssr": "3.3.4",
+        "@vue/reactivity-transform": "3.3.4",
+        "@vue/shared": "3.3.4",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.0",
+        "postcss": "^8.1.10",
+        "source-map-js": "^1.0.2"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/compiler-ssr/-/compiler-ssr-3.3.4.tgz",
+      "integrity": "sha512-m0v6oKpup2nMSehwA6Uuu+j+wEwcy7QmwMkVNVfrV9P2qE5KshC6RwOCq8fjGS/Eak/uNb8AaWekfiXxbBB6gQ==",
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-dom": "3.3.4",
+        "@vue/shared": "3.3.4"
+      }
+    },
+    "node_modules/@vue/devtools-api": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmmirror.com/@vue/devtools-api/-/devtools-api-6.5.0.tgz",
+      "integrity": "sha512-o9KfBeaBmCKl10usN4crU53fYtC1r7jJwdGKjPT24t348rHxgfpZ0xL3Xm/gLUYnc0oTp8LAmrxOeLyu6tbk2Q=="
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/reactivity/-/reactivity-3.3.4.tgz",
+      "integrity": "sha512-kLTDLwd0B1jG08NBF3R5rqULtv/f8x3rOFByTDz4J53ttIQEDmALqKqXY0J+XQeN0aV2FBxY8nJDf88yvOPAqQ==",
+      "peer": true,
+      "dependencies": {
+        "@vue/shared": "3.3.4"
+      }
+    },
+    "node_modules/@vue/reactivity-transform": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/reactivity-transform/-/reactivity-transform-3.3.4.tgz",
+      "integrity": "sha512-MXgwjako4nu5WFLAjpBnCj/ieqcjE2aJBINUNQzkZQfzIZA4xn+0fV1tIYBJvvva3N3OvKGofRLvQIwEQPpaXw==",
+      "peer": true,
+      "dependencies": {
+        "@babel/parser": "^7.20.15",
+        "@vue/compiler-core": "3.3.4",
+        "@vue/shared": "3.3.4",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.0"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/runtime-core/-/runtime-core-3.3.4.tgz",
+      "integrity": "sha512-R+bqxMN6pWO7zGI4OMlmvePOdP2c93GsHFM/siJI7O2nxFRzj55pLwkpCedEY+bTMgp5miZ8CxfIZo3S+gFqvA==",
+      "peer": true,
+      "dependencies": {
+        "@vue/reactivity": "3.3.4",
+        "@vue/shared": "3.3.4"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/runtime-dom/-/runtime-dom-3.3.4.tgz",
+      "integrity": "sha512-Aj5bTJ3u5sFsUckRghsNjVTtxZQ1OyMWCr5dZRAPijF/0Vy4xEoRCwLyHXcj4D0UFbJ4lbx3gPTgg06K/GnPnQ==",
+      "peer": true,
+      "dependencies": {
+        "@vue/runtime-core": "3.3.4",
+        "@vue/shared": "3.3.4",
+        "csstype": "^3.1.1"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/server-renderer/-/server-renderer-3.3.4.tgz",
+      "integrity": "sha512-Q6jDDzR23ViIb67v+vM1Dqntu+HUexQcsWKhhQa4ARVzxOY2HbC7QRW/ggkDBd5BU+uM1sV6XOAP0b216o34JQ==",
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-ssr": "3.3.4",
+        "@vue/shared": "3.3.4"
+      },
+      "peerDependencies": {
+        "vue": "3.3.4"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/@vue/shared/-/shared-3.3.4.tgz",
+      "integrity": "sha512-7OjdcV8vQ74eiz1TZLzZP4JwqM5fA94K6yntPS5Z25r9HDuGNzaGdgvwKYq6S+MxwF0TFRwe50fIR/MYnakdkQ==",
+      "peer": true
+    },
+    "node_modules/boolean": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmmirror.com/boolean/-/boolean-3.2.0.tgz",
+      "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw=="
+    },
+    "node_modules/csstype": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmmirror.com/csstype/-/csstype-3.1.2.tgz",
+      "integrity": "sha512-I7K1Uu0MBPzaFKg4nI5Q7Vs2t+3gWWW648spaF+Rg7pI9ds18Ugn+lvg4SHczUdKlHI5LWBXyqfS8+DufyBsgQ==",
+      "peer": true
+    },
+    "node_modules/debug": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-4.3.4.tgz",
+      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/echarts": {
       "version": "5.4.3",
       "resolved": "https://registry.npmmirror.com/echarts/-/echarts-5.4.3.tgz",
@@ -12,6 +245,127 @@
         "zrender": "5.4.4"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmmirror.com/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "peer": true
+    },
+    "node_modules/fast-printf": {
+      "version": "1.6.9",
+      "resolved": "https://registry.npmmirror.com/fast-printf/-/fast-printf-1.6.9.tgz",
+      "integrity": "sha512-FChq8hbz65WMj4rstcQsFB0O7Cy++nmbNfLYnD9cYv2cRn8EG6k/MGn9kO/tjO66t09DLDugj3yL+V2o6Qftrg==",
+      "dependencies": {
+        "boolean": "^3.1.4"
+      },
+      "engines": {
+        "node": ">=10.0"
+      }
+    },
+    "node_modules/i18n": {
+      "version": "0.15.1",
+      "resolved": "https://registry.npmmirror.com/i18n/-/i18n-0.15.1.tgz",
+      "integrity": "sha512-yue187t8MqUPMHdKjiZGrX+L+xcUsDClGO0Cz4loaKUOK9WrGw5pgan4bv130utOwX7fHE9w2iUeHFalVQWkXA==",
+      "dependencies": {
+        "@messageformat/core": "^3.0.0",
+        "debug": "^4.3.3",
+        "fast-printf": "^1.6.9",
+        "make-plural": "^7.0.0",
+        "math-interval-parser": "^2.0.1",
+        "mustache": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.4",
+      "resolved": "https://registry.npmmirror.com/magic-string/-/magic-string-0.30.4.tgz",
+      "integrity": "sha512-Q/TKtsC5BPm0kGqgBIF9oXAs/xEf2vRKiIB4wCRQTJOQIByZ1d+NnUOotvJOvNpi5RNIgVOMC3pOuaP1ZTDlVg==",
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.4.15"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/make-plural": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmmirror.com/make-plural/-/make-plural-7.3.0.tgz",
+      "integrity": "sha512-/K3BC0KIsO+WK2i94LkMPv3wslMrazrQhfi5We9fMbLlLjzoOSJWr7TAdupLlDWaJcWxwoNosBkhFDejiu5VDw=="
+    },
+    "node_modules/math-interval-parser": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/math-interval-parser/-/math-interval-parser-2.0.1.tgz",
+      "integrity": "sha512-VmlAmb0UJwlvMyx8iPhXUDnVW1F9IrGEd9CIOmv+XL8AErCUUuozoDMrgImvnYt2A+53qVX/tPW6YJurMKYsvA==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/moo": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmmirror.com/moo/-/moo-0.5.2.tgz",
+      "integrity": "sha512-iSAJLHYKnX41mKcJKjqvnAN9sf0LMDTXDEvFv+ffuRR9a1MIuXLjMNL6EsnDHSkKLTWNqQQ5uo61P4EbU4NU+Q=="
+    },
+    "node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+    },
+    "node_modules/mustache": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmmirror.com/mustache/-/mustache-4.2.0.tgz",
+      "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==",
+      "bin": {
+        "mustache": "bin/mustache"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmmirror.com/nanoid/-/nanoid-3.3.6.tgz",
+      "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==",
+      "peer": true,
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/picocolors/-/picocolors-1.0.0.tgz",
+      "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==",
+      "peer": true
+    },
+    "node_modules/postcss": {
+      "version": "8.4.31",
+      "resolved": "https://registry.npmmirror.com/postcss/-/postcss-8.4.31.tgz",
+      "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==",
+      "peer": true,
+      "dependencies": {
+        "nanoid": "^3.3.6",
+        "picocolors": "^1.0.0",
+        "source-map-js": "^1.0.2"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/safe-identifier": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmmirror.com/safe-identifier/-/safe-identifier-0.4.2.tgz",
+      "integrity": "sha512-6pNbSMW6OhAi9j+N8V+U715yBQsaWJ7eyEUaOrawX+isg5ZxhUlV1NipNtgaKHmFGiABwt+ZF04Ii+3Xjkg+8w=="
+    },
+    "node_modules/source-map-js": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/source-map-js/-/source-map-js-1.0.2.tgz",
+      "integrity": "sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/tslib": {
       "version": "2.3.0",
       "resolved": "https://registry.npmmirror.com/tslib/-/tslib-2.3.0.tgz",
@@ -22,6 +376,35 @@
       "resolved": "https://registry.npmmirror.com/uqrcodejs/-/uqrcodejs-4.0.7.tgz",
       "integrity": "sha512-84+aZmD2godCVI+93lxE3YUAPNY8zAJvNA7xRS7R7U+q57KzMDepBSfNCwoRUhWOfR6eHFoAOcHRPwsP6ka1cA=="
     },
+    "node_modules/vue": {
+      "version": "3.3.4",
+      "resolved": "https://registry.npmmirror.com/vue/-/vue-3.3.4.tgz",
+      "integrity": "sha512-VTyEYn3yvIeY1Py0WaYGZsXnz3y5UnGi62GjVEqvEGPl6nxbOrCXbVOTQWBEJUqAyTUk2uJ5JLVnYJ6ZzGbrSw==",
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-dom": "3.3.4",
+        "@vue/compiler-sfc": "3.3.4",
+        "@vue/runtime-dom": "3.3.4",
+        "@vue/server-renderer": "3.3.4",
+        "@vue/shared": "3.3.4"
+      }
+    },
+    "node_modules/vue-i18n": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmmirror.com/vue-i18n/-/vue-i18n-9.5.0.tgz",
+      "integrity": "sha512-NiI3Ph1qMstNf7uhYh8trQBOBFLxeJgcOxBq51pCcZ28Vs18Y7BDS58r8HGDKCYgXdLUYqPDXdKatIF4bvBVZg==",
+      "dependencies": {
+        "@intlify/core-base": "9.5.0",
+        "@intlify/shared": "9.5.0",
+        "@vue/devtools-api": "^6.5.0"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "peerDependencies": {
+        "vue": "^3.0.0"
+      }
+    },
     "node_modules/zrender": {
       "version": "5.4.4",
       "resolved": "https://registry.npmmirror.com/zrender/-/zrender-5.4.4.tgz",

node_modules/@babel/parser/CHANGELOG.md

@@ -0,0 +1,1073 @@
+# Changelog
+
+> **Tags:**
+> - :boom:       [Breaking Change]
+> - :eyeglasses: [Spec Compliance]
+> - :rocket:     [New Feature]
+> - :bug:        [Bug Fix]
+> - :memo:       [Documentation]
+> - :house:      [Internal]
+> - :nail_care:  [Polish]
+
+> Semver Policy: https://github.com/babel/babel/tree/main/packages/babel-parser#semver
+
+_Note: Gaps between patch versions are faulty, broken or test releases._
+
+See the [Babel Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) for the pre-6.8.0 version Changelog.
+
+## 6.17.1 (2017-05-10)
+
+### :bug: Bug Fix
+ * Fix typo in flow spread operator error (Brian Ng)
+ * Fixed invalid number literal parsing ([#473](https://github.com/babel/babylon/pull/473)) (Alex Kuzmenko)
+ * Fix number parser ([#433](https://github.com/babel/babylon/pull/433)) (Alex Kuzmenko)
+ * Ensure non pattern shorthand props are checked for reserved words ([#479](https://github.com/babel/babylon/pull/479)) (Brian Ng)
+ * Remove jsx context when parsing arrow functions ([#475](https://github.com/babel/babylon/pull/475)) (Brian Ng)
+ * Allow super in class properties ([#499](https://github.com/babel/babylon/pull/499)) (Brian Ng)
+ * Allow flow class field to be named constructor ([#510](https://github.com/babel/babylon/pull/510)) (Brian Ng)
+
+## 6.17.0 (2017-04-20)
+
+### :bug: Bug Fix
+ * Cherry-pick #418 to 6.x ([#476](https://github.com/babel/babylon/pull/476)) (Sebastian McKenzie)
+ * Add support for invalid escapes in tagged templates ([#274](https://github.com/babel/babylon/pull/274)) (Kevin Gibbons)
+ * Throw error if new.target is used outside of a function ([#402](https://github.com/babel/babylon/pull/402)) (Brian Ng)
+ * Fix parsing of class properties ([#351](https://github.com/babel/babylon/pull/351)) (Kevin Gibbons)
+ * Fix parsing yield with dynamicImport ([#383](https://github.com/babel/babylon/pull/383)) (Brian Ng)
+ * Ensure consistent start args for parseParenItem ([#386](https://github.com/babel/babylon/pull/386)) (Brian Ng)
+
+## 7.0.0-beta.8 (2017-04-04)
+
+### New Feature
+* Add support for flow type spread (#418) (Conrad Buck)
+* Allow statics in flow interfaces (#427) (Brian Ng)
+
+### Bug Fix
+* Fix predicate attachment to match flow parser (#428) (Brian Ng)
+* Add extra.raw back to JSXText and JSXAttribute (#344) (Alex Rattray)
+* Fix rest parameters with array and objects (#424) (Brian Ng)
+* Fix number parser (#433) (Alex Kuzmenko)
+
+### Docs
+* Fix CONTRIBUTING.md [skip ci] (#432) (Alex Kuzmenko)
+
+### Internal
+* Use babel-register script when running babel smoke tests (#442) (Brian Ng)
+
+## 7.0.0-beta.7 (2017-03-22)
+
+### Spec Compliance
+* Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu)
+
+### Bug Fix
+
+* Fix push-pop logic in flow (#405) (Daniel Tschinder)
+
+## 7.0.0-beta.6 (2017-03-21)
+
+### New Feature
+* Add support for invalid escapes in tagged templates (#274) (Kevin Gibbons)
+
+### Polish
+* Improves error message when super is called outside of constructor (#408) (Arshabh Kumar Agarwal)
+
+### Docs
+
+* [7.0] Moved value field in spec from ObjectMember to ObjectProperty as ObjectMethod's don't have it (#415) [skip ci] (James Browning)
+
+## 7.0.0-beta.5 (2017-03-21)
+
+### Bug Fix
+* Throw error if new.target is used outside of a function (#402) (Brian Ng)
+* Fix parsing of class properties (#351) (Kevin Gibbons)
+
+### Other
+ * Test runner: Detect extra property in 'actual' but not in 'expected'. (#407) (Andy)
+ * Optimize travis builds (#419) (Daniel Tschinder)
+ * Update codecov to 2.0 (#412) (Daniel Tschinder)
+ * Fix spec for ClassMethod: It doesn't have a function, it *is* a function. (#406) [skip ci] (Andy)
+ * Changed Non-existent RestPattern to RestElement which is what is actually parsed (#409) [skip ci] (James Browning)
+ * Upgrade flow to 0.41 (Daniel Tschinder)
+ * Fix watch command (#403) (Brian Ng)
+ * Update yarn lock (Daniel Tschinder)
+ * Fix watch command (#403) (Brian Ng)
+ * chore(package): update flow-bin to version 0.41.0 (#395) (greenkeeper[bot])
+ * Add estree test for correct order of directives (Daniel Tschinder)
+ * Add DoExpression to spec (#364) (Alex Kuzmenko)
+ * Mention cloning of repository in CONTRIBUTING.md (#391) [skip ci] (Sumedh Nimkarde)
+ * Explain how to run only one test (#389) [skip ci] (Aaron Ang)
+
+ ## 7.0.0-beta.4 (2017-03-01)
+
+* Don't consume async when checking for async func decl (#377) (Brian Ng)
+* add `ranges` option [skip ci] (Henry Zhu)
+* Don't parse class properties without initializers when classProperties is disabled and Flow is enabled (#300) (Andrew Levine)
+
+## 7.0.0-beta.3 (2017-02-28)
+
+- [7.0] Change RestProperty/SpreadProperty to RestElement/SpreadElement (#384)
+- Merge changes from 6.x
+
+## 7.0.0-beta.2 (2017-02-20)
+
+- estree: correctly change literals in all cases (#368) (Daniel Tschinder)
+
+## 7.0.0-beta.1 (2017-02-20)
+
+- Fix negative number literal typeannotations (#366) (Daniel Tschinder)
+- Update contributing with more test info [skip ci] (#355) (Brian Ng)
+
+## 7.0.0-beta.0 (2017-02-15)
+
+- Reintroduce Variance node (#333) (Daniel Tschinder)
+- Rename NumericLiteralTypeAnnotation to NumberLiteralTypeAnnotation (#332) (Charles Pick)
+- [7.0] Remove ForAwaitStatement, add await flag to ForOfStatement (#349) (Brandon Dail)
+- chore(package): update ava to version 0.18.0 (#345) (greenkeeper[bot])
+- chore(package): update babel-plugin-istanbul to version 4.0.0 (#350) (greenkeeper[bot])
+- Change location of ObjectTypeIndexer to match flow (#228) (Daniel Tschinder)
+- Rename flow AST Type ExistentialTypeParam to ExistsTypeAnnotation (#322) (Toru Kobayashi)
+- Revert "Temporary rollback for erroring on trailing comma with spread (#154)" (#290) (Daniel Tschinder)
+- Remove classConstructorCall plugin (#291) (Brian Ng)
+- Update yarn.lock (Daniel Tschinder)
+- Update cross-env to 3.x (Daniel Tschinder)
+- [7.0] Remove node 0.10, 0.12 and 5 from Travis (#284) (Sergey Rubanov)
+- Remove `String.fromCodePoint` shim (#279) (Mathias Bynens)
+
+## 6.16.1 (2017-02-23)
+
+### :bug: Regression
+
+- Revert "Fix export default async function to be FunctionDeclaration" ([#375](https://github.com/babel/babylon/pull/375))
+
+Need to modify Babel for this AST node change, so moving to 7.0.
+
+- Revert "Don't parse class properties without initializers when classProperties plugin is disabled, and Flow is enabled" ([#376](https://github.com/babel/babylon/pull/376))
+
+[react-native](https://github.com/facebook/react-native/issues/12542) broke with this so we reverted.
+
+## 6.16.0 (2017-02-23)
+
+### :rocket: New Feature
+
+***ESTree*** compatibility as plugin ([#277](https://github.com/babel/babylon/pull/277)) (Daniel Tschinder)
+
+We finally introduce a new compatibility layer for ESTree. To put babylon into ESTree-compatible mode the new plugin `estree` can be enabled. In this mode the parser will output an AST that is compliant to the specs of [ESTree](https://github.com/estree/estree/)
+
+We highly recommend everyone who uses babylon outside of babel to use this plugin. This will make it much easier for users to switch between different ESTree-compatible parsers. We so far tested several projects with different parsers and exchanged their parser to babylon and in nearly all cases it worked out of the box. Some other estree-compatible parsers include `acorn`, `esprima`, `espree`, `flow-parser`, etc.
+
+To enable `estree` mode simply add the plugin in the config:
+```json
+{
+  "plugins": [ "estree" ]
+}
+```
+
+If you want to migrate your project from non-ESTree mode to ESTree, have a look at our [Readme](https://github.com/babel/babylon/#output), where all deviations are mentioned.
+
+Add a parseExpression public method ([#213](https://github.com/babel/babylon/pull/213)) (jeromew)
+
+Babylon exports a new function to parse a single expression
+
+```js
+import { parseExpression } from 'babylon';
+
+const ast = parseExpression('x || y && z', options);
+```
+
+The returned AST will only consist of the expression. The options are the same as for `parse()`
+
+Add startLine option ([#346](https://github.com/babel/babylon/pull/346)) (Raphael Mu)
+
+A new option was added to babylon allowing to change the initial linenumber for the first line which is usually `1`.
+Changing this for example to `100` will make line `1` of the input source to be marked as line `100`, line `2` as `101`, line `3` as `102`, ...
+
+Function predicate declaration ([#103](https://github.com/babel/babylon/pull/103)) (Panagiotis Vekris)
+
+Added support for function predicates which flow introduced in version 0.33.0
+
+```js
+declare function is_number(x: mixed): boolean %checks(typeof x === "number");
+```
+
+Allow imports in declare module ([#315](https://github.com/babel/babylon/pull/315)) (Daniel Tschinder)
+
+Added support for imports within module declarations which flow introduced in version 0.37.0
+
+```js
+declare module "C" {
+  import type { DT } from "D";
+  declare export type CT = { D: DT };
+}
+```
+
+### :eyeglasses: Spec Compliance
+
+Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons)
+
+This example now correctly throws an error when there is a semicolon after the decorator:
+
+```js
+class A {
+@a;
+foo(){}
+}
+```
+
+Keywords are not allowed as local specifier ([#307](https://github.com/babel/babylon/pull/307)) (Daniel Tschinder)
+
+Using keywords in imports is not allowed anymore:
+
+```js
+import { default } from "foo";
+import { a as debugger } from "foo";
+```
+
+Do not allow overwritting of primitive types ([#314](https://github.com/babel/babylon/pull/314)) (Daniel Tschinder)
+
+In flow it is now forbidden to overwrite the primitive types `"any"`, `"mixed"`, `"empty"`, `"bool"`, `"boolean"`, `"number"`, `"string"`, `"void"` and `"null"` with your own type declaration.
+
+Disallow import type { type a } from … ([#305](https://github.com/babel/babylon/pull/305)) (Daniel Tschinder)
+
+The following code now correctly throws an error
+
+```js
+import type { type a } from "foo";
+```
+
+Don't parse class properties without initializers when classProperties is disabled and Flow is enabled ([#300](https://github.com/babel/babylon/pull/300)) (Andrew Levine)
+
+Ensure that you enable the `classProperties` plugin in order to enable correct parsing of class properties. Prior to this version it was possible to parse them by enabling the `flow` plugin but this was not intended the behaviour.
+
+If you enable the flow plugin you can only define the type of the class properties, but not initialize them.
+
+Fix export default async function to be FunctionDeclaration ([#324](https://github.com/babel/babylon/pull/324)) (Daniel Tschinder)
+
+Parsing the following code now returns a `FunctionDeclaration` AST node instead of `FunctionExpression`.
+
+```js
+export default async function bar() {};
+```
+
+### :nail_care: Polish
+
+Improve error message on attempt to destructure named import ([#288](https://github.com/babel/babylon/pull/288)) (Brian Ng)
+
+### :bug: Bug Fix
+
+Fix negative number literal typeannotations ([#366](https://github.com/babel/babylon/pull/366)) (Daniel Tschinder)
+
+Ensure takeDecorators is called on exported class ([#358](https://github.com/babel/babylon/pull/358)) (Brian Ng)
+
+ESTree: correctly change literals in all cases ([#368](https://github.com/babel/babylon/pull/368)) (Daniel Tschinder)
+
+Correctly convert RestProperty to Assignable ([#339](https://github.com/babel/babylon/pull/339)) (Daniel Tschinder)
+
+Fix #321 by allowing question marks in type params ([#338](https://github.com/babel/babylon/pull/338)) (Daniel Tschinder)
+
+Fix #336 by correctly setting arrow-param ([#337](https://github.com/babel/babylon/pull/337)) (Daniel Tschinder)
+
+Fix parse error when destructuring `set` with default value ([#317](https://github.com/babel/babylon/pull/317)) (Brian Ng)
+
+Fix ObjectTypeCallProperty static ([#298](https://github.com/babel/babylon/pull/298)) (Dan Harper)
+
+
+### :house: Internal
+
+Fix generator-method-with-computed-name spec ([#360](https://github.com/babel/babylon/pull/360)) (Alex Rattray)
+
+Fix flow type-parameter-declaration test with unintended semantic ([#361](https://github.com/babel/babylon/pull/361)) (Alex Rattray)
+
+Cleanup and splitup parser functions ([#295](https://github.com/babel/babylon/pull/295)) (Daniel Tschinder)
+
+chore(package): update flow-bin to version 0.38.0 ([#313](https://github.com/babel/babylon/pull/313)) (greenkeeper[bot])
+
+Call inner function instead of 1:1 copy to plugin ([#294](https://github.com/babel/babylon/pull/294)) (Daniel Tschinder)
+
+Update eslint-config-babel to the latest version 🚀 ([#299](https://github.com/babel/babylon/pull/299)) (greenkeeper[bot])
+
+Update eslint-config-babel to the latest version 🚀 ([#293](https://github.com/babel/babylon/pull/293)) (greenkeeper[bot])
+
+devDeps: remove eslint-plugin-babel ([#292](https://github.com/babel/babylon/pull/292)) (Kai Cataldo)
+
+Correct indent eslint rule config ([#276](https://github.com/babel/babylon/pull/276)) (Daniel Tschinder)
+
+Fail tests that have expected.json and throws-option ([#285](https://github.com/babel/babylon/pull/285)) (Daniel Tschinder)
+
+### :memo: Documentation
+
+Update contributing with more test info [skip ci] ([#355](https://github.com/babel/babylon/pull/355)) (Brian Ng)
+
+Update API documentation ([#330](https://github.com/babel/babylon/pull/330)) (Timothy Gu)
+
+Added keywords to package.json ([#323](https://github.com/babel/babylon/pull/323)) (Dmytro)
+
+AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon/pull/318)) (Mathias Bynens)
+
+## 6.15.0 (2017-01-10)
+
+### :eyeglasses: Spec Compliance
+
+Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)
+
+This change implements flows new shorthand import syntax
+and where previously you had to write this code:
+
+```js
+import {someValue} from "blah";
+import type {someType} from "blah";
+import typeof {someOtherValue} from "blah";
+```
+
+you can now write it like this:
+
+```js
+import {
+  someValue,
+  type someType,
+  typeof someOtherValue,
+} from "blah";
+```
+
+For more information look at [this](https://github.com/facebook/flow/pull/2890) pull request.
+
+flow: allow leading pipes in all positions ([#256](https://github.com/babel/babylon/pull/256)) (Vladimir Kurchatkin)
+
+This change now allows a leading pipe everywhere types can be used:
+```js
+var f = (x): | 1 | 2 => 1;
+```
+
+Throw error when exporting non-declaration ([#241](https://github.com/babel/babylon/pull/241)) (Kai Cataldo)
+
+Previously babylon parsed the following exports, although they are not valid:
+```js
+export typeof foo;
+export new Foo();
+export function() {};
+export for (;;);
+export while(foo);
+```
+
+### :bug: Bug Fix
+
+Don't set inType flag when parsing property names ([#266](https://github.com/babel/babylon/pull/266)) (Vladimir Kurchatkin)
+
+This fixes parsing of this case:
+
+```js
+const map = {
+  [age <= 17] : 'Too young'
+};
+```
+
+Fix source location for JSXEmptyExpression nodes (fixes #248) ([#249](https://github.com/babel/babylon/pull/249)) (James Long)
+
+The following case produced an invalid AST
+```js
+<div>{/* foo */}</div>
+```
+
+Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy)
+
+When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.
+
+Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant)
+
+Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray)
+
+### :house: Internal
+
+User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder)
+
+Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo)
+
+Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine)
+
+Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder)
+
+Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine)
+
+Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU)
+
+Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot])
+
+chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot])
+
+chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot])
+
+## 6.14.1 (2016-11-17)
+
+### :bug: Bug Fix
+
+Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder)
+
+```js
+{
+  "plugins": ["*"]
+}
+```
+
+Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.
+
+## 6.14.0 (2016-11-16)
+
+### :eyeglasses: Spec Compliance
+
+Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
+
+[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words)
+
+Babylon will throw for more reserved words such as `enum` or `await` (in strict mode).
+
+```
+class enum {} // throws
+class await {} // throws in strict mode (module)
+```
+
+Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi)
+
+So where you used to have to write
+
+```js
+type A = (x: string, y: boolean) => number;
+type B = (z: string) => number;
+type C = { [key: string]: number };
+```
+
+you can now write (with flow 0.34.0)
+
+```js
+type A = (string, boolean) => number;
+type B = string => number;
+type C = { [string]: number };
+```
+
+Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner)
+
+Supports these form now of specifying array types:
+
+```js
+var a: number[][][][];
+var b: string[][];
+```
+
+### :bug: Bug Fix
+
+Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223))  (Daniel Tschinder)
+
+```
+declare module "foo" { declare module.exports: number }
+declare module "foo" { declare module.exports: number; }  // also allowed now
+```
+
+### :house: Internal
+
+ * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman)
+ * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger)
+ * Add node 7 (Daniel Tschinder)
+ * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper)
+
+## v6.13.1 (2016-10-26)
+
+### :nail_care: Polish
+
+- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML))
+
+```js
+const babylon = require('babylon');
+const ast = babylon.parse('var foo = "lol";');
+```
+
+With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.
+
+**Without bundling**
+![image](https://cloud.githubusercontent.com/assets/5233399/19420264/3133497e-93ad-11e6-9a6a-2da59c4f5c13.png)
+
+**With bundling**
+![image](https://cloud.githubusercontent.com/assets/5233399/19420267/388f556e-93ad-11e6-813e-7c5c396be322.png)
+
+- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu)
+- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu)
+
+## v6.13.0 (2016-10-21)
+
+### :eyeglasses: Spec Compliance
+
+Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
+
+> See https://flowtype.org/docs/variance.html for more information
+
+```js
+type T = { +p: T };
+interface T { -p: T };
+declare class T { +[k:K]: V };
+class T { -[k:K]: V };
+class C2 { +p: T = e };
+```
+
+Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman)
+
+```js
+({ __proto__: 1, __proto__: 2 }) // Throws an error now
+```
+
+### :bug: Bug Fix
+
+Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman)
+
+```js
+declare class A {
+  static: T;
+}
+```
+
+Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine)
+
+```js
+var foo = { async, bar };
+```
+
+### :nail_care: Polish
+
+Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder)
+
+> This improves the performance slightly (because of hidden classes)
+
+### :house: Internal
+
+Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman)
+
+Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman)
+
+Readd missin .eslinignore for IDEs (Daniel Tschinder)
+
+Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman)
+
+Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman)
+
+Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman)
+
+## v6.12.0 (2016-10-14)
+
+### :eyeglasses: Spec Compliance
+
+Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
+
+#### Dynamic Import
+
+- Proposal Repo: https://github.com/domenic/proposal-dynamic-import
+- Championed by [@domenic](https://github.com/domenic)
+- stage-2
+- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import)
+
+> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript
+
+```js
+import(`./section-modules/${link.dataset.entryModule}.js`)
+.then(module => {
+  module.loadPageInto(main);
+})
+```
+
+Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman)
+
+#### EmptyTypeAnnotation
+
+Just wasn't covered before.
+
+```js
+type T = empty;
+```
+
+### :bug: Bug Fix
+
+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
+
+```js
+// was failing due to sparse array
+export const { foo: [ ,, qux7 ] } = bar;
+```
+
+Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper)
+
+```js
+declare class X {
+  foobar<T>(): void;
+  static foobar<T>(): void;
+}
+```
+
+Allow keyword in object/class property names with Flow type parameters ([#145](https://github.com/babel/babylon/pull/145)) (Dan Harper)
+
+```js
+class Foo {
+  delete<T>(item: T): T {
+    return item;
+  }
+}
+```
+
+Allow typeAnnotations for yield expressions ([#174](https://github.com/babel/babylon/pull/174))) (Daniel Tschinder)
+
+```js
+function *foo() {
+  const x = (yield 5: any);
+}
+```
+
+### :nail_care: Polish
+
+Annotate more errors with expected token ([#172](https://github.com/babel/babylon/pull/172))) (Moti Zilberman)
+
+```js
+// Unexpected token, expected ; (1:6)
+{ set 1 }
+```
+
+### :house: Internal
+
+Remove kcheck ([#173](https://github.com/babel/babylon/pull/173)))  (Daniel Tschinder)
+
+Also run flow, linting, babel tests on separate instances (add back node 0.10)
+
+## v6.11.6 (2016-10-12)
+
+### :bug: Bug Fix/Regression
+
+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
+
+```js
+// was failing with `Cannot read property 'type' of null` because of null identifiers
+export const { foo: [ ,, qux7 ] } = bar;
+```
+
+## v6.11.5 (2016-10-12)
+
+### :eyeglasses: Spec Compliance
+
+Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo)
+
+```js
+// `foo` has already been exported. Exported identifiers must be unique. (2:20)
+export function foo() {};
+export const { a: [{foo}] } = bar;
+```
+
+Fix: Check for duplicate named exports in exported rest elements/properties ([#164](https://github.com/babel/babylon/pull/164)) (Kai Cataldo)
+
+```js
+// `foo` has already been exported. Exported identifiers must be unique. (2:22)
+export const foo = 1;
+export const [bar, ...foo] = baz;
+```
+
+### :bug: Bug Fix
+
+Fix: Allow identifier `async` for default param in arrow expression ([#165](https://github.com/babel/babylon/pull/165)) (Kai Cataldo)
+
+```js
+// this is ok now
+const test = ({async = true}) => {};
+```
+
+### :nail_care: Polish
+
+Babylon will now print out the token it's expecting if there's a `SyntaxError` ([#150](https://github.com/babel/babylon/pull/150)) (Daniel Tschinder)
+
+```bash
+# So in the case of a missing ending curly (`}`)
+Module build failed: SyntaxError: Unexpected token, expected } (30:0)
+  28 |   }
+  29 |
+> 30 |
+     | ^
+```
+
+## v6.11.4 (2016-10-03)
+
+Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)
+
+## v6.11.3 (2016-10-01)
+
+### :eyeglasses: Spec Compliance
+
+Add static errors for object rest (#149) ([@danez](https://github.com/danez))
+
+> https://github.com/sebmarkbage/ecmascript-rest-spread
+
+Object rest copies the *rest* of properties from the right hand side `obj` starting from the left to right.
+
+```js
+let { x, y, ...z } =  { x: 1, y: 2, z: 3 };
+// x = 1
+// y = 2
+// z = { z: 3 }
+```
+
+#### New Syntax Errors:
+
+**SyntaxError**: The rest element has to be the last element when destructuring (1:10)
+```bash
+> 1 | let { ...x, y, z } = { x: 1, y: 2, z: 3};
+    |           ^
+# Previous behavior:
+# x = { x: 1, y: 2, z: 3 }
+# y = 2
+# z = 3
+```
+
+Before, this was just a more verbose way of shallow copying `obj` since it doesn't actually do what you think.
+
+**SyntaxError**: Cannot have multiple rest elements when destructuring (1:13)
+
+```bash
+> 1 | let { x, ...y, ...z } = { x: 1, y: 2, z: 3};
+    |              ^
+# Previous behavior:
+# x = 1
+# y = { y: 2, z: 3 }
+# z = { y: 2, z: 3 }
+```
+
+Before y and z would just be the same value anyway so there is no reason to need to have both.
+
+**SyntaxError**: A trailing comma is not permitted after the rest element (1:16)
+
+```js
+let { x, y, ...z, } = obj;
+```
+
+The rationale for this is that the use case for trailing comma is that you can add something at the end without affecting the line above. Since a RestProperty always has to be the last property it doesn't make sense.
+
+---
+
+get / set are valid property names in default assignment (#142) ([@jezell](https://github.com/jezell))
+
+```js
+// valid
+function something({ set = null, get = null }) {}
+```
+
+## v6.11.2 (2016-09-23)
+
+### Bug Fix
+
+- [#139](https://github.com/babel/babylon/issues/139) Don't do the duplicate check if not an identifier (#140) @hzoo
+
+```js
+// regression with duplicate export check
+SyntaxError: ./typography.js: `undefined` has already been exported. Exported identifiers must be unique. (22:13)
+  20 |
+  21 | export const { rhythm } = typography;
+> 22 | export const { TypographyStyle } = typography
+```
+
+Bail out for now, and make a change to account for destructuring in the next release.
+
+## 6.11.1 (2016-09-22)
+
+### Bug Fix
+- [#137](https://github.com/babel/babylon/pull/137) - Fix a regression with duplicate exports - it was erroring on all keys in `Object.prototype`. @danez
+
+```javascript
+export toString from './toString';
+```
+
+```bash
+`toString` has already been exported. Exported identifiers must be unique. (1:7)
+> 1 | export toString from './toString';
+    |        ^
+  2 |
+```
+
+## 6.11.0 (2016-09-22)
+
+### Spec Compliance (will break CI)
+
+- Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo
+
+```js
+// Only one default export allowed per module. (2:9)
+export default function() {};
+export { foo as default };
+
+// Only one default export allowed per module. (2:0)
+export default {};
+export default function() {};
+
+// `Foo` has already been exported. Exported identifiers must be unique. (2:0)
+export { Foo };
+export class Foo {};
+```
+
+### New Feature (Syntax)
+
+- Add support for computed class property names ([#121](https://github.com/babel/babylon/pull/121)) @motiz88
+
+```js
+// AST
+interface ClassProperty <: Node {
+  type: "ClassProperty";
+  key: Identifier;
+  value: Expression;
+  computed: boolean; // added
+}
+```
+
+```js
+// with "plugins": ["classProperties"]
+class Foo {
+  [x]
+  ['y']
+}
+
+class Bar {
+  [p]
+  [m] () {}
+}
+ ```
+
+### Bug Fix
+
+- Fix `static` property falling through in the declare class Flow AST ([#135](https://github.com/babel/babylon/pull/135)) @danharper
+
+```js
+declare class X {
+    a: number;
+    static b: number; // static
+    c: number; // this was being marked as static in the AST as well
+}
+```
+
+### Polish
+
+- Rephrase "assigning/binding to rvalue" errors to include context ([#119](https://github.com/babel/babylon/pull/119)) @motiz88
+
+```js
+// Used to error with:
+// SyntaxError: Assigning to rvalue (1:0)
+
+// Now:
+// Invalid left-hand side in assignment expression (1:0)
+3 = 4
+
+// Invalid left-hand side in for-in statement (1:5)
+for (+i in {});
+```
+
+### Internal
+
+- Fix call to `this.parseMaybeAssign` with correct arguments ([#133](https://github.com/babel/babylon/pull/133)) @danez
+- Add semver note to changelog ([#131](https://github.com/babel/babylon/pull/131)) @hzoo
+
+## 6.10.0 (2016-09-19)
+
+> We plan to include some spec compliance bugs in patch versions. An example was the multiple default exports issue.
+
+### Spec Compliance
+
+* Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu)
+
+> It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. https://tc39.github.io/ecma262/2016/#sec-function-definitions-static-semantics-early-errors
+
+More Context: [tc39-notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2015-07/july-29.md#611-the-scope-of-use-strict-with-respect-to-destructuring-in-parameter-lists)
+
+For example:
+
+```js
+// this errors because it uses destructuring and default parameters
+// in a function with a "use strict" directive
+function a([ option1, option2 ] = []) {
+  "use strict";
+}
+ ```
+
+The solution would be to use a top level "use strict" or to remove the destructuring or default parameters when using a function + "use strict" or to.
+
+### New Feature
+
+* Exact object type annotations for Flow plugin ([#104](https://github.com/babel/babylon/pull/104)) (Basil Hosmer)
+
+Added to flow in https://github.com/facebook/flow/commit/c710c40aa2a115435098d6c0dfeaadb023cd39b8
+
+Looks like:
+
+```js
+var a : {| x: number, y: string |} = { x: 0, y: 'foo' };
+```
+
+### Bug Fixes
+
+* Include `typeParameter` location in `ArrowFunctionExpression` ([#126](https://github.com/babel/babylon/pull/126)) (Daniel Tschinder)
+* Error on invalid flow type annotation with default assignment ([#122](https://github.com/babel/babylon/pull/122)) (Dan Harper)
+* Fix Flow return types on arrow functions ([#124](https://github.com/babel/babylon/pull/124)) (Dan Harper)
+
+### Misc
+
+* Add tests for export extensions ([#127](https://github.com/babel/babylon/pull/127)) (Daniel Tschinder)
+* Fix Contributing guidelines [skip ci] (Daniel Tschinder)
+
+## 6.9.2 (2016-09-09)
+
+The only change is to remove the `babel-runtime` dependency by compiling with Babel's ES2015 loose mode. So using babylon standalone should be smaller.
+
+## 6.9.1 (2016-08-23)
+
+This release contains mainly small bugfixes but also updates babylons default mode to es2017. The features for `exponentiationOperator`, `asyncFunctions` and `trailingFunctionCommas` which previously needed to be activated via plugin are now enabled by default and the plugins are now no-ops.
+
+### Bug Fixes
+
+- Fix issues with default object params in async functions ([#96](https://github.com/babel/babylon/pull/96)) @danez
+- Fix issues with flow-types and async function ([#95](https://github.com/babel/babylon/pull/95)) @danez
+- Fix arrow functions with destructuring, types & default value ([#94](https://github.com/babel/babylon/pull/94)) @danharper
+- Fix declare class with qualified type identifier ([#97](https://github.com/babel/babylon/pull/97)) @danez
+- Remove exponentiationOperator, asyncFunctions, trailingFunctionCommas plugins and enable them by default ([#98](https://github.com/babel/babylon/pull/98)) @danez
+
+## 6.9.0 (2016-08-16)
+
+### New syntax support
+
+- Add JSX spread children ([#42](https://github.com/babel/babylon/pull/42)) @calebmer
+
+(Be aware that React is not going to support this syntax)
+
+```js
+<div>
+  {...todos.map(todo => <Todo key={todo.id} todo={todo}/>)}
+</div>
+```
+
+- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez
+
+```js
+declare module "foo" {
+  declare module.exports: {}
+}
+```
+
+### New Features
+
+- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain
+- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens
+
+### Bug Fixes
+
+- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez
+- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez
+- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi
+- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez
+- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi
+- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez
+- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez
+
+### Internal
+
+- Add codecoverage to tests @danez
+- Fix tests to not save expected output if we expect the test to fail @danez
+- Make a shallow clone of babel for testing @danez
+- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot
+- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot
+- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot
+- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot
+
+## 6.8.4 (2016-07-06)
+
+### Bug Fixes
+
+- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez
+
+## 6.8.3 (2016-07-02)
+
+### Bug Fixes
+
+- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez
+
+## 6.8.2 (2016-06-24)
+
+### Bug Fixes
+
+- Fix parse error with yielding jsx elements in generators `function* it() { yield <a></a>; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal
+- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez
+- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez
+- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez
+- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez
+- Support negative numeric type literals @kittens
+- Remove line terminator restriction after await keyword @kittens
+- Remove grouped type arrow restriction as it seems flow no longer has it @kittens
+- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin
+- Fix parse error with arrow functions that have flow type parameter declarations `<T>(x: T): T => x;` ([#54](https://github.com/babel/babylon/pull/54)) @gabelevi
+
+### Documentation
+
+- Document AST differences from ESTree ([#41](https://github.com/babel/babylon/pull/41)) @nene
+- Move ast spec from babel/babel ([#46](https://github.com/babel/babylon/pull/46)) @hzoo
+
+### Internal
+
+- Enable skipped tests ([#16](https://github.com/babel/babylon/pull/16)) @danez
+- Add script to test latest version of babylon with babel ([#21](https://github.com/babel/babylon/pull/21)) @danez
+- Upgrade test runner ava @kittens
+- Add missing generate-identifier-regex script @kittens
+- Rename parser context types @kittens
+- Add node v6 to travis testing @hzoo
+- Update to Unicode v9 ([#45](https://github.com/babel/babylon/pull/45)) @mathiasbynens
+
+## 6.8.1 (2016-06-06)
+
+### New Feature
+
+- Parse type parameter declarations with defaults like `type Foo<T = string> = T`
+
+### Bug Fixes
+- Type parameter declarations need 1 or more type parameters.
+- The existential type `*` is not a valid type parameter.
+- The existential type `*` is a primary type
+
+### Spec Compliance
+- The param list for type parameter declarations now consists of `TypeParameter` nodes
+- New `TypeParameter` AST Node (replaces using the `Identifier` node before)
+
+```
+interface TypeParameter <: Node {
+  bound: TypeAnnotation;
+  default: TypeAnnotation;
+  name: string;
+  variance: "plus" | "minus";
+}
+```
+
+## 6.8.0 (2016-05-02)
+
+#### New Feature
+
+##### Parse Method Parameter Decorators ([#12](https://github.com/babel/babylon/pull/12))
+
+> [Method Parameter Decorators](https://goo.gl/8MmCMG) is now a TC39 [stage 0 proposal](https://github.com/tc39/ecma262/blob/master/stage0.md).
+
+Examples:
+
+```js
+class Foo {
+  constructor(@foo() x, @bar({ a: 123 }) @baz() y) {}
+}
+
+export default function func(@foo() x, @bar({ a: 123 }) @baz() y) {}
+
+var obj = {
+  method(@foo() x, @bar({ a: 123 }) @baz() y) {}
+};
+```
+
+##### Parse for-await statements (w/ `asyncGenerators` plugin) ([#17](https://github.com/babel/babylon/pull/17))
+
+There is also a new node type, `ForAwaitStatement`.
+
+> [Async generators and for-await](https://github.com/tc39/proposal-async-iteration) are now a [stage 2 proposal](https://github.com/tc39/ecma262#current-proposals).
+
+Example:
+
+```js
+async function f() {
+  for await (let x of y);
+}
+```

node_modules/@babel/parser/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
+
+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.

node_modules/@babel/parser/README.md

@@ -0,0 +1,19 @@
+# @babel/parser
+
+> A JavaScript parser
+
+See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/parser --dev
+```

node_modules/@babel/parser/bin/babel-parser.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/* eslint no-var: 0 */
+
+var parser = require("..");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}

node_modules/@babel/parser/index.cjs

@@ -0,0 +1,5 @@
+try {
+  module.exports = require("./lib/index.cjs");
+} catch {
+  module.exports = require("./lib/index.js");
+}

node_modules/@babel/parser/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@babel/parser",
+  "version": "7.23.0",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings/babel-parser.d.ts",
+    "index.cjs"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.22.13",
+    "@babel/helper-check-duplicate-nodes": "^7.22.5",
+    "@babel/helper-fixtures": "^7.22.19",
+    "@babel/helper-string-parser": "^7.22.5",
+    "@babel/helper-validator-identifier": "^7.22.20",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js",
+  "type": "commonjs"
+}

node_modules/@babel/parser/typings/babel-parser.d.ts

@@ -0,0 +1,250 @@
+// This file is auto-generated! Do not modify it directly.
+/* eslint-disable import/no-extraneous-dependencies, @typescript-eslint/consistent-type-imports, prettier/prettier */
+import * as _babel_types from '@babel/types';
+
+type Plugin =
+  | "asyncDoExpressions"
+  | "asyncGenerators"
+  | "bigInt"
+  | "classPrivateMethods"
+  | "classPrivateProperties"
+  | "classProperties"
+  | "classStaticBlock" // Enabled by default
+  | "decimal"
+  | "decorators-legacy"
+  | "deferredImportEvaluation"
+  | "decoratorAutoAccessors"
+  | "destructuringPrivate"
+  | "doExpressions"
+  | "dynamicImport"
+  | "explicitResourceManagement"
+  | "exportDefaultFrom"
+  | "exportNamespaceFrom" // deprecated
+  | "flow"
+  | "flowComments"
+  | "functionBind"
+  | "functionSent"
+  | "importMeta"
+  | "jsx"
+  | "logicalAssignment"
+  | "importAssertions" // deprecated
+  | "importAttributes"
+  | "importReflection"
+  | "moduleBlocks"
+  | "moduleStringNames"
+  | "nullishCoalescingOperator"
+  | "numericSeparator"
+  | "objectRestSpread"
+  | "optionalCatchBinding"
+  | "optionalChaining"
+  | "partialApplication"
+  | "placeholders"
+  | "privateIn" // Enabled by default
+  | "regexpUnicodeSets" // Enabled by default
+  | "sourcePhaseImports"
+  | "throwExpressions"
+  | "topLevelAwait"
+  | "v8intrinsic"
+  | ParserPluginWithOptions[0];
+
+type ParserPluginWithOptions =
+  | ["decorators", DecoratorsPluginOptions]
+  | ["estree", { classFeatures?: boolean }]
+  | ["importAttributes", { deprecatedAssertSyntax: boolean }]
+  // @deprecated
+  | ["moduleAttributes", { version: "may-2020" }]
+  | ["optionalChainingAssign", { version: "2023-07" }]
+  | ["pipelineOperator", PipelineOperatorPluginOptions]
+  | ["recordAndTuple", RecordAndTuplePluginOptions]
+  | ["flow", FlowPluginOptions]
+  | ["typescript", TypeScriptPluginOptions];
+
+type PluginConfig = Plugin | ParserPluginWithOptions;
+
+interface DecoratorsPluginOptions {
+  decoratorsBeforeExport?: boolean;
+  allowCallParenthesized?: boolean;
+}
+
+interface PipelineOperatorPluginOptions {
+  proposal: "minimal" | "fsharp" | "hack" | "smart";
+  topicToken?: "%" | "#" | "@@" | "^^" | "^";
+}
+
+interface RecordAndTuplePluginOptions {
+  syntaxType: "bar" | "hash";
+}
+
+interface FlowPluginOptions {
+  all?: boolean;
+  enums?: boolean;
+}
+
+interface TypeScriptPluginOptions {
+  dts?: boolean;
+  disallowAmbiguousJSXLike?: boolean;
+}
+
+// Type definitions for @babel/parser
+// Project: https://github.com/babel/babel/tree/main/packages/babel-parser
+// Definitions by: Troy Gerwien <https://github.com/yortus>
+//                 Marvin Hagemeister <https://github.com/marvinhagemeister>
+//                 Avi Vahl <https://github.com/AviVahl>
+// TypeScript Version: 2.9
+
+/**
+ * Parse the provided code as an entire ECMAScript program.
+ */
+declare function parse(
+  input: string,
+  options?: ParserOptions
+): ParseResult<_babel_types.File>;
+
+/**
+ * Parse the provided code as a single expression.
+ */
+declare function parseExpression(
+  input: string,
+  options?: ParserOptions
+): ParseResult<_babel_types.Expression>;
+
+interface ParserOptions {
+  /**
+   * By default, import and export declarations can only appear at a program's top level.
+   * Setting this option to true allows them anywhere where a statement is allowed.
+   */
+  allowImportExportEverywhere?: boolean;
+
+  /**
+   * By default, await use is not allowed outside of an async function.
+   * Set this to true to accept such code.
+   */
+  allowAwaitOutsideFunction?: boolean;
+
+  /**
+   * By default, a return statement at the top level raises an error.
+   * Set this to true to accept such code.
+   */
+  allowReturnOutsideFunction?: boolean;
+
+  /**
+   * By default, new.target use is not allowed outside of a function or class.
+   * Set this to true to accept such code.
+   */
+  allowNewTargetOutsideFunction?: boolean;
+
+  allowSuperOutsideMethod?: boolean;
+
+  /**
+   * By default, exported identifiers must refer to a declared variable.
+   * Set this to true to allow export statements to reference undeclared variables.
+   */
+  allowUndeclaredExports?: boolean;
+
+  /**
+   * By default, Babel parser JavaScript code according to Annex B syntax.
+   * Set this to `false` to disable such behavior.
+   */
+  annexB?: boolean;
+
+  /**
+   * By default, Babel attaches comments to adjacent AST nodes.
+   * When this option is set to false, comments are not attached.
+   * It can provide up to 30% performance improvement when the input code has many comments.
+   * @babel/eslint-parser will set it for you.
+   * It is not recommended to use attachComment: false with Babel transform,
+   * as doing so removes all the comments in output code, and renders annotations such as
+   * /* istanbul ignore next *\/ nonfunctional.
+   */
+  attachComment?: boolean;
+
+  /**
+   * By default, Babel always throws an error when it finds some invalid code.
+   * When this option is set to true, it will store the parsing error and
+   * try to continue parsing the invalid input file.
+   */
+  errorRecovery?: boolean;
+
+  /**
+   * Indicate the mode the code should be parsed in.
+   * Can be one of "script", "module", or "unambiguous". Defaults to "script".
+   * "unambiguous" will make @babel/parser attempt to guess, based on the presence
+   * of ES6 import or export statements.
+   * Files with ES6 imports and exports are considered "module" and are otherwise "script".
+   */
+  sourceType?: "script" | "module" | "unambiguous";
+
+  /**
+   * Correlate output AST nodes with their source filename.
+   * Useful when generating code and source maps from the ASTs of multiple input files.
+   */
+  sourceFilename?: string;
+
+  /**
+   * By default, the first line of code parsed is treated as line 1.
+   * You can provide a line number to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startLine?: number;
+
+  /**
+   * By default, the parsed code is treated as if it starts from line 1, column 0.
+   * You can provide a column number to alternatively start with.
+   * Useful for integration with other source tools.
+   */
+  startColumn?: number;
+
+  /**
+   * Array containing the plugins that you want to enable.
+   */
+  plugins?: ParserPlugin[];
+
+  /**
+   * Should the parser work in strict mode.
+   * Defaults to true if sourceType === 'module'. Otherwise, false.
+   */
+  strictMode?: boolean;
+
+  /**
+   * Adds a ranges property to each node: [node.start, node.end]
+   */
+  ranges?: boolean;
+
+  /**
+   * Adds all parsed tokens to a tokens property on the File node.
+   */
+  tokens?: boolean;
+
+  /**
+   * By default, the parser adds information about parentheses by setting
+   * `extra.parenthesized` to `true` as needed.
+   * When this option is `true` the parser creates `ParenthesizedExpression`
+   * AST nodes instead of using the `extra` property.
+   */
+  createParenthesizedExpressions?: boolean;
+
+  /**
+   * By default, `import(foo)` is parsed as `CallExpression(Import, [Identifier(foo)])`.
+   * Set this to true to parse it as an `ImportExpression` node.
+   */
+  createImportExpressions?: boolean;
+}
+
+type ParserPlugin = PluginConfig;
+
+
+declare const tokTypes: {
+  // todo(flow->ts) real token type
+  [name: string]: any;
+};
+
+interface ParseError {
+  code: string;
+  reasonCode: string;
+}
+
+type ParseResult<Result> = Result & {
+  errors: ParseError[];
+};
+
+export { DecoratorsPluginOptions, FlowPluginOptions, ParseError, ParseResult, ParserOptions, ParserPlugin, ParserPluginWithOptions, PipelineOperatorPluginOptions, RecordAndTuplePluginOptions, TypeScriptPluginOptions, parse, parseExpression, tokTypes };

node_modules/@intlify/core-base/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kazuya kawaguchi
+
+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.

node_modules/@intlify/core-base/README.md

@@ -0,0 +1,7 @@
+# @intlify/core-base
+
+The intlify core base module
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

node_modules/@intlify/core-base/dist/core-base.cjs

@@ -0,0 +1,1777 @@
+/*!
+  * core-base v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+var messageCompiler = require('@intlify/message-compiler');
+var shared = require('@intlify/shared');
+
+const pathStateMachine =  [];
+pathStateMachine[0 /* States.BEFORE_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[1 /* States.IN_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[3 /* States.IN_IDENT */] = {
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
+};
+pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+        4 /* States.IN_SUB_PATH */,
+        2 /* Actions.INC_SUB_PATH_DEPTH */
+    ],
+    ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+/**
+ * Check if an expression is a literal value.
+ */
+const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+function isLiteral(exp) {
+    return literalValueRE.test(exp);
+}
+/**
+ * Strip quotes from a string
+ */
+function stripQuotes(str) {
+    const a = str.charCodeAt(0);
+    const b = str.charCodeAt(str.length - 1);
+    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+}
+/**
+ * Determine the type of a character in a keypath.
+ */
+function getPathCharType(ch) {
+    if (ch === undefined || ch === null) {
+        return "o" /* PathCharTypes.END_OF_FAIL */;
+    }
+    const code = ch.charCodeAt(0);
+    switch (code) {
+        case 0x5b: // [
+        case 0x5d: // ]
+        case 0x2e: // .
+        case 0x22: // "
+        case 0x27: // '
+            return ch;
+        case 0x5f: // _
+        case 0x24: // $
+        case 0x2d: // -
+            return "i" /* PathCharTypes.IDENT */;
+        case 0x09: // Tab (HT)
+        case 0x0a: // Newline (LF)
+        case 0x0d: // Return (CR)
+        case 0xa0: // No-break space (NBSP)
+        case 0xfeff: // Byte Order Mark (BOM)
+        case 0x2028: // Line Separator (LS)
+        case 0x2029: // Paragraph Separator (PS)
+            return "w" /* PathCharTypes.WORKSPACE */;
+    }
+    return "i" /* PathCharTypes.IDENT */;
+}
+/**
+ * Format a subPath, return its plain form if it is
+ * a literal string or number. Otherwise prepend the
+ * dynamic indicator (*).
+ */
+function formatSubPath(path) {
+    const trimmed = path.trim();
+    // invalid leading 0
+    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+        return false;
+    }
+    return isLiteral(trimmed)
+        ? stripQuotes(trimmed)
+        : "*" /* PathCharTypes.ASTARISK */ + trimmed;
+}
+/**
+ * Parse a string path into an array of segments
+ */
+function parse(path) {
+    const keys = [];
+    let index = -1;
+    let mode = 0 /* States.BEFORE_PATH */;
+    let subPathDepth = 0;
+    let c;
+    let key; // eslint-disable-line
+    let newChar;
+    let type;
+    let transition;
+    let action;
+    let typeMap;
+    const actions = [];
+    actions[0 /* Actions.APPEND */] = () => {
+        if (key === undefined) {
+            key = newChar;
+        }
+        else {
+            key += newChar;
+        }
+    };
+    actions[1 /* Actions.PUSH */] = () => {
+        if (key !== undefined) {
+            keys.push(key);
+            key = undefined;
+        }
+    };
+    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+        actions[0 /* Actions.APPEND */]();
+        subPathDepth++;
+    };
+    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
+        if (subPathDepth > 0) {
+            subPathDepth--;
+            mode = 4 /* States.IN_SUB_PATH */;
+            actions[0 /* Actions.APPEND */]();
+        }
+        else {
+            subPathDepth = 0;
+            if (key === undefined) {
+                return false;
+            }
+            key = formatSubPath(key);
+            if (key === false) {
+                return false;
+            }
+            else {
+                actions[1 /* Actions.PUSH */]();
+            }
+        }
+    };
+    function maybeUnescapeQuote() {
+        const nextChar = path[index + 1];
+        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+            nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
+            index++;
+            newChar = '\\' + nextChar;
+            actions[0 /* Actions.APPEND */]();
+            return true;
+        }
+    }
+    while (mode !== null) {
+        index++;
+        c = path[index];
+        if (c === '\\' && maybeUnescapeQuote()) {
+            continue;
+        }
+        type = getPathCharType(c);
+        typeMap = pathStateMachine[mode];
+        transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
+        // check parse error
+        if (transition === 8 /* States.ERROR */) {
+            return;
+        }
+        mode = transition[0];
+        if (transition[1] !== undefined) {
+            action = actions[transition[1]];
+            if (action) {
+                newChar = c;
+                if (action() === false) {
+                    return;
+                }
+            }
+        }
+        // check parse finish
+        if (mode === 7 /* States.AFTER_PATH */) {
+            return keys;
+        }
+    }
+}
+// path token cache
+const cache = new Map();
+/**
+ * key-value message resolver
+ *
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveWithKeyValue(obj, path) {
+    return shared.isObject(obj) ? obj[path] : null;
+}
+/**
+ * message resolver
+ *
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveValue(obj, path) {
+    // check object
+    if (!shared.isObject(obj)) {
+        return null;
+    }
+    // parse path
+    let hit = cache.get(path);
+    if (!hit) {
+        hit = parse(path);
+        if (hit) {
+            cache.set(path, hit);
+        }
+    }
+    // check hit
+    if (!hit) {
+        return null;
+    }
+    // resolve path value
+    const len = hit.length;
+    let last = obj;
+    let i = 0;
+    while (i < len) {
+        const val = last[hit[i]];
+        if (val === undefined) {
+            return null;
+        }
+        last = val;
+        i++;
+    }
+    return last;
+}
+
+const DEFAULT_MODIFIER = (str) => str;
+const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : shared.join(values);
+const DEFAULT_INTERPOLATE = shared.toDisplayString;
+function pluralDefault(choice, choicesLength) {
+    choice = Math.abs(choice);
+    if (choicesLength === 2) {
+        // prettier-ignore
+        return choice
+            ? choice > 1
+                ? 1
+                : 0
+            : 1;
+    }
+    return choice ? Math.min(choice, 2) : 0;
+}
+function getPluralIndex(options) {
+    // prettier-ignore
+    const index = shared.isNumber(options.pluralIndex)
+        ? options.pluralIndex
+        : -1;
+    // prettier-ignore
+    return options.named && (shared.isNumber(options.named.count) || shared.isNumber(options.named.n))
+        ? shared.isNumber(options.named.count)
+            ? options.named.count
+            : shared.isNumber(options.named.n)
+                ? options.named.n
+                : index
+        : index;
+}
+function normalizeNamed(pluralIndex, props) {
+    if (!props.count) {
+        props.count = pluralIndex;
+    }
+    if (!props.n) {
+        props.n = pluralIndex;
+    }
+}
+function createMessageContext(options = {}) {
+    const locale = options.locale;
+    const pluralIndex = getPluralIndex(options);
+    const pluralRule = shared.isObject(options.pluralRules) &&
+        shared.isString(locale) &&
+        shared.isFunction(options.pluralRules[locale])
+        ? options.pluralRules[locale]
+        : pluralDefault;
+    const orgPluralRule = shared.isObject(options.pluralRules) &&
+        shared.isString(locale) &&
+        shared.isFunction(options.pluralRules[locale])
+        ? pluralDefault
+        : undefined;
+    const plural = (messages) => {
+        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+    };
+    const _list = options.list || [];
+    const list = (index) => _list[index];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _named = options.named || {};
+    shared.isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+    const named = (key) => _named[key];
+    function message(key) {
+        // prettier-ignore
+        const msg = shared.isFunction(options.messages)
+            ? options.messages(key)
+            : shared.isObject(options.messages)
+                ? options.messages[key]
+                : false;
+        return !msg
+            ? options.parent
+                ? options.parent.message(key) // resolve from parent messages
+                : DEFAULT_MESSAGE
+            : msg;
+    }
+    const _modifier = (name) => options.modifiers
+        ? options.modifiers[name]
+        : DEFAULT_MODIFIER;
+    const normalize = shared.isPlainObject(options.processor) && shared.isFunction(options.processor.normalize)
+        ? options.processor.normalize
+        : DEFAULT_NORMALIZE;
+    const interpolate = shared.isPlainObject(options.processor) &&
+        shared.isFunction(options.processor.interpolate)
+        ? options.processor.interpolate
+        : DEFAULT_INTERPOLATE;
+    const type = shared.isPlainObject(options.processor) && shared.isString(options.processor.type)
+        ? options.processor.type
+        : DEFAULT_MESSAGE_DATA_TYPE;
+    const linked = (key, ...args) => {
+        const [arg1, arg2] = args;
+        let type = 'text';
+        let modifier = '';
+        if (args.length === 1) {
+            if (shared.isObject(arg1)) {
+                modifier = arg1.modifier || modifier;
+                type = arg1.type || type;
+            }
+            else if (shared.isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+        }
+        else if (args.length === 2) {
+            if (shared.isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+            if (shared.isString(arg2)) {
+                type = arg2 || type;
+            }
+        }
+        const ret = message(key)(ctx);
+        const msg = 
+        // The message in vnode resolved with linked are returned as an array by processor.nomalize
+        type === 'vnode' && shared.isArray(ret) && modifier
+            ? ret[0]
+            : ret;
+        return modifier ? _modifier(modifier)(msg, type) : msg;
+    };
+    const ctx = {
+        ["list" /* HelperNameMap.LIST */]: list,
+        ["named" /* HelperNameMap.NAMED */]: named,
+        ["plural" /* HelperNameMap.PLURAL */]: plural,
+        ["linked" /* HelperNameMap.LINKED */]: linked,
+        ["message" /* HelperNameMap.MESSAGE */]: message,
+        ["type" /* HelperNameMap.TYPE */]: type,
+        ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+        ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
+        ["values" /* HelperNameMap.VALUES */]: shared.assign({}, _list, _named)
+    };
+    return ctx;
+}
+
+let devtools = null;
+function setDevToolsHook(hook) {
+    devtools = hook;
+}
+function getDevToolsHook() {
+    return devtools;
+}
+function initI18nDevTools(i18n, version, meta) {
+    // TODO: queue if devtools is undefined
+    devtools &&
+        devtools.emit("i18n:init" /* IntlifyDevToolsHooks.I18nInit */, {
+            timestamp: Date.now(),
+            i18n,
+            version,
+            meta
+        });
+}
+const translateDevTools = /* #__PURE__*/ createDevToolsHook("function:translate" /* IntlifyDevToolsHooks.FunctionTranslate */);
+function createDevToolsHook(hook) {
+    return (payloads) => devtools && devtools.emit(hook, payloads);
+}
+
+const CoreWarnCodes = {
+    NOT_FOUND_KEY: 1,
+    FALLBACK_TO_TRANSLATE: 2,
+    CANNOT_FORMAT_NUMBER: 3,
+    FALLBACK_TO_NUMBER_FORMAT: 4,
+    CANNOT_FORMAT_DATE: 5,
+    FALLBACK_TO_DATE_FORMAT: 6,
+    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7,
+    __EXTEND_POINT__: 8
+};
+/** @internal */
+const warnMessages = {
+    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`
+};
+function getWarnMessage(code, ...args) {
+    return shared.format(warnMessages[code], ...args);
+}
+
+/** @internal */
+function getLocale(context, options) {
+    return options.locale != null
+        ? resolveLocale(options.locale)
+        : resolveLocale(context.locale);
+}
+let _resolveLocale;
+/** @internal */
+function resolveLocale(locale) {
+    // prettier-ignore
+    return shared.isString(locale)
+        ? locale
+        : _resolveLocale != null && locale.resolvedOnce
+            ? _resolveLocale
+            : (_resolveLocale = locale());
+}
+/**
+ * Fallback with simple implemenation
+ *
+ * @remarks
+ * A fallback locale function implemented with a simple fallback algorithm.
+ *
+ * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
+    // prettier-ignore
+    return [...new Set([
+            start,
+            ...(shared.isArray(fallback)
+                ? fallback
+                : shared.isObject(fallback)
+                    ? Object.keys(fallback)
+                    : shared.isString(fallback)
+                        ? [fallback]
+                        : [start])
+        ])];
+}
+/**
+ * Fallback with locale chain
+ *
+ * @remarks
+ * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithLocaleChain(ctx, fallback, start) {
+    const startLocale = shared.isString(start) ? start : DEFAULT_LOCALE;
+    const context = ctx;
+    if (!context.__localeChainCache) {
+        context.__localeChainCache = new Map();
+    }
+    let chain = context.__localeChainCache.get(startLocale);
+    if (!chain) {
+        chain = [];
+        // first block defined by start
+        let block = [start];
+        // while any intervening block found
+        while (shared.isArray(block)) {
+            block = appendBlockToChain(chain, block, fallback);
+        }
+        // prettier-ignore
+        // last block defined by default
+        const defaults = shared.isArray(fallback) || !shared.isPlainObject(fallback)
+            ? fallback
+            : fallback['default']
+                ? fallback['default']
+                : null;
+        // convert defaults to array
+        block = shared.isString(defaults) ? [defaults] : defaults;
+        if (shared.isArray(block)) {
+            appendBlockToChain(chain, block, false);
+        }
+        context.__localeChainCache.set(startLocale, chain);
+    }
+    return chain;
+}
+function appendBlockToChain(chain, block, blocks) {
+    let follow = true;
+    for (let i = 0; i < block.length && shared.isBoolean(follow); i++) {
+        const locale = block[i];
+        if (shared.isString(locale)) {
+            follow = appendLocaleToChain(chain, block[i], blocks);
+        }
+    }
+    return follow;
+}
+function appendLocaleToChain(chain, locale, blocks) {
+    let follow;
+    const tokens = locale.split('-');
+    do {
+        const target = tokens.join('-');
+        follow = appendItemToChain(chain, target, blocks);
+        tokens.splice(-1, 1);
+    } while (tokens.length && follow === true);
+    return follow;
+}
+function appendItemToChain(chain, target, blocks) {
+    let follow = false;
+    if (!chain.includes(target)) {
+        follow = true;
+        if (target) {
+            follow = target[target.length - 1] !== '!';
+            const locale = target.replace(/!/g, '');
+            chain.push(locale);
+            if ((shared.isArray(blocks) || shared.isPlainObject(blocks)) &&
+                blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any
+            ) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                follow = blocks[locale];
+            }
+        }
+    }
+    return follow;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Intlify core-base version
+ * @internal
+ */
+const VERSION = '9.5.0';
+const NOT_REOSLVED = -1;
+const DEFAULT_LOCALE = 'en-US';
+const MISSING_RESOLVE_VALUE = '';
+const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+function getDefaultLinkedModifiers() {
+    return {
+        upper: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && shared.isString(val)
+                ? val.toUpperCase()
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? val.children.toUpperCase()
+                    : val;
+        },
+        lower: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && shared.isString(val)
+                ? val.toLowerCase()
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? val.children.toLowerCase()
+                    : val;
+        },
+        capitalize: (val, type) => {
+            // prettier-ignore
+            return (type === 'text' && shared.isString(val)
+                ? capitalize(val)
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? capitalize(val.children)
+                    : val);
+        }
+    };
+}
+let _compiler;
+function registerMessageCompiler(compiler) {
+    _compiler = compiler;
+}
+let _resolver;
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+function registerMessageResolver(resolver) {
+    _resolver = resolver;
+}
+let _fallbacker;
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
+ *
+ * @VueI18nGeneral
+ */
+function registerLocaleFallbacker(fallbacker) {
+    _fallbacker = fallbacker;
+}
+// Additional Meta for Intlify DevTools
+let _additionalMeta =  null;
+const setAdditionalMeta = /* #__PURE__*/ (meta) => {
+    _additionalMeta = meta;
+};
+const getAdditionalMeta = /* #__PURE__*/ () => _additionalMeta;
+let _fallbackContext = null;
+const setFallbackContext = (context) => {
+    _fallbackContext = context;
+};
+const getFallbackContext = () => _fallbackContext;
+// ID for CoreContext
+let _cid = 0;
+function createCoreContext(options = {}) {
+    // setup options
+    const onWarn = shared.isFunction(options.onWarn) ? options.onWarn : shared.warn;
+    const version = shared.isString(options.version) ? options.version : VERSION;
+    const locale = shared.isString(options.locale) || shared.isFunction(options.locale)
+        ? options.locale
+        : DEFAULT_LOCALE;
+    const _locale = shared.isFunction(locale) ? DEFAULT_LOCALE : locale;
+    const fallbackLocale = shared.isArray(options.fallbackLocale) ||
+        shared.isPlainObject(options.fallbackLocale) ||
+        shared.isString(options.fallbackLocale) ||
+        options.fallbackLocale === false
+        ? options.fallbackLocale
+        : _locale;
+    const messages = shared.isPlainObject(options.messages)
+        ? options.messages
+        : { [_locale]: {} };
+    const datetimeFormats = shared.isPlainObject(options.datetimeFormats)
+            ? options.datetimeFormats
+            : { [_locale]: {} }
+        ;
+    const numberFormats = shared.isPlainObject(options.numberFormats)
+            ? options.numberFormats
+            : { [_locale]: {} }
+        ;
+    const modifiers = shared.assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
+    const pluralRules = options.pluralRules || {};
+    const missing = shared.isFunction(options.missing) ? options.missing : null;
+    const missingWarn = shared.isBoolean(options.missingWarn) || shared.isRegExp(options.missingWarn)
+        ? options.missingWarn
+        : true;
+    const fallbackWarn = shared.isBoolean(options.fallbackWarn) || shared.isRegExp(options.fallbackWarn)
+        ? options.fallbackWarn
+        : true;
+    const fallbackFormat = !!options.fallbackFormat;
+    const unresolving = !!options.unresolving;
+    const postTranslation = shared.isFunction(options.postTranslation)
+        ? options.postTranslation
+        : null;
+    const processor = shared.isPlainObject(options.processor) ? options.processor : null;
+    const warnHtmlMessage = shared.isBoolean(options.warnHtmlMessage)
+        ? options.warnHtmlMessage
+        : true;
+    const escapeParameter = !!options.escapeParameter;
+    const messageCompiler = shared.isFunction(options.messageCompiler)
+        ? options.messageCompiler
+        : _compiler;
+    if (shared.isFunction(options.messageCompiler)) {
+        shared.warnOnce(getWarnMessage(CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER));
+    }
+    const messageResolver = shared.isFunction(options.messageResolver)
+        ? options.messageResolver
+        : _resolver || resolveWithKeyValue;
+    const localeFallbacker = shared.isFunction(options.localeFallbacker)
+        ? options.localeFallbacker
+        : _fallbacker || fallbackWithSimple;
+    const fallbackContext = shared.isObject(options.fallbackContext)
+        ? options.fallbackContext
+        : undefined;
+    // setup internal options
+    const internalOptions = options;
+    const __datetimeFormatters = shared.isObject(internalOptions.__datetimeFormatters)
+            ? internalOptions.__datetimeFormatters
+            : new Map()
+        ;
+    const __numberFormatters = shared.isObject(internalOptions.__numberFormatters)
+            ? internalOptions.__numberFormatters
+            : new Map()
+        ;
+    const __meta = shared.isObject(internalOptions.__meta) ? internalOptions.__meta : {};
+    _cid++;
+    const context = {
+        version,
+        cid: _cid,
+        locale,
+        fallbackLocale,
+        messages,
+        modifiers,
+        pluralRules,
+        missing,
+        missingWarn,
+        fallbackWarn,
+        fallbackFormat,
+        unresolving,
+        postTranslation,
+        processor,
+        warnHtmlMessage,
+        escapeParameter,
+        messageCompiler,
+        messageResolver,
+        localeFallbacker,
+        fallbackContext,
+        onWarn,
+        __meta
+    };
+    {
+        context.datetimeFormats = datetimeFormats;
+        context.numberFormats = numberFormats;
+        context.__datetimeFormatters = __datetimeFormatters;
+        context.__numberFormatters = __numberFormatters;
+    }
+    // for vue-devtools timeline event
+    {
+        context.__v_emitter =
+            internalOptions.__v_emitter != null
+                ? internalOptions.__v_emitter
+                : undefined;
+    }
+    // NOTE: experimental !!
+    {
+        initI18nDevTools(context, version, __meta);
+    }
+    return context;
+}
+/** @internal */
+function isTranslateFallbackWarn(fallback, key) {
+    return fallback instanceof RegExp ? fallback.test(key) : fallback;
+}
+/** @internal */
+function isTranslateMissingWarn(missing, key) {
+    return missing instanceof RegExp ? missing.test(key) : missing;
+}
+/** @internal */
+function handleMissing(context, key, locale, missingWarn, type) {
+    const { missing, onWarn } = context;
+    // for vue-devtools timeline event
+    {
+        const emitter = context.__v_emitter;
+        if (emitter) {
+            emitter.emit("missing" /* VueDevToolsTimelineEvents.MISSING */, {
+                locale,
+                key,
+                type,
+                groupId: `${type}:${key}`
+            });
+        }
+    }
+    if (missing !== null) {
+        const ret = missing(context, locale, key, type);
+        return shared.isString(ret) ? ret : key;
+    }
+    else {
+        if (isTranslateMissingWarn(missingWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
+        }
+        return key;
+    }
+}
+/** @internal */
+function updateFallbackLocale(ctx, locale, fallback) {
+    const context = ctx;
+    context.__localeChainCache = new Map();
+    ctx.localeFallbacker(ctx, fallback, locale);
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+function format(ast) {
+    const msg = (ctx) => formatParts(ctx, ast);
+    return msg;
+}
+function formatParts(ctx, ast) {
+    const body = ast.b || ast.body;
+    if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+        const plural = body;
+        const cases = plural.c || plural.cases;
+        return ctx.plural(cases.reduce((messages, c) => [
+            ...messages,
+            formatMessageParts(ctx, c)
+        ], []));
+    }
+    else {
+        return formatMessageParts(ctx, body);
+    }
+}
+function formatMessageParts(ctx, node) {
+    const _static = node.s || node.static;
+    if (_static) {
+        return ctx.type === 'text'
+            ? _static
+            : ctx.normalize([_static]);
+    }
+    else {
+        const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+        return ctx.normalize(messages);
+    }
+}
+function formatMessagePart(ctx, node) {
+    const type = node.t || node.type;
+    switch (type) {
+        case 3 /* NodeTypes.Text */:
+            const text = node;
+            return (text.v || text.value);
+        case 9 /* NodeTypes.Literal */:
+            const literal = node;
+            return (literal.v || literal.value);
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            return ctx.interpolate(ctx.named(named.k || named.key));
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            const modifier = linked.m || linked.modifier;
+            return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
+        case 7 /* NodeTypes.LinkedKey */:
+            const linkedKey = node;
+            return (linkedKey.v || linkedKey.value);
+        case 8 /* NodeTypes.LinkedModifier */:
+            const linkedModifier = node;
+            return (linkedModifier.v || linkedModifier.value);
+        default:
+            throw new Error(`unhandled node type on format message part: ${type}`);
+    }
+}
+
+const code = messageCompiler.CompileErrorCodes.__EXTEND_POINT__;
+const inc = shared.incrementer(code);
+const CoreErrorCodes = {
+    INVALID_ARGUMENT: code,
+    INVALID_DATE_ARGUMENT: inc(),
+    INVALID_ISO_DATE_ARGUMENT: inc(),
+    NOT_SUPPORT_NON_STRING_MESSAGE: inc(),
+    __EXTEND_POINT__: inc() // 22
+};
+function createCoreError(code) {
+    return messageCompiler.createCompileError(code, null, { messages: errorMessages } );
+}
+/** @internal */
+const errorMessages = {
+    [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',
+    [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +
+        'Make sure your Date represents a valid date.',
+    [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string',
+    [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]: 'Not support non-string message'
+};
+
+const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
+function checkHtmlMessage(source, warnHtmlMessage) {
+    if (warnHtmlMessage && messageCompiler.detectHtmlTag(source)) {
+        shared.warn(shared.format(WARN_MESSAGE, { source }));
+    }
+}
+const defaultOnCacheKey = (message) => message;
+let compileCache = Object.create(null);
+function clearCompileCache() {
+    compileCache = Object.create(null);
+}
+const isMessageAST = (val) => shared.isObject(val) &&
+    (val.t === 0 || val.type === 0) &&
+    ('b' in val || 'body' in val);
+function baseCompile(message, options = {}) {
+    // error detecting on compile
+    let detectError = false;
+    const onError = options.onError || messageCompiler.defaultOnError;
+    options.onError = (err) => {
+        detectError = true;
+        onError(err);
+    };
+    // compile with mesasge-compiler
+    return { ...messageCompiler.baseCompile(message, options), detectError };
+}
+const compileToFunction = /* #__PURE__*/ (message, context) => {
+    if (!shared.isString(message)) {
+        throw createCoreError(CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE);
+    }
+    {
+        // check HTML message
+        const warnHtmlMessage = shared.isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        checkHtmlMessage(message, warnHtmlMessage);
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile
+        const { code, detectError } = baseCompile(message, context);
+        // evaluate function
+        const msg = new Function(`return ${code}`)();
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+};
+function compile(message, context) {
+    if (shared.isString(message)) {
+        // check HTML message
+        const warnHtmlMessage = shared.isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        checkHtmlMessage(message, warnHtmlMessage);
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile with JIT mode
+        const { ast, detectError } = baseCompile(message, {
+            ...context,
+            location: true,
+            jit: true
+        });
+        // compose message function from AST
+        const msg = format(ast);
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+    else {
+        if (!isMessageAST(message)) {
+            shared.warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
+            return (() => message);
+        }
+        // AST case (passed from bundler)
+        const cacheKey = message.cacheKey;
+        if (cacheKey) {
+            const cached = compileCache[cacheKey];
+            if (cached) {
+                return cached;
+            }
+            // compose message function from message (AST)
+            return (compileCache[cacheKey] =
+                format(message));
+        }
+        else {
+            return format(message);
+        }
+    }
+}
+
+const NOOP_MESSAGE_FUNCTION = () => '';
+const isMessageFunction = (val) => shared.isFunction(val);
+// implementation of `translate` function
+function translate(context, ...args) {
+    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+    const [key, options] = parseTranslateArgs(...args);
+    const missingWarn = shared.isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = shared.isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const escapeParameter = shared.isBoolean(options.escapeParameter)
+        ? options.escapeParameter
+        : context.escapeParameter;
+    const resolvedMessage = !!options.resolvedMessage;
+    // prettier-ignore
+    const defaultMsgOrKey = shared.isString(options.default) || shared.isBoolean(options.default) // default by function option
+        ? !shared.isBoolean(options.default)
+            ? options.default
+            : (!messageCompiler ? () => key : key)
+        : fallbackFormat // default by `fallbackFormat` option
+            ? (!messageCompiler ? () => key : key)
+            : '';
+    const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';
+    const locale = getLocale(context, options);
+    // escape params
+    escapeParameter && escapeParams(options);
+    // resolve message format
+    // eslint-disable-next-line prefer-const
+    let [formatScope, targetLocale, message] = !resolvedMessage
+        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+        : [
+            key,
+            locale,
+            messages[locale] || {}
+        ];
+    // NOTE:
+    //  Fix to work around `ssrTransfrom` bug in Vite.
+    //  https://github.com/vitejs/vite/issues/4306
+    //  To get around this, use temporary variables.
+    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+    let format = formatScope;
+    // if you use default message, set it as message format!
+    let cacheBaseKey = key;
+    if (!resolvedMessage &&
+        !(shared.isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format))) {
+        if (enableDefaultMsg) {
+            format = defaultMsgOrKey;
+            cacheBaseKey = format;
+        }
+    }
+    // checking message format and target locale
+    if (!resolvedMessage &&
+        (!(shared.isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format)) ||
+            !shared.isString(targetLocale))) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    // TODO: refactor
+    if (shared.isString(format) && context.messageCompiler == null) {
+        shared.warn(`The message format compilation is not supported in this build. ` +
+            `Because message compiler isn't included. ` +
+            `You need to pre-compilation all message format. ` +
+            `So translate function return '${key}'.`);
+        return key;
+    }
+    // setup compile error detecting
+    let occurred = false;
+    const onError = () => {
+        occurred = true;
+    };
+    // compile message format
+    const msg = !isMessageFunction(format)
+        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
+        : format;
+    // if occurred compile error, return the message format
+    if (occurred) {
+        return format;
+    }
+    // evaluate message with context
+    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+    const msgContext = createMessageContext(ctxOptions);
+    const messaged = evaluateMessage(context, msg, msgContext);
+    // if use post translation option, proceed it with handler
+    const ret = postTranslation
+        ? postTranslation(messaged, key)
+        : messaged;
+    // NOTE: experimental !!
+    {
+        // prettier-ignore
+        const payloads = {
+            timestamp: Date.now(),
+            key: shared.isString(key)
+                ? key
+                : isMessageFunction(format)
+                    ? format.key
+                    : '',
+            locale: targetLocale || (isMessageFunction(format)
+                ? format.locale
+                : ''),
+            format: shared.isString(format)
+                ? format
+                : isMessageFunction(format)
+                    ? format.source
+                    : '',
+            message: ret
+        };
+        payloads.meta = shared.assign({}, context.__meta, getAdditionalMeta() || {});
+        translateDevTools(payloads);
+    }
+    return ret;
+}
+function escapeParams(options) {
+    if (shared.isArray(options.list)) {
+        options.list = options.list.map(item => shared.isString(item) ? shared.escapeHtml(item) : item);
+    }
+    else if (shared.isObject(options.named)) {
+        Object.keys(options.named).forEach(key => {
+            if (shared.isString(options.named[key])) {
+                options.named[key] = shared.escapeHtml(options.named[key]);
+            }
+        });
+    }
+}
+function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+    let message = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'translate';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        message =
+            messages[targetLocale] || {};
+        // for vue-devtools timeline event
+        let start = null;
+        let startTag;
+        let endTag;
+        if (shared.inBrowser) {
+            start = window.performance.now();
+            startTag = 'intlify-message-resolve-start';
+            endTag = 'intlify-message-resolve-end';
+            shared.mark && shared.mark(startTag);
+        }
+        if ((format = resolveValue(message, key)) === null) {
+            // if null, resolve with object key path
+            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        // for vue-devtools timeline event
+        if (shared.inBrowser) {
+            const end = window.performance.now();
+            const emitter = context.__v_emitter;
+            if (emitter && start && format) {
+                emitter.emit("message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */, {
+                    type: "message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */,
+                    key,
+                    message: format,
+                    time: end - start,
+                    groupId: `${type}:${key}`
+                });
+            }
+            if (startTag && endTag && shared.mark && shared.measure) {
+                shared.mark(endTag);
+                shared.measure('intlify message resolve', startTag, endTag);
+            }
+        }
+        if (shared.isString(format) || isMessageAST(format) || isMessageFunction(format)) {
+            break;
+        }
+        const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+        key, targetLocale, missingWarn, type);
+        if (missingRet !== key) {
+            format = missingRet;
+        }
+        from = to;
+    }
+    return [format, targetLocale, message];
+}
+function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
+    const { messageCompiler, warnHtmlMessage } = context;
+    if (isMessageFunction(format)) {
+        const msg = format;
+        msg.locale = msg.locale || targetLocale;
+        msg.key = msg.key || key;
+        return msg;
+    }
+    if (messageCompiler == null) {
+        const msg = (() => format);
+        msg.locale = targetLocale;
+        msg.key = key;
+        return msg;
+    }
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if (shared.inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-compilation-start';
+        endTag = 'intlify-message-compilation-end';
+        shared.mark && shared.mark(startTag);
+    }
+    const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+    // for vue-devtools timeline event
+    if (shared.inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */, {
+                type: "message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */,
+                message: format,
+                time: end - start,
+                groupId: `${'translate'}:${key}`
+            });
+        }
+        if (startTag && endTag && shared.mark && shared.measure) {
+            shared.mark(endTag);
+            shared.measure('intlify message compilation', startTag, endTag);
+        }
+    }
+    msg.locale = targetLocale;
+    msg.key = key;
+    msg.source = format;
+    return msg;
+}
+function evaluateMessage(context, msg, msgCtx) {
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if (shared.inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-evaluation-start';
+        endTag = 'intlify-message-evaluation-end';
+        shared.mark && shared.mark(startTag);
+    }
+    const messaged = msg(msgCtx);
+    // for vue-devtools timeline event
+    if (shared.inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */, {
+                type: "message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */,
+                value: messaged,
+                time: end - start,
+                groupId: `${'translate'}:${msg.key}`
+            });
+        }
+        if (startTag && endTag && shared.mark && shared.measure) {
+            shared.mark(endTag);
+            shared.measure('intlify message evaluation', startTag, endTag);
+        }
+    }
+    return messaged;
+}
+/** @internal */
+function parseTranslateArgs(...args) {
+    const [arg1, arg2, arg3] = args;
+    const options = {};
+    if (!shared.isString(arg1) &&
+        !shared.isNumber(arg1) &&
+        !isMessageFunction(arg1) &&
+        !isMessageAST(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    // prettier-ignore
+    const key = shared.isNumber(arg1)
+        ? String(arg1)
+        : isMessageFunction(arg1)
+            ? arg1
+            : arg1;
+    if (shared.isNumber(arg2)) {
+        options.plural = arg2;
+    }
+    else if (shared.isString(arg2)) {
+        options.default = arg2;
+    }
+    else if (shared.isPlainObject(arg2) && !shared.isEmptyObject(arg2)) {
+        options.named = arg2;
+    }
+    else if (shared.isArray(arg2)) {
+        options.list = arg2;
+    }
+    if (shared.isNumber(arg3)) {
+        options.plural = arg3;
+    }
+    else if (shared.isString(arg3)) {
+        options.default = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        shared.assign(options, arg3);
+    }
+    return [key, options];
+}
+function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
+    return {
+        locale,
+        key,
+        warnHtmlMessage,
+        onError: (err) => {
+            onError && onError(err);
+            {
+                const _source = getSourceForCodeFrame(source);
+                const message = `Message compilation error: ${err.message}`;
+                const codeFrame = err.location &&
+                    _source &&
+                    shared.generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);
+                const emitter = context.__v_emitter;
+                if (emitter && _source) {
+                    emitter.emit("compile-error" /* VueDevToolsTimelineEvents.COMPILE_ERROR */, {
+                        message: _source,
+                        error: err.message,
+                        start: err.location && err.location.start.offset,
+                        end: err.location && err.location.end.offset,
+                        groupId: `${'translate'}:${key}`
+                    });
+                }
+                console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+            }
+        },
+        onCacheKey: (source) => shared.generateFormatCacheKey(locale, key, source)
+    };
+}
+function getSourceForCodeFrame(source) {
+    if (shared.isString(source)) ;
+    else {
+        if (source.loc?.source) {
+            return source.loc.source;
+        }
+    }
+}
+function getMessageContextOptions(context, locale, message, options) {
+    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+    const resolveMessage = (key) => {
+        let val = resolveValue(message, key);
+        // fallback to root context
+        if (val == null && fallbackContext) {
+            const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
+            val = resolveValue(message, key);
+        }
+        if (shared.isString(val) || isMessageAST(val)) {
+            let occurred = false;
+            const onError = () => {
+                occurred = true;
+            };
+            const msg = compileMessageFormat(context, key, locale, val, key, onError);
+            return !occurred
+                ? msg
+                : NOOP_MESSAGE_FUNCTION;
+        }
+        else if (isMessageFunction(val)) {
+            return val;
+        }
+        else {
+            // TODO: should be implemented warning message
+            return NOOP_MESSAGE_FUNCTION;
+        }
+    };
+    const ctxOptions = {
+        locale,
+        modifiers,
+        pluralRules,
+        messages: resolveMessage
+    };
+    if (context.processor) {
+        ctxOptions.processor = context.processor;
+    }
+    if (options.list) {
+        ctxOptions.list = options.list;
+    }
+    if (options.named) {
+        ctxOptions.named = options.named;
+    }
+    if (shared.isNumber(options.plural)) {
+        ctxOptions.pluralIndex = options.plural;
+    }
+    return ctxOptions;
+}
+
+const intlDefined = typeof Intl !== 'undefined';
+const Availabilities = {
+    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
+    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
+};
+
+// implementation of `datetime` function
+function datetime(context, ...args) {
+    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __datetimeFormatters } = context;
+    if (!Availabilities.dateTimeFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseDateTimeArgs(...args);
+    const missingWarn = shared.isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = shared.isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!shared.isString(key) || key === '') {
+        return new Intl.DateTimeFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let datetimeFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'datetime format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        datetimeFormat =
+            datetimeFormats[targetLocale] || {};
+        format = datetimeFormat[key];
+        if (shared.isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!shared.isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __datetimeFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(targetLocale, shared.assign({}, format, overrides));
+        __datetimeFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const DATETIME_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+    'formatMatcher',
+    'hour12',
+    'timeZone',
+    'dateStyle',
+    'timeStyle',
+    'calendar',
+    'dayPeriod',
+    'numberingSystem',
+    'hourCycle',
+    'fractionalSecondDigits'
+];
+/** @internal */
+function parseDateTimeArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    let value;
+    if (shared.isString(arg1)) {
+        // Only allow ISO strings - other date formats are often supported,
+        // but may cause different results in different browsers.
+        const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+        if (!matches) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+        // Some browsers can not parse the iso datetime separated by space,
+        // this is a compromise solution by replace the 'T'/' ' with 'T'
+        const dateTime = matches[3]
+            ? matches[3].trim().startsWith('T')
+                ? `${matches[1].trim()}${matches[3].trim()}`
+                : `${matches[1].trim()}T${matches[3].trim()}`
+            : matches[1].trim();
+        value = new Date(dateTime);
+        try {
+            // This will fail if the date is not valid
+            value.toISOString();
+        }
+        catch (e) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+    }
+    else if (shared.isDate(arg1)) {
+        if (isNaN(arg1.getTime())) {
+            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+        }
+        value = arg1;
+    }
+    else if (shared.isNumber(arg1)) {
+        value = arg1;
+    }
+    else {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    if (shared.isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (shared.isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (shared.isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (shared.isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearDateTimeFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__datetimeFormatters.has(id)) {
+            continue;
+        }
+        context.__datetimeFormatters.delete(id);
+    }
+}
+
+// implementation of `number` function
+function number(context, ...args) {
+    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __numberFormatters } = context;
+    if (!Availabilities.numberFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseNumberArgs(...args);
+    const missingWarn = shared.isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = shared.isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!shared.isString(key) || key === '') {
+        return new Intl.NumberFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let numberFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'number format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        numberFormat =
+            numberFormats[targetLocale] || {};
+        format = numberFormat[key];
+        if (shared.isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!shared.isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __numberFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(targetLocale, shared.assign({}, format, overrides));
+        __numberFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const NUMBER_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'style',
+    'currency',
+    'currencyDisplay',
+    'currencySign',
+    'useGrouping',
+    'minimumIntegerDigits',
+    'minimumFractionDigits',
+    'maximumFractionDigits',
+    'minimumSignificantDigits',
+    'maximumSignificantDigits',
+    'compactDisplay',
+    'notation',
+    'signDisplay',
+    'unit',
+    'unitDisplay',
+    'roundingMode',
+    'roundingPriority',
+    'roundingIncrement',
+    'trailingZeroDisplay'
+];
+/** @internal */
+function parseNumberArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    if (!shared.isNumber(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    const value = arg1;
+    if (shared.isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (shared.isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (shared.isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (shared.isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearNumberFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__numberFormatters.has(id)) {
+            continue;
+        }
+        context.__numberFormatters.delete(id);
+    }
+}
+
+exports.CompileErrorCodes = messageCompiler.CompileErrorCodes;
+exports.createCompileError = messageCompiler.createCompileError;
+exports.CoreErrorCodes = CoreErrorCodes;
+exports.CoreWarnCodes = CoreWarnCodes;
+exports.DATETIME_FORMAT_OPTIONS_KEYS = DATETIME_FORMAT_OPTIONS_KEYS;
+exports.DEFAULT_LOCALE = DEFAULT_LOCALE;
+exports.DEFAULT_MESSAGE_DATA_TYPE = DEFAULT_MESSAGE_DATA_TYPE;
+exports.MISSING_RESOLVE_VALUE = MISSING_RESOLVE_VALUE;
+exports.NOT_REOSLVED = NOT_REOSLVED;
+exports.NUMBER_FORMAT_OPTIONS_KEYS = NUMBER_FORMAT_OPTIONS_KEYS;
+exports.VERSION = VERSION;
+exports.clearCompileCache = clearCompileCache;
+exports.clearDateTimeFormat = clearDateTimeFormat;
+exports.clearNumberFormat = clearNumberFormat;
+exports.compile = compile;
+exports.compileToFunction = compileToFunction;
+exports.createCoreContext = createCoreContext;
+exports.createCoreError = createCoreError;
+exports.createMessageContext = createMessageContext;
+exports.datetime = datetime;
+exports.fallbackWithLocaleChain = fallbackWithLocaleChain;
+exports.fallbackWithSimple = fallbackWithSimple;
+exports.getAdditionalMeta = getAdditionalMeta;
+exports.getDevToolsHook = getDevToolsHook;
+exports.getFallbackContext = getFallbackContext;
+exports.getLocale = getLocale;
+exports.getWarnMessage = getWarnMessage;
+exports.handleMissing = handleMissing;
+exports.initI18nDevTools = initI18nDevTools;
+exports.isMessageAST = isMessageAST;
+exports.isMessageFunction = isMessageFunction;
+exports.isTranslateFallbackWarn = isTranslateFallbackWarn;
+exports.isTranslateMissingWarn = isTranslateMissingWarn;
+exports.number = number;
+exports.parse = parse;
+exports.parseDateTimeArgs = parseDateTimeArgs;
+exports.parseNumberArgs = parseNumberArgs;
+exports.parseTranslateArgs = parseTranslateArgs;
+exports.registerLocaleFallbacker = registerLocaleFallbacker;
+exports.registerMessageCompiler = registerMessageCompiler;
+exports.registerMessageResolver = registerMessageResolver;
+exports.resolveLocale = resolveLocale;
+exports.resolveValue = resolveValue;
+exports.resolveWithKeyValue = resolveWithKeyValue;
+exports.setAdditionalMeta = setAdditionalMeta;
+exports.setDevToolsHook = setDevToolsHook;
+exports.setFallbackContext = setFallbackContext;
+exports.translate = translate;
+exports.translateDevTools = translateDevTools;
+exports.updateFallbackLocale = updateFallbackLocale;

node_modules/@intlify/core-base/dist/core-base.cjs.js

@@ -0,0 +1 @@
+module.exports = require('../dist/core-base.cjs')

node_modules/@intlify/core-base/dist/core-base.cjs.prod.js

@@ -0,0 +1 @@
+module.exports = require('../dist/core-base.prod.cjs')

node_modules/@intlify/core-base/dist/core-base.d.ts

@@ -0,0 +1,1187 @@
+import type { BaseError } from '@intlify/shared';
+import { CompileError } from '@intlify/message-compiler';
+import { CompileErrorCodes } from '@intlify/message-compiler';
+import type { CompileOptions } from '@intlify/message-compiler';
+import type { CoreMissingType as CoreMissingType_2 } from '@intlify/core-base';
+import { createCompileError } from '@intlify/message-compiler';
+import type { Emittable } from '@intlify/shared';
+import type { Locale as Locale_2 } from '@intlify/core-base';
+import type { MessageFunction as MessageFunction_2 } from '@intlify/core-base';
+import type { Path as Path_2 } from '@intlify/core-base';
+import type { PathValue as PathValue_2 } from '@intlify/core-base';
+import { ResourceNode } from '@intlify/message-compiler';
+import type { ResourceNode as ResourceNode_2 } from '@intlify/core-base';
+
+declare type __ResourceFormatPath<T, Key extends keyof T> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}` : never : never;
+
+export declare type __ResourcePath<T, Key extends keyof T> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}.${__ResourcePath<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}` | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}` : never : never;
+
+declare type AdditionalPayloads = {
+    meta?: Record<string, unknown>;
+};
+
+export declare function clearCompileCache(): void;
+
+/* Excluded from this release type: clearDateTimeFormat */
+
+/* Excluded from this release type: clearNumberFormat */
+
+export declare function compile<Message = string, MessageSource = string | ResourceNode>(message: MessageSource, context: MessageCompilerContext): MessageFunction<Message>;
+export { CompileError }
+export { CompileErrorCodes }
+
+export declare const compileToFunction: <Message = string, MessageSource = string | ResourceNode>(message: MessageSource, context: MessageCompilerContext) => MessageFunction<Message>;
+
+export declare interface CoreCommonContext<Message = string, Locales = 'en-US'> {
+    cid: number;
+    version: string;
+    locale: Locales;
+    fallbackLocale: FallbackLocales<Locales>;
+    missing: CoreMissingHandler<Message> | null;
+    missingWarn: boolean | RegExp;
+    fallbackWarn: boolean | RegExp;
+    fallbackFormat: boolean;
+    unresolving: boolean;
+    localeFallbacker: LocaleFallbacker;
+    onWarn(msg: string, err?: Error): void;
+}
+
+export declare type CoreContext<Message = string, Messages = {}, DateTimeFormats = {}, NumberFormats = {}, LocaleType = Locale, ResourceLocales = PickupLocales<NonNullable<Messages>> | PickupLocales<NonNullable<DateTimeFormats>> | PickupLocales<NonNullable<NumberFormats>>, Locales = LocaleType extends LocaleDetector ? Locale : [ResourceLocales] extends [never] ? Locale : ResourceLocales> = CoreCommonContext<Message, Locales> & CoreTranslationContext<NonNullable<Messages>, Message> & CoreDateTimeContext<NonNullable<DateTimeFormats>> & CoreNumberContext<NonNullable<NumberFormats>> & {
+    fallbackContext?: CoreContext<Message, Messages, DateTimeFormats, NumberFormats, LocaleType, ResourceLocales, Locales>;
+};
+
+export declare interface CoreDateTimeContext<DateTimeFormats = {}> {
+    datetimeFormats: {
+        [K in keyof DateTimeFormats]: DateTimeFormats[K];
+    };
+}
+
+export declare interface CoreError extends BaseError {
+}
+
+export declare const CoreErrorCodes: {
+    readonly INVALID_ARGUMENT: 17;
+    readonly INVALID_DATE_ARGUMENT: number;
+    readonly INVALID_ISO_DATE_ARGUMENT: number;
+    readonly NOT_SUPPORT_NON_STRING_MESSAGE: number;
+    readonly __EXTEND_POINT__: number;
+};
+
+export declare type CoreErrorCodes = (typeof CoreErrorCodes)[keyof typeof CoreErrorCodes];
+
+export declare interface CoreInternalContext {
+    __datetimeFormatters: Map<string, Intl.DateTimeFormat>;
+    __numberFormatters: Map<string, Intl.NumberFormat>;
+    __localeChainCache?: Map<Locale, Locale[]>;
+    __v_emitter?: VueDevToolsEmitter;
+    __meta: MetaInfo;
+}
+
+export declare interface CoreInternalOptions {
+    __datetimeFormatters?: Map<string, Intl.DateTimeFormat>;
+    __numberFormatters?: Map<string, Intl.NumberFormat>;
+    __v_emitter?: VueDevToolsEmitter;
+    __meta?: MetaInfo;
+}
+
+export declare type CoreMissingHandler<Message = string> = (context: CoreContext<Message>, locale: Locale, key: Path, type: CoreMissingType, ...values: unknown[]) => string | void;
+
+export declare type CoreMissingType = 'translate' | 'datetime format' | 'number format';
+
+export declare interface CoreNumberContext<NumberFormats = {}> {
+    numberFormats: {
+        [K in keyof NumberFormats]: NumberFormats[K];
+    };
+}
+
+export declare interface CoreOptions<Message = string, Schema extends {
+    message?: unknown;
+    datetime?: unknown;
+    number?: unknown;
+} = {
+    message: LocaleMessage<Message>;
+    datetime: DateTimeFormat;
+    number: NumberFormat;
+}, Locales extends {
+    messages: unknown;
+    datetimeFormats: unknown;
+    numberFormats: unknown;
+} | string = Locale, MessagesLocales = Locales extends {
+    messages: infer M;
+} ? M : Locales extends string ? Locales : Locale, DateTimeFormatsLocales = Locales extends {
+    datetimeFormats: infer D;
+} ? D : Locales extends string ? Locales : Locale, NumberFormatsLocales = Locales extends {
+    numberFormats: infer N;
+} ? N : Locales extends string ? Locales : Locale, MessageSchema = Schema extends {
+    message: infer M;
+} ? M : LocaleMessage<Message>, DateTimeSchema = Schema extends {
+    datetime: infer D;
+} ? D : DateTimeFormat, NumberSchema = Schema extends {
+    number: infer N;
+} ? N : NumberFormat, _Messages extends LocaleMessages<MessageSchema, MessagesLocales, Message> = LocaleMessages<MessageSchema, MessagesLocales, Message>, _DateTimeFormats extends DateTimeFormats<DateTimeSchema, DateTimeFormatsLocales> = DateTimeFormats<DateTimeSchema, DateTimeFormatsLocales>, _NumberFormats extends NumberFormats<NumberSchema, NumberFormatsLocales> = NumberFormats<NumberSchema, NumberFormatsLocales>> {
+    version?: string;
+    locale?: Locale | LocaleDetector;
+    fallbackLocale?: FallbackLocale;
+    messages?: {
+        [K in keyof _Messages]: MessageSchema;
+    };
+    datetimeFormats?: {
+        [K in keyof _DateTimeFormats]: DateTimeSchema;
+    };
+    numberFormats?: {
+        [K in keyof _NumberFormats]: NumberSchema;
+    };
+    modifiers?: LinkedModifiers<Message>;
+    pluralRules?: PluralizationRules;
+    missing?: CoreMissingHandler<Message>;
+    missingWarn?: boolean | RegExp;
+    fallbackWarn?: boolean | RegExp;
+    fallbackFormat?: boolean;
+    unresolving?: boolean;
+    postTranslation?: PostTranslationHandler<Message>;
+    processor?: MessageProcessor<Message>;
+    warnHtmlMessage?: boolean;
+    escapeParameter?: boolean;
+    messageCompiler?: MessageCompiler<Message, string | ResourceNode>;
+    messageResolver?: MessageResolver;
+    localeFallbacker?: LocaleFallbacker;
+    fallbackContext?: CoreContext<Message, MessagesLocales, DateTimeFormatsLocales, NumberFormatsLocales>;
+    onWarn?: (msg: string, err?: Error) => void;
+}
+
+export declare interface CoreTranslationContext<Messages = {}, Message = string> {
+    messages: {
+        [K in keyof Messages]: Messages[K];
+    };
+    modifiers: LinkedModifiers<Message>;
+    pluralRules?: PluralizationRules;
+    postTranslation: PostTranslationHandler<Message> | null;
+    processor: MessageProcessor<Message> | null;
+    warnHtmlMessage: boolean;
+    escapeParameter: boolean;
+    messageCompiler: MessageCompiler<Message, string | ResourceNode> | null;
+    messageResolver: MessageResolver;
+}
+
+export declare const CoreWarnCodes: {
+    readonly NOT_FOUND_KEY: 1;
+    readonly FALLBACK_TO_TRANSLATE: 2;
+    readonly CANNOT_FORMAT_NUMBER: 3;
+    readonly FALLBACK_TO_NUMBER_FORMAT: 4;
+    readonly CANNOT_FORMAT_DATE: 5;
+    readonly FALLBACK_TO_DATE_FORMAT: 6;
+    readonly EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7;
+    readonly __EXTEND_POINT__: 8;
+};
+
+export declare type CoreWarnCodes = (typeof CoreWarnCodes)[keyof typeof CoreWarnCodes];
+export { createCompileError }
+
+export declare function createCoreContext<Message = string, Options extends CoreOptions<Message> = CoreOptions<Message>, Messages extends Record<string, any> = Options['messages'] extends Record<string, any> ? Options['messages'] : {}, DateTimeFormats extends Record<string, any> = Options['datetimeFormats'] extends Record<string, any> ? Options['datetimeFormats'] : {}, NumberFormats extends Record<string, any> = Options['numberFormats'] extends Record<string, any> ? Options['numberFormats'] : {}, LocaleType extends LocaleDetector | Locale = NonNullable<Options['locale']> extends LocaleDetector ? LocaleDetector : Locale>(options: Options): CoreContext<Message, Messages, DateTimeFormats, NumberFormats, LocaleType>;
+
+export declare function createCoreContext<Schema = LocaleMessage, Locales = 'en-US', Message = string, Options extends CoreOptions<Message, SchemaParams<Schema, Message>, LocaleParams<Locales>> = CoreOptions<Message, SchemaParams<Schema, Message>, LocaleParams<Locales>>, Messages extends Record<string, any> = NonNullable<Options['messages']> extends Record<string, any> ? NonNullable<Options['messages']> : {}, DateTimeFormats extends Record<string, any> = NonNullable<Options['datetimeFormats']> extends Record<string, any> ? NonNullable<Options['datetimeFormats']> : {}, NumberFormats extends Record<string, any> = NonNullable<Options['numberFormats']> extends Record<string, any> ? NonNullable<Options['numberFormats']> : {}, LocaleType extends LocaleDetector | Locale = NonNullable<Options['locale']> extends LocaleDetector ? LocaleDetector : Locale>(options: Options): CoreContext<Message, Messages, DateTimeFormats, NumberFormats, LocaleType>;
+
+export declare function createCoreError(code: CoreErrorCodes): CoreError;
+
+export declare function createMessageContext<T = string, N = {}>(options?: MessageContextOptions<T, N>): MessageContext<T>;
+
+/**
+ *  number
+ */
+export declare type CurrencyDisplay = 'symbol' | 'code' | 'name';
+
+export declare interface CurrencyNumberFormatOptions extends Intl.NumberFormatOptions {
+    style: 'currency';
+    currency: string;
+    currencyDisplay?: CurrencyDisplay;
+    localeMatcher?: LocaleMatcher;
+    formatMatcher?: FormatMatcher;
+}
+
+/**
+ * `datetime` function overloads
+ */
+export declare function datetime<Context extends CoreContext<Message, {}, {}, {}>, Message = string>(context: Context, value: number | string | Date): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, {}, {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, {}, {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale']): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, {}, {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>, override: Intl.DateTimeFormatOptions): string | number | Intl.DateTimeFormatPart[];
+
+export declare function datetime<Context extends CoreContext<Message, {}, {}, {}>, Value extends number | string | Date = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['datetimeFormats']> = PickupFormatKeys<Context['datetimeFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | DateTimeOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale'], override: Intl.DateTimeFormatOptions): string | number | Intl.DateTimeFormatPart[];
+
+/* Excluded from this release type: DATETIME_FORMAT_OPTIONS_KEYS */
+
+export declare type DateTimeDigital = 'numeric' | '2-digit';
+
+export declare type DateTimeFormat = {
+    [key: string]: DateTimeFormatOptions;
+};
+
+export declare type DateTimeFormatOptions = Intl.DateTimeFormatOptions | SpecificDateTimeFormatOptions;
+
+export declare type DateTimeFormats<Schema = DateTimeFormat, Locales = Locale> = LocaleRecord<UnionToTuple<Locales>, Schema>;
+
+/**
+ *  datetime
+ */
+export declare type DateTimeHumanReadable = 'long' | 'short' | 'narrow';
+
+/**
+ *  # datetime
+ *
+ *  ## usages:
+ *    // for example `context.datetimeFormats` below
+ *    'en-US': {
+ *      short: {
+ *        year: 'numeric', month: '2-digit', day: '2-digit',
+ *        hour: '2-digit', minute: '2-digit'
+ *      }
+ *    },
+ *    'ja-JP': { ... }
+ *
+ *    // datetimeable value only
+ *    datetime(context, value)
+ *
+ *    // key argument
+ *    datetime(context, value, 'short')
+ *
+ *    // key & locale argument
+ *    datetime(context, value, 'short', 'ja-JP')
+ *
+ *    // object sytle argument
+ *    datetime(context, value, { key: 'short', locale: 'ja-JP' })
+ *
+ *    // suppress localize miss warning option, override context.missingWarn
+ *    datetime(context, value, { key: 'short', locale: 'ja-JP', missingWarn: false })
+ *
+ *    // suppress localize fallback warning option, override context.fallbackWarn
+ *    datetime(context, value, { key: 'short', locale: 'ja-JP', fallbackWarn: false })
+ *
+ *    // if you specify `part` options, you can get an array of objects containing the formatted datetime in parts
+ *    datetime(context, value, { key: 'short', part: true })
+ *
+ *    // orverride context.datetimeFormats[locale] options with functino options
+ *    datetime(cnotext, value, 'short', { year: '2-digit' })
+ *    datetime(cnotext, value, 'short', 'ja-JP', { year: '2-digit' })
+ *    datetime(context, value, { key: 'short', part: true, year: '2-digit' })
+ */
+/**
+ * DateTime options
+ *
+ * @remarks
+ * Options for Datetime formatting API
+ *
+ * @VueI18nGeneral
+ */
+export declare interface DateTimeOptions<Key = string, Locales = Locale> extends Intl.DateTimeFormatOptions, LocaleOptions<Locales> {
+    /**
+     * @remarks
+     * The target format key
+     */
+    key?: Key;
+    /**
+     * @remarks
+     * Whether suppress warnings outputted when localization fails
+     */
+    missingWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do resolve on format keys when your language lacks a formatting for a key
+     */
+    fallbackWarn?: boolean;
+    /**
+     * @remarks
+     * Whether to use [Intel.DateTimeFormat#formatToParts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/formatToParts)
+     */
+    part?: boolean;
+}
+
+export declare const DEFAULT_LOCALE = "en-US";
+
+export declare const DEFAULT_MESSAGE_DATA_TYPE = "text";
+
+declare type ExtractToStringFunction<T> = T[ExtractToStringKey<T>];
+
+declare type ExtractToStringKey<T> = Extract<keyof T, 'toString'>;
+
+/** @VueI18nGeneral */
+export declare type FallbackLocale = Locale | Locale[] | {
+    [locale in string]: Locale[];
+} | false;
+
+export declare type FallbackLocales<Locales = 'en-US'> = Locales | Array<Locales> | {
+    [locale in string]: Array<PickupFallbackLocales<UnionToTuple<Locales>>>;
+} | false;
+
+/**
+ * Fallback with locale chain
+ *
+ * @remarks
+ * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+ *
+ * @VueI18nGeneral
+ */
+export declare function fallbackWithLocaleChain<Message = string>(ctx: CoreContext<Message>, fallback: FallbackLocale, start: Locale): Locale[];
+
+/**
+ * Fallback with simple implemenation
+ *
+ * @remarks
+ * A fallback locale function implemented with a simple fallback algorithm.
+ *
+ * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nGeneral
+ */
+export declare function fallbackWithSimple<Message = string>(ctx: CoreContext<Message>, fallback: FallbackLocale, start: Locale): Locale[];
+
+export declare type First<T extends readonly any[]> = T[0];
+
+export declare type FormatMatcher = 'basic' | 'best fit';
+
+export declare type FormattedNumberPart = {
+    type: FormattedNumberPartType;
+    value: string;
+};
+
+export declare type FormattedNumberPartType = 'currency' | 'decimal' | 'fraction' | 'group' | 'infinity' | 'integer' | 'literal' | 'minusSign' | 'nan' | 'plusSign' | 'percentSign';
+
+export declare const getAdditionalMeta: () => MetaInfo | null;
+
+export declare function getDevToolsHook(): IntlifyDevToolsEmitter | null;
+
+export declare const getFallbackContext: () => CoreContext | null;
+
+/* Excluded from this release type: getLocale */
+
+export declare function getWarnMessage(code: CoreWarnCodes, ...args: unknown[]): string;
+
+/* Excluded from this release type: handleMissing */
+
+export declare function initI18nDevTools(i18n: unknown, version: string, meta?: Record<string, unknown>): void;
+
+declare type IntlifyDevToolsEmitter = Emittable<IntlifyDevToolsEmitterHooks>;
+
+declare type IntlifyDevToolsEmitterHooks = {
+    [IntlifyDevToolsHooks.I18nInit]: IntlifyDevToolsHookPayloads[IntlifyDevToolsHooks.I18nInit];
+    [IntlifyDevToolsHooks.FunctionTranslate]: IntlifyDevToolsHookPayloads[IntlifyDevToolsHooks.FunctionTranslate];
+};
+
+declare type IntlifyDevToolsHookPayloads = {
+    [IntlifyDevToolsHooks.I18nInit]: {
+        timestamp: number;
+        i18n: unknown;
+        version: string;
+    } & AdditionalPayloads;
+    [IntlifyDevToolsHooks.FunctionTranslate]: {
+        timestamp: number;
+        message: string | number;
+        key: string;
+        locale: string;
+        format?: string;
+    } & AdditionalPayloads;
+};
+
+declare const enum IntlifyDevToolsHooks {
+    I18nInit = "i18n:init",
+    FunctionTranslate = "function:translate"
+}
+
+export declare type IsEmptyObject<T> = [keyof T] extends [never] ? true : false;
+
+export declare const isMessageAST: (val: unknown) => val is ResourceNode;
+
+export declare const isMessageFunction: <T>(val: unknown) => val is MessageFunction<T>;
+
+export declare type IsNever<T> = [T] extends [never] ? true : false;
+
+/* Excluded from this release type: isTranslateFallbackWarn */
+
+/* Excluded from this release type: isTranslateMissingWarn */
+
+export declare type IsUnion<T, B = T> = T extends B ? [B] extends [T] ? false : true : never;
+
+export declare type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+
+/** @VueI18nGeneral */
+export declare type LinkedModifiers<T = string> = {
+    [key: string]: LinkedModify<T>;
+};
+
+export declare type LinkedModify<T = string> = (value: T, type: string) => MessageType<T>;
+
+export declare interface LinkedOptions {
+    /**
+     * The message type of linked message
+     */
+    type?: string;
+    /**
+     * The modifier of linked message
+     */
+    modifier?: string;
+}
+
+/** @VueI18nGeneral */
+export declare type Locale = string;
+
+/** @VueI18nGeneral */
+export declare interface LocaleDetector {
+    (): Locale;
+    resolvedOnce?: boolean;
+}
+
+/**
+ * The locale fallbacker
+ *
+ * @VueI18nGeneral
+ */
+export declare type LocaleFallbacker = <Message = string>(ctx: CoreContext<Message>, fallback: FallbackLocale, start: Locale) => Locale[];
+
+export declare type LocaleMatcher = 'lookup' | 'best fit';
+
+/** @VueI18nGeneral */
+export declare type LocaleMessage<Message = string> = Record<string, LocaleMessageValue<Message>>;
+
+/** @VueI18nGeneral */
+export declare type LocaleMessageDictionary<T, Message = string> = {
+    [K in keyof T]: LocaleMessageType<T[K], Message>;
+};
+
+/** @VueI18nGeneral */
+export declare type LocaleMessages<Schema, Locales = Locale, Message = string> = LocaleRecord<UnionToTuple<Locales>, Schema>;
+
+/** @VueI18nGeneral */
+export declare type LocaleMessageType<T, Message = string> = T extends string ? string : T extends () => Promise<infer P> ? LocaleMessageDictionary<P, Message> : T extends (...args: infer Arguments) => any ? (...args: Arguments) => ReturnType<T> : T extends Record<string, unknown> ? LocaleMessageDictionary<T, Message> : T extends Array<T> ? {
+    [K in keyof T]: T[K];
+} : T;
+
+/** @VueI18nGeneral */
+export declare type LocaleMessageValue<Message = string> = LocaleMessageDictionary<any, Message> | string;
+
+/** @VueI18nGeneral */
+export declare interface LocaleOptions<Locales = Locale> {
+    /**
+     * @remarks
+     * The locale of localization
+     */
+    locale?: Locales | LocaleDetector;
+}
+
+export declare type LocaleParams<T, Default = 'en-US'> = T extends IsUnion<T> ? {
+    messages: T;
+    datetimeFormats: T;
+    numberFormats: T;
+} : T extends {
+    messages?: infer M;
+    datetimeFormats?: infer D;
+    numberFormats?: infer N;
+} ? {
+    messages: LocaleParamsType<M, Default>;
+    datetimeFormats: LocaleParamsType<D, Default>;
+    numberFormats: LocaleParamsType<N, Default>;
+} : T extends string ? {
+    messages: T;
+    datetimeFormats: T;
+    numberFormats: T;
+} : {
+    messages: Default;
+    datetimeFormats: Default;
+    numberFormats: Default;
+};
+
+declare type LocaleParamsType<T, R> = T extends IsUnion<T> ? T : T extends string ? T : R;
+
+export declare type LocaleRecord<T extends any[], R> = {
+    [K in T[number]]: R;
+};
+
+/**
+ * The message compiler
+ *
+ * @param message - A resolved message that ususally will be passed the string. if you can transform to it with bundler, will be passed the AST.
+ * @param context - A message context {@link MessageCompilerContext}
+ *
+ * @returns A {@link MessageFunction}
+ *
+ * @VueI18nGeneral
+ */
+export declare type MessageCompiler<Message = string, MessageSource = string | ResourceNode> = (message: MessageSource, context: MessageCompilerContext) => MessageFunction<Message>;
+
+/**
+ * The context that will pass the message compiler.
+ *
+ * @VueI18nGeneral
+ */
+export declare type MessageCompilerContext = Pick<CompileOptions, 'onError' | 'onCacheKey'> & {
+    /**
+     * Whether to allow the use locale messages of HTML formatting.
+     */
+    warnHtmlMessage?: boolean;
+    /**
+     * The resolved locale message key
+     */
+    key: string;
+    /**
+     * The locale
+     */
+    locale: Locale;
+};
+
+/**
+ * The message context.
+ *
+ * @VueI18nGeneral
+ */
+export declare interface MessageContext<T = string> {
+    /**
+     * Resolve message value from list.
+     *
+     * @param index - An index of message values.
+     *
+     * @returns A resolved message value.
+     *
+     * @example
+     * ```js
+     * const messages = {
+     *   en: {
+     *     greeting: ({ list }) => `hello, ${list(0)}!`
+     *   }
+     * }
+     * ```
+     */
+    list(index: number): unknown;
+    /**
+     * Resolve message value from named.
+     *
+     * @param key - A key of message value.
+     *
+     * @returns A resolved message value.
+     *
+     * @example
+     * ```js
+     * const messages = {
+     *   en: {
+     *     greeting: ({ named }) => `hello, ${named('name')}!`
+     *   }
+     * }
+     * ```
+     */
+    named(key: string): unknown;
+    /**
+     * Resolve message with plural index.
+     *
+     * @remarks
+     * That's resolved with plural index with translation function.
+     *
+     * @param messages - the messages, that is resolved with plural index with translation function.
+     *
+     * @returns A resolved message.
+     *
+     * @example
+     * ```js
+     * const messages = {
+     *   en: {
+     *     car: ({ plural }) => plural(['car', 'cars']),
+     *     apple: ({ plural, named }) =>
+     *       plural([
+     *         'no apples',
+     *         'one apple',
+     *         `${named('count')} apples`
+     *       ])
+     *   }
+     * }
+     * ```
+     */
+    plural(messages: T[]): T;
+    /**
+     * Resolve linked message.
+     *
+     * @param key - A message key
+     * @param modifier - A modifier
+     *
+     * @returns A resolve message.
+     */
+    linked(key: Path, modifier?: string): MessageType<T>;
+    /**
+     * Overloaded `linked`
+     *
+     * @param key - A message key
+     * @param modifier - A modifier
+     * @param type - A message type
+     *
+     * @returns A resolve message.
+     */
+    linked(key: Path, modifier?: string, type?: string): MessageType<T>;
+    /**
+     * Overloaded `linked`
+     *
+     * @param key - A message key
+     * @param optoins - An {@link LinkedOptions | linked options}
+     *
+     * @returns A resolve message.
+     */
+    linked(key: Path, optoins?: LinkedOptions): MessageType<T>;
+    /* Excluded from this release type: message */
+    /**
+     * The message type to be handled by the message function.
+     *
+     * @remarks
+     * Usually `text`, you need to return **string** in message function.
+     */
+    type: string;
+    /* Excluded from this release type: interpolate */
+    /* Excluded from this release type: normalize */
+    /**
+     * The message values.
+     *
+     * @remarks
+     * The message values are the argument values passed from translation fucntion, such as `$t`, `t`, or `translate`.
+     *
+     * @example
+     * vue-i18n `$t` (or `t`) case:
+     * ```html
+     * <p>{{ $t('greeting', { name: 'DIO' }) }}</p> <!-- `{ name: 'DIO' }` is message vlaues -->
+     * ```
+     *
+     * `@intlify/core` (`@intlify/core-base`) `translate` case:
+     * ```js
+     * translate(context, 'foo.bar', ['dio']) // `['dio']` is message values
+     * ```
+     */
+    values: Record<string, unknown>;
+}
+
+export declare interface MessageContextOptions<T = string, N = {}> {
+    parent?: MessageContext<T>;
+    locale?: string;
+    list?: unknown[];
+    named?: NamedValue<N>;
+    modifiers?: LinkedModifiers<T>;
+    pluralIndex?: number;
+    pluralRules?: PluralizationRules;
+    messages?: MessageFunctions<T> | MessageResolveFunction<T>;
+    processor?: MessageProcessor<T>;
+}
+
+/**
+ * The Message Function.
+ *
+ * @param ctx - A {@link MessageContext}
+ *
+ * @return A resolved format message, that is string type basically.
+ *
+ * @VueI18nGeneral
+ */
+export declare type MessageFunction<T = string> = MessageFunctionCallable | MessageFunctionInternal<T>;
+
+export declare type MessageFunctionCallable = <T = string>(ctx: MessageContext<T>) => MessageFunctionReturn<T>;
+
+export declare type MessageFunctionInternal<T = string> = {
+    (ctx: MessageContext<T>): MessageFunctionReturn<T>;
+    key?: string;
+    locale?: string;
+    source?: string;
+};
+
+/** @VueI18nGeneral */
+export declare type MessageFunctionReturn<T = string> = T extends string ? MessageType<T> : MessageType<T>[];
+
+export declare type MessageFunctions<T = string> = Record<string, MessageFunction<T>>;
+
+export declare type MessageInterpolate<T = string> = (val: unknown) => MessageType<T>;
+
+export declare type MessageNormalize<T = string> = (values: MessageType<T>[]) => MessageFunctionReturn<T>;
+
+export declare interface MessageProcessor<T = string> {
+    type?: string;
+    interpolate?: MessageInterpolate<T>;
+    normalize?: MessageNormalize<T>;
+}
+
+export declare type MessageResolveFunction<T = string> = (key: string) => MessageFunction<T>;
+
+/** @VueI18nGeneral */
+export declare type MessageResolver = (obj: unknown, path: Path) => PathValue;
+
+export declare type MessageType<T = string> = T extends string ? string : StringConvertable<T>;
+
+export declare interface MetaInfo {
+    [field: string]: unknown;
+}
+
+export declare const MISSING_RESOLVE_VALUE = "";
+
+/** @VueI18nGeneral */
+export declare type NamedValue<T = {}> = T & Record<string, unknown>;
+
+export declare const NOT_REOSLVED = -1;
+
+/**
+ * `number` function overloads
+ */
+export declare function number<Context extends CoreContext<Message, {}, {}, {}>, Message = string>(context: Context, value: number): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, {}>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, {}>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale']): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, {}>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>, override: Intl.NumberFormatOptions): string | number | Intl.NumberFormatPart[];
+
+export declare function number<Context extends CoreContext<Message, {}, {}, {}>, Value extends number = number, Key extends string = string, ResourceKeys extends PickupFormatKeys<Context['numberFormats']> = PickupFormatKeys<Context['numberFormats']>, Message = string>(context: Context, value: Value, keyOrOptions: Key | ResourceKeys | NumberOptions<Key | ResourceKeys, Context['locale']>, locale: Context['locale'], override: Intl.NumberFormatOptions): string | number | Intl.NumberFormatPart[];
+
+/* Excluded from this release type: NUMBER_FORMAT_OPTIONS_KEYS */
+
+export declare type NumberFormat = {
+    [key: string]: NumberFormatOptions;
+};
+
+export declare type NumberFormatOptions = Intl.NumberFormatOptions | SpecificNumberFormatOptions | CurrencyNumberFormatOptions;
+
+export declare type NumberFormats<Schema = NumberFormat, Locales = Locale> = LocaleRecord<UnionToTuple<Locales>, Schema>;
+
+export declare type NumberFormatToPartsResult = {
+    [index: number]: FormattedNumberPart;
+};
+
+/**
+ *  # number
+ *
+ *  ## usages
+ *    // for example `context.numberFormats` below
+ *    'en-US': {
+ *      'currency': {
+ *        style: 'currency', currency: 'USD', currencyDisplay: 'symbol'
+ *      }
+ *    },
+ *    'ja-JP: { ... }
+ *
+ *    // value only
+ *    number(context, value)
+ *
+ *    // key argument
+ *    number(context, value, 'currency')
+ *
+ *    // key & locale argument
+ *    number(context, value, 'currency', 'ja-JP')
+ *
+ *    // object sytle argument
+ *    number(context, value, { key: 'currency', locale: 'ja-JP' })
+ *
+ *    // suppress localize miss warning option, override context.missingWarn
+ *    number(context, value, { key: 'currency', locale: 'ja-JP', missingWarn: false })
+ *
+ *    // suppress localize fallback warning option, override context.fallbackWarn
+ *    number(context, value, { key: 'currency', locale: 'ja-JP', fallbackWarn: false })
+ *
+ *    // if you specify `part` options, you can get an array of objects containing the formatted number in parts
+ *    number(context, value, { key: 'currenty', part: true })
+ *
+ *    // orverride context.numberFormats[locale] options with functino options
+ *    number(cnotext, value, 'currency', { year: '2-digit' })
+ *    number(cnotext, value, 'currency', 'ja-JP', { year: '2-digit' })
+ *    number(context, value, { key: 'currenty', locale: 'ja-JP', part: true, year: '2-digit'})
+ */
+/**
+ * Number Options
+ *
+ * @remarks
+ * Options for Number formatting API
+ *
+ * @VueI18nGeneral
+ */
+export declare interface NumberOptions<Key = string, Locales = Locale> extends Intl.NumberFormatOptions, LocaleOptions<Locales> {
+    /**
+     * @remarks
+     * The target format key
+     */
+    key?: Key;
+    /**
+     * @remarks
+     * Whether suppress warnings outputted when localization fails
+     */
+    missingWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do resolve on format keys when your language lacks a formatting for a key
+     */
+    fallbackWarn?: boolean;
+    /**
+     * @remarks
+     * Whether to use [Intel.NumberFormat#formatToParts](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/formatToParts)
+     */
+    part?: boolean;
+}
+
+/**
+ * Parse a string path into an array of segments
+ */
+export declare function parse(path: Path): string[] | undefined;
+
+/* Excluded from this release type: parseDateTimeArgs */
+
+/* Excluded from this release type: parseNumberArgs */
+
+/* Excluded from this release type: parseTranslateArgs */
+
+/** @VueI18nGeneral */
+export declare type Path = string;
+
+/** @VueI18nGeneral */
+export declare type PathValue = string | number | boolean | Function | null | {
+    [key: string]: PathValue;
+} | PathValue[];
+
+export declare type PickupFallbackLocales<T extends any[]> = T[number] | `${T[number]}!`;
+
+export declare type PickupFormatKeys<T extends Record<string, any>, K = keyof T> = K extends string ? ResourceFormatPath<T[K]> : never;
+
+export declare type PickupFormatPathKeys<T extends object> = ResourceFormatPath<T>;
+
+export declare type PickupKeys<T extends Record<string, any>, K = keyof T> = K extends string ? ResourcePath<T[K]> : never;
+
+export declare type PickupLocales<T extends Record<string, any>, K = keyof T> = K extends string ? K : never;
+
+export declare type PickupPaths<T extends object> = ResourcePath<T>;
+
+export declare type PluralizationProps = {
+    n?: number;
+    count?: number;
+};
+
+export declare type PluralizationRule = (choice: number, choicesLength: number, orgRule?: PluralizationRule) => number;
+
+/** @VueI18nGeneral */
+export declare type PluralizationRules = {
+    [locale: string]: PluralizationRule;
+};
+
+/** @VueI18nGeneral */
+export declare type PostTranslationHandler<Message = string> = (translated: MessageFunctionReturn<Message>, key: string) => MessageFunctionReturn<Message>;
+
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
+ *
+ * @VueI18nGeneral
+ */
+export declare function registerLocaleFallbacker(fallbacker: LocaleFallbacker): void;
+
+export declare function registerMessageCompiler<Message>(compiler: MessageCompiler<Message, string | ResourceNode>): void;
+
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+export declare function registerMessageResolver(resolver: MessageResolver): void;
+
+export declare type RemoveIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+
+/* Excluded from this release type: resolveLocale */
+
+/**
+ * message resolver
+ *
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+export declare function resolveValue(obj: unknown, path: Path): PathValue;
+
+/**
+ * key-value message resolver
+ *
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+export declare function resolveWithKeyValue(obj: unknown, path: Path): PathValue;
+
+export declare type ResourceFormatPath<T> = _ResourceFormatPath<T> extends string | keyof T ? _ResourceFormatPath<T> : keyof T;
+
+declare type _ResourceFormatPath<T> = __ResourceFormatPath<T, keyof T> | keyof T;
+export { ResourceNode }
+
+export declare type ResourcePath<T> = _ResourcePath<T> extends string | keyof T ? _ResourcePath<T> : keyof T;
+
+export declare type _ResourcePath<T> = __ResourcePath<T, keyof T> | keyof T;
+
+export declare type ResourceValue<T, P extends ResourcePath<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends ResourcePath<T[Key]> ? ResourceValue<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+
+export declare type SchemaParams<T, Message = string> = T extends readonly any[] ? {
+    message: First<T>;
+    datetime: DateTimeFormat;
+    number: NumberFormat;
+} : T extends {
+    message?: infer M;
+    datetime?: infer D;
+    number?: infer N;
+} ? {
+    message: M extends LocaleMessage<Message> ? M : LocaleMessage<Message>;
+    datetime: D extends DateTimeFormat ? D : DateTimeFormat;
+    number: N extends NumberFormat ? N : NumberFormat;
+} : {
+    message: LocaleMessage<Message>;
+    datetime: DateTimeFormat;
+    number: NumberFormat;
+};
+
+export declare const setAdditionalMeta: (meta: MetaInfo | null) => void;
+
+export declare function setDevToolsHook(hook: IntlifyDevToolsEmitter | null): void;
+
+export declare const setFallbackContext: (context: CoreContext | null) => void;
+
+export declare interface SpecificDateTimeFormatOptions extends Intl.DateTimeFormatOptions {
+    year?: DateTimeDigital;
+    month?: DateTimeDigital | DateTimeHumanReadable;
+    day?: DateTimeDigital;
+    hour?: DateTimeDigital;
+    minute?: DateTimeDigital;
+    second?: DateTimeDigital;
+    weekday?: DateTimeHumanReadable;
+    era?: DateTimeHumanReadable;
+    timeZoneName?: 'long' | 'short';
+    localeMatcher?: LocaleMatcher;
+    formatMatcher?: FormatMatcher;
+}
+
+export declare interface SpecificNumberFormatOptions extends Intl.NumberFormatOptions {
+    style?: 'decimal' | 'percent';
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    localeMatcher?: LocaleMatcher;
+    formatMatcher?: FormatMatcher;
+}
+
+declare type StringConvertable<T> = ExtractToStringKey<T> extends never ? unknown : ExtractToStringFunction<T> extends (...args: any) => string ? T : unknown;
+
+/**
+ * `translate` function overloads
+ */
+export declare function translate<Context extends CoreContext<Message>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, plural: number): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, plural: number, options: TranslateOptions<Context['locale']>): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, defaultMsg: string): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, defaultMsg: string, options: TranslateOptions<Context['locale']>): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[]): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[], plural: number): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[], defaultMsg: string): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, list: unknown[], options: TranslateOptions<Context['locale']>): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue, plural: number): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue, defaultMsg: string): MessageFunctionReturn<Message> | number;
+
+export declare function translate<Context extends CoreContext<Message, {}, {}, {}>, Key extends string = string, ResourceKeys extends PickupKeys<Context['messages']> = PickupKeys<Context['messages']>, Message = string>(context: Context, key: Key | ResourceKeys | number | MessageFunction<Message>, named: NamedValue, options: TranslateOptions<Context['locale']>): MessageFunctionReturn<Message> | number;
+
+export declare const translateDevTools: (payloads: IntlifyDevToolsHookPayloads[IntlifyDevToolsHooks]) => void | null;
+
+/**
+ *  # translate
+ *
+ *  ## usages:
+ *    // for example, locale messages key
+ *    { 'foo.bar': 'hi {0} !' or 'hi {name} !' }
+ *
+ *    // no argument, context & path only
+ *    translate(context, 'foo.bar')
+ *
+ *    // list argument
+ *    translate(context, 'foo.bar', ['kazupon'])
+ *
+ *    // named argument
+ *    translate(context, 'foo.bar', { name: 'kazupon' })
+ *
+ *    // plural choice number
+ *    translate(context, 'foo.bar', 2)
+ *
+ *    // plural choice number with name argument
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, 2)
+ *
+ *    // default message argument
+ *    translate(context, 'foo.bar', 'this is default message')
+ *
+ *    // default message with named argument
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, 'Hello {name} !')
+ *
+ *    // use key as default message
+ *    translate(context, 'hi {0} !', ['kazupon'], { default: true })
+ *
+ *    // locale option, override context.locale
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { locale: 'ja' })
+ *
+ *    // suppress localize miss warning option, override context.missingWarn
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { missingWarn: false })
+ *
+ *    // suppress localize fallback warning option, override context.fallbackWarn
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { fallbackWarn: false })
+ *
+ *    // escape parameter option, override context.escapeParameter
+ *    translate(context, 'foo.bar', { name: 'kazupon' }, { escapeParameter: true })
+ */
+/**
+ * Translate Options
+ *
+ * @remarks
+ * Options for Translation API
+ *
+ * @VueI18nGeneral
+ */
+export declare interface TranslateOptions<Locales = Locale> extends LocaleOptions<Locales> {
+    /**
+     * @remarks
+     * List interpolation
+     */
+    list?: unknown[];
+    /**
+     * @remarks
+     * Named interpolation
+     */
+    named?: NamedValue;
+    /**
+     * @remarks
+     * Plulralzation choice number
+     */
+    plural?: number;
+    /**
+     * @remarks
+     * Default message when is occurred translation missing
+     */
+    default?: string | boolean;
+    /**
+     * @remarks
+     * Whether suppress warnings outputted when localization fails
+     */
+    missingWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do template interpolation on translation keys when your language lacks a translation for a key
+     */
+    fallbackWarn?: boolean;
+    /**
+     * @remarks
+     * Whether do escape parameter for list or named interpolation values
+     */
+    escapeParameter?: boolean;
+    /**
+     * @remarks
+     * Whether the message has been resolved
+     */
+    resolvedMessage?: boolean;
+}
+
+export declare type UnionToIntersection<U> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
+
+export declare type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, Last>>, Last];
+
+/* Excluded from this release type: updateFallbackLocale */
+
+/* Excluded from this release type: VERSION */
+
+declare type VueDevToolsEmitter = Emittable<VueDevToolsEmitterEvents>;
+
+declare type VueDevToolsEmitterEvents = {
+    [VueDevToolsTimelineEvents.COMPILE_ERROR]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.COMPILE_ERROR];
+    [VueDevToolsTimelineEvents.MISSING]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MISSING];
+    [VueDevToolsTimelineEvents.FALBACK]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.FALBACK];
+    [VueDevToolsTimelineEvents.MESSAGE_RESOLVE]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MESSAGE_RESOLVE];
+    [VueDevToolsTimelineEvents.MESSAGE_COMPILATION]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MESSAGE_COMPILATION];
+    [VueDevToolsTimelineEvents.MESSAGE_EVALUATION]: VueDevToolsTimelineEventPayloads[VueDevToolsTimelineEvents.MESSAGE_EVALUATION];
+};
+
+declare type VueDevToolsTimelineEventPayloads = {
+    [VueDevToolsTimelineEvents.COMPILE_ERROR]: {
+        message: string;
+        error: string;
+        start?: number;
+        end?: number;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MISSING]: {
+        locale: Locale_2;
+        key: Path_2;
+        type: CoreMissingType_2;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.FALBACK]: {
+        key: Path_2;
+        type: CoreMissingType_2;
+        from?: Locale_2;
+        to: Locale_2 | 'global';
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MESSAGE_RESOLVE]: {
+        type: VueDevToolsTimelineEvents.MESSAGE_RESOLVE;
+        key: Path_2;
+        message: PathValue_2;
+        time: number;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MESSAGE_COMPILATION]: {
+        type: VueDevToolsTimelineEvents.MESSAGE_COMPILATION;
+        message: string | ResourceNode_2 | MessageFunction_2;
+        time: number;
+        groupId?: string;
+    };
+    [VueDevToolsTimelineEvents.MESSAGE_EVALUATION]: {
+        type: VueDevToolsTimelineEvents.MESSAGE_EVALUATION;
+        value: unknown;
+        time: number;
+        groupId?: string;
+    };
+};
+
+declare const enum VueDevToolsTimelineEvents {
+    COMPILE_ERROR = "compile-error",
+    MISSING = "missing",
+    FALBACK = "fallback",
+    MESSAGE_RESOLVE = "message-resolve",
+    MESSAGE_COMPILATION = "message-compilation",
+    MESSAGE_EVALUATION = "message-evaluation"
+}
+
+export { }

node_modules/@intlify/core-base/dist/core-base.esm-browser.js

@@ -0,0 +1,3381 @@
+/*!
+  * core-base v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+{
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        // @ts-ignore browser compat
+        perf.clearMeasures) {
+        mark = (tag) => {
+            perf.mark(tag);
+        };
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format$1(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+const assign = Object.assign;
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => {
+    if (!isObject(val))
+        return false;
+    const proto = Object.getPrototypeOf(val);
+    return proto === null || proto.constructor === Object;
+};
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function incrementer(code) {
+    let current = code;
+    return () => ++current;
+}
+
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const hasWarned = {};
+function warnOnce(msg) {
+    if (!hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+
+function createPosition(line, column, offset) {
+    return { line, column, offset };
+}
+function createLocation(start, end, source) {
+    const loc = { start, end };
+    if (source != null) {
+        loc.source = source;
+    }
+    return loc;
+}
+
+const CompileErrorCodes = {
+    // tokenizer error codes
+    EXPECTED_TOKEN: 1,
+    INVALID_TOKEN_IN_PLACEHOLDER: 2,
+    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+    UNKNOWN_ESCAPE_SEQUENCE: 4,
+    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+    UNBALANCED_CLOSING_BRACE: 6,
+    UNTERMINATED_CLOSING_BRACE: 7,
+    EMPTY_PLACEHOLDER: 8,
+    NOT_ALLOW_NEST_PLACEHOLDER: 9,
+    INVALID_LINKED_FORMAT: 10,
+    // parser error codes
+    MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+    UNEXPECTED_EMPTY_LINKED_KEY: 13,
+    UNEXPECTED_LEXICAL_ANALYSIS: 14,
+    // generator error codes
+    UNHANDLED_CODEGEN_NODE_TYPE: 15,
+    // minifier error codes
+    UNHANDLED_MINIFIER_NODE_TYPE: 16,
+    // Special value for higher-order compilers to pick up the last code
+    // to avoid collision of error codes. This should always be kept as the last
+    // item.
+    __EXTEND_POINT__: 17
+};
+/** @internal */
+const errorMessages$1 = {
+    // tokenizer error messages
+    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+    // parser error messages
+    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+    // generator error messages
+    [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+    // minimizer error messages
+    [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+};
+function createCompileError(code, loc, options = {}) {
+    const { domain, messages, args } = options;
+    const msg = format$1((messages || errorMessages$1)[code] || '', ...(args || []))
+        ;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    if (loc) {
+        error.location = loc;
+    }
+    error.domain = domain;
+    return error;
+}
+/** @internal */
+function defaultOnError(error) {
+    throw error;
+}
+
+const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+const CHAR_SP = ' ';
+const CHAR_CR = '\r';
+const CHAR_LF = '\n';
+const CHAR_LS = String.fromCharCode(0x2028);
+const CHAR_PS = String.fromCharCode(0x2029);
+function createScanner(str) {
+    const _buf = str;
+    let _index = 0;
+    let _line = 1;
+    let _column = 1;
+    let _peekOffset = 0;
+    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+    const isLF = (index) => _buf[index] === CHAR_LF;
+    const isPS = (index) => _buf[index] === CHAR_PS;
+    const isLS = (index) => _buf[index] === CHAR_LS;
+    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+    const index = () => _index;
+    const line = () => _line;
+    const column = () => _column;
+    const peekOffset = () => _peekOffset;
+    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+    const currentChar = () => charAt(_index);
+    const currentPeek = () => charAt(_index + _peekOffset);
+    function next() {
+        _peekOffset = 0;
+        if (isLineEnd(_index)) {
+            _line++;
+            _column = 0;
+        }
+        if (isCRLF(_index)) {
+            _index++;
+        }
+        _index++;
+        _column++;
+        return _buf[_index];
+    }
+    function peek() {
+        if (isCRLF(_index + _peekOffset)) {
+            _peekOffset++;
+        }
+        _peekOffset++;
+        return _buf[_index + _peekOffset];
+    }
+    function reset() {
+        _index = 0;
+        _line = 1;
+        _column = 1;
+        _peekOffset = 0;
+    }
+    function resetPeek(offset = 0) {
+        _peekOffset = offset;
+    }
+    function skipToPeek() {
+        const target = _index + _peekOffset;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (target !== _index) {
+            next();
+        }
+        _peekOffset = 0;
+    }
+    return {
+        index,
+        line,
+        column,
+        peekOffset,
+        charAt,
+        currentChar,
+        currentPeek,
+        next,
+        peek,
+        reset,
+        resetPeek,
+        skipToPeek
+    };
+}
+
+const EOF = undefined;
+const DOT = '.';
+const LITERAL_DELIMITER = "'";
+const ERROR_DOMAIN$3 = 'tokenizer';
+function createTokenizer(source, options = {}) {
+    const location = options.location !== false;
+    const _scnr = createScanner(source);
+    const currentOffset = () => _scnr.index();
+    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+    const _initLoc = currentPosition();
+    const _initOffset = currentOffset();
+    const _context = {
+        currentType: 14 /* TokenTypes.EOF */,
+        offset: _initOffset,
+        startLoc: _initLoc,
+        endLoc: _initLoc,
+        lastType: 14 /* TokenTypes.EOF */,
+        lastOffset: _initOffset,
+        lastStartLoc: _initLoc,
+        lastEndLoc: _initLoc,
+        braceNest: 0,
+        inLinked: false,
+        text: ''
+    };
+    const context = () => _context;
+    const { onError } = options;
+    function emitError(code, pos, offset, ...args) {
+        const ctx = context();
+        pos.column += offset;
+        pos.offset += offset;
+        if (onError) {
+            const loc = location ? createLocation(ctx.startLoc, pos) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$3,
+                args
+            });
+            onError(err);
+        }
+    }
+    function getToken(context, type, value) {
+        context.endLoc = currentPosition();
+        context.currentType = type;
+        const token = { type };
+        if (location) {
+            token.loc = createLocation(context.startLoc, context.endLoc);
+        }
+        if (value != null) {
+            token.value = value;
+        }
+        return token;
+    }
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    function eat(scnr, ch) {
+        if (scnr.currentChar() === ch) {
+            scnr.next();
+            return ch;
+        }
+        else {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+            return '';
+        }
+    }
+    function peekSpaces(scnr) {
+        let buf = '';
+        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+            buf += scnr.currentPeek();
+            scnr.peek();
+        }
+        return buf;
+    }
+    function skipSpaces(scnr) {
+        const buf = peekSpaces(scnr);
+        scnr.skipToPeek();
+        return buf;
+    }
+    function isIdentifierStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return ((cc >= 97 && cc <= 122) || // a-z
+            (cc >= 65 && cc <= 90) || // A-Z
+            cc === 95 // _
+        );
+    }
+    function isNumberStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return cc >= 48 && cc <= 57; // 0-9
+    }
+    function isNamedIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isListIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+        const ret = isNumberStart(ch);
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLiteralStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDotStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedModifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDelimiterStart(scnr, context) {
+        const { currentType } = context;
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedReferStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+            return false;
+        }
+        const fn = () => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return isIdentifierStart(scnr.peek());
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
+                ch === CHAR_SP ||
+                !ch) {
+                return false;
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn();
+            }
+            else {
+                // other characters
+                return isIdentifierStart(ch);
+            }
+        };
+        const ret = fn();
+        scnr.resetPeek();
+        return ret;
+    }
+    function isPluralStart(scnr) {
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function detectModuloStart(scnr) {
+        const spaces = peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
+        scnr.resetPeek();
+        return {
+            isModulo: ret,
+            hasSpace: spaces.length > 0
+        };
+    }
+    function isTextStart(scnr, reset = true) {
+        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                scnr.peek();
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+            }
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                    ? true
+                    : !(prev === CHAR_SP || prev === CHAR_LF);
+            }
+            else if (ch === CHAR_SP) {
+                scnr.peek();
+                return fn(true, CHAR_SP, detectModulo);
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn(true, CHAR_LF, detectModulo);
+            }
+            else {
+                return true;
+            }
+        };
+        const ret = fn();
+        reset && scnr.resetPeek();
+        return ret;
+    }
+    function takeChar(scnr, fn) {
+        const ch = scnr.currentChar();
+        if (ch === EOF) {
+            return EOF;
+        }
+        if (fn(ch)) {
+            scnr.next();
+            return ch;
+        }
+        return null;
+    }
+    function takeIdentifierChar(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 97 && cc <= 122) || // a-z
+                (cc >= 65 && cc <= 90) || // A-Z
+                (cc >= 48 && cc <= 57) || // 0-9
+                cc === 95 || // _
+                cc === 36 // $
+            );
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return cc >= 48 && cc <= 57; // 0-9
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeHexDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 48 && cc <= 57) || // 0-9
+                (cc >= 65 && cc <= 70) || // A-F
+                (cc >= 97 && cc <= 102)); // a-f
+        };
+        return takeChar(scnr, closure);
+    }
+    function getDigits(scnr) {
+        let ch = '';
+        let num = '';
+        while ((ch = takeDigit(scnr))) {
+            num += ch;
+        }
+        return num;
+    }
+    function readModulo(scnr) {
+        skipSpaces(scnr);
+        const ch = scnr.currentChar();
+        if (ch !== "%" /* TokenChars.Modulo */) {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+        }
+        scnr.next();
+        return "%" /* TokenChars.Modulo */;
+    }
+    function readText(scnr) {
+        let buf = '';
+        while (true) {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                !ch) {
+                break;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === CHAR_SP || ch === CHAR_LF) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else if (isPluralStart(scnr)) {
+                    break;
+                }
+                else {
+                    buf += ch;
+                    scnr.next();
+                }
+            }
+            else {
+                buf += ch;
+                scnr.next();
+            }
+        }
+        return buf;
+    }
+    function readNamedIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return name;
+    }
+    function readListIdentifier(scnr) {
+        skipSpaces(scnr);
+        let value = '';
+        if (scnr.currentChar() === '-') {
+            scnr.next();
+            value += `-${getDigits(scnr)}`;
+        }
+        else {
+            value += getDigits(scnr);
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return value;
+    }
+    function readLiteral(scnr) {
+        skipSpaces(scnr);
+        eat(scnr, `\'`);
+        let ch = '';
+        let literal = '';
+        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+        while ((ch = takeChar(scnr, fn))) {
+            if (ch === '\\') {
+                literal += readEscapeSequence(scnr);
+            }
+            else {
+                literal += ch;
+            }
+        }
+        const current = scnr.currentChar();
+        if (current === CHAR_LF || current === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+            // TODO: Is it correct really?
+            if (current === CHAR_LF) {
+                scnr.next();
+                eat(scnr, `\'`);
+            }
+            return literal;
+        }
+        eat(scnr, `\'`);
+        return literal;
+    }
+    function readEscapeSequence(scnr) {
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case '\\':
+            case `\'`:
+                scnr.next();
+                return `\\${ch}`;
+            case 'u':
+                return readUnicodeEscapeSequence(scnr, ch, 4);
+            case 'U':
+                return readUnicodeEscapeSequence(scnr, ch, 6);
+            default:
+                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                return '';
+        }
+    }
+    function readUnicodeEscapeSequence(scnr, unicode, digits) {
+        eat(scnr, unicode);
+        let sequence = '';
+        for (let i = 0; i < digits; i++) {
+            const ch = takeHexDigit(scnr);
+            if (!ch) {
+                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                break;
+            }
+            sequence += ch;
+        }
+        return `\\${unicode}${sequence}`;
+    }
+    function readInvalidIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let identifiers = '';
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
+            ch !== CHAR_SP &&
+            ch !== CHAR_LF;
+        while ((ch = takeChar(scnr, closure))) {
+            identifiers += ch;
+        }
+        return identifiers;
+    }
+    function readLinkedModifier(scnr) {
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        return name;
+    }
+    function readLinkedRefer(scnr) {
+        const fn = (detect = false, buf) => {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === "(" /* TokenChars.ParenLeft */ ||
+                ch === ")" /* TokenChars.ParenRight */ ||
+                !ch) {
+                return buf;
+            }
+            else if (ch === CHAR_SP) {
+                return buf;
+            }
+            else if (ch === CHAR_LF || ch === DOT) {
+                buf += ch;
+                scnr.next();
+                return fn(detect, buf);
+            }
+            else {
+                buf += ch;
+                scnr.next();
+                return fn(true, buf);
+            }
+        };
+        return fn(false, '');
+    }
+    function readPlural(scnr) {
+        skipSpaces(scnr);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+        skipSpaces(scnr);
+        return plural;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInPlaceholder(scnr, context) {
+        let token = null;
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                if (context.braceNest >= 1) {
+                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                skipSpaces(scnr);
+                context.braceNest++;
+                return token;
+            case "}" /* TokenChars.BraceRight */:
+                if (context.braceNest > 0 &&
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                context.braceNest--;
+                context.braceNest > 0 && skipSpaces(scnr);
+                if (context.inLinked && context.braceNest === 0) {
+                    context.inLinked = false;
+                }
+                return token;
+            case "@" /* TokenChars.LinkedAlias */:
+                if (context.braceNest > 0) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                }
+                token = readTokenInLinked(scnr, context) || getEndToken(context);
+                context.braceNest = 0;
+                return token;
+            default:
+                let validNamedIdentifier = true;
+                let validListIdentifier = true;
+                let validLiteral = true;
+                if (isPluralStart(scnr)) {
+                    if (context.braceNest > 0) {
+                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    }
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (context.braceNest > 0 &&
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    context.braceNest = 0;
+                    return readToken(scnr, context);
+                }
+                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validLiteral = isLiteralStart(scnr, context))) {
+                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                    skipSpaces(scnr);
+                    return token;
+                }
+                break;
+        }
+        return token;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInLinked(scnr, context) {
+        const { currentType } = context;
+        let token = null;
+        const ch = scnr.currentChar();
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+            (ch === CHAR_LF || ch === CHAR_SP)) {
+            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+        }
+        switch (ch) {
+            case "@" /* TokenChars.LinkedAlias */:
+                scnr.next();
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                context.inLinked = true;
+                return token;
+            case "." /* TokenChars.LinkedDot */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (isLinkedDotStart(scnr, context) ||
+                    isLinkedDelimiterStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return readTokenInLinked(scnr, context);
+                }
+                if (isLinkedModifierStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                }
+                if (isLinkedReferStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
+                        // scan the placeholder
+                        return readTokenInPlaceholder(scnr, context) || token;
+                    }
+                    else {
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                    }
+                }
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                }
+                context.braceNest = 0;
+                context.inLinked = false;
+                return readToken(scnr, context);
+        }
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readToken(scnr, context) {
+        let token = { type: 14 /* TokenTypes.EOF */ };
+        if (context.braceNest > 0) {
+            return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+        }
+        if (context.inLinked) {
+            return readTokenInLinked(scnr, context) || getEndToken(context);
+        }
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+            case "}" /* TokenChars.BraceRight */:
+                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                scnr.next();
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
+                return readTokenInLinked(scnr, context) || getEndToken(context);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                const { isModulo, hasSpace } = detectModuloStart(scnr);
+                if (isModulo) {
+                    return hasSpace
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                }
+                if (isTextStart(scnr)) {
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                }
+                break;
+        }
+        return token;
+    }
+    function nextToken() {
+        const { currentType, offset, startLoc, endLoc } = _context;
+        _context.lastType = currentType;
+        _context.lastOffset = offset;
+        _context.lastStartLoc = startLoc;
+        _context.lastEndLoc = endLoc;
+        _context.offset = currentOffset();
+        _context.startLoc = currentPosition();
+        if (_scnr.currentChar() === EOF) {
+            return getToken(_context, 14 /* TokenTypes.EOF */);
+        }
+        return readToken(_scnr, _context);
+    }
+    return {
+        nextToken,
+        currentOffset,
+        currentPosition,
+        context
+    };
+}
+
+const ERROR_DOMAIN$2 = 'parser';
+// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+function fromEscapeSequence(match, codePoint4, codePoint6) {
+    switch (match) {
+        case `\\\\`:
+            return `\\`;
+        case `\\\'`:
+            return `\'`;
+        default: {
+            const codePoint = parseInt(codePoint4 || codePoint6, 16);
+            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                return String.fromCodePoint(codePoint);
+            }
+            // invalid ...
+            // Replace them with U+FFFD REPLACEMENT CHARACTER.
+            return '�';
+        }
+    }
+}
+function createParser(options = {}) {
+    const location = options.location !== false;
+    const { onError } = options;
+    function emitError(tokenzer, code, start, offset, ...args) {
+        const end = tokenzer.currentPosition();
+        end.offset += offset;
+        end.column += offset;
+        if (onError) {
+            const loc = location ? createLocation(start, end) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$2,
+                args
+            });
+            onError(err);
+        }
+    }
+    function startNode(type, offset, loc) {
+        const node = { type };
+        if (location) {
+            node.start = offset;
+            node.end = offset;
+            node.loc = { start: loc, end: loc };
+        }
+        return node;
+    }
+    function endNode(node, offset, pos, type) {
+        if (type) {
+            node.type = type;
+        }
+        if (location) {
+            node.end = offset;
+            if (node.loc) {
+                node.loc.end = pos;
+            }
+        }
+    }
+    function parseText(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseList(tokenizer, index) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
+        node.index = parseInt(index, 10);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseNamed(tokenizer, key) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+        node.key = key;
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLiteral(tokenizer, value) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinkedModifier(tokenizer) {
+        const token = tokenizer.nextToken();
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+            // empty modifier
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+            node.value = '';
+            endNode(node, offset, loc);
+            return {
+                nextConsumeToken: token,
+                node
+            };
+        }
+        // check token
+        if (token.value == null) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        node.value = token.value || '';
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node
+        };
+    }
+    function parseLinkedKey(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinked(tokenizer) {
+        const context = tokenizer.context();
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+        let token = tokenizer.nextToken();
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+            const parsed = parseLinkedModifier(tokenizer);
+            linkedNode.modifier = parsed.node;
+            token = parsed.nextConsumeToken || tokenizer.nextToken();
+        }
+        // asset check token
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        token = tokenizer.nextToken();
+        // skip brace left
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
+            token = tokenizer.nextToken();
+        }
+        switch (token.type) {
+            case 11 /* TokenTypes.LinkedKey */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                break;
+            case 5 /* TokenTypes.Named */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseNamed(tokenizer, token.value || '');
+                break;
+            case 6 /* TokenTypes.List */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseList(tokenizer, token.value || '');
+                break;
+            case 7 /* TokenTypes.Literal */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                break;
+            default:
+                // empty key
+                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                const nextContext = tokenizer.context();
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                emptyLinkedKeyNode.value = '';
+                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                linkedNode.key = emptyLinkedKeyNode;
+                endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                return {
+                    nextConsumeToken: token,
+                    node: linkedNode
+                };
+        }
+        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node: linkedNode
+        };
+    }
+    function parseMessage(tokenizer) {
+        const context = tokenizer.context();
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? tokenizer.currentOffset()
+            : context.offset;
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.endLoc
+            : context.startLoc;
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+        node.items = [];
+        let nextToken = null;
+        do {
+            const token = nextToken || tokenizer.nextToken();
+            nextToken = null;
+            switch (token.type) {
+                case 0 /* TokenTypes.Text */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseText(tokenizer, token.value || ''));
+                    break;
+                case 6 /* TokenTypes.List */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseList(tokenizer, token.value || ''));
+                    break;
+                case 5 /* TokenTypes.Named */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
+                    break;
+                case 7 /* TokenTypes.Literal */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseLiteral(tokenizer, token.value || ''));
+                    break;
+                case 8 /* TokenTypes.LinkedAlias */:
+                    const parsed = parseLinked(tokenizer);
+                    node.items.push(parsed.node);
+                    nextToken = parsed.nextConsumeToken || null;
+                    break;
+            }
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
+        // adjust message node loc
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastOffset
+            : tokenizer.currentOffset();
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastEndLoc
+            : tokenizer.currentPosition();
+        endNode(node, endOffset, endLoc);
+        return node;
+    }
+    function parsePlural(tokenizer, offset, loc, msgNode) {
+        const context = tokenizer.context();
+        let hasEmptyMessage = msgNode.items.length === 0;
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+        node.cases = [];
+        node.cases.push(msgNode);
+        do {
+            const msg = parseMessage(tokenizer);
+            if (!hasEmptyMessage) {
+                hasEmptyMessage = msg.items.length === 0;
+            }
+            node.cases.push(msg);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        if (hasEmptyMessage) {
+            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseResource(tokenizer) {
+        const context = tokenizer.context();
+        const { offset, startLoc } = context;
+        const msgNode = parseMessage(tokenizer);
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
+            return msgNode;
+        }
+        else {
+            return parsePlural(tokenizer, offset, startLoc, msgNode);
+        }
+    }
+    function parse(source) {
+        const tokenizer = createTokenizer(source, assign({}, options));
+        const context = tokenizer.context();
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+        if (location && node.loc) {
+            node.loc.source = source;
+        }
+        node.body = parseResource(tokenizer);
+        if (options.onCacheKey) {
+            node.cacheKey = options.onCacheKey(source);
+        }
+        // assert whether achieved to EOF
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    return { parse };
+}
+function getTokenCaption(token) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
+        return 'EOF';
+    }
+    const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+    return name.length > 10 ? name.slice(0, 9) + '…' : name;
+}
+
+function createTransformer(ast, options = {} // eslint-disable-line
+) {
+    const _context = {
+        ast,
+        helpers: new Set()
+    };
+    const context = () => _context;
+    const helper = (name) => {
+        _context.helpers.add(name);
+        return name;
+    };
+    return { context, helper };
+}
+function traverseNodes(nodes, transformer) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], transformer);
+    }
+}
+function traverseNode(node, transformer) {
+    // TODO: if we need pre-hook of transform, should be implemented to here
+    switch (node.type) {
+        case 1 /* NodeTypes.Plural */:
+            traverseNodes(node.cases, transformer);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
+            break;
+        case 2 /* NodeTypes.Message */:
+            traverseNodes(node.items, transformer);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            traverseNode(linked.key, transformer);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
+            break;
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
+            break;
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
+            break;
+    }
+    // TODO: if we need post-hook of transform, should be implemented to here
+}
+// transform AST
+function transform(ast, options = {} // eslint-disable-line
+) {
+    const transformer = createTransformer(ast);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+    // traverse
+    ast.body && traverseNode(ast.body, transformer);
+    // set meta information
+    const context = transformer.context();
+    ast.helpers = Array.from(context.helpers);
+}
+
+function optimize(ast) {
+    const body = ast.body;
+    if (body.type === 2 /* NodeTypes.Message */) {
+        optimizeMessageNode(body);
+    }
+    else {
+        body.cases.forEach(c => optimizeMessageNode(c));
+    }
+    return ast;
+}
+function optimizeMessageNode(message) {
+    if (message.items.length === 1) {
+        const item = message.items[0];
+        if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+            message.static = item.value;
+            delete item.value; // optimization for size
+        }
+    }
+    else {
+        const values = [];
+        for (let i = 0; i < message.items.length; i++) {
+            const item = message.items[i];
+            if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                break;
+            }
+            if (item.value == null) {
+                break;
+            }
+            values.push(item.value);
+        }
+        if (values.length === message.items.length) {
+            message.static = join(values);
+            for (let i = 0; i < message.items.length; i++) {
+                const item = message.items[i];
+                if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                    delete item.value; // optimization for size
+                }
+            }
+        }
+    }
+}
+
+const ERROR_DOMAIN$1 = 'minifier';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function minify(node) {
+    node.t = node.type;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            const resource = node;
+            minify(resource.body);
+            resource.b = resource.body;
+            delete resource.body;
+            break;
+        case 1 /* NodeTypes.Plural */:
+            const plural = node;
+            const cases = plural.cases;
+            for (let i = 0; i < cases.length; i++) {
+                minify(cases[i]);
+            }
+            plural.c = cases;
+            delete plural.cases;
+            break;
+        case 2 /* NodeTypes.Message */:
+            const message = node;
+            const items = message.items;
+            for (let i = 0; i < items.length; i++) {
+                minify(items[i]);
+            }
+            message.i = items;
+            delete message.items;
+            if (message.static) {
+                message.s = message.static;
+                delete message.static;
+            }
+            break;
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            const valueNode = node;
+            if (valueNode.value) {
+                valueNode.v = valueNode.value;
+                delete valueNode.value;
+            }
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            minify(linked.key);
+            linked.k = linked.key;
+            delete linked.key;
+            if (linked.modifier) {
+                minify(linked.modifier);
+                linked.m = linked.modifier;
+                delete linked.modifier;
+            }
+            break;
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            list.i = list.index;
+            delete list.index;
+            break;
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            named.k = named.key;
+            delete named.key;
+            break;
+        default:
+            {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN$1,
+                    args: [node.type]
+                });
+            }
+    }
+    delete node.type;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const ERROR_DOMAIN = 'parser';
+function createCodeGenerator(ast, options) {
+    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+    const location = options.location !== false;
+    const _context = {
+        filename,
+        code: '',
+        column: 1,
+        line: 1,
+        offset: 0,
+        map: undefined,
+        breakLineCode,
+        needIndent: _needIndent,
+        indentLevel: 0
+    };
+    if (location && ast.loc) {
+        _context.source = ast.loc.source;
+    }
+    const context = () => _context;
+    function push(code, node) {
+        _context.code += code;
+    }
+    function _newline(n, withBreakLine = true) {
+        const _breakLineCode = withBreakLine ? breakLineCode : '';
+        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+    }
+    function indent(withNewLine = true) {
+        const level = ++_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function deindent(withNewLine = true) {
+        const level = --_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function newline() {
+        _newline(_context.indentLevel);
+    }
+    const helper = (key) => `_${key}`;
+    const needIndent = () => _context.needIndent;
+    return {
+        context,
+        push,
+        indent,
+        deindent,
+        newline,
+        helper,
+        needIndent
+    };
+}
+function generateLinkedNode(generator, node) {
+    const { helper } = generator;
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+    generateNode(generator, node.key);
+    if (node.modifier) {
+        generator.push(`, `);
+        generateNode(generator, node.modifier);
+        generator.push(`, _type`);
+    }
+    else {
+        generator.push(`, undefined, _type`);
+    }
+    generator.push(`)`);
+}
+function generateMessageNode(generator, node) {
+    const { helper, needIndent } = generator;
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+    generator.indent(needIndent());
+    const length = node.items.length;
+    for (let i = 0; i < length; i++) {
+        generateNode(generator, node.items[i]);
+        if (i === length - 1) {
+            break;
+        }
+        generator.push(', ');
+    }
+    generator.deindent(needIndent());
+    generator.push('])');
+}
+function generatePluralNode(generator, node) {
+    const { helper, needIndent } = generator;
+    if (node.cases.length > 1) {
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+        generator.indent(needIndent());
+        const length = node.cases.length;
+        for (let i = 0; i < length; i++) {
+            generateNode(generator, node.cases[i]);
+            if (i === length - 1) {
+                break;
+            }
+            generator.push(', ');
+        }
+        generator.deindent(needIndent());
+        generator.push(`])`);
+    }
+}
+function generateResource(generator, node) {
+    if (node.body) {
+        generateNode(generator, node.body);
+    }
+    else {
+        generator.push('null');
+    }
+}
+function generateNode(generator, node) {
+    const { helper } = generator;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            generateResource(generator, node);
+            break;
+        case 1 /* NodeTypes.Plural */:
+            generatePluralNode(generator, node);
+            break;
+        case 2 /* NodeTypes.Message */:
+            generateMessageNode(generator, node);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            generateLinkedNode(generator, node);
+            break;
+        case 8 /* NodeTypes.LinkedModifier */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 7 /* NodeTypes.LinkedKey */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+            break;
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+            break;
+        case 9 /* NodeTypes.Literal */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 3 /* NodeTypes.Text */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        default:
+            {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN,
+                    args: [node.type]
+                });
+            }
+    }
+}
+// generate code from AST
+const generate = (ast, options = {} // eslint-disable-line
+) => {
+    const mode = isString(options.mode) ? options.mode : 'normal';
+    const filename = isString(options.filename)
+        ? options.filename
+        : 'message.intl';
+    const sourceMap = !!options.sourceMap;
+    // prettier-ignore
+    const breakLineCode = options.breakLineCode != null
+        ? options.breakLineCode
+        : mode === 'arrow'
+            ? ';'
+            : '\n';
+    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+    const helpers = ast.helpers || [];
+    const generator = createCodeGenerator(ast, {
+        mode,
+        filename,
+        sourceMap,
+        breakLineCode,
+        needIndent
+    });
+    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+    generator.indent(needIndent);
+    if (helpers.length > 0) {
+        generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+        generator.newline();
+    }
+    generator.push(`return `);
+    generateNode(generator, ast);
+    generator.deindent(needIndent);
+    generator.push(`}`);
+    delete ast.helpers;
+    const { code, map } = generator.context();
+    return {
+        ast,
+        code,
+        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+    };
+};
+
+function baseCompile$1(source, options = {}) {
+    const assignedOptions = assign({}, options);
+    const jit = !!assignedOptions.jit;
+    const enalbeMinify = !!assignedOptions.minify;
+    const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+    // parse source codes
+    const parser = createParser(assignedOptions);
+    const ast = parser.parse(source);
+    if (!jit) {
+        // transform ASTs
+        transform(ast, assignedOptions);
+        // generate javascript codes
+        return generate(ast, assignedOptions);
+    }
+    else {
+        // optimize ASTs
+        enambeOptimize && optimize(ast);
+        // minimize ASTs
+        enalbeMinify && minify(ast);
+        // In JIT mode, no ast transform, no code generation.
+        return { ast, code: '' };
+    }
+}
+
+const pathStateMachine =  [];
+pathStateMachine[0 /* States.BEFORE_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[1 /* States.IN_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[3 /* States.IN_IDENT */] = {
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
+};
+pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+        4 /* States.IN_SUB_PATH */,
+        2 /* Actions.INC_SUB_PATH_DEPTH */
+    ],
+    ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+/**
+ * Check if an expression is a literal value.
+ */
+const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+function isLiteral(exp) {
+    return literalValueRE.test(exp);
+}
+/**
+ * Strip quotes from a string
+ */
+function stripQuotes(str) {
+    const a = str.charCodeAt(0);
+    const b = str.charCodeAt(str.length - 1);
+    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+}
+/**
+ * Determine the type of a character in a keypath.
+ */
+function getPathCharType(ch) {
+    if (ch === undefined || ch === null) {
+        return "o" /* PathCharTypes.END_OF_FAIL */;
+    }
+    const code = ch.charCodeAt(0);
+    switch (code) {
+        case 0x5b: // [
+        case 0x5d: // ]
+        case 0x2e: // .
+        case 0x22: // "
+        case 0x27: // '
+            return ch;
+        case 0x5f: // _
+        case 0x24: // $
+        case 0x2d: // -
+            return "i" /* PathCharTypes.IDENT */;
+        case 0x09: // Tab (HT)
+        case 0x0a: // Newline (LF)
+        case 0x0d: // Return (CR)
+        case 0xa0: // No-break space (NBSP)
+        case 0xfeff: // Byte Order Mark (BOM)
+        case 0x2028: // Line Separator (LS)
+        case 0x2029: // Paragraph Separator (PS)
+            return "w" /* PathCharTypes.WORKSPACE */;
+    }
+    return "i" /* PathCharTypes.IDENT */;
+}
+/**
+ * Format a subPath, return its plain form if it is
+ * a literal string or number. Otherwise prepend the
+ * dynamic indicator (*).
+ */
+function formatSubPath(path) {
+    const trimmed = path.trim();
+    // invalid leading 0
+    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+        return false;
+    }
+    return isLiteral(trimmed)
+        ? stripQuotes(trimmed)
+        : "*" /* PathCharTypes.ASTARISK */ + trimmed;
+}
+/**
+ * Parse a string path into an array of segments
+ */
+function parse(path) {
+    const keys = [];
+    let index = -1;
+    let mode = 0 /* States.BEFORE_PATH */;
+    let subPathDepth = 0;
+    let c;
+    let key; // eslint-disable-line
+    let newChar;
+    let type;
+    let transition;
+    let action;
+    let typeMap;
+    const actions = [];
+    actions[0 /* Actions.APPEND */] = () => {
+        if (key === undefined) {
+            key = newChar;
+        }
+        else {
+            key += newChar;
+        }
+    };
+    actions[1 /* Actions.PUSH */] = () => {
+        if (key !== undefined) {
+            keys.push(key);
+            key = undefined;
+        }
+    };
+    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+        actions[0 /* Actions.APPEND */]();
+        subPathDepth++;
+    };
+    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
+        if (subPathDepth > 0) {
+            subPathDepth--;
+            mode = 4 /* States.IN_SUB_PATH */;
+            actions[0 /* Actions.APPEND */]();
+        }
+        else {
+            subPathDepth = 0;
+            if (key === undefined) {
+                return false;
+            }
+            key = formatSubPath(key);
+            if (key === false) {
+                return false;
+            }
+            else {
+                actions[1 /* Actions.PUSH */]();
+            }
+        }
+    };
+    function maybeUnescapeQuote() {
+        const nextChar = path[index + 1];
+        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+            nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
+            index++;
+            newChar = '\\' + nextChar;
+            actions[0 /* Actions.APPEND */]();
+            return true;
+        }
+    }
+    while (mode !== null) {
+        index++;
+        c = path[index];
+        if (c === '\\' && maybeUnescapeQuote()) {
+            continue;
+        }
+        type = getPathCharType(c);
+        typeMap = pathStateMachine[mode];
+        transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
+        // check parse error
+        if (transition === 8 /* States.ERROR */) {
+            return;
+        }
+        mode = transition[0];
+        if (transition[1] !== undefined) {
+            action = actions[transition[1]];
+            if (action) {
+                newChar = c;
+                if (action() === false) {
+                    return;
+                }
+            }
+        }
+        // check parse finish
+        if (mode === 7 /* States.AFTER_PATH */) {
+            return keys;
+        }
+    }
+}
+// path token cache
+const cache = new Map();
+/**
+ * key-value message resolver
+ *
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveWithKeyValue(obj, path) {
+    return isObject(obj) ? obj[path] : null;
+}
+/**
+ * message resolver
+ *
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveValue(obj, path) {
+    // check object
+    if (!isObject(obj)) {
+        return null;
+    }
+    // parse path
+    let hit = cache.get(path);
+    if (!hit) {
+        hit = parse(path);
+        if (hit) {
+            cache.set(path, hit);
+        }
+    }
+    // check hit
+    if (!hit) {
+        return null;
+    }
+    // resolve path value
+    const len = hit.length;
+    let last = obj;
+    let i = 0;
+    while (i < len) {
+        const val = last[hit[i]];
+        if (val === undefined) {
+            return null;
+        }
+        last = val;
+        i++;
+    }
+    return last;
+}
+
+const DEFAULT_MODIFIER = (str) => str;
+const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : join(values);
+const DEFAULT_INTERPOLATE = toDisplayString;
+function pluralDefault(choice, choicesLength) {
+    choice = Math.abs(choice);
+    if (choicesLength === 2) {
+        // prettier-ignore
+        return choice
+            ? choice > 1
+                ? 1
+                : 0
+            : 1;
+    }
+    return choice ? Math.min(choice, 2) : 0;
+}
+function getPluralIndex(options) {
+    // prettier-ignore
+    const index = isNumber(options.pluralIndex)
+        ? options.pluralIndex
+        : -1;
+    // prettier-ignore
+    return options.named && (isNumber(options.named.count) || isNumber(options.named.n))
+        ? isNumber(options.named.count)
+            ? options.named.count
+            : isNumber(options.named.n)
+                ? options.named.n
+                : index
+        : index;
+}
+function normalizeNamed(pluralIndex, props) {
+    if (!props.count) {
+        props.count = pluralIndex;
+    }
+    if (!props.n) {
+        props.n = pluralIndex;
+    }
+}
+function createMessageContext(options = {}) {
+    const locale = options.locale;
+    const pluralIndex = getPluralIndex(options);
+    const pluralRule = isObject(options.pluralRules) &&
+        isString(locale) &&
+        isFunction(options.pluralRules[locale])
+        ? options.pluralRules[locale]
+        : pluralDefault;
+    const orgPluralRule = isObject(options.pluralRules) &&
+        isString(locale) &&
+        isFunction(options.pluralRules[locale])
+        ? pluralDefault
+        : undefined;
+    const plural = (messages) => {
+        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+    };
+    const _list = options.list || [];
+    const list = (index) => _list[index];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _named = options.named || {};
+    isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+    const named = (key) => _named[key];
+    function message(key) {
+        // prettier-ignore
+        const msg = isFunction(options.messages)
+            ? options.messages(key)
+            : isObject(options.messages)
+                ? options.messages[key]
+                : false;
+        return !msg
+            ? options.parent
+                ? options.parent.message(key) // resolve from parent messages
+                : DEFAULT_MESSAGE
+            : msg;
+    }
+    const _modifier = (name) => options.modifiers
+        ? options.modifiers[name]
+        : DEFAULT_MODIFIER;
+    const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize)
+        ? options.processor.normalize
+        : DEFAULT_NORMALIZE;
+    const interpolate = isPlainObject(options.processor) &&
+        isFunction(options.processor.interpolate)
+        ? options.processor.interpolate
+        : DEFAULT_INTERPOLATE;
+    const type = isPlainObject(options.processor) && isString(options.processor.type)
+        ? options.processor.type
+        : DEFAULT_MESSAGE_DATA_TYPE;
+    const linked = (key, ...args) => {
+        const [arg1, arg2] = args;
+        let type = 'text';
+        let modifier = '';
+        if (args.length === 1) {
+            if (isObject(arg1)) {
+                modifier = arg1.modifier || modifier;
+                type = arg1.type || type;
+            }
+            else if (isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+        }
+        else if (args.length === 2) {
+            if (isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+            if (isString(arg2)) {
+                type = arg2 || type;
+            }
+        }
+        const ret = message(key)(ctx);
+        const msg = 
+        // The message in vnode resolved with linked are returned as an array by processor.nomalize
+        type === 'vnode' && isArray(ret) && modifier
+            ? ret[0]
+            : ret;
+        return modifier ? _modifier(modifier)(msg, type) : msg;
+    };
+    const ctx = {
+        ["list" /* HelperNameMap.LIST */]: list,
+        ["named" /* HelperNameMap.NAMED */]: named,
+        ["plural" /* HelperNameMap.PLURAL */]: plural,
+        ["linked" /* HelperNameMap.LINKED */]: linked,
+        ["message" /* HelperNameMap.MESSAGE */]: message,
+        ["type" /* HelperNameMap.TYPE */]: type,
+        ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+        ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
+        ["values" /* HelperNameMap.VALUES */]: assign({}, _list, _named)
+    };
+    return ctx;
+}
+
+let devtools = null;
+function setDevToolsHook(hook) {
+    devtools = hook;
+}
+function getDevToolsHook() {
+    return devtools;
+}
+function initI18nDevTools(i18n, version, meta) {
+    // TODO: queue if devtools is undefined
+    devtools &&
+        devtools.emit("i18n:init" /* IntlifyDevToolsHooks.I18nInit */, {
+            timestamp: Date.now(),
+            i18n,
+            version,
+            meta
+        });
+}
+const translateDevTools = /* #__PURE__*/ createDevToolsHook("function:translate" /* IntlifyDevToolsHooks.FunctionTranslate */);
+function createDevToolsHook(hook) {
+    return (payloads) => devtools && devtools.emit(hook, payloads);
+}
+
+const CoreWarnCodes = {
+    NOT_FOUND_KEY: 1,
+    FALLBACK_TO_TRANSLATE: 2,
+    CANNOT_FORMAT_NUMBER: 3,
+    FALLBACK_TO_NUMBER_FORMAT: 4,
+    CANNOT_FORMAT_DATE: 5,
+    FALLBACK_TO_DATE_FORMAT: 6,
+    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7,
+    __EXTEND_POINT__: 8
+};
+/** @internal */
+const warnMessages = {
+    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`
+};
+function getWarnMessage(code, ...args) {
+    return format$1(warnMessages[code], ...args);
+}
+
+/** @internal */
+function getLocale(context, options) {
+    return options.locale != null
+        ? resolveLocale(options.locale)
+        : resolveLocale(context.locale);
+}
+let _resolveLocale;
+/** @internal */
+function resolveLocale(locale) {
+    // prettier-ignore
+    return isString(locale)
+        ? locale
+        : _resolveLocale != null && locale.resolvedOnce
+            ? _resolveLocale
+            : (_resolveLocale = locale());
+}
+/**
+ * Fallback with simple implemenation
+ *
+ * @remarks
+ * A fallback locale function implemented with a simple fallback algorithm.
+ *
+ * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
+    // prettier-ignore
+    return [...new Set([
+            start,
+            ...(isArray(fallback)
+                ? fallback
+                : isObject(fallback)
+                    ? Object.keys(fallback)
+                    : isString(fallback)
+                        ? [fallback]
+                        : [start])
+        ])];
+}
+/**
+ * Fallback with locale chain
+ *
+ * @remarks
+ * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithLocaleChain(ctx, fallback, start) {
+    const startLocale = isString(start) ? start : DEFAULT_LOCALE;
+    const context = ctx;
+    if (!context.__localeChainCache) {
+        context.__localeChainCache = new Map();
+    }
+    let chain = context.__localeChainCache.get(startLocale);
+    if (!chain) {
+        chain = [];
+        // first block defined by start
+        let block = [start];
+        // while any intervening block found
+        while (isArray(block)) {
+            block = appendBlockToChain(chain, block, fallback);
+        }
+        // prettier-ignore
+        // last block defined by default
+        const defaults = isArray(fallback) || !isPlainObject(fallback)
+            ? fallback
+            : fallback['default']
+                ? fallback['default']
+                : null;
+        // convert defaults to array
+        block = isString(defaults) ? [defaults] : defaults;
+        if (isArray(block)) {
+            appendBlockToChain(chain, block, false);
+        }
+        context.__localeChainCache.set(startLocale, chain);
+    }
+    return chain;
+}
+function appendBlockToChain(chain, block, blocks) {
+    let follow = true;
+    for (let i = 0; i < block.length && isBoolean(follow); i++) {
+        const locale = block[i];
+        if (isString(locale)) {
+            follow = appendLocaleToChain(chain, block[i], blocks);
+        }
+    }
+    return follow;
+}
+function appendLocaleToChain(chain, locale, blocks) {
+    let follow;
+    const tokens = locale.split('-');
+    do {
+        const target = tokens.join('-');
+        follow = appendItemToChain(chain, target, blocks);
+        tokens.splice(-1, 1);
+    } while (tokens.length && follow === true);
+    return follow;
+}
+function appendItemToChain(chain, target, blocks) {
+    let follow = false;
+    if (!chain.includes(target)) {
+        follow = true;
+        if (target) {
+            follow = target[target.length - 1] !== '!';
+            const locale = target.replace(/!/g, '');
+            chain.push(locale);
+            if ((isArray(blocks) || isPlainObject(blocks)) &&
+                blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any
+            ) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                follow = blocks[locale];
+            }
+        }
+    }
+    return follow;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Intlify core-base version
+ * @internal
+ */
+const VERSION = '9.5.0';
+const NOT_REOSLVED = -1;
+const DEFAULT_LOCALE = 'en-US';
+const MISSING_RESOLVE_VALUE = '';
+const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+function getDefaultLinkedModifiers() {
+    return {
+        upper: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && isString(val)
+                ? val.toUpperCase()
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? val.children.toUpperCase()
+                    : val;
+        },
+        lower: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && isString(val)
+                ? val.toLowerCase()
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? val.children.toLowerCase()
+                    : val;
+        },
+        capitalize: (val, type) => {
+            // prettier-ignore
+            return (type === 'text' && isString(val)
+                ? capitalize(val)
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? capitalize(val.children)
+                    : val);
+        }
+    };
+}
+let _compiler;
+function registerMessageCompiler(compiler) {
+    _compiler = compiler;
+}
+let _resolver;
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+function registerMessageResolver(resolver) {
+    _resolver = resolver;
+}
+let _fallbacker;
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
+ *
+ * @VueI18nGeneral
+ */
+function registerLocaleFallbacker(fallbacker) {
+    _fallbacker = fallbacker;
+}
+// Additional Meta for Intlify DevTools
+let _additionalMeta =  null;
+const setAdditionalMeta = /* #__PURE__*/ (meta) => {
+    _additionalMeta = meta;
+};
+const getAdditionalMeta = /* #__PURE__*/ () => _additionalMeta;
+let _fallbackContext = null;
+const setFallbackContext = (context) => {
+    _fallbackContext = context;
+};
+const getFallbackContext = () => _fallbackContext;
+// ID for CoreContext
+let _cid = 0;
+function createCoreContext(options = {}) {
+    // setup options
+    const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;
+    const version = isString(options.version) ? options.version : VERSION;
+    const locale = isString(options.locale) || isFunction(options.locale)
+        ? options.locale
+        : DEFAULT_LOCALE;
+    const _locale = isFunction(locale) ? DEFAULT_LOCALE : locale;
+    const fallbackLocale = isArray(options.fallbackLocale) ||
+        isPlainObject(options.fallbackLocale) ||
+        isString(options.fallbackLocale) ||
+        options.fallbackLocale === false
+        ? options.fallbackLocale
+        : _locale;
+    const messages = isPlainObject(options.messages)
+        ? options.messages
+        : { [_locale]: {} };
+    const datetimeFormats = isPlainObject(options.datetimeFormats)
+            ? options.datetimeFormats
+            : { [_locale]: {} }
+        ;
+    const numberFormats = isPlainObject(options.numberFormats)
+            ? options.numberFormats
+            : { [_locale]: {} }
+        ;
+    const modifiers = assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
+    const pluralRules = options.pluralRules || {};
+    const missing = isFunction(options.missing) ? options.missing : null;
+    const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+        ? options.missingWarn
+        : true;
+    const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+        ? options.fallbackWarn
+        : true;
+    const fallbackFormat = !!options.fallbackFormat;
+    const unresolving = !!options.unresolving;
+    const postTranslation = isFunction(options.postTranslation)
+        ? options.postTranslation
+        : null;
+    const processor = isPlainObject(options.processor) ? options.processor : null;
+    const warnHtmlMessage = isBoolean(options.warnHtmlMessage)
+        ? options.warnHtmlMessage
+        : true;
+    const escapeParameter = !!options.escapeParameter;
+    const messageCompiler = isFunction(options.messageCompiler)
+        ? options.messageCompiler
+        : _compiler;
+    if (isFunction(options.messageCompiler)) {
+        warnOnce(getWarnMessage(CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER));
+    }
+    const messageResolver = isFunction(options.messageResolver)
+        ? options.messageResolver
+        : _resolver || resolveWithKeyValue;
+    const localeFallbacker = isFunction(options.localeFallbacker)
+        ? options.localeFallbacker
+        : _fallbacker || fallbackWithSimple;
+    const fallbackContext = isObject(options.fallbackContext)
+        ? options.fallbackContext
+        : undefined;
+    // setup internal options
+    const internalOptions = options;
+    const __datetimeFormatters = isObject(internalOptions.__datetimeFormatters)
+            ? internalOptions.__datetimeFormatters
+            : new Map()
+        ;
+    const __numberFormatters = isObject(internalOptions.__numberFormatters)
+            ? internalOptions.__numberFormatters
+            : new Map()
+        ;
+    const __meta = isObject(internalOptions.__meta) ? internalOptions.__meta : {};
+    _cid++;
+    const context = {
+        version,
+        cid: _cid,
+        locale,
+        fallbackLocale,
+        messages,
+        modifiers,
+        pluralRules,
+        missing,
+        missingWarn,
+        fallbackWarn,
+        fallbackFormat,
+        unresolving,
+        postTranslation,
+        processor,
+        warnHtmlMessage,
+        escapeParameter,
+        messageCompiler,
+        messageResolver,
+        localeFallbacker,
+        fallbackContext,
+        onWarn,
+        __meta
+    };
+    {
+        context.datetimeFormats = datetimeFormats;
+        context.numberFormats = numberFormats;
+        context.__datetimeFormatters = __datetimeFormatters;
+        context.__numberFormatters = __numberFormatters;
+    }
+    // for vue-devtools timeline event
+    {
+        context.__v_emitter =
+            internalOptions.__v_emitter != null
+                ? internalOptions.__v_emitter
+                : undefined;
+    }
+    // NOTE: experimental !!
+    {
+        initI18nDevTools(context, version, __meta);
+    }
+    return context;
+}
+/** @internal */
+function isTranslateFallbackWarn(fallback, key) {
+    return fallback instanceof RegExp ? fallback.test(key) : fallback;
+}
+/** @internal */
+function isTranslateMissingWarn(missing, key) {
+    return missing instanceof RegExp ? missing.test(key) : missing;
+}
+/** @internal */
+function handleMissing(context, key, locale, missingWarn, type) {
+    const { missing, onWarn } = context;
+    // for vue-devtools timeline event
+    {
+        const emitter = context.__v_emitter;
+        if (emitter) {
+            emitter.emit("missing" /* VueDevToolsTimelineEvents.MISSING */, {
+                locale,
+                key,
+                type,
+                groupId: `${type}:${key}`
+            });
+        }
+    }
+    if (missing !== null) {
+        const ret = missing(context, locale, key, type);
+        return isString(ret) ? ret : key;
+    }
+    else {
+        if (isTranslateMissingWarn(missingWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
+        }
+        return key;
+    }
+}
+/** @internal */
+function updateFallbackLocale(ctx, locale, fallback) {
+    const context = ctx;
+    context.__localeChainCache = new Map();
+    ctx.localeFallbacker(ctx, fallback, locale);
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+function format(ast) {
+    const msg = (ctx) => formatParts(ctx, ast);
+    return msg;
+}
+function formatParts(ctx, ast) {
+    const body = ast.b || ast.body;
+    if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+        const plural = body;
+        const cases = plural.c || plural.cases;
+        return ctx.plural(cases.reduce((messages, c) => [
+            ...messages,
+            formatMessageParts(ctx, c)
+        ], []));
+    }
+    else {
+        return formatMessageParts(ctx, body);
+    }
+}
+function formatMessageParts(ctx, node) {
+    const _static = node.s || node.static;
+    if (_static) {
+        return ctx.type === 'text'
+            ? _static
+            : ctx.normalize([_static]);
+    }
+    else {
+        const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+        return ctx.normalize(messages);
+    }
+}
+function formatMessagePart(ctx, node) {
+    const type = node.t || node.type;
+    switch (type) {
+        case 3 /* NodeTypes.Text */:
+            const text = node;
+            return (text.v || text.value);
+        case 9 /* NodeTypes.Literal */:
+            const literal = node;
+            return (literal.v || literal.value);
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            return ctx.interpolate(ctx.named(named.k || named.key));
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            const modifier = linked.m || linked.modifier;
+            return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
+        case 7 /* NodeTypes.LinkedKey */:
+            const linkedKey = node;
+            return (linkedKey.v || linkedKey.value);
+        case 8 /* NodeTypes.LinkedModifier */:
+            const linkedModifier = node;
+            return (linkedModifier.v || linkedModifier.value);
+        default:
+            throw new Error(`unhandled node type on format message part: ${type}`);
+    }
+}
+
+const code = CompileErrorCodes.__EXTEND_POINT__;
+const inc = incrementer(code);
+const CoreErrorCodes = {
+    INVALID_ARGUMENT: code,
+    INVALID_DATE_ARGUMENT: inc(),
+    INVALID_ISO_DATE_ARGUMENT: inc(),
+    NOT_SUPPORT_NON_STRING_MESSAGE: inc(),
+    __EXTEND_POINT__: inc() // 22
+};
+function createCoreError(code) {
+    return createCompileError(code, null, { messages: errorMessages } );
+}
+/** @internal */
+const errorMessages = {
+    [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',
+    [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +
+        'Make sure your Date represents a valid date.',
+    [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string',
+    [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]: 'Not support non-string message'
+};
+
+const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
+function checkHtmlMessage(source, warnHtmlMessage) {
+    if (warnHtmlMessage && detectHtmlTag(source)) {
+        warn(format$1(WARN_MESSAGE, { source }));
+    }
+}
+const defaultOnCacheKey = (message) => message;
+let compileCache = Object.create(null);
+function clearCompileCache() {
+    compileCache = Object.create(null);
+}
+const isMessageAST = (val) => isObject(val) &&
+    (val.t === 0 || val.type === 0) &&
+    ('b' in val || 'body' in val);
+function baseCompile(message, options = {}) {
+    // error detecting on compile
+    let detectError = false;
+    const onError = options.onError || defaultOnError;
+    options.onError = (err) => {
+        detectError = true;
+        onError(err);
+    };
+    // compile with mesasge-compiler
+    return { ...baseCompile$1(message, options), detectError };
+}
+const compileToFunction = /* #__PURE__*/ (message, context) => {
+    if (!isString(message)) {
+        throw createCoreError(CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE);
+    }
+    {
+        // check HTML message
+        const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        checkHtmlMessage(message, warnHtmlMessage);
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile
+        const { code, detectError } = baseCompile(message, context);
+        // evaluate function
+        const msg = new Function(`return ${code}`)();
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+};
+function compile(message, context) {
+    if (isString(message)) {
+        // check HTML message
+        const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        checkHtmlMessage(message, warnHtmlMessage);
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile with JIT mode
+        const { ast, detectError } = baseCompile(message, {
+            ...context,
+            location: true,
+            jit: true
+        });
+        // compose message function from AST
+        const msg = format(ast);
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+    else {
+        if (!isMessageAST(message)) {
+            warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
+            return (() => message);
+        }
+        // AST case (passed from bundler)
+        const cacheKey = message.cacheKey;
+        if (cacheKey) {
+            const cached = compileCache[cacheKey];
+            if (cached) {
+                return cached;
+            }
+            // compose message function from message (AST)
+            return (compileCache[cacheKey] =
+                format(message));
+        }
+        else {
+            return format(message);
+        }
+    }
+}
+
+const NOOP_MESSAGE_FUNCTION = () => '';
+const isMessageFunction = (val) => isFunction(val);
+// implementation of `translate` function
+function translate(context, ...args) {
+    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+    const [key, options] = parseTranslateArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const escapeParameter = isBoolean(options.escapeParameter)
+        ? options.escapeParameter
+        : context.escapeParameter;
+    const resolvedMessage = !!options.resolvedMessage;
+    // prettier-ignore
+    const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option
+        ? !isBoolean(options.default)
+            ? options.default
+            : (!messageCompiler ? () => key : key)
+        : fallbackFormat // default by `fallbackFormat` option
+            ? (!messageCompiler ? () => key : key)
+            : '';
+    const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';
+    const locale = getLocale(context, options);
+    // escape params
+    escapeParameter && escapeParams(options);
+    // resolve message format
+    // eslint-disable-next-line prefer-const
+    let [formatScope, targetLocale, message] = !resolvedMessage
+        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+        : [
+            key,
+            locale,
+            messages[locale] || {}
+        ];
+    // NOTE:
+    //  Fix to work around `ssrTransfrom` bug in Vite.
+    //  https://github.com/vitejs/vite/issues/4306
+    //  To get around this, use temporary variables.
+    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+    let format = formatScope;
+    // if you use default message, set it as message format!
+    let cacheBaseKey = key;
+    if (!resolvedMessage &&
+        !(isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format))) {
+        if (enableDefaultMsg) {
+            format = defaultMsgOrKey;
+            cacheBaseKey = format;
+        }
+    }
+    // checking message format and target locale
+    if (!resolvedMessage &&
+        (!(isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format)) ||
+            !isString(targetLocale))) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    // TODO: refactor
+    if (isString(format) && context.messageCompiler == null) {
+        warn(`The message format compilation is not supported in this build. ` +
+            `Because message compiler isn't included. ` +
+            `You need to pre-compilation all message format. ` +
+            `So translate function return '${key}'.`);
+        return key;
+    }
+    // setup compile error detecting
+    let occurred = false;
+    const onError = () => {
+        occurred = true;
+    };
+    // compile message format
+    const msg = !isMessageFunction(format)
+        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
+        : format;
+    // if occurred compile error, return the message format
+    if (occurred) {
+        return format;
+    }
+    // evaluate message with context
+    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+    const msgContext = createMessageContext(ctxOptions);
+    const messaged = evaluateMessage(context, msg, msgContext);
+    // if use post translation option, proceed it with handler
+    const ret = postTranslation
+        ? postTranslation(messaged, key)
+        : messaged;
+    // NOTE: experimental !!
+    {
+        // prettier-ignore
+        const payloads = {
+            timestamp: Date.now(),
+            key: isString(key)
+                ? key
+                : isMessageFunction(format)
+                    ? format.key
+                    : '',
+            locale: targetLocale || (isMessageFunction(format)
+                ? format.locale
+                : ''),
+            format: isString(format)
+                ? format
+                : isMessageFunction(format)
+                    ? format.source
+                    : '',
+            message: ret
+        };
+        payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
+        translateDevTools(payloads);
+    }
+    return ret;
+}
+function escapeParams(options) {
+    if (isArray(options.list)) {
+        options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);
+    }
+    else if (isObject(options.named)) {
+        Object.keys(options.named).forEach(key => {
+            if (isString(options.named[key])) {
+                options.named[key] = escapeHtml(options.named[key]);
+            }
+        });
+    }
+}
+function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+    let message = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'translate';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        message =
+            messages[targetLocale] || {};
+        // for vue-devtools timeline event
+        let start = null;
+        let startTag;
+        let endTag;
+        if (inBrowser) {
+            start = window.performance.now();
+            startTag = 'intlify-message-resolve-start';
+            endTag = 'intlify-message-resolve-end';
+            mark && mark(startTag);
+        }
+        if ((format = resolveValue(message, key)) === null) {
+            // if null, resolve with object key path
+            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        // for vue-devtools timeline event
+        if (inBrowser) {
+            const end = window.performance.now();
+            const emitter = context.__v_emitter;
+            if (emitter && start && format) {
+                emitter.emit("message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */, {
+                    type: "message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */,
+                    key,
+                    message: format,
+                    time: end - start,
+                    groupId: `${type}:${key}`
+                });
+            }
+            if (startTag && endTag && mark && measure) {
+                mark(endTag);
+                measure('intlify message resolve', startTag, endTag);
+            }
+        }
+        if (isString(format) || isMessageAST(format) || isMessageFunction(format)) {
+            break;
+        }
+        const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+        key, targetLocale, missingWarn, type);
+        if (missingRet !== key) {
+            format = missingRet;
+        }
+        from = to;
+    }
+    return [format, targetLocale, message];
+}
+function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
+    const { messageCompiler, warnHtmlMessage } = context;
+    if (isMessageFunction(format)) {
+        const msg = format;
+        msg.locale = msg.locale || targetLocale;
+        msg.key = msg.key || key;
+        return msg;
+    }
+    if (messageCompiler == null) {
+        const msg = (() => format);
+        msg.locale = targetLocale;
+        msg.key = key;
+        return msg;
+    }
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if (inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-compilation-start';
+        endTag = 'intlify-message-compilation-end';
+        mark && mark(startTag);
+    }
+    const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+    // for vue-devtools timeline event
+    if (inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */, {
+                type: "message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */,
+                message: format,
+                time: end - start,
+                groupId: `${'translate'}:${key}`
+            });
+        }
+        if (startTag && endTag && mark && measure) {
+            mark(endTag);
+            measure('intlify message compilation', startTag, endTag);
+        }
+    }
+    msg.locale = targetLocale;
+    msg.key = key;
+    msg.source = format;
+    return msg;
+}
+function evaluateMessage(context, msg, msgCtx) {
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if (inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-evaluation-start';
+        endTag = 'intlify-message-evaluation-end';
+        mark && mark(startTag);
+    }
+    const messaged = msg(msgCtx);
+    // for vue-devtools timeline event
+    if (inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */, {
+                type: "message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */,
+                value: messaged,
+                time: end - start,
+                groupId: `${'translate'}:${msg.key}`
+            });
+        }
+        if (startTag && endTag && mark && measure) {
+            mark(endTag);
+            measure('intlify message evaluation', startTag, endTag);
+        }
+    }
+    return messaged;
+}
+/** @internal */
+function parseTranslateArgs(...args) {
+    const [arg1, arg2, arg3] = args;
+    const options = {};
+    if (!isString(arg1) &&
+        !isNumber(arg1) &&
+        !isMessageFunction(arg1) &&
+        !isMessageAST(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    // prettier-ignore
+    const key = isNumber(arg1)
+        ? String(arg1)
+        : isMessageFunction(arg1)
+            ? arg1
+            : arg1;
+    if (isNumber(arg2)) {
+        options.plural = arg2;
+    }
+    else if (isString(arg2)) {
+        options.default = arg2;
+    }
+    else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
+        options.named = arg2;
+    }
+    else if (isArray(arg2)) {
+        options.list = arg2;
+    }
+    if (isNumber(arg3)) {
+        options.plural = arg3;
+    }
+    else if (isString(arg3)) {
+        options.default = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        assign(options, arg3);
+    }
+    return [key, options];
+}
+function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
+    return {
+        locale,
+        key,
+        warnHtmlMessage,
+        onError: (err) => {
+            onError && onError(err);
+            {
+                const _source = getSourceForCodeFrame(source);
+                const message = `Message compilation error: ${err.message}`;
+                const codeFrame = err.location &&
+                    _source &&
+                    generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);
+                const emitter = context.__v_emitter;
+                if (emitter && _source) {
+                    emitter.emit("compile-error" /* VueDevToolsTimelineEvents.COMPILE_ERROR */, {
+                        message: _source,
+                        error: err.message,
+                        start: err.location && err.location.start.offset,
+                        end: err.location && err.location.end.offset,
+                        groupId: `${'translate'}:${key}`
+                    });
+                }
+                console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+            }
+        },
+        onCacheKey: (source) => generateFormatCacheKey(locale, key, source)
+    };
+}
+function getSourceForCodeFrame(source) {
+    if (isString(source)) ;
+    else {
+        if (source.loc?.source) {
+            return source.loc.source;
+        }
+    }
+}
+function getMessageContextOptions(context, locale, message, options) {
+    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+    const resolveMessage = (key) => {
+        let val = resolveValue(message, key);
+        // fallback to root context
+        if (val == null && fallbackContext) {
+            const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
+            val = resolveValue(message, key);
+        }
+        if (isString(val) || isMessageAST(val)) {
+            let occurred = false;
+            const onError = () => {
+                occurred = true;
+            };
+            const msg = compileMessageFormat(context, key, locale, val, key, onError);
+            return !occurred
+                ? msg
+                : NOOP_MESSAGE_FUNCTION;
+        }
+        else if (isMessageFunction(val)) {
+            return val;
+        }
+        else {
+            // TODO: should be implemented warning message
+            return NOOP_MESSAGE_FUNCTION;
+        }
+    };
+    const ctxOptions = {
+        locale,
+        modifiers,
+        pluralRules,
+        messages: resolveMessage
+    };
+    if (context.processor) {
+        ctxOptions.processor = context.processor;
+    }
+    if (options.list) {
+        ctxOptions.list = options.list;
+    }
+    if (options.named) {
+        ctxOptions.named = options.named;
+    }
+    if (isNumber(options.plural)) {
+        ctxOptions.pluralIndex = options.plural;
+    }
+    return ctxOptions;
+}
+
+const intlDefined = typeof Intl !== 'undefined';
+const Availabilities = {
+    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
+    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
+};
+
+// implementation of `datetime` function
+function datetime(context, ...args) {
+    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __datetimeFormatters } = context;
+    if (!Availabilities.dateTimeFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseDateTimeArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!isString(key) || key === '') {
+        return new Intl.DateTimeFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let datetimeFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'datetime format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        datetimeFormat =
+            datetimeFormats[targetLocale] || {};
+        format = datetimeFormat[key];
+        if (isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!isPlainObject(format) || !isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __datetimeFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
+        __datetimeFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const DATETIME_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+    'formatMatcher',
+    'hour12',
+    'timeZone',
+    'dateStyle',
+    'timeStyle',
+    'calendar',
+    'dayPeriod',
+    'numberingSystem',
+    'hourCycle',
+    'fractionalSecondDigits'
+];
+/** @internal */
+function parseDateTimeArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    let value;
+    if (isString(arg1)) {
+        // Only allow ISO strings - other date formats are often supported,
+        // but may cause different results in different browsers.
+        const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+        if (!matches) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+        // Some browsers can not parse the iso datetime separated by space,
+        // this is a compromise solution by replace the 'T'/' ' with 'T'
+        const dateTime = matches[3]
+            ? matches[3].trim().startsWith('T')
+                ? `${matches[1].trim()}${matches[3].trim()}`
+                : `${matches[1].trim()}T${matches[3].trim()}`
+            : matches[1].trim();
+        value = new Date(dateTime);
+        try {
+            // This will fail if the date is not valid
+            value.toISOString();
+        }
+        catch (e) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+    }
+    else if (isDate(arg1)) {
+        if (isNaN(arg1.getTime())) {
+            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+        }
+        value = arg1;
+    }
+    else if (isNumber(arg1)) {
+        value = arg1;
+    }
+    else {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    if (isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearDateTimeFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__datetimeFormatters.has(id)) {
+            continue;
+        }
+        context.__datetimeFormatters.delete(id);
+    }
+}
+
+// implementation of `number` function
+function number(context, ...args) {
+    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __numberFormatters } = context;
+    if (!Availabilities.numberFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseNumberArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!isString(key) || key === '') {
+        return new Intl.NumberFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let numberFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'number format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if (locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if (locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        numberFormat =
+            numberFormats[targetLocale] || {};
+        format = numberFormat[key];
+        if (isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!isPlainObject(format) || !isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __numberFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));
+        __numberFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const NUMBER_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'style',
+    'currency',
+    'currencyDisplay',
+    'currencySign',
+    'useGrouping',
+    'minimumIntegerDigits',
+    'minimumFractionDigits',
+    'maximumFractionDigits',
+    'minimumSignificantDigits',
+    'maximumSignificantDigits',
+    'compactDisplay',
+    'notation',
+    'signDisplay',
+    'unit',
+    'unitDisplay',
+    'roundingMode',
+    'roundingPriority',
+    'roundingIncrement',
+    'trailingZeroDisplay'
+];
+/** @internal */
+function parseNumberArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    if (!isNumber(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    const value = arg1;
+    if (isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearNumberFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__numberFormatters.has(id)) {
+            continue;
+        }
+        context.__numberFormatters.delete(id);
+    }
+}
+
+export { CompileErrorCodes, CoreErrorCodes, CoreWarnCodes, DATETIME_FORMAT_OPTIONS_KEYS, DEFAULT_LOCALE, DEFAULT_MESSAGE_DATA_TYPE, MISSING_RESOLVE_VALUE, NOT_REOSLVED, NUMBER_FORMAT_OPTIONS_KEYS, VERSION, clearCompileCache, clearDateTimeFormat, clearNumberFormat, compile, compileToFunction, createCompileError, createCoreContext, createCoreError, createMessageContext, datetime, fallbackWithLocaleChain, fallbackWithSimple, getAdditionalMeta, getDevToolsHook, getFallbackContext, getLocale, getWarnMessage, handleMissing, initI18nDevTools, isMessageAST, isMessageFunction, isTranslateFallbackWarn, isTranslateMissingWarn, number, parse, parseDateTimeArgs, parseNumberArgs, parseTranslateArgs, registerLocaleFallbacker, registerMessageCompiler, registerMessageResolver, resolveLocale, resolveValue, resolveWithKeyValue, setAdditionalMeta, setDevToolsHook, setFallbackContext, translate, translateDevTools, updateFallbackLocale };

node_modules/@intlify/core-base/dist/core-base.esm-bundler.js

@@ -0,0 +1 @@
+export * from '../dist/core-base.mjs'

node_modules/@intlify/core-base/dist/core-base.global.js

@@ -0,0 +1,3427 @@
+/*!
+  * core-base v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+var IntlifyCoreBase = (function (exports) {
+  'use strict';
+
+  /**
+   * Original Utilities
+   * written by kazuya kawaguchi
+   */
+  const inBrowser = typeof window !== 'undefined';
+  let mark;
+  let measure;
+  {
+      const perf = inBrowser && window.performance;
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          // @ts-ignore browser compat
+          perf.clearMeasures) {
+          mark = (tag) => {
+              perf.mark(tag);
+          };
+          measure = (name, startTag, endTag) => {
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
+          };
+      }
+  }
+  const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+  /* eslint-disable */
+  function format$1(message, ...args) {
+      if (args.length === 1 && isObject(args[0])) {
+          args = args[0];
+      }
+      if (!args || !args.hasOwnProperty) {
+          args = {};
+      }
+      return message.replace(RE_ARGS, (match, identifier) => {
+          return args.hasOwnProperty(identifier) ? args[identifier] : '';
+      });
+  }
+  const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+  const friendlyJSONstringify = (json) => JSON.stringify(json)
+      .replace(/\u2028/g, '\\u2028')
+      .replace(/\u2029/g, '\\u2029')
+      .replace(/\u0027/g, '\\u0027');
+  const isNumber = (val) => typeof val === 'number' && isFinite(val);
+  const isDate = (val) => toTypeString(val) === '[object Date]';
+  const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+  const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+  const assign = Object.assign;
+  function escapeHtml(rawText) {
+      return rawText
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/'/g, '&apos;');
+  }
+  /* eslint-enable */
+  /**
+   * Useful Utilities By Evan you
+   * Modified by kazuya kawaguchi
+   * MIT License
+   * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+   * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+   */
+  const isArray = Array.isArray;
+  const isFunction = (val) => typeof val === 'function';
+  const isString = (val) => typeof val === 'string';
+  const isBoolean = (val) => typeof val === 'boolean';
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const isObject = (val) => val !== null && typeof val === 'object';
+  const objectToString = Object.prototype.toString;
+  const toTypeString = (value) => objectToString.call(value);
+  const isPlainObject = (val) => {
+      if (!isObject(val))
+          return false;
+      const proto = Object.getPrototypeOf(val);
+      return proto === null || proto.constructor === Object;
+  };
+  // for converting list and named values to displayed strings.
+  const toDisplayString = (val) => {
+      return val == null
+          ? ''
+          : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
+  };
+  function join(items, separator = '') {
+      return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+  }
+  const RANGE = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+      const lines = source.split(/\r?\n/);
+      let count = 0;
+      const res = [];
+      for (let i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      continue;
+                  const line = j + 1;
+                  res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                  const lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      const pad = start - (count - lineLength) + 1;
+                      const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                      res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          const length = Math.max(Math.min(end - count, lineLength), 1);
+                          res.push(`   |  ` + '^'.repeat(length));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
+          }
+      }
+      return res.join('\n');
+  }
+  function incrementer(code) {
+      let current = code;
+      return () => ++current;
+  }
+
+  function warn(msg, err) {
+      if (typeof console !== 'undefined') {
+          console.warn(`[intlify] ` + msg);
+          /* istanbul ignore if */
+          if (err) {
+              console.warn(err.stack);
+          }
+      }
+  }
+
+  function createPosition(line, column, offset) {
+      return { line, column, offset };
+  }
+  function createLocation(start, end, source) {
+      const loc = { start, end };
+      if (source != null) {
+          loc.source = source;
+      }
+      return loc;
+  }
+
+  const CompileErrorCodes = {
+      // tokenizer error codes
+      EXPECTED_TOKEN: 1,
+      INVALID_TOKEN_IN_PLACEHOLDER: 2,
+      UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+      UNKNOWN_ESCAPE_SEQUENCE: 4,
+      INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+      UNBALANCED_CLOSING_BRACE: 6,
+      UNTERMINATED_CLOSING_BRACE: 7,
+      EMPTY_PLACEHOLDER: 8,
+      NOT_ALLOW_NEST_PLACEHOLDER: 9,
+      INVALID_LINKED_FORMAT: 10,
+      // parser error codes
+      MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+      UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+      UNEXPECTED_EMPTY_LINKED_KEY: 13,
+      UNEXPECTED_LEXICAL_ANALYSIS: 14,
+      // generator error codes
+      UNHANDLED_CODEGEN_NODE_TYPE: 15,
+      // minifier error codes
+      UNHANDLED_MINIFIER_NODE_TYPE: 16,
+      // Special value for higher-order compilers to pick up the last code
+      // to avoid collision of error codes. This should always be kept as the last
+      // item.
+      __EXTEND_POINT__: 17
+  };
+  /** @internal */
+  const errorMessages$1 = {
+      // tokenizer error messages
+      [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+      [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+      [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+      [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+      [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+      [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+      [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+      [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+      [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+      [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+      // parser error messages
+      [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+      [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+      [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+      [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+      // generator error messages
+      [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+      // minimizer error messages
+      [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+  };
+  function createCompileError(code, loc, options = {}) {
+      const { domain, messages, args } = options;
+      const msg = format$1((messages || errorMessages$1)[code] || '', ...(args || []))
+          ;
+      const error = new SyntaxError(String(msg));
+      error.code = code;
+      if (loc) {
+          error.location = loc;
+      }
+      error.domain = domain;
+      return error;
+  }
+  /** @internal */
+  function defaultOnError(error) {
+      throw error;
+  }
+
+  const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+  const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+  const CHAR_SP = ' ';
+  const CHAR_CR = '\r';
+  const CHAR_LF = '\n';
+  const CHAR_LS = String.fromCharCode(0x2028);
+  const CHAR_PS = String.fromCharCode(0x2029);
+  function createScanner(str) {
+      const _buf = str;
+      let _index = 0;
+      let _line = 1;
+      let _column = 1;
+      let _peekOffset = 0;
+      const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+      const isLF = (index) => _buf[index] === CHAR_LF;
+      const isPS = (index) => _buf[index] === CHAR_PS;
+      const isLS = (index) => _buf[index] === CHAR_LS;
+      const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+      const index = () => _index;
+      const line = () => _line;
+      const column = () => _column;
+      const peekOffset = () => _peekOffset;
+      const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+      const currentChar = () => charAt(_index);
+      const currentPeek = () => charAt(_index + _peekOffset);
+      function next() {
+          _peekOffset = 0;
+          if (isLineEnd(_index)) {
+              _line++;
+              _column = 0;
+          }
+          if (isCRLF(_index)) {
+              _index++;
+          }
+          _index++;
+          _column++;
+          return _buf[_index];
+      }
+      function peek() {
+          if (isCRLF(_index + _peekOffset)) {
+              _peekOffset++;
+          }
+          _peekOffset++;
+          return _buf[_index + _peekOffset];
+      }
+      function reset() {
+          _index = 0;
+          _line = 1;
+          _column = 1;
+          _peekOffset = 0;
+      }
+      function resetPeek(offset = 0) {
+          _peekOffset = offset;
+      }
+      function skipToPeek() {
+          const target = _index + _peekOffset;
+          // eslint-disable-next-line no-unmodified-loop-condition
+          while (target !== _index) {
+              next();
+          }
+          _peekOffset = 0;
+      }
+      return {
+          index,
+          line,
+          column,
+          peekOffset,
+          charAt,
+          currentChar,
+          currentPeek,
+          next,
+          peek,
+          reset,
+          resetPeek,
+          skipToPeek
+      };
+  }
+
+  const EOF = undefined;
+  const DOT = '.';
+  const LITERAL_DELIMITER = "'";
+  const ERROR_DOMAIN$3 = 'tokenizer';
+  function createTokenizer(source, options = {}) {
+      const location = options.location !== false;
+      const _scnr = createScanner(source);
+      const currentOffset = () => _scnr.index();
+      const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+      const _initLoc = currentPosition();
+      const _initOffset = currentOffset();
+      const _context = {
+          currentType: 14 /* TokenTypes.EOF */,
+          offset: _initOffset,
+          startLoc: _initLoc,
+          endLoc: _initLoc,
+          lastType: 14 /* TokenTypes.EOF */,
+          lastOffset: _initOffset,
+          lastStartLoc: _initLoc,
+          lastEndLoc: _initLoc,
+          braceNest: 0,
+          inLinked: false,
+          text: ''
+      };
+      const context = () => _context;
+      const { onError } = options;
+      function emitError(code, pos, offset, ...args) {
+          const ctx = context();
+          pos.column += offset;
+          pos.offset += offset;
+          if (onError) {
+              const loc = location ? createLocation(ctx.startLoc, pos) : null;
+              const err = createCompileError(code, loc, {
+                  domain: ERROR_DOMAIN$3,
+                  args
+              });
+              onError(err);
+          }
+      }
+      function getToken(context, type, value) {
+          context.endLoc = currentPosition();
+          context.currentType = type;
+          const token = { type };
+          if (location) {
+              token.loc = createLocation(context.startLoc, context.endLoc);
+          }
+          if (value != null) {
+              token.value = value;
+          }
+          return token;
+      }
+      const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+      function eat(scnr, ch) {
+          if (scnr.currentChar() === ch) {
+              scnr.next();
+              return ch;
+          }
+          else {
+              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+              return '';
+          }
+      }
+      function peekSpaces(scnr) {
+          let buf = '';
+          while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+              buf += scnr.currentPeek();
+              scnr.peek();
+          }
+          return buf;
+      }
+      function skipSpaces(scnr) {
+          const buf = peekSpaces(scnr);
+          scnr.skipToPeek();
+          return buf;
+      }
+      function isIdentifierStart(ch) {
+          if (ch === EOF) {
+              return false;
+          }
+          const cc = ch.charCodeAt(0);
+          return ((cc >= 97 && cc <= 122) || // a-z
+              (cc >= 65 && cc <= 90) || // A-Z
+              cc === 95 // _
+          );
+      }
+      function isNumberStart(ch) {
+          if (ch === EOF) {
+              return false;
+          }
+          const cc = ch.charCodeAt(0);
+          return cc >= 48 && cc <= 57; // 0-9
+      }
+      function isNamedIdentifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = isIdentifierStart(scnr.currentPeek());
+          scnr.resetPeek();
+          return ret;
+      }
+      function isListIdentifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+          const ret = isNumberStart(ch);
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLiteralStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedDotStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedModifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = isIdentifierStart(scnr.currentPeek());
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedDelimiterStart(scnr, context) {
+          const { currentType } = context;
+          if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+              currentType === 12 /* TokenTypes.LinkedModifier */)) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedReferStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+              return false;
+          }
+          const fn = () => {
+              const ch = scnr.currentPeek();
+              if (ch === "{" /* TokenChars.BraceLeft */) {
+                  return isIdentifierStart(scnr.peek());
+              }
+              else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "%" /* TokenChars.Modulo */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                  ch === "." /* TokenChars.LinkedDot */ ||
+                  ch === CHAR_SP ||
+                  !ch) {
+                  return false;
+              }
+              else if (ch === CHAR_LF) {
+                  scnr.peek();
+                  return fn();
+              }
+              else {
+                  // other characters
+                  return isIdentifierStart(ch);
+              }
+          };
+          const ret = fn();
+          scnr.resetPeek();
+          return ret;
+      }
+      function isPluralStart(scnr) {
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function detectModuloStart(scnr) {
+          const spaces = peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+              scnr.peek() === "{" /* TokenChars.BraceLeft */;
+          scnr.resetPeek();
+          return {
+              isModulo: ret,
+              hasSpace: spaces.length > 0
+          };
+      }
+      function isTextStart(scnr, reset = true) {
+          const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+              const ch = scnr.currentPeek();
+              if (ch === "{" /* TokenChars.BraceLeft */) {
+                  return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+              }
+              else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                  return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+              }
+              else if (ch === "%" /* TokenChars.Modulo */) {
+                  scnr.peek();
+                  return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+              }
+              else if (ch === "|" /* TokenChars.Pipe */) {
+                  return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                      ? true
+                      : !(prev === CHAR_SP || prev === CHAR_LF);
+              }
+              else if (ch === CHAR_SP) {
+                  scnr.peek();
+                  return fn(true, CHAR_SP, detectModulo);
+              }
+              else if (ch === CHAR_LF) {
+                  scnr.peek();
+                  return fn(true, CHAR_LF, detectModulo);
+              }
+              else {
+                  return true;
+              }
+          };
+          const ret = fn();
+          reset && scnr.resetPeek();
+          return ret;
+      }
+      function takeChar(scnr, fn) {
+          const ch = scnr.currentChar();
+          if (ch === EOF) {
+              return EOF;
+          }
+          if (fn(ch)) {
+              scnr.next();
+              return ch;
+          }
+          return null;
+      }
+      function takeIdentifierChar(scnr) {
+          const closure = (ch) => {
+              const cc = ch.charCodeAt(0);
+              return ((cc >= 97 && cc <= 122) || // a-z
+                  (cc >= 65 && cc <= 90) || // A-Z
+                  (cc >= 48 && cc <= 57) || // 0-9
+                  cc === 95 || // _
+                  cc === 36 // $
+              );
+          };
+          return takeChar(scnr, closure);
+      }
+      function takeDigit(scnr) {
+          const closure = (ch) => {
+              const cc = ch.charCodeAt(0);
+              return cc >= 48 && cc <= 57; // 0-9
+          };
+          return takeChar(scnr, closure);
+      }
+      function takeHexDigit(scnr) {
+          const closure = (ch) => {
+              const cc = ch.charCodeAt(0);
+              return ((cc >= 48 && cc <= 57) || // 0-9
+                  (cc >= 65 && cc <= 70) || // A-F
+                  (cc >= 97 && cc <= 102)); // a-f
+          };
+          return takeChar(scnr, closure);
+      }
+      function getDigits(scnr) {
+          let ch = '';
+          let num = '';
+          while ((ch = takeDigit(scnr))) {
+              num += ch;
+          }
+          return num;
+      }
+      function readModulo(scnr) {
+          skipSpaces(scnr);
+          const ch = scnr.currentChar();
+          if (ch !== "%" /* TokenChars.Modulo */) {
+              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+          }
+          scnr.next();
+          return "%" /* TokenChars.Modulo */;
+      }
+      function readText(scnr) {
+          let buf = '';
+          while (true) {
+              const ch = scnr.currentChar();
+              if (ch === "{" /* TokenChars.BraceLeft */ ||
+                  ch === "}" /* TokenChars.BraceRight */ ||
+                  ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  !ch) {
+                  break;
+              }
+              else if (ch === "%" /* TokenChars.Modulo */) {
+                  if (isTextStart(scnr)) {
+                      buf += ch;
+                      scnr.next();
+                  }
+                  else {
+                      break;
+                  }
+              }
+              else if (ch === CHAR_SP || ch === CHAR_LF) {
+                  if (isTextStart(scnr)) {
+                      buf += ch;
+                      scnr.next();
+                  }
+                  else if (isPluralStart(scnr)) {
+                      break;
+                  }
+                  else {
+                      buf += ch;
+                      scnr.next();
+                  }
+              }
+              else {
+                  buf += ch;
+                  scnr.next();
+              }
+          }
+          return buf;
+      }
+      function readNamedIdentifier(scnr) {
+          skipSpaces(scnr);
+          let ch = '';
+          let name = '';
+          while ((ch = takeIdentifierChar(scnr))) {
+              name += ch;
+          }
+          if (scnr.currentChar() === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+          }
+          return name;
+      }
+      function readListIdentifier(scnr) {
+          skipSpaces(scnr);
+          let value = '';
+          if (scnr.currentChar() === '-') {
+              scnr.next();
+              value += `-${getDigits(scnr)}`;
+          }
+          else {
+              value += getDigits(scnr);
+          }
+          if (scnr.currentChar() === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+          }
+          return value;
+      }
+      function readLiteral(scnr) {
+          skipSpaces(scnr);
+          eat(scnr, `\'`);
+          let ch = '';
+          let literal = '';
+          const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+          while ((ch = takeChar(scnr, fn))) {
+              if (ch === '\\') {
+                  literal += readEscapeSequence(scnr);
+              }
+              else {
+                  literal += ch;
+              }
+          }
+          const current = scnr.currentChar();
+          if (current === CHAR_LF || current === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+              // TODO: Is it correct really?
+              if (current === CHAR_LF) {
+                  scnr.next();
+                  eat(scnr, `\'`);
+              }
+              return literal;
+          }
+          eat(scnr, `\'`);
+          return literal;
+      }
+      function readEscapeSequence(scnr) {
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case '\\':
+              case `\'`:
+                  scnr.next();
+                  return `\\${ch}`;
+              case 'u':
+                  return readUnicodeEscapeSequence(scnr, ch, 4);
+              case 'U':
+                  return readUnicodeEscapeSequence(scnr, ch, 6);
+              default:
+                  emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                  return '';
+          }
+      }
+      function readUnicodeEscapeSequence(scnr, unicode, digits) {
+          eat(scnr, unicode);
+          let sequence = '';
+          for (let i = 0; i < digits; i++) {
+              const ch = takeHexDigit(scnr);
+              if (!ch) {
+                  emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                  break;
+              }
+              sequence += ch;
+          }
+          return `\\${unicode}${sequence}`;
+      }
+      function readInvalidIdentifier(scnr) {
+          skipSpaces(scnr);
+          let ch = '';
+          let identifiers = '';
+          const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+              ch !== "}" /* TokenChars.BraceRight */ &&
+              ch !== CHAR_SP &&
+              ch !== CHAR_LF;
+          while ((ch = takeChar(scnr, closure))) {
+              identifiers += ch;
+          }
+          return identifiers;
+      }
+      function readLinkedModifier(scnr) {
+          let ch = '';
+          let name = '';
+          while ((ch = takeIdentifierChar(scnr))) {
+              name += ch;
+          }
+          return name;
+      }
+      function readLinkedRefer(scnr) {
+          const fn = (detect = false, buf) => {
+              const ch = scnr.currentChar();
+              if (ch === "{" /* TokenChars.BraceLeft */ ||
+                  ch === "%" /* TokenChars.Modulo */ ||
+                  ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  ch === "(" /* TokenChars.ParenLeft */ ||
+                  ch === ")" /* TokenChars.ParenRight */ ||
+                  !ch) {
+                  return buf;
+              }
+              else if (ch === CHAR_SP) {
+                  return buf;
+              }
+              else if (ch === CHAR_LF || ch === DOT) {
+                  buf += ch;
+                  scnr.next();
+                  return fn(detect, buf);
+              }
+              else {
+                  buf += ch;
+                  scnr.next();
+                  return fn(true, buf);
+              }
+          };
+          return fn(false, '');
+      }
+      function readPlural(scnr) {
+          skipSpaces(scnr);
+          const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+          skipSpaces(scnr);
+          return plural;
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readTokenInPlaceholder(scnr, context) {
+          let token = null;
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case "{" /* TokenChars.BraceLeft */:
+                  if (context.braceNest >= 1) {
+                      emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                  }
+                  scnr.next();
+                  token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                  skipSpaces(scnr);
+                  context.braceNest++;
+                  return token;
+              case "}" /* TokenChars.BraceRight */:
+                  if (context.braceNest > 0 &&
+                      context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                      emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                  }
+                  scnr.next();
+                  token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                  context.braceNest--;
+                  context.braceNest > 0 && skipSpaces(scnr);
+                  if (context.inLinked && context.braceNest === 0) {
+                      context.inLinked = false;
+                  }
+                  return token;
+              case "@" /* TokenChars.LinkedAlias */:
+                  if (context.braceNest > 0) {
+                      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                  }
+                  token = readTokenInLinked(scnr, context) || getEndToken(context);
+                  context.braceNest = 0;
+                  return token;
+              default:
+                  let validNamedIdentifier = true;
+                  let validListIdentifier = true;
+                  let validLiteral = true;
+                  if (isPluralStart(scnr)) {
+                      if (context.braceNest > 0) {
+                          emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                      }
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  if (context.braceNest > 0 &&
+                      (context.currentType === 5 /* TokenTypes.Named */ ||
+                          context.currentType === 6 /* TokenTypes.List */ ||
+                          context.currentType === 7 /* TokenTypes.Literal */)) {
+                      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                      context.braceNest = 0;
+                      return readToken(scnr, context);
+                  }
+                  if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                      token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                      token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if ((validLiteral = isLiteralStart(scnr, context))) {
+                      token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                      // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                      token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                      emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  break;
+          }
+          return token;
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readTokenInLinked(scnr, context) {
+          const { currentType } = context;
+          let token = null;
+          const ch = scnr.currentChar();
+          if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+              currentType === 9 /* TokenTypes.LinkedDot */ ||
+              currentType === 12 /* TokenTypes.LinkedModifier */ ||
+              currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+              (ch === CHAR_LF || ch === CHAR_SP)) {
+              emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+          }
+          switch (ch) {
+              case "@" /* TokenChars.LinkedAlias */:
+                  scnr.next();
+                  token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                  context.inLinked = true;
+                  return token;
+              case "." /* TokenChars.LinkedDot */:
+                  skipSpaces(scnr);
+                  scnr.next();
+                  return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+              case ":" /* TokenChars.LinkedDelimiter */:
+                  skipSpaces(scnr);
+                  scnr.next();
+                  return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+              default:
+                  if (isPluralStart(scnr)) {
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  if (isLinkedDotStart(scnr, context) ||
+                      isLinkedDelimiterStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      return readTokenInLinked(scnr, context);
+                  }
+                  if (isLinkedModifierStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                  }
+                  if (isLinkedReferStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      if (ch === "{" /* TokenChars.BraceLeft */) {
+                          // scan the placeholder
+                          return readTokenInPlaceholder(scnr, context) || token;
+                      }
+                      else {
+                          return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                      }
+                  }
+                  if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                      emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                  }
+                  context.braceNest = 0;
+                  context.inLinked = false;
+                  return readToken(scnr, context);
+          }
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readToken(scnr, context) {
+          let token = { type: 14 /* TokenTypes.EOF */ };
+          if (context.braceNest > 0) {
+              return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+          }
+          if (context.inLinked) {
+              return readTokenInLinked(scnr, context) || getEndToken(context);
+          }
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case "{" /* TokenChars.BraceLeft */:
+                  return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+              case "}" /* TokenChars.BraceRight */:
+                  emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                  scnr.next();
+                  return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+              case "@" /* TokenChars.LinkedAlias */:
+                  return readTokenInLinked(scnr, context) || getEndToken(context);
+              default:
+                  if (isPluralStart(scnr)) {
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  const { isModulo, hasSpace } = detectModuloStart(scnr);
+                  if (isModulo) {
+                      return hasSpace
+                          ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                          : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                  }
+                  if (isTextStart(scnr)) {
+                      return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                  }
+                  break;
+          }
+          return token;
+      }
+      function nextToken() {
+          const { currentType, offset, startLoc, endLoc } = _context;
+          _context.lastType = currentType;
+          _context.lastOffset = offset;
+          _context.lastStartLoc = startLoc;
+          _context.lastEndLoc = endLoc;
+          _context.offset = currentOffset();
+          _context.startLoc = currentPosition();
+          if (_scnr.currentChar() === EOF) {
+              return getToken(_context, 14 /* TokenTypes.EOF */);
+          }
+          return readToken(_scnr, _context);
+      }
+      return {
+          nextToken,
+          currentOffset,
+          currentPosition,
+          context
+      };
+  }
+
+  const ERROR_DOMAIN$2 = 'parser';
+  // Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+  const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+  function fromEscapeSequence(match, codePoint4, codePoint6) {
+      switch (match) {
+          case `\\\\`:
+              return `\\`;
+          case `\\\'`:
+              return `\'`;
+          default: {
+              const codePoint = parseInt(codePoint4 || codePoint6, 16);
+              if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                  return String.fromCodePoint(codePoint);
+              }
+              // invalid ...
+              // Replace them with U+FFFD REPLACEMENT CHARACTER.
+              return '�';
+          }
+      }
+  }
+  function createParser(options = {}) {
+      const location = options.location !== false;
+      const { onError } = options;
+      function emitError(tokenzer, code, start, offset, ...args) {
+          const end = tokenzer.currentPosition();
+          end.offset += offset;
+          end.column += offset;
+          if (onError) {
+              const loc = location ? createLocation(start, end) : null;
+              const err = createCompileError(code, loc, {
+                  domain: ERROR_DOMAIN$2,
+                  args
+              });
+              onError(err);
+          }
+      }
+      function startNode(type, offset, loc) {
+          const node = { type };
+          if (location) {
+              node.start = offset;
+              node.end = offset;
+              node.loc = { start: loc, end: loc };
+          }
+          return node;
+      }
+      function endNode(node, offset, pos, type) {
+          if (type) {
+              node.type = type;
+          }
+          if (location) {
+              node.end = offset;
+              if (node.loc) {
+                  node.loc.end = pos;
+              }
+          }
+      }
+      function parseText(tokenizer, value) {
+          const context = tokenizer.context();
+          const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+          node.value = value;
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseList(tokenizer, index) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(5 /* NodeTypes.List */, offset, loc);
+          node.index = parseInt(index, 10);
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseNamed(tokenizer, key) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+          node.key = key;
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLiteral(tokenizer, value) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+          node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLinkedModifier(tokenizer) {
+          const token = tokenizer.nextToken();
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+          const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+          if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+              // empty modifier
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+              node.value = '';
+              endNode(node, offset, loc);
+              return {
+                  nextConsumeToken: token,
+                  node
+              };
+          }
+          // check token
+          if (token.value == null) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+          }
+          node.value = token.value || '';
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return {
+              node
+          };
+      }
+      function parseLinkedKey(tokenizer, value) {
+          const context = tokenizer.context();
+          const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+          node.value = value;
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLinked(tokenizer) {
+          const context = tokenizer.context();
+          const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+          let token = tokenizer.nextToken();
+          if (token.type === 9 /* TokenTypes.LinkedDot */) {
+              const parsed = parseLinkedModifier(tokenizer);
+              linkedNode.modifier = parsed.node;
+              token = parsed.nextConsumeToken || tokenizer.nextToken();
+          }
+          // asset check token
+          if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+          }
+          token = tokenizer.nextToken();
+          // skip brace left
+          if (token.type === 2 /* TokenTypes.BraceLeft */) {
+              token = tokenizer.nextToken();
+          }
+          switch (token.type) {
+              case 11 /* TokenTypes.LinkedKey */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                  break;
+              case 5 /* TokenTypes.Named */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseNamed(tokenizer, token.value || '');
+                  break;
+              case 6 /* TokenTypes.List */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseList(tokenizer, token.value || '');
+                  break;
+              case 7 /* TokenTypes.Literal */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                  break;
+              default:
+                  // empty key
+                  emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                  const nextContext = tokenizer.context();
+                  const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                  emptyLinkedKeyNode.value = '';
+                  endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                  linkedNode.key = emptyLinkedKeyNode;
+                  endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                  return {
+                      nextConsumeToken: token,
+                      node: linkedNode
+                  };
+          }
+          endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return {
+              node: linkedNode
+          };
+      }
+      function parseMessage(tokenizer) {
+          const context = tokenizer.context();
+          const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+              ? tokenizer.currentOffset()
+              : context.offset;
+          const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.endLoc
+              : context.startLoc;
+          const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+          node.items = [];
+          let nextToken = null;
+          do {
+              const token = nextToken || tokenizer.nextToken();
+              nextToken = null;
+              switch (token.type) {
+                  case 0 /* TokenTypes.Text */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseText(tokenizer, token.value || ''));
+                      break;
+                  case 6 /* TokenTypes.List */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseList(tokenizer, token.value || ''));
+                      break;
+                  case 5 /* TokenTypes.Named */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseNamed(tokenizer, token.value || ''));
+                      break;
+                  case 7 /* TokenTypes.Literal */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseLiteral(tokenizer, token.value || ''));
+                      break;
+                  case 8 /* TokenTypes.LinkedAlias */:
+                      const parsed = parseLinked(tokenizer);
+                      node.items.push(parsed.node);
+                      nextToken = parsed.nextConsumeToken || null;
+                      break;
+              }
+          } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+              context.currentType !== 1 /* TokenTypes.Pipe */);
+          // adjust message node loc
+          const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.lastOffset
+              : tokenizer.currentOffset();
+          const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.lastEndLoc
+              : tokenizer.currentPosition();
+          endNode(node, endOffset, endLoc);
+          return node;
+      }
+      function parsePlural(tokenizer, offset, loc, msgNode) {
+          const context = tokenizer.context();
+          let hasEmptyMessage = msgNode.items.length === 0;
+          const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+          node.cases = [];
+          node.cases.push(msgNode);
+          do {
+              const msg = parseMessage(tokenizer);
+              if (!hasEmptyMessage) {
+                  hasEmptyMessage = msg.items.length === 0;
+              }
+              node.cases.push(msg);
+          } while (context.currentType !== 14 /* TokenTypes.EOF */);
+          if (hasEmptyMessage) {
+              emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+          }
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseResource(tokenizer) {
+          const context = tokenizer.context();
+          const { offset, startLoc } = context;
+          const msgNode = parseMessage(tokenizer);
+          if (context.currentType === 14 /* TokenTypes.EOF */) {
+              return msgNode;
+          }
+          else {
+              return parsePlural(tokenizer, offset, startLoc, msgNode);
+          }
+      }
+      function parse(source) {
+          const tokenizer = createTokenizer(source, assign({}, options));
+          const context = tokenizer.context();
+          const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+          if (location && node.loc) {
+              node.loc.source = source;
+          }
+          node.body = parseResource(tokenizer);
+          if (options.onCacheKey) {
+              node.cacheKey = options.onCacheKey(source);
+          }
+          // assert whether achieved to EOF
+          if (context.currentType !== 14 /* TokenTypes.EOF */) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+          }
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      return { parse };
+  }
+  function getTokenCaption(token) {
+      if (token.type === 14 /* TokenTypes.EOF */) {
+          return 'EOF';
+      }
+      const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+      return name.length > 10 ? name.slice(0, 9) + '…' : name;
+  }
+
+  function createTransformer(ast, options = {} // eslint-disable-line
+  ) {
+      const _context = {
+          ast,
+          helpers: new Set()
+      };
+      const context = () => _context;
+      const helper = (name) => {
+          _context.helpers.add(name);
+          return name;
+      };
+      return { context, helper };
+  }
+  function traverseNodes(nodes, transformer) {
+      for (let i = 0; i < nodes.length; i++) {
+          traverseNode(nodes[i], transformer);
+      }
+  }
+  function traverseNode(node, transformer) {
+      // TODO: if we need pre-hook of transform, should be implemented to here
+      switch (node.type) {
+          case 1 /* NodeTypes.Plural */:
+              traverseNodes(node.cases, transformer);
+              transformer.helper("plural" /* HelperNameMap.PLURAL */);
+              break;
+          case 2 /* NodeTypes.Message */:
+              traverseNodes(node.items, transformer);
+              break;
+          case 6 /* NodeTypes.Linked */:
+              const linked = node;
+              traverseNode(linked.key, transformer);
+              transformer.helper("linked" /* HelperNameMap.LINKED */);
+              transformer.helper("type" /* HelperNameMap.TYPE */);
+              break;
+          case 5 /* NodeTypes.List */:
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("list" /* HelperNameMap.LIST */);
+              break;
+          case 4 /* NodeTypes.Named */:
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("named" /* HelperNameMap.NAMED */);
+              break;
+      }
+      // TODO: if we need post-hook of transform, should be implemented to here
+  }
+  // transform AST
+  function transform(ast, options = {} // eslint-disable-line
+  ) {
+      const transformer = createTransformer(ast);
+      transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+      // traverse
+      ast.body && traverseNode(ast.body, transformer);
+      // set meta information
+      const context = transformer.context();
+      ast.helpers = Array.from(context.helpers);
+  }
+
+  function optimize(ast) {
+      const body = ast.body;
+      if (body.type === 2 /* NodeTypes.Message */) {
+          optimizeMessageNode(body);
+      }
+      else {
+          body.cases.forEach(c => optimizeMessageNode(c));
+      }
+      return ast;
+  }
+  function optimizeMessageNode(message) {
+      if (message.items.length === 1) {
+          const item = message.items[0];
+          if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+              message.static = item.value;
+              delete item.value; // optimization for size
+          }
+      }
+      else {
+          const values = [];
+          for (let i = 0; i < message.items.length; i++) {
+              const item = message.items[i];
+              if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                  break;
+              }
+              if (item.value == null) {
+                  break;
+              }
+              values.push(item.value);
+          }
+          if (values.length === message.items.length) {
+              message.static = join(values);
+              for (let i = 0; i < message.items.length; i++) {
+                  const item = message.items[i];
+                  if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                      delete item.value; // optimization for size
+                  }
+              }
+          }
+      }
+  }
+
+  const ERROR_DOMAIN$1 = 'minifier';
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  function minify(node) {
+      node.t = node.type;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */:
+              const resource = node;
+              minify(resource.body);
+              resource.b = resource.body;
+              delete resource.body;
+              break;
+          case 1 /* NodeTypes.Plural */:
+              const plural = node;
+              const cases = plural.cases;
+              for (let i = 0; i < cases.length; i++) {
+                  minify(cases[i]);
+              }
+              plural.c = cases;
+              delete plural.cases;
+              break;
+          case 2 /* NodeTypes.Message */:
+              const message = node;
+              const items = message.items;
+              for (let i = 0; i < items.length; i++) {
+                  minify(items[i]);
+              }
+              message.i = items;
+              delete message.items;
+              if (message.static) {
+                  message.s = message.static;
+                  delete message.static;
+              }
+              break;
+          case 3 /* NodeTypes.Text */:
+          case 9 /* NodeTypes.Literal */:
+          case 8 /* NodeTypes.LinkedModifier */:
+          case 7 /* NodeTypes.LinkedKey */:
+              const valueNode = node;
+              if (valueNode.value) {
+                  valueNode.v = valueNode.value;
+                  delete valueNode.value;
+              }
+              break;
+          case 6 /* NodeTypes.Linked */:
+              const linked = node;
+              minify(linked.key);
+              linked.k = linked.key;
+              delete linked.key;
+              if (linked.modifier) {
+                  minify(linked.modifier);
+                  linked.m = linked.modifier;
+                  delete linked.modifier;
+              }
+              break;
+          case 5 /* NodeTypes.List */:
+              const list = node;
+              list.i = list.index;
+              delete list.index;
+              break;
+          case 4 /* NodeTypes.Named */:
+              const named = node;
+              named.k = named.key;
+              delete named.key;
+              break;
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN$1,
+                      args: [node.type]
+                  });
+              }
+      }
+      delete node.type;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  const ERROR_DOMAIN = 'parser';
+  function createCodeGenerator(ast, options) {
+      const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+      const location = options.location !== false;
+      const _context = {
+          filename,
+          code: '',
+          column: 1,
+          line: 1,
+          offset: 0,
+          map: undefined,
+          breakLineCode,
+          needIndent: _needIndent,
+          indentLevel: 0
+      };
+      if (location && ast.loc) {
+          _context.source = ast.loc.source;
+      }
+      const context = () => _context;
+      function push(code, node) {
+          _context.code += code;
+      }
+      function _newline(n, withBreakLine = true) {
+          const _breakLineCode = withBreakLine ? breakLineCode : '';
+          push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+      }
+      function indent(withNewLine = true) {
+          const level = ++_context.indentLevel;
+          withNewLine && _newline(level);
+      }
+      function deindent(withNewLine = true) {
+          const level = --_context.indentLevel;
+          withNewLine && _newline(level);
+      }
+      function newline() {
+          _newline(_context.indentLevel);
+      }
+      const helper = (key) => `_${key}`;
+      const needIndent = () => _context.needIndent;
+      return {
+          context,
+          push,
+          indent,
+          deindent,
+          newline,
+          helper,
+          needIndent
+      };
+  }
+  function generateLinkedNode(generator, node) {
+      const { helper } = generator;
+      generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+      generateNode(generator, node.key);
+      if (node.modifier) {
+          generator.push(`, `);
+          generateNode(generator, node.modifier);
+          generator.push(`, _type`);
+      }
+      else {
+          generator.push(`, undefined, _type`);
+      }
+      generator.push(`)`);
+  }
+  function generateMessageNode(generator, node) {
+      const { helper, needIndent } = generator;
+      generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+      generator.indent(needIndent());
+      const length = node.items.length;
+      for (let i = 0; i < length; i++) {
+          generateNode(generator, node.items[i]);
+          if (i === length - 1) {
+              break;
+          }
+          generator.push(', ');
+      }
+      generator.deindent(needIndent());
+      generator.push('])');
+  }
+  function generatePluralNode(generator, node) {
+      const { helper, needIndent } = generator;
+      if (node.cases.length > 1) {
+          generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+          generator.indent(needIndent());
+          const length = node.cases.length;
+          for (let i = 0; i < length; i++) {
+              generateNode(generator, node.cases[i]);
+              if (i === length - 1) {
+                  break;
+              }
+              generator.push(', ');
+          }
+          generator.deindent(needIndent());
+          generator.push(`])`);
+      }
+  }
+  function generateResource(generator, node) {
+      if (node.body) {
+          generateNode(generator, node.body);
+      }
+      else {
+          generator.push('null');
+      }
+  }
+  function generateNode(generator, node) {
+      const { helper } = generator;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */:
+              generateResource(generator, node);
+              break;
+          case 1 /* NodeTypes.Plural */:
+              generatePluralNode(generator, node);
+              break;
+          case 2 /* NodeTypes.Message */:
+              generateMessageNode(generator, node);
+              break;
+          case 6 /* NodeTypes.Linked */:
+              generateLinkedNode(generator, node);
+              break;
+          case 8 /* NodeTypes.LinkedModifier */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 7 /* NodeTypes.LinkedKey */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 5 /* NodeTypes.List */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+              break;
+          case 4 /* NodeTypes.Named */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+              break;
+          case 9 /* NodeTypes.Literal */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 3 /* NodeTypes.Text */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN,
+                      args: [node.type]
+                  });
+              }
+      }
+  }
+  // generate code from AST
+  const generate = (ast, options = {} // eslint-disable-line
+  ) => {
+      const mode = isString(options.mode) ? options.mode : 'normal';
+      const filename = isString(options.filename)
+          ? options.filename
+          : 'message.intl';
+      const sourceMap = !!options.sourceMap;
+      // prettier-ignore
+      const breakLineCode = options.breakLineCode != null
+          ? options.breakLineCode
+          : mode === 'arrow'
+              ? ';'
+              : '\n';
+      const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+      const helpers = ast.helpers || [];
+      const generator = createCodeGenerator(ast, {
+          mode,
+          filename,
+          sourceMap,
+          breakLineCode,
+          needIndent
+      });
+      generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+      generator.indent(needIndent);
+      if (helpers.length > 0) {
+          generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+          generator.newline();
+      }
+      generator.push(`return `);
+      generateNode(generator, ast);
+      generator.deindent(needIndent);
+      generator.push(`}`);
+      delete ast.helpers;
+      const { code, map } = generator.context();
+      return {
+          ast,
+          code,
+          map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+      };
+  };
+
+  function baseCompile$1(source, options = {}) {
+      const assignedOptions = assign({}, options);
+      const jit = !!assignedOptions.jit;
+      const enalbeMinify = !!assignedOptions.minify;
+      const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+      // parse source codes
+      const parser = createParser(assignedOptions);
+      const ast = parser.parse(source);
+      if (!jit) {
+          // transform ASTs
+          transform(ast, assignedOptions);
+          // generate javascript codes
+          return generate(ast, assignedOptions);
+      }
+      else {
+          // optimize ASTs
+          enambeOptimize && optimize(ast);
+          // minimize ASTs
+          enalbeMinify && minify(ast);
+          // In JIT mode, no ast transform, no code generation.
+          return { ast, code: '' };
+      }
+  }
+
+  const pathStateMachine =  [];
+  pathStateMachine[0 /* States.BEFORE_PATH */] = {
+      ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+      ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+  };
+  pathStateMachine[1 /* States.IN_PATH */] = {
+      ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+      ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+  };
+  pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+      ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+      ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
+  };
+  pathStateMachine[3 /* States.IN_IDENT */] = {
+      ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+      ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+      ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
+  };
+  pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+      ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+      ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+      ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+          4 /* States.IN_SUB_PATH */,
+          2 /* Actions.INC_SUB_PATH_DEPTH */
+      ],
+      ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+      ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
+  };
+  pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+      ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+      ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
+  };
+  pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+      ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+      ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+      ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
+  };
+  /**
+   * Check if an expression is a literal value.
+   */
+  const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+  function isLiteral(exp) {
+      return literalValueRE.test(exp);
+  }
+  /**
+   * Strip quotes from a string
+   */
+  function stripQuotes(str) {
+      const a = str.charCodeAt(0);
+      const b = str.charCodeAt(str.length - 1);
+      return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+  }
+  /**
+   * Determine the type of a character in a keypath.
+   */
+  function getPathCharType(ch) {
+      if (ch === undefined || ch === null) {
+          return "o" /* PathCharTypes.END_OF_FAIL */;
+      }
+      const code = ch.charCodeAt(0);
+      switch (code) {
+          case 0x5b: // [
+          case 0x5d: // ]
+          case 0x2e: // .
+          case 0x22: // "
+          case 0x27: // '
+              return ch;
+          case 0x5f: // _
+          case 0x24: // $
+          case 0x2d: // -
+              return "i" /* PathCharTypes.IDENT */;
+          case 0x09: // Tab (HT)
+          case 0x0a: // Newline (LF)
+          case 0x0d: // Return (CR)
+          case 0xa0: // No-break space (NBSP)
+          case 0xfeff: // Byte Order Mark (BOM)
+          case 0x2028: // Line Separator (LS)
+          case 0x2029: // Paragraph Separator (PS)
+              return "w" /* PathCharTypes.WORKSPACE */;
+      }
+      return "i" /* PathCharTypes.IDENT */;
+  }
+  /**
+   * Format a subPath, return its plain form if it is
+   * a literal string or number. Otherwise prepend the
+   * dynamic indicator (*).
+   */
+  function formatSubPath(path) {
+      const trimmed = path.trim();
+      // invalid leading 0
+      if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+          return false;
+      }
+      return isLiteral(trimmed)
+          ? stripQuotes(trimmed)
+          : "*" /* PathCharTypes.ASTARISK */ + trimmed;
+  }
+  /**
+   * Parse a string path into an array of segments
+   */
+  function parse(path) {
+      const keys = [];
+      let index = -1;
+      let mode = 0 /* States.BEFORE_PATH */;
+      let subPathDepth = 0;
+      let c;
+      let key; // eslint-disable-line
+      let newChar;
+      let type;
+      let transition;
+      let action;
+      let typeMap;
+      const actions = [];
+      actions[0 /* Actions.APPEND */] = () => {
+          if (key === undefined) {
+              key = newChar;
+          }
+          else {
+              key += newChar;
+          }
+      };
+      actions[1 /* Actions.PUSH */] = () => {
+          if (key !== undefined) {
+              keys.push(key);
+              key = undefined;
+          }
+      };
+      actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+          actions[0 /* Actions.APPEND */]();
+          subPathDepth++;
+      };
+      actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
+          if (subPathDepth > 0) {
+              subPathDepth--;
+              mode = 4 /* States.IN_SUB_PATH */;
+              actions[0 /* Actions.APPEND */]();
+          }
+          else {
+              subPathDepth = 0;
+              if (key === undefined) {
+                  return false;
+              }
+              key = formatSubPath(key);
+              if (key === false) {
+                  return false;
+              }
+              else {
+                  actions[1 /* Actions.PUSH */]();
+              }
+          }
+      };
+      function maybeUnescapeQuote() {
+          const nextChar = path[index + 1];
+          if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+              nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+              (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                  nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
+              index++;
+              newChar = '\\' + nextChar;
+              actions[0 /* Actions.APPEND */]();
+              return true;
+          }
+      }
+      while (mode !== null) {
+          index++;
+          c = path[index];
+          if (c === '\\' && maybeUnescapeQuote()) {
+              continue;
+          }
+          type = getPathCharType(c);
+          typeMap = pathStateMachine[mode];
+          transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
+          // check parse error
+          if (transition === 8 /* States.ERROR */) {
+              return;
+          }
+          mode = transition[0];
+          if (transition[1] !== undefined) {
+              action = actions[transition[1]];
+              if (action) {
+                  newChar = c;
+                  if (action() === false) {
+                      return;
+                  }
+              }
+          }
+          // check parse finish
+          if (mode === 7 /* States.AFTER_PATH */) {
+              return keys;
+          }
+      }
+  }
+  // path token cache
+  const cache = new Map();
+  /**
+   * key-value message resolver
+   *
+   * @remarks
+   * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+   *
+   * @param obj - A target object to be resolved with path
+   * @param path - A {@link Path | path} to resolve the value of message
+   *
+   * @returns A resolved {@link PathValue | path value}
+   *
+   * @VueI18nGeneral
+   */
+  function resolveWithKeyValue(obj, path) {
+      return isObject(obj) ? obj[path] : null;
+  }
+  /**
+   * message resolver
+   *
+   * @remarks
+   * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+   *
+   * @param obj - A target object to be resolved with path
+   * @param path - A {@link Path | path} to resolve the value of message
+   *
+   * @returns A resolved {@link PathValue | path value}
+   *
+   * @VueI18nGeneral
+   */
+  function resolveValue(obj, path) {
+      // check object
+      if (!isObject(obj)) {
+          return null;
+      }
+      // parse path
+      let hit = cache.get(path);
+      if (!hit) {
+          hit = parse(path);
+          if (hit) {
+              cache.set(path, hit);
+          }
+      }
+      // check hit
+      if (!hit) {
+          return null;
+      }
+      // resolve path value
+      const len = hit.length;
+      let last = obj;
+      let i = 0;
+      while (i < len) {
+          const val = last[hit[i]];
+          if (val === undefined) {
+              return null;
+          }
+          last = val;
+          i++;
+      }
+      return last;
+  }
+
+  const DEFAULT_MODIFIER = (str) => str;
+  const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+  const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+  const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : join(values);
+  const DEFAULT_INTERPOLATE = toDisplayString;
+  function pluralDefault(choice, choicesLength) {
+      choice = Math.abs(choice);
+      if (choicesLength === 2) {
+          // prettier-ignore
+          return choice
+              ? choice > 1
+                  ? 1
+                  : 0
+              : 1;
+      }
+      return choice ? Math.min(choice, 2) : 0;
+  }
+  function getPluralIndex(options) {
+      // prettier-ignore
+      const index = isNumber(options.pluralIndex)
+          ? options.pluralIndex
+          : -1;
+      // prettier-ignore
+      return options.named && (isNumber(options.named.count) || isNumber(options.named.n))
+          ? isNumber(options.named.count)
+              ? options.named.count
+              : isNumber(options.named.n)
+                  ? options.named.n
+                  : index
+          : index;
+  }
+  function normalizeNamed(pluralIndex, props) {
+      if (!props.count) {
+          props.count = pluralIndex;
+      }
+      if (!props.n) {
+          props.n = pluralIndex;
+      }
+  }
+  function createMessageContext(options = {}) {
+      const locale = options.locale;
+      const pluralIndex = getPluralIndex(options);
+      const pluralRule = isObject(options.pluralRules) &&
+          isString(locale) &&
+          isFunction(options.pluralRules[locale])
+          ? options.pluralRules[locale]
+          : pluralDefault;
+      const orgPluralRule = isObject(options.pluralRules) &&
+          isString(locale) &&
+          isFunction(options.pluralRules[locale])
+          ? pluralDefault
+          : undefined;
+      const plural = (messages) => {
+          return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+      };
+      const _list = options.list || [];
+      const list = (index) => _list[index];
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const _named = options.named || {};
+      isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+      const named = (key) => _named[key];
+      function message(key) {
+          // prettier-ignore
+          const msg = isFunction(options.messages)
+              ? options.messages(key)
+              : isObject(options.messages)
+                  ? options.messages[key]
+                  : false;
+          return !msg
+              ? options.parent
+                  ? options.parent.message(key) // resolve from parent messages
+                  : DEFAULT_MESSAGE
+              : msg;
+      }
+      const _modifier = (name) => options.modifiers
+          ? options.modifiers[name]
+          : DEFAULT_MODIFIER;
+      const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize)
+          ? options.processor.normalize
+          : DEFAULT_NORMALIZE;
+      const interpolate = isPlainObject(options.processor) &&
+          isFunction(options.processor.interpolate)
+          ? options.processor.interpolate
+          : DEFAULT_INTERPOLATE;
+      const type = isPlainObject(options.processor) && isString(options.processor.type)
+          ? options.processor.type
+          : DEFAULT_MESSAGE_DATA_TYPE;
+      const linked = (key, ...args) => {
+          const [arg1, arg2] = args;
+          let type = 'text';
+          let modifier = '';
+          if (args.length === 1) {
+              if (isObject(arg1)) {
+                  modifier = arg1.modifier || modifier;
+                  type = arg1.type || type;
+              }
+              else if (isString(arg1)) {
+                  modifier = arg1 || modifier;
+              }
+          }
+          else if (args.length === 2) {
+              if (isString(arg1)) {
+                  modifier = arg1 || modifier;
+              }
+              if (isString(arg2)) {
+                  type = arg2 || type;
+              }
+          }
+          const ret = message(key)(ctx);
+          const msg = 
+          // The message in vnode resolved with linked are returned as an array by processor.nomalize
+          type === 'vnode' && isArray(ret) && modifier
+              ? ret[0]
+              : ret;
+          return modifier ? _modifier(modifier)(msg, type) : msg;
+      };
+      const ctx = {
+          ["list" /* HelperNameMap.LIST */]: list,
+          ["named" /* HelperNameMap.NAMED */]: named,
+          ["plural" /* HelperNameMap.PLURAL */]: plural,
+          ["linked" /* HelperNameMap.LINKED */]: linked,
+          ["message" /* HelperNameMap.MESSAGE */]: message,
+          ["type" /* HelperNameMap.TYPE */]: type,
+          ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+          ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
+          ["values" /* HelperNameMap.VALUES */]: assign({}, _list, _named)
+      };
+      return ctx;
+  }
+
+  let devtools = null;
+  function setDevToolsHook(hook) {
+      devtools = hook;
+  }
+  function getDevToolsHook() {
+      return devtools;
+  }
+  function initI18nDevTools(i18n, version, meta) {
+      // TODO: queue if devtools is undefined
+      devtools &&
+          devtools.emit("i18n:init" /* IntlifyDevToolsHooks.I18nInit */, {
+              timestamp: Date.now(),
+              i18n,
+              version,
+              meta
+          });
+  }
+  const translateDevTools = /* #__PURE__*/ createDevToolsHook("function:translate" /* IntlifyDevToolsHooks.FunctionTranslate */);
+  function createDevToolsHook(hook) {
+      return (payloads) => devtools && devtools.emit(hook, payloads);
+  }
+
+  const CoreWarnCodes = {
+      NOT_FOUND_KEY: 1,
+      FALLBACK_TO_TRANSLATE: 2,
+      CANNOT_FORMAT_NUMBER: 3,
+      FALLBACK_TO_NUMBER_FORMAT: 4,
+      CANNOT_FORMAT_DATE: 5,
+      FALLBACK_TO_DATE_FORMAT: 6,
+      EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7,
+      __EXTEND_POINT__: 8
+  };
+  /** @internal */
+  const warnMessages = {
+      [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+      [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+      [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+      [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+      [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+      [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
+      [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`
+  };
+  function getWarnMessage(code, ...args) {
+      return format$1(warnMessages[code], ...args);
+  }
+
+  /** @internal */
+  function getLocale(context, options) {
+      return options.locale != null
+          ? resolveLocale(options.locale)
+          : resolveLocale(context.locale);
+  }
+  let _resolveLocale;
+  /** @internal */
+  function resolveLocale(locale) {
+      // prettier-ignore
+      return isString(locale)
+          ? locale
+          : _resolveLocale != null && locale.resolvedOnce
+              ? _resolveLocale
+              : (_resolveLocale = locale());
+  }
+  /**
+   * Fallback with simple implemenation
+   *
+   * @remarks
+   * A fallback locale function implemented with a simple fallback algorithm.
+   *
+   * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+   *
+   * @param ctx - A {@link CoreContext | context}
+   * @param fallback - A {@link FallbackLocale | fallback locale}
+   * @param start - A starting {@link Locale | locale}
+   *
+   * @returns Fallback locales
+   *
+   * @VueI18nGeneral
+   */
+  function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
+  ) {
+      // prettier-ignore
+      return [...new Set([
+              start,
+              ...(isArray(fallback)
+                  ? fallback
+                  : isObject(fallback)
+                      ? Object.keys(fallback)
+                      : isString(fallback)
+                          ? [fallback]
+                          : [start])
+          ])];
+  }
+  /**
+   * Fallback with locale chain
+   *
+   * @remarks
+   * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+   *
+   * @param ctx - A {@link CoreContext | context}
+   * @param fallback - A {@link FallbackLocale | fallback locale}
+   * @param start - A starting {@link Locale | locale}
+   *
+   * @returns Fallback locales
+   *
+   * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+   *
+   * @VueI18nGeneral
+   */
+  function fallbackWithLocaleChain(ctx, fallback, start) {
+      const startLocale = isString(start) ? start : DEFAULT_LOCALE;
+      const context = ctx;
+      if (!context.__localeChainCache) {
+          context.__localeChainCache = new Map();
+      }
+      let chain = context.__localeChainCache.get(startLocale);
+      if (!chain) {
+          chain = [];
+          // first block defined by start
+          let block = [start];
+          // while any intervening block found
+          while (isArray(block)) {
+              block = appendBlockToChain(chain, block, fallback);
+          }
+          // prettier-ignore
+          // last block defined by default
+          const defaults = isArray(fallback) || !isPlainObject(fallback)
+              ? fallback
+              : fallback['default']
+                  ? fallback['default']
+                  : null;
+          // convert defaults to array
+          block = isString(defaults) ? [defaults] : defaults;
+          if (isArray(block)) {
+              appendBlockToChain(chain, block, false);
+          }
+          context.__localeChainCache.set(startLocale, chain);
+      }
+      return chain;
+  }
+  function appendBlockToChain(chain, block, blocks) {
+      let follow = true;
+      for (let i = 0; i < block.length && isBoolean(follow); i++) {
+          const locale = block[i];
+          if (isString(locale)) {
+              follow = appendLocaleToChain(chain, block[i], blocks);
+          }
+      }
+      return follow;
+  }
+  function appendLocaleToChain(chain, locale, blocks) {
+      let follow;
+      const tokens = locale.split('-');
+      do {
+          const target = tokens.join('-');
+          follow = appendItemToChain(chain, target, blocks);
+          tokens.splice(-1, 1);
+      } while (tokens.length && follow === true);
+      return follow;
+  }
+  function appendItemToChain(chain, target, blocks) {
+      let follow = false;
+      if (!chain.includes(target)) {
+          follow = true;
+          if (target) {
+              follow = target[target.length - 1] !== '!';
+              const locale = target.replace(/!/g, '');
+              chain.push(locale);
+              if ((isArray(blocks) || isPlainObject(blocks)) &&
+                  blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any
+              ) {
+                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  follow = blocks[locale];
+              }
+          }
+      }
+      return follow;
+  }
+
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  /**
+   * Intlify core-base version
+   * @internal
+   */
+  const VERSION = '9.5.0';
+  const NOT_REOSLVED = -1;
+  const DEFAULT_LOCALE = 'en-US';
+  const MISSING_RESOLVE_VALUE = '';
+  const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+  function getDefaultLinkedModifiers() {
+      return {
+          upper: (val, type) => {
+              // prettier-ignore
+              return type === 'text' && isString(val)
+                  ? val.toUpperCase()
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? val.children.toUpperCase()
+                      : val;
+          },
+          lower: (val, type) => {
+              // prettier-ignore
+              return type === 'text' && isString(val)
+                  ? val.toLowerCase()
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? val.children.toLowerCase()
+                      : val;
+          },
+          capitalize: (val, type) => {
+              // prettier-ignore
+              return (type === 'text' && isString(val)
+                  ? capitalize(val)
+                  : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                      ? capitalize(val.children)
+                      : val);
+          }
+      };
+  }
+  let _compiler;
+  function registerMessageCompiler(compiler) {
+      _compiler = compiler;
+  }
+  let _resolver;
+  /**
+   * Register the message resolver
+   *
+   * @param resolver - A {@link MessageResolver} function
+   *
+   * @VueI18nGeneral
+   */
+  function registerMessageResolver(resolver) {
+      _resolver = resolver;
+  }
+  let _fallbacker;
+  /**
+   * Register the locale fallbacker
+   *
+   * @param fallbacker - A {@link LocaleFallbacker} function
+   *
+   * @VueI18nGeneral
+   */
+  function registerLocaleFallbacker(fallbacker) {
+      _fallbacker = fallbacker;
+  }
+  // Additional Meta for Intlify DevTools
+  let _additionalMeta =  null;
+  const setAdditionalMeta = /* #__PURE__*/ (meta) => {
+      _additionalMeta = meta;
+  };
+  const getAdditionalMeta = /* #__PURE__*/ () => _additionalMeta;
+  let _fallbackContext = null;
+  const setFallbackContext = (context) => {
+      _fallbackContext = context;
+  };
+  const getFallbackContext = () => _fallbackContext;
+  // ID for CoreContext
+  let _cid = 0;
+  function createCoreContext(options = {}) {
+      // setup options
+      const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;
+      const version = isString(options.version) ? options.version : VERSION;
+      const locale = isString(options.locale) || isFunction(options.locale)
+          ? options.locale
+          : DEFAULT_LOCALE;
+      const _locale = isFunction(locale) ? DEFAULT_LOCALE : locale;
+      const fallbackLocale = isArray(options.fallbackLocale) ||
+          isPlainObject(options.fallbackLocale) ||
+          isString(options.fallbackLocale) ||
+          options.fallbackLocale === false
+          ? options.fallbackLocale
+          : _locale;
+      const messages = isPlainObject(options.messages)
+          ? options.messages
+          : { [_locale]: {} };
+      const datetimeFormats = isPlainObject(options.datetimeFormats)
+              ? options.datetimeFormats
+              : { [_locale]: {} }
+          ;
+      const numberFormats = isPlainObject(options.numberFormats)
+              ? options.numberFormats
+              : { [_locale]: {} }
+          ;
+      const modifiers = assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
+      const pluralRules = options.pluralRules || {};
+      const missing = isFunction(options.missing) ? options.missing : null;
+      const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+          ? options.missingWarn
+          : true;
+      const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+          ? options.fallbackWarn
+          : true;
+      const fallbackFormat = !!options.fallbackFormat;
+      const unresolving = !!options.unresolving;
+      const postTranslation = isFunction(options.postTranslation)
+          ? options.postTranslation
+          : null;
+      const processor = isPlainObject(options.processor) ? options.processor : null;
+      const warnHtmlMessage = isBoolean(options.warnHtmlMessage)
+          ? options.warnHtmlMessage
+          : true;
+      const escapeParameter = !!options.escapeParameter;
+      const messageCompiler = isFunction(options.messageCompiler)
+          ? options.messageCompiler
+          : _compiler;
+      const messageResolver = isFunction(options.messageResolver)
+          ? options.messageResolver
+          : _resolver || resolveWithKeyValue;
+      const localeFallbacker = isFunction(options.localeFallbacker)
+          ? options.localeFallbacker
+          : _fallbacker || fallbackWithSimple;
+      const fallbackContext = isObject(options.fallbackContext)
+          ? options.fallbackContext
+          : undefined;
+      // setup internal options
+      const internalOptions = options;
+      const __datetimeFormatters = isObject(internalOptions.__datetimeFormatters)
+              ? internalOptions.__datetimeFormatters
+              : new Map()
+          ;
+      const __numberFormatters = isObject(internalOptions.__numberFormatters)
+              ? internalOptions.__numberFormatters
+              : new Map()
+          ;
+      const __meta = isObject(internalOptions.__meta) ? internalOptions.__meta : {};
+      _cid++;
+      const context = {
+          version,
+          cid: _cid,
+          locale,
+          fallbackLocale,
+          messages,
+          modifiers,
+          pluralRules,
+          missing,
+          missingWarn,
+          fallbackWarn,
+          fallbackFormat,
+          unresolving,
+          postTranslation,
+          processor,
+          warnHtmlMessage,
+          escapeParameter,
+          messageCompiler,
+          messageResolver,
+          localeFallbacker,
+          fallbackContext,
+          onWarn,
+          __meta
+      };
+      {
+          context.datetimeFormats = datetimeFormats;
+          context.numberFormats = numberFormats;
+          context.__datetimeFormatters = __datetimeFormatters;
+          context.__numberFormatters = __numberFormatters;
+      }
+      // for vue-devtools timeline event
+      {
+          context.__v_emitter =
+              internalOptions.__v_emitter != null
+                  ? internalOptions.__v_emitter
+                  : undefined;
+      }
+      // NOTE: experimental !!
+      {
+          initI18nDevTools(context, version, __meta);
+      }
+      return context;
+  }
+  /** @internal */
+  function isTranslateFallbackWarn(fallback, key) {
+      return fallback instanceof RegExp ? fallback.test(key) : fallback;
+  }
+  /** @internal */
+  function isTranslateMissingWarn(missing, key) {
+      return missing instanceof RegExp ? missing.test(key) : missing;
+  }
+  /** @internal */
+  function handleMissing(context, key, locale, missingWarn, type) {
+      const { missing, onWarn } = context;
+      // for vue-devtools timeline event
+      {
+          const emitter = context.__v_emitter;
+          if (emitter) {
+              emitter.emit("missing" /* VueDevToolsTimelineEvents.MISSING */, {
+                  locale,
+                  key,
+                  type,
+                  groupId: `${type}:${key}`
+              });
+          }
+      }
+      if (missing !== null) {
+          const ret = missing(context, locale, key, type);
+          return isString(ret) ? ret : key;
+      }
+      else {
+          if (isTranslateMissingWarn(missingWarn, key)) {
+              onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
+          }
+          return key;
+      }
+  }
+  /** @internal */
+  function updateFallbackLocale(ctx, locale, fallback) {
+      const context = ctx;
+      context.__localeChainCache = new Map();
+      ctx.localeFallbacker(ctx, fallback, locale);
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  function format(ast) {
+      const msg = (ctx) => formatParts(ctx, ast);
+      return msg;
+  }
+  function formatParts(ctx, ast) {
+      const body = ast.b || ast.body;
+      if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+          const plural = body;
+          const cases = plural.c || plural.cases;
+          return ctx.plural(cases.reduce((messages, c) => [
+              ...messages,
+              formatMessageParts(ctx, c)
+          ], []));
+      }
+      else {
+          return formatMessageParts(ctx, body);
+      }
+  }
+  function formatMessageParts(ctx, node) {
+      const _static = node.s || node.static;
+      if (_static) {
+          return ctx.type === 'text'
+              ? _static
+              : ctx.normalize([_static]);
+      }
+      else {
+          const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+          return ctx.normalize(messages);
+      }
+  }
+  function formatMessagePart(ctx, node) {
+      const type = node.t || node.type;
+      switch (type) {
+          case 3 /* NodeTypes.Text */:
+              const text = node;
+              return (text.v || text.value);
+          case 9 /* NodeTypes.Literal */:
+              const literal = node;
+              return (literal.v || literal.value);
+          case 4 /* NodeTypes.Named */:
+              const named = node;
+              return ctx.interpolate(ctx.named(named.k || named.key));
+          case 5 /* NodeTypes.List */:
+              const list = node;
+              return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
+          case 6 /* NodeTypes.Linked */:
+              const linked = node;
+              const modifier = linked.m || linked.modifier;
+              return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
+          case 7 /* NodeTypes.LinkedKey */:
+              const linkedKey = node;
+              return (linkedKey.v || linkedKey.value);
+          case 8 /* NodeTypes.LinkedModifier */:
+              const linkedModifier = node;
+              return (linkedModifier.v || linkedModifier.value);
+          default:
+              throw new Error(`unhandled node type on format message part: ${type}`);
+      }
+  }
+
+  const code = CompileErrorCodes.__EXTEND_POINT__;
+  const inc = incrementer(code);
+  const CoreErrorCodes = {
+      INVALID_ARGUMENT: code,
+      INVALID_DATE_ARGUMENT: inc(),
+      INVALID_ISO_DATE_ARGUMENT: inc(),
+      NOT_SUPPORT_NON_STRING_MESSAGE: inc(),
+      __EXTEND_POINT__: inc() // 22
+  };
+  function createCoreError(code) {
+      return createCompileError(code, null, { messages: errorMessages } );
+  }
+  /** @internal */
+  const errorMessages = {
+      [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',
+      [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +
+          'Make sure your Date represents a valid date.',
+      [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string',
+      [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]: 'Not support non-string message'
+  };
+
+  const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
+  function checkHtmlMessage(source, warnHtmlMessage) {
+      if (warnHtmlMessage && detectHtmlTag(source)) {
+          warn(format$1(WARN_MESSAGE, { source }));
+      }
+  }
+  const defaultOnCacheKey = (message) => message;
+  let compileCache = Object.create(null);
+  function clearCompileCache() {
+      compileCache = Object.create(null);
+  }
+  const isMessageAST = (val) => isObject(val) &&
+      (val.t === 0 || val.type === 0) &&
+      ('b' in val || 'body' in val);
+  function baseCompile(message, options = {}) {
+      // error detecting on compile
+      let detectError = false;
+      const onError = options.onError || defaultOnError;
+      options.onError = (err) => {
+          detectError = true;
+          onError(err);
+      };
+      // compile with mesasge-compiler
+      return { ...baseCompile$1(message, options), detectError };
+  }
+  const compileToFunction = /* #__PURE__*/ (message, context) => {
+      if (!isString(message)) {
+          throw createCoreError(CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE);
+      }
+      {
+          // check HTML message
+          const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
+              ? context.warnHtmlMessage
+              : true;
+          checkHtmlMessage(message, warnHtmlMessage);
+          // check caches
+          const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+          const cacheKey = onCacheKey(message);
+          const cached = compileCache[cacheKey];
+          if (cached) {
+              return cached;
+          }
+          // compile
+          const { code, detectError } = baseCompile(message, context);
+          // evaluate function
+          const msg = new Function(`return ${code}`)();
+          // if occurred compile error, don't cache
+          return !detectError
+              ? (compileCache[cacheKey] = msg)
+              : msg;
+      }
+  };
+  function compile(message, context) {
+      if (isString(message)) {
+          // check HTML message
+          const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
+              ? context.warnHtmlMessage
+              : true;
+          checkHtmlMessage(message, warnHtmlMessage);
+          // check caches
+          const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+          const cacheKey = onCacheKey(message);
+          const cached = compileCache[cacheKey];
+          if (cached) {
+              return cached;
+          }
+          // compile with JIT mode
+          const { ast, detectError } = baseCompile(message, {
+              ...context,
+              location: true,
+              jit: true
+          });
+          // compose message function from AST
+          const msg = format(ast);
+          // if occurred compile error, don't cache
+          return !detectError
+              ? (compileCache[cacheKey] = msg)
+              : msg;
+      }
+      else {
+          if (!isMessageAST(message)) {
+              warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
+              return (() => message);
+          }
+          // AST case (passed from bundler)
+          const cacheKey = message.cacheKey;
+          if (cacheKey) {
+              const cached = compileCache[cacheKey];
+              if (cached) {
+                  return cached;
+              }
+              // compose message function from message (AST)
+              return (compileCache[cacheKey] =
+                  format(message));
+          }
+          else {
+              return format(message);
+          }
+      }
+  }
+
+  const NOOP_MESSAGE_FUNCTION = () => '';
+  const isMessageFunction = (val) => isFunction(val);
+  // implementation of `translate` function
+  function translate(context, ...args) {
+      const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+      const [key, options] = parseTranslateArgs(...args);
+      const missingWarn = isBoolean(options.missingWarn)
+          ? options.missingWarn
+          : context.missingWarn;
+      const fallbackWarn = isBoolean(options.fallbackWarn)
+          ? options.fallbackWarn
+          : context.fallbackWarn;
+      const escapeParameter = isBoolean(options.escapeParameter)
+          ? options.escapeParameter
+          : context.escapeParameter;
+      const resolvedMessage = !!options.resolvedMessage;
+      // prettier-ignore
+      const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option
+          ? !isBoolean(options.default)
+              ? options.default
+              : (!messageCompiler ? () => key : key)
+          : fallbackFormat // default by `fallbackFormat` option
+              ? (!messageCompiler ? () => key : key)
+              : '';
+      const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';
+      const locale = getLocale(context, options);
+      // escape params
+      escapeParameter && escapeParams(options);
+      // resolve message format
+      // eslint-disable-next-line prefer-const
+      let [formatScope, targetLocale, message] = !resolvedMessage
+          ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+          : [
+              key,
+              locale,
+              messages[locale] || {}
+          ];
+      // NOTE:
+      //  Fix to work around `ssrTransfrom` bug in Vite.
+      //  https://github.com/vitejs/vite/issues/4306
+      //  To get around this, use temporary variables.
+      //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+      let format = formatScope;
+      // if you use default message, set it as message format!
+      let cacheBaseKey = key;
+      if (!resolvedMessage &&
+          !(isString(format) ||
+              isMessageAST(format) ||
+              isMessageFunction(format))) {
+          if (enableDefaultMsg) {
+              format = defaultMsgOrKey;
+              cacheBaseKey = format;
+          }
+      }
+      // checking message format and target locale
+      if (!resolvedMessage &&
+          (!(isString(format) ||
+              isMessageAST(format) ||
+              isMessageFunction(format)) ||
+              !isString(targetLocale))) {
+          return unresolving ? NOT_REOSLVED : key;
+      }
+      // TODO: refactor
+      if (isString(format) && context.messageCompiler == null) {
+          warn(`The message format compilation is not supported in this build. ` +
+              `Because message compiler isn't included. ` +
+              `You need to pre-compilation all message format. ` +
+              `So translate function return '${key}'.`);
+          return key;
+      }
+      // setup compile error detecting
+      let occurred = false;
+      const onError = () => {
+          occurred = true;
+      };
+      // compile message format
+      const msg = !isMessageFunction(format)
+          ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
+          : format;
+      // if occurred compile error, return the message format
+      if (occurred) {
+          return format;
+      }
+      // evaluate message with context
+      const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+      const msgContext = createMessageContext(ctxOptions);
+      const messaged = evaluateMessage(context, msg, msgContext);
+      // if use post translation option, proceed it with handler
+      const ret = postTranslation
+          ? postTranslation(messaged, key)
+          : messaged;
+      // NOTE: experimental !!
+      {
+          // prettier-ignore
+          const payloads = {
+              timestamp: Date.now(),
+              key: isString(key)
+                  ? key
+                  : isMessageFunction(format)
+                      ? format.key
+                      : '',
+              locale: targetLocale || (isMessageFunction(format)
+                  ? format.locale
+                  : ''),
+              format: isString(format)
+                  ? format
+                  : isMessageFunction(format)
+                      ? format.source
+                      : '',
+              message: ret
+          };
+          payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
+          translateDevTools(payloads);
+      }
+      return ret;
+  }
+  function escapeParams(options) {
+      if (isArray(options.list)) {
+          options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);
+      }
+      else if (isObject(options.named)) {
+          Object.keys(options.named).forEach(key => {
+              if (isString(options.named[key])) {
+                  options.named[key] = escapeHtml(options.named[key]);
+              }
+          });
+      }
+  }
+  function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+      const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+      const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+      let message = {};
+      let targetLocale;
+      let format = null;
+      let from = locale;
+      let to = null;
+      const type = 'translate';
+      for (let i = 0; i < locales.length; i++) {
+          targetLocale = to = locales[i];
+          if (locale !== targetLocale &&
+              isTranslateFallbackWarn(fallbackWarn, key)) {
+              onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
+                  key,
+                  target: targetLocale
+              }));
+          }
+          // for vue-devtools timeline event
+          if (locale !== targetLocale) {
+              const emitter = context.__v_emitter;
+              if (emitter) {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                      type,
+                      key,
+                      from,
+                      to,
+                      groupId: `${type}:${key}`
+                  });
+              }
+          }
+          message =
+              messages[targetLocale] || {};
+          // for vue-devtools timeline event
+          let start = null;
+          let startTag;
+          let endTag;
+          if (inBrowser) {
+              start = window.performance.now();
+              startTag = 'intlify-message-resolve-start';
+              endTag = 'intlify-message-resolve-end';
+              mark && mark(startTag);
+          }
+          if ((format = resolveValue(message, key)) === null) {
+              // if null, resolve with object key path
+              format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+          }
+          // for vue-devtools timeline event
+          if (inBrowser) {
+              const end = window.performance.now();
+              const emitter = context.__v_emitter;
+              if (emitter && start && format) {
+                  emitter.emit("message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */, {
+                      type: "message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */,
+                      key,
+                      message: format,
+                      time: end - start,
+                      groupId: `${type}:${key}`
+                  });
+              }
+              if (startTag && endTag && mark && measure) {
+                  mark(endTag);
+                  measure('intlify message resolve', startTag, endTag);
+              }
+          }
+          if (isString(format) || isMessageAST(format) || isMessageFunction(format)) {
+              break;
+          }
+          const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+          key, targetLocale, missingWarn, type);
+          if (missingRet !== key) {
+              format = missingRet;
+          }
+          from = to;
+      }
+      return [format, targetLocale, message];
+  }
+  function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
+      const { messageCompiler, warnHtmlMessage } = context;
+      if (isMessageFunction(format)) {
+          const msg = format;
+          msg.locale = msg.locale || targetLocale;
+          msg.key = msg.key || key;
+          return msg;
+      }
+      if (messageCompiler == null) {
+          const msg = (() => format);
+          msg.locale = targetLocale;
+          msg.key = key;
+          return msg;
+      }
+      // for vue-devtools timeline event
+      let start = null;
+      let startTag;
+      let endTag;
+      if (inBrowser) {
+          start = window.performance.now();
+          startTag = 'intlify-message-compilation-start';
+          endTag = 'intlify-message-compilation-end';
+          mark && mark(startTag);
+      }
+      const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+      // for vue-devtools timeline event
+      if (inBrowser) {
+          const end = window.performance.now();
+          const emitter = context.__v_emitter;
+          if (emitter && start) {
+              emitter.emit("message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */, {
+                  type: "message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */,
+                  message: format,
+                  time: end - start,
+                  groupId: `${'translate'}:${key}`
+              });
+          }
+          if (startTag && endTag && mark && measure) {
+              mark(endTag);
+              measure('intlify message compilation', startTag, endTag);
+          }
+      }
+      msg.locale = targetLocale;
+      msg.key = key;
+      msg.source = format;
+      return msg;
+  }
+  function evaluateMessage(context, msg, msgCtx) {
+      // for vue-devtools timeline event
+      let start = null;
+      let startTag;
+      let endTag;
+      if (inBrowser) {
+          start = window.performance.now();
+          startTag = 'intlify-message-evaluation-start';
+          endTag = 'intlify-message-evaluation-end';
+          mark && mark(startTag);
+      }
+      const messaged = msg(msgCtx);
+      // for vue-devtools timeline event
+      if (inBrowser) {
+          const end = window.performance.now();
+          const emitter = context.__v_emitter;
+          if (emitter && start) {
+              emitter.emit("message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */, {
+                  type: "message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */,
+                  value: messaged,
+                  time: end - start,
+                  groupId: `${'translate'}:${msg.key}`
+              });
+          }
+          if (startTag && endTag && mark && measure) {
+              mark(endTag);
+              measure('intlify message evaluation', startTag, endTag);
+          }
+      }
+      return messaged;
+  }
+  /** @internal */
+  function parseTranslateArgs(...args) {
+      const [arg1, arg2, arg3] = args;
+      const options = {};
+      if (!isString(arg1) &&
+          !isNumber(arg1) &&
+          !isMessageFunction(arg1) &&
+          !isMessageAST(arg1)) {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      // prettier-ignore
+      const key = isNumber(arg1)
+          ? String(arg1)
+          : isMessageFunction(arg1)
+              ? arg1
+              : arg1;
+      if (isNumber(arg2)) {
+          options.plural = arg2;
+      }
+      else if (isString(arg2)) {
+          options.default = arg2;
+      }
+      else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
+          options.named = arg2;
+      }
+      else if (isArray(arg2)) {
+          options.list = arg2;
+      }
+      if (isNumber(arg3)) {
+          options.plural = arg3;
+      }
+      else if (isString(arg3)) {
+          options.default = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          assign(options, arg3);
+      }
+      return [key, options];
+  }
+  function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
+      return {
+          locale,
+          key,
+          warnHtmlMessage,
+          onError: (err) => {
+              onError && onError(err);
+              {
+                  const _source = getSourceForCodeFrame(source);
+                  const message = `Message compilation error: ${err.message}`;
+                  const codeFrame = err.location &&
+                      _source &&
+                      generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);
+                  const emitter = context.__v_emitter;
+                  if (emitter && _source) {
+                      emitter.emit("compile-error" /* VueDevToolsTimelineEvents.COMPILE_ERROR */, {
+                          message: _source,
+                          error: err.message,
+                          start: err.location && err.location.start.offset,
+                          end: err.location && err.location.end.offset,
+                          groupId: `${'translate'}:${key}`
+                      });
+                  }
+                  console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+              }
+          },
+          onCacheKey: (source) => generateFormatCacheKey(locale, key, source)
+      };
+  }
+  function getSourceForCodeFrame(source) {
+      if (isString(source)) ;
+      else {
+          if (source.loc?.source) {
+              return source.loc.source;
+          }
+      }
+  }
+  function getMessageContextOptions(context, locale, message, options) {
+      const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+      const resolveMessage = (key) => {
+          let val = resolveValue(message, key);
+          // fallback to root context
+          if (val == null && fallbackContext) {
+              const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
+              val = resolveValue(message, key);
+          }
+          if (isString(val) || isMessageAST(val)) {
+              let occurred = false;
+              const onError = () => {
+                  occurred = true;
+              };
+              const msg = compileMessageFormat(context, key, locale, val, key, onError);
+              return !occurred
+                  ? msg
+                  : NOOP_MESSAGE_FUNCTION;
+          }
+          else if (isMessageFunction(val)) {
+              return val;
+          }
+          else {
+              // TODO: should be implemented warning message
+              return NOOP_MESSAGE_FUNCTION;
+          }
+      };
+      const ctxOptions = {
+          locale,
+          modifiers,
+          pluralRules,
+          messages: resolveMessage
+      };
+      if (context.processor) {
+          ctxOptions.processor = context.processor;
+      }
+      if (options.list) {
+          ctxOptions.list = options.list;
+      }
+      if (options.named) {
+          ctxOptions.named = options.named;
+      }
+      if (isNumber(options.plural)) {
+          ctxOptions.pluralIndex = options.plural;
+      }
+      return ctxOptions;
+  }
+
+  const intlDefined = typeof Intl !== 'undefined';
+  const Availabilities = {
+      dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
+      numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
+  };
+
+  // implementation of `datetime` function
+  function datetime(context, ...args) {
+      const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+      const { __datetimeFormatters } = context;
+      if (!Availabilities.dateTimeFormat) {
+          onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
+          return MISSING_RESOLVE_VALUE;
+      }
+      const [key, value, options, overrides] = parseDateTimeArgs(...args);
+      const missingWarn = isBoolean(options.missingWarn)
+          ? options.missingWarn
+          : context.missingWarn;
+      const fallbackWarn = isBoolean(options.fallbackWarn)
+          ? options.fallbackWarn
+          : context.fallbackWarn;
+      const part = !!options.part;
+      const locale = getLocale(context, options);
+      const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+      fallbackLocale, locale);
+      if (!isString(key) || key === '') {
+          return new Intl.DateTimeFormat(locale, overrides).format(value);
+      }
+      // resolve format
+      let datetimeFormat = {};
+      let targetLocale;
+      let format = null;
+      let from = locale;
+      let to = null;
+      const type = 'datetime format';
+      for (let i = 0; i < locales.length; i++) {
+          targetLocale = to = locales[i];
+          if (locale !== targetLocale &&
+              isTranslateFallbackWarn(fallbackWarn, key)) {
+              onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+                  key,
+                  target: targetLocale
+              }));
+          }
+          // for vue-devtools timeline event
+          if (locale !== targetLocale) {
+              const emitter = context.__v_emitter;
+              if (emitter) {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                      type,
+                      key,
+                      from,
+                      to,
+                      groupId: `${type}:${key}`
+                  });
+              }
+          }
+          datetimeFormat =
+              datetimeFormats[targetLocale] || {};
+          format = datetimeFormat[key];
+          if (isPlainObject(format))
+              break;
+          handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+          from = to;
+      }
+      // checking format and target locale
+      if (!isPlainObject(format) || !isString(targetLocale)) {
+          return unresolving ? NOT_REOSLVED : key;
+      }
+      let id = `${targetLocale}__${key}`;
+      if (!isEmptyObject(overrides)) {
+          id = `${id}__${JSON.stringify(overrides)}`;
+      }
+      let formatter = __datetimeFormatters.get(id);
+      if (!formatter) {
+          formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
+          __datetimeFormatters.set(id, formatter);
+      }
+      return !part ? formatter.format(value) : formatter.formatToParts(value);
+  }
+  /** @internal */
+  const DATETIME_FORMAT_OPTIONS_KEYS = [
+      'localeMatcher',
+      'weekday',
+      'era',
+      'year',
+      'month',
+      'day',
+      'hour',
+      'minute',
+      'second',
+      'timeZoneName',
+      'formatMatcher',
+      'hour12',
+      'timeZone',
+      'dateStyle',
+      'timeStyle',
+      'calendar',
+      'dayPeriod',
+      'numberingSystem',
+      'hourCycle',
+      'fractionalSecondDigits'
+  ];
+  /** @internal */
+  function parseDateTimeArgs(...args) {
+      const [arg1, arg2, arg3, arg4] = args;
+      const options = {};
+      let overrides = {};
+      let value;
+      if (isString(arg1)) {
+          // Only allow ISO strings - other date formats are often supported,
+          // but may cause different results in different browsers.
+          const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+          if (!matches) {
+              throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+          }
+          // Some browsers can not parse the iso datetime separated by space,
+          // this is a compromise solution by replace the 'T'/' ' with 'T'
+          const dateTime = matches[3]
+              ? matches[3].trim().startsWith('T')
+                  ? `${matches[1].trim()}${matches[3].trim()}`
+                  : `${matches[1].trim()}T${matches[3].trim()}`
+              : matches[1].trim();
+          value = new Date(dateTime);
+          try {
+              // This will fail if the date is not valid
+              value.toISOString();
+          }
+          catch (e) {
+              throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+          }
+      }
+      else if (isDate(arg1)) {
+          if (isNaN(arg1.getTime())) {
+              throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+          }
+          value = arg1;
+      }
+      else if (isNumber(arg1)) {
+          value = arg1;
+      }
+      else {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      if (isString(arg2)) {
+          options.key = arg2;
+      }
+      else if (isPlainObject(arg2)) {
+          Object.keys(arg2).forEach(key => {
+              if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                  overrides[key] = arg2[key];
+              }
+              else {
+                  options[key] = arg2[key];
+              }
+          });
+      }
+      if (isString(arg3)) {
+          options.locale = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          overrides = arg3;
+      }
+      if (isPlainObject(arg4)) {
+          overrides = arg4;
+      }
+      return [options.key || '', value, options, overrides];
+  }
+  /** @internal */
+  function clearDateTimeFormat(ctx, locale, format) {
+      const context = ctx;
+      for (const key in format) {
+          const id = `${locale}__${key}`;
+          if (!context.__datetimeFormatters.has(id)) {
+              continue;
+          }
+          context.__datetimeFormatters.delete(id);
+      }
+  }
+
+  // implementation of `number` function
+  function number(context, ...args) {
+      const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+      const { __numberFormatters } = context;
+      if (!Availabilities.numberFormat) {
+          onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
+          return MISSING_RESOLVE_VALUE;
+      }
+      const [key, value, options, overrides] = parseNumberArgs(...args);
+      const missingWarn = isBoolean(options.missingWarn)
+          ? options.missingWarn
+          : context.missingWarn;
+      const fallbackWarn = isBoolean(options.fallbackWarn)
+          ? options.fallbackWarn
+          : context.fallbackWarn;
+      const part = !!options.part;
+      const locale = getLocale(context, options);
+      const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+      fallbackLocale, locale);
+      if (!isString(key) || key === '') {
+          return new Intl.NumberFormat(locale, overrides).format(value);
+      }
+      // resolve format
+      let numberFormat = {};
+      let targetLocale;
+      let format = null;
+      let from = locale;
+      let to = null;
+      const type = 'number format';
+      for (let i = 0; i < locales.length; i++) {
+          targetLocale = to = locales[i];
+          if (locale !== targetLocale &&
+              isTranslateFallbackWarn(fallbackWarn, key)) {
+              onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                  key,
+                  target: targetLocale
+              }));
+          }
+          // for vue-devtools timeline event
+          if (locale !== targetLocale) {
+              const emitter = context.__v_emitter;
+              if (emitter) {
+                  emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                      type,
+                      key,
+                      from,
+                      to,
+                      groupId: `${type}:${key}`
+                  });
+              }
+          }
+          numberFormat =
+              numberFormats[targetLocale] || {};
+          format = numberFormat[key];
+          if (isPlainObject(format))
+              break;
+          handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+          from = to;
+      }
+      // checking format and target locale
+      if (!isPlainObject(format) || !isString(targetLocale)) {
+          return unresolving ? NOT_REOSLVED : key;
+      }
+      let id = `${targetLocale}__${key}`;
+      if (!isEmptyObject(overrides)) {
+          id = `${id}__${JSON.stringify(overrides)}`;
+      }
+      let formatter = __numberFormatters.get(id);
+      if (!formatter) {
+          formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));
+          __numberFormatters.set(id, formatter);
+      }
+      return !part ? formatter.format(value) : formatter.formatToParts(value);
+  }
+  /** @internal */
+  const NUMBER_FORMAT_OPTIONS_KEYS = [
+      'localeMatcher',
+      'style',
+      'currency',
+      'currencyDisplay',
+      'currencySign',
+      'useGrouping',
+      'minimumIntegerDigits',
+      'minimumFractionDigits',
+      'maximumFractionDigits',
+      'minimumSignificantDigits',
+      'maximumSignificantDigits',
+      'compactDisplay',
+      'notation',
+      'signDisplay',
+      'unit',
+      'unitDisplay',
+      'roundingMode',
+      'roundingPriority',
+      'roundingIncrement',
+      'trailingZeroDisplay'
+  ];
+  /** @internal */
+  function parseNumberArgs(...args) {
+      const [arg1, arg2, arg3, arg4] = args;
+      const options = {};
+      let overrides = {};
+      if (!isNumber(arg1)) {
+          throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+      }
+      const value = arg1;
+      if (isString(arg2)) {
+          options.key = arg2;
+      }
+      else if (isPlainObject(arg2)) {
+          Object.keys(arg2).forEach(key => {
+              if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                  overrides[key] = arg2[key];
+              }
+              else {
+                  options[key] = arg2[key];
+              }
+          });
+      }
+      if (isString(arg3)) {
+          options.locale = arg3;
+      }
+      else if (isPlainObject(arg3)) {
+          overrides = arg3;
+      }
+      if (isPlainObject(arg4)) {
+          overrides = arg4;
+      }
+      return [options.key || '', value, options, overrides];
+  }
+  /** @internal */
+  function clearNumberFormat(ctx, locale, format) {
+      const context = ctx;
+      for (const key in format) {
+          const id = `${locale}__${key}`;
+          if (!context.__numberFormatters.has(id)) {
+              continue;
+          }
+          context.__numberFormatters.delete(id);
+      }
+  }
+
+  exports.CompileErrorCodes = CompileErrorCodes;
+  exports.CoreErrorCodes = CoreErrorCodes;
+  exports.CoreWarnCodes = CoreWarnCodes;
+  exports.DATETIME_FORMAT_OPTIONS_KEYS = DATETIME_FORMAT_OPTIONS_KEYS;
+  exports.DEFAULT_LOCALE = DEFAULT_LOCALE;
+  exports.DEFAULT_MESSAGE_DATA_TYPE = DEFAULT_MESSAGE_DATA_TYPE;
+  exports.MISSING_RESOLVE_VALUE = MISSING_RESOLVE_VALUE;
+  exports.NOT_REOSLVED = NOT_REOSLVED;
+  exports.NUMBER_FORMAT_OPTIONS_KEYS = NUMBER_FORMAT_OPTIONS_KEYS;
+  exports.VERSION = VERSION;
+  exports.clearCompileCache = clearCompileCache;
+  exports.clearDateTimeFormat = clearDateTimeFormat;
+  exports.clearNumberFormat = clearNumberFormat;
+  exports.compile = compile;
+  exports.compileToFunction = compileToFunction;
+  exports.createCompileError = createCompileError;
+  exports.createCoreContext = createCoreContext;
+  exports.createCoreError = createCoreError;
+  exports.createMessageContext = createMessageContext;
+  exports.datetime = datetime;
+  exports.fallbackWithLocaleChain = fallbackWithLocaleChain;
+  exports.fallbackWithSimple = fallbackWithSimple;
+  exports.getAdditionalMeta = getAdditionalMeta;
+  exports.getDevToolsHook = getDevToolsHook;
+  exports.getFallbackContext = getFallbackContext;
+  exports.getLocale = getLocale;
+  exports.getWarnMessage = getWarnMessage;
+  exports.handleMissing = handleMissing;
+  exports.initI18nDevTools = initI18nDevTools;
+  exports.isMessageAST = isMessageAST;
+  exports.isMessageFunction = isMessageFunction;
+  exports.isTranslateFallbackWarn = isTranslateFallbackWarn;
+  exports.isTranslateMissingWarn = isTranslateMissingWarn;
+  exports.number = number;
+  exports.parse = parse;
+  exports.parseDateTimeArgs = parseDateTimeArgs;
+  exports.parseNumberArgs = parseNumberArgs;
+  exports.parseTranslateArgs = parseTranslateArgs;
+  exports.registerLocaleFallbacker = registerLocaleFallbacker;
+  exports.registerMessageCompiler = registerMessageCompiler;
+  exports.registerMessageResolver = registerMessageResolver;
+  exports.resolveLocale = resolveLocale;
+  exports.resolveValue = resolveValue;
+  exports.resolveWithKeyValue = resolveWithKeyValue;
+  exports.setAdditionalMeta = setAdditionalMeta;
+  exports.setDevToolsHook = setDevToolsHook;
+  exports.setFallbackContext = setFallbackContext;
+  exports.translate = translate;
+  exports.translateDevTools = translateDevTools;
+  exports.updateFallbackLocale = updateFallbackLocale;
+
+  return exports;
+
+})({});

node_modules/@intlify/core-base/dist/core-base.mjs

@@ -0,0 +1,1757 @@
+/*!
+  * core-base v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+import { getGlobalThis, isObject, isString, isFunction, isNumber, isPlainObject, assign, join, toDisplayString, isArray, format as format$1, isBoolean, warn, isRegExp, warnOnce, incrementer, escapeHtml, inBrowser, mark, measure, isEmptyObject, generateCodeFrame, generateFormatCacheKey, isDate } from '@intlify/shared';
+import { CompileErrorCodes, createCompileError, detectHtmlTag, defaultOnError, baseCompile as baseCompile$1 } from '@intlify/message-compiler';
+export { CompileErrorCodes, createCompileError } from '@intlify/message-compiler';
+
+/**
+ * This is only called in esm-bundler builds.
+ * istanbul-ignore-next
+ */
+function initFeatureFlags() {
+    if (typeof __INTLIFY_PROD_DEVTOOLS__ !== 'boolean') {
+        getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;
+    }
+    if (typeof __INTLIFY_JIT_COMPILATION__ !== 'boolean') {
+        getGlobalThis().__INTLIFY_JIT_COMPILATION__ = false;
+    }
+    if (typeof __INTLIFY_DROP_MESSAGE_COMPILER__ !== 'boolean') {
+        getGlobalThis().__INTLIFY_DROP_MESSAGE_COMPILER__ = false;
+    }
+}
+
+const pathStateMachine =  [];
+pathStateMachine[0 /* States.BEFORE_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[1 /* States.IN_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[3 /* States.IN_IDENT */] = {
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
+};
+pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+        4 /* States.IN_SUB_PATH */,
+        2 /* Actions.INC_SUB_PATH_DEPTH */
+    ],
+    ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+/**
+ * Check if an expression is a literal value.
+ */
+const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+function isLiteral(exp) {
+    return literalValueRE.test(exp);
+}
+/**
+ * Strip quotes from a string
+ */
+function stripQuotes(str) {
+    const a = str.charCodeAt(0);
+    const b = str.charCodeAt(str.length - 1);
+    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+}
+/**
+ * Determine the type of a character in a keypath.
+ */
+function getPathCharType(ch) {
+    if (ch === undefined || ch === null) {
+        return "o" /* PathCharTypes.END_OF_FAIL */;
+    }
+    const code = ch.charCodeAt(0);
+    switch (code) {
+        case 0x5b: // [
+        case 0x5d: // ]
+        case 0x2e: // .
+        case 0x22: // "
+        case 0x27: // '
+            return ch;
+        case 0x5f: // _
+        case 0x24: // $
+        case 0x2d: // -
+            return "i" /* PathCharTypes.IDENT */;
+        case 0x09: // Tab (HT)
+        case 0x0a: // Newline (LF)
+        case 0x0d: // Return (CR)
+        case 0xa0: // No-break space (NBSP)
+        case 0xfeff: // Byte Order Mark (BOM)
+        case 0x2028: // Line Separator (LS)
+        case 0x2029: // Paragraph Separator (PS)
+            return "w" /* PathCharTypes.WORKSPACE */;
+    }
+    return "i" /* PathCharTypes.IDENT */;
+}
+/**
+ * Format a subPath, return its plain form if it is
+ * a literal string or number. Otherwise prepend the
+ * dynamic indicator (*).
+ */
+function formatSubPath(path) {
+    const trimmed = path.trim();
+    // invalid leading 0
+    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+        return false;
+    }
+    return isLiteral(trimmed)
+        ? stripQuotes(trimmed)
+        : "*" /* PathCharTypes.ASTARISK */ + trimmed;
+}
+/**
+ * Parse a string path into an array of segments
+ */
+function parse(path) {
+    const keys = [];
+    let index = -1;
+    let mode = 0 /* States.BEFORE_PATH */;
+    let subPathDepth = 0;
+    let c;
+    let key; // eslint-disable-line
+    let newChar;
+    let type;
+    let transition;
+    let action;
+    let typeMap;
+    const actions = [];
+    actions[0 /* Actions.APPEND */] = () => {
+        if (key === undefined) {
+            key = newChar;
+        }
+        else {
+            key += newChar;
+        }
+    };
+    actions[1 /* Actions.PUSH */] = () => {
+        if (key !== undefined) {
+            keys.push(key);
+            key = undefined;
+        }
+    };
+    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+        actions[0 /* Actions.APPEND */]();
+        subPathDepth++;
+    };
+    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
+        if (subPathDepth > 0) {
+            subPathDepth--;
+            mode = 4 /* States.IN_SUB_PATH */;
+            actions[0 /* Actions.APPEND */]();
+        }
+        else {
+            subPathDepth = 0;
+            if (key === undefined) {
+                return false;
+            }
+            key = formatSubPath(key);
+            if (key === false) {
+                return false;
+            }
+            else {
+                actions[1 /* Actions.PUSH */]();
+            }
+        }
+    };
+    function maybeUnescapeQuote() {
+        const nextChar = path[index + 1];
+        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+            nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
+            index++;
+            newChar = '\\' + nextChar;
+            actions[0 /* Actions.APPEND */]();
+            return true;
+        }
+    }
+    while (mode !== null) {
+        index++;
+        c = path[index];
+        if (c === '\\' && maybeUnescapeQuote()) {
+            continue;
+        }
+        type = getPathCharType(c);
+        typeMap = pathStateMachine[mode];
+        transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
+        // check parse error
+        if (transition === 8 /* States.ERROR */) {
+            return;
+        }
+        mode = transition[0];
+        if (transition[1] !== undefined) {
+            action = actions[transition[1]];
+            if (action) {
+                newChar = c;
+                if (action() === false) {
+                    return;
+                }
+            }
+        }
+        // check parse finish
+        if (mode === 7 /* States.AFTER_PATH */) {
+            return keys;
+        }
+    }
+}
+// path token cache
+const cache = new Map();
+/**
+ * key-value message resolver
+ *
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveWithKeyValue(obj, path) {
+    return isObject(obj) ? obj[path] : null;
+}
+/**
+ * message resolver
+ *
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveValue(obj, path) {
+    // check object
+    if (!isObject(obj)) {
+        return null;
+    }
+    // parse path
+    let hit = cache.get(path);
+    if (!hit) {
+        hit = parse(path);
+        if (hit) {
+            cache.set(path, hit);
+        }
+    }
+    // check hit
+    if (!hit) {
+        return null;
+    }
+    // resolve path value
+    const len = hit.length;
+    let last = obj;
+    let i = 0;
+    while (i < len) {
+        const val = last[hit[i]];
+        if (val === undefined) {
+            return null;
+        }
+        last = val;
+        i++;
+    }
+    return last;
+}
+
+const DEFAULT_MODIFIER = (str) => str;
+const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : join(values);
+const DEFAULT_INTERPOLATE = toDisplayString;
+function pluralDefault(choice, choicesLength) {
+    choice = Math.abs(choice);
+    if (choicesLength === 2) {
+        // prettier-ignore
+        return choice
+            ? choice > 1
+                ? 1
+                : 0
+            : 1;
+    }
+    return choice ? Math.min(choice, 2) : 0;
+}
+function getPluralIndex(options) {
+    // prettier-ignore
+    const index = isNumber(options.pluralIndex)
+        ? options.pluralIndex
+        : -1;
+    // prettier-ignore
+    return options.named && (isNumber(options.named.count) || isNumber(options.named.n))
+        ? isNumber(options.named.count)
+            ? options.named.count
+            : isNumber(options.named.n)
+                ? options.named.n
+                : index
+        : index;
+}
+function normalizeNamed(pluralIndex, props) {
+    if (!props.count) {
+        props.count = pluralIndex;
+    }
+    if (!props.n) {
+        props.n = pluralIndex;
+    }
+}
+function createMessageContext(options = {}) {
+    const locale = options.locale;
+    const pluralIndex = getPluralIndex(options);
+    const pluralRule = isObject(options.pluralRules) &&
+        isString(locale) &&
+        isFunction(options.pluralRules[locale])
+        ? options.pluralRules[locale]
+        : pluralDefault;
+    const orgPluralRule = isObject(options.pluralRules) &&
+        isString(locale) &&
+        isFunction(options.pluralRules[locale])
+        ? pluralDefault
+        : undefined;
+    const plural = (messages) => {
+        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+    };
+    const _list = options.list || [];
+    const list = (index) => _list[index];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _named = options.named || {};
+    isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+    const named = (key) => _named[key];
+    function message(key) {
+        // prettier-ignore
+        const msg = isFunction(options.messages)
+            ? options.messages(key)
+            : isObject(options.messages)
+                ? options.messages[key]
+                : false;
+        return !msg
+            ? options.parent
+                ? options.parent.message(key) // resolve from parent messages
+                : DEFAULT_MESSAGE
+            : msg;
+    }
+    const _modifier = (name) => options.modifiers
+        ? options.modifiers[name]
+        : DEFAULT_MODIFIER;
+    const normalize = isPlainObject(options.processor) && isFunction(options.processor.normalize)
+        ? options.processor.normalize
+        : DEFAULT_NORMALIZE;
+    const interpolate = isPlainObject(options.processor) &&
+        isFunction(options.processor.interpolate)
+        ? options.processor.interpolate
+        : DEFAULT_INTERPOLATE;
+    const type = isPlainObject(options.processor) && isString(options.processor.type)
+        ? options.processor.type
+        : DEFAULT_MESSAGE_DATA_TYPE;
+    const linked = (key, ...args) => {
+        const [arg1, arg2] = args;
+        let type = 'text';
+        let modifier = '';
+        if (args.length === 1) {
+            if (isObject(arg1)) {
+                modifier = arg1.modifier || modifier;
+                type = arg1.type || type;
+            }
+            else if (isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+        }
+        else if (args.length === 2) {
+            if (isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+            if (isString(arg2)) {
+                type = arg2 || type;
+            }
+        }
+        const ret = message(key)(ctx);
+        const msg = 
+        // The message in vnode resolved with linked are returned as an array by processor.nomalize
+        type === 'vnode' && isArray(ret) && modifier
+            ? ret[0]
+            : ret;
+        return modifier ? _modifier(modifier)(msg, type) : msg;
+    };
+    const ctx = {
+        ["list" /* HelperNameMap.LIST */]: list,
+        ["named" /* HelperNameMap.NAMED */]: named,
+        ["plural" /* HelperNameMap.PLURAL */]: plural,
+        ["linked" /* HelperNameMap.LINKED */]: linked,
+        ["message" /* HelperNameMap.MESSAGE */]: message,
+        ["type" /* HelperNameMap.TYPE */]: type,
+        ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+        ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
+        ["values" /* HelperNameMap.VALUES */]: assign({}, _list, _named)
+    };
+    return ctx;
+}
+
+let devtools = null;
+function setDevToolsHook(hook) {
+    devtools = hook;
+}
+function getDevToolsHook() {
+    return devtools;
+}
+function initI18nDevTools(i18n, version, meta) {
+    // TODO: queue if devtools is undefined
+    devtools &&
+        devtools.emit("i18n:init" /* IntlifyDevToolsHooks.I18nInit */, {
+            timestamp: Date.now(),
+            i18n,
+            version,
+            meta
+        });
+}
+const translateDevTools = /* #__PURE__*/ createDevToolsHook("function:translate" /* IntlifyDevToolsHooks.FunctionTranslate */);
+function createDevToolsHook(hook) {
+    return (payloads) => devtools && devtools.emit(hook, payloads);
+}
+
+const CoreWarnCodes = {
+    NOT_FOUND_KEY: 1,
+    FALLBACK_TO_TRANSLATE: 2,
+    CANNOT_FORMAT_NUMBER: 3,
+    FALLBACK_TO_NUMBER_FORMAT: 4,
+    CANNOT_FORMAT_DATE: 5,
+    FALLBACK_TO_DATE_FORMAT: 6,
+    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7,
+    __EXTEND_POINT__: 8
+};
+/** @internal */
+const warnMessages = {
+    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`
+};
+function getWarnMessage(code, ...args) {
+    return format$1(warnMessages[code], ...args);
+}
+
+/** @internal */
+function getLocale(context, options) {
+    return options.locale != null
+        ? resolveLocale(options.locale)
+        : resolveLocale(context.locale);
+}
+let _resolveLocale;
+/** @internal */
+function resolveLocale(locale) {
+    // prettier-ignore
+    return isString(locale)
+        ? locale
+        : _resolveLocale != null && locale.resolvedOnce
+            ? _resolveLocale
+            : (_resolveLocale = locale());
+}
+/**
+ * Fallback with simple implemenation
+ *
+ * @remarks
+ * A fallback locale function implemented with a simple fallback algorithm.
+ *
+ * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
+    // prettier-ignore
+    return [...new Set([
+            start,
+            ...(isArray(fallback)
+                ? fallback
+                : isObject(fallback)
+                    ? Object.keys(fallback)
+                    : isString(fallback)
+                        ? [fallback]
+                        : [start])
+        ])];
+}
+/**
+ * Fallback with locale chain
+ *
+ * @remarks
+ * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithLocaleChain(ctx, fallback, start) {
+    const startLocale = isString(start) ? start : DEFAULT_LOCALE;
+    const context = ctx;
+    if (!context.__localeChainCache) {
+        context.__localeChainCache = new Map();
+    }
+    let chain = context.__localeChainCache.get(startLocale);
+    if (!chain) {
+        chain = [];
+        // first block defined by start
+        let block = [start];
+        // while any intervening block found
+        while (isArray(block)) {
+            block = appendBlockToChain(chain, block, fallback);
+        }
+        // prettier-ignore
+        // last block defined by default
+        const defaults = isArray(fallback) || !isPlainObject(fallback)
+            ? fallback
+            : fallback['default']
+                ? fallback['default']
+                : null;
+        // convert defaults to array
+        block = isString(defaults) ? [defaults] : defaults;
+        if (isArray(block)) {
+            appendBlockToChain(chain, block, false);
+        }
+        context.__localeChainCache.set(startLocale, chain);
+    }
+    return chain;
+}
+function appendBlockToChain(chain, block, blocks) {
+    let follow = true;
+    for (let i = 0; i < block.length && isBoolean(follow); i++) {
+        const locale = block[i];
+        if (isString(locale)) {
+            follow = appendLocaleToChain(chain, block[i], blocks);
+        }
+    }
+    return follow;
+}
+function appendLocaleToChain(chain, locale, blocks) {
+    let follow;
+    const tokens = locale.split('-');
+    do {
+        const target = tokens.join('-');
+        follow = appendItemToChain(chain, target, blocks);
+        tokens.splice(-1, 1);
+    } while (tokens.length && follow === true);
+    return follow;
+}
+function appendItemToChain(chain, target, blocks) {
+    let follow = false;
+    if (!chain.includes(target)) {
+        follow = true;
+        if (target) {
+            follow = target[target.length - 1] !== '!';
+            const locale = target.replace(/!/g, '');
+            chain.push(locale);
+            if ((isArray(blocks) || isPlainObject(blocks)) &&
+                blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any
+            ) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                follow = blocks[locale];
+            }
+        }
+    }
+    return follow;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Intlify core-base version
+ * @internal
+ */
+const VERSION = '9.5.0';
+const NOT_REOSLVED = -1;
+const DEFAULT_LOCALE = 'en-US';
+const MISSING_RESOLVE_VALUE = '';
+const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+function getDefaultLinkedModifiers() {
+    return {
+        upper: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && isString(val)
+                ? val.toUpperCase()
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? val.children.toUpperCase()
+                    : val;
+        },
+        lower: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && isString(val)
+                ? val.toLowerCase()
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? val.children.toLowerCase()
+                    : val;
+        },
+        capitalize: (val, type) => {
+            // prettier-ignore
+            return (type === 'text' && isString(val)
+                ? capitalize(val)
+                : type === 'vnode' && isObject(val) && '__v_isVNode' in val
+                    ? capitalize(val.children)
+                    : val);
+        }
+    };
+}
+let _compiler;
+function registerMessageCompiler(compiler) {
+    _compiler = compiler;
+}
+let _resolver;
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+function registerMessageResolver(resolver) {
+    _resolver = resolver;
+}
+let _fallbacker;
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
+ *
+ * @VueI18nGeneral
+ */
+function registerLocaleFallbacker(fallbacker) {
+    _fallbacker = fallbacker;
+}
+// Additional Meta for Intlify DevTools
+let _additionalMeta =  null;
+const setAdditionalMeta = /* #__PURE__*/ (meta) => {
+    _additionalMeta = meta;
+};
+const getAdditionalMeta = /* #__PURE__*/ () => _additionalMeta;
+let _fallbackContext = null;
+const setFallbackContext = (context) => {
+    _fallbackContext = context;
+};
+const getFallbackContext = () => _fallbackContext;
+// ID for CoreContext
+let _cid = 0;
+function createCoreContext(options = {}) {
+    // setup options
+    const onWarn = isFunction(options.onWarn) ? options.onWarn : warn;
+    const version = isString(options.version) ? options.version : VERSION;
+    const locale = isString(options.locale) || isFunction(options.locale)
+        ? options.locale
+        : DEFAULT_LOCALE;
+    const _locale = isFunction(locale) ? DEFAULT_LOCALE : locale;
+    const fallbackLocale = isArray(options.fallbackLocale) ||
+        isPlainObject(options.fallbackLocale) ||
+        isString(options.fallbackLocale) ||
+        options.fallbackLocale === false
+        ? options.fallbackLocale
+        : _locale;
+    const messages = isPlainObject(options.messages)
+        ? options.messages
+        : { [_locale]: {} };
+    const datetimeFormats = isPlainObject(options.datetimeFormats)
+            ? options.datetimeFormats
+            : { [_locale]: {} }
+        ;
+    const numberFormats = isPlainObject(options.numberFormats)
+            ? options.numberFormats
+            : { [_locale]: {} }
+        ;
+    const modifiers = assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
+    const pluralRules = options.pluralRules || {};
+    const missing = isFunction(options.missing) ? options.missing : null;
+    const missingWarn = isBoolean(options.missingWarn) || isRegExp(options.missingWarn)
+        ? options.missingWarn
+        : true;
+    const fallbackWarn = isBoolean(options.fallbackWarn) || isRegExp(options.fallbackWarn)
+        ? options.fallbackWarn
+        : true;
+    const fallbackFormat = !!options.fallbackFormat;
+    const unresolving = !!options.unresolving;
+    const postTranslation = isFunction(options.postTranslation)
+        ? options.postTranslation
+        : null;
+    const processor = isPlainObject(options.processor) ? options.processor : null;
+    const warnHtmlMessage = isBoolean(options.warnHtmlMessage)
+        ? options.warnHtmlMessage
+        : true;
+    const escapeParameter = !!options.escapeParameter;
+    const messageCompiler = isFunction(options.messageCompiler)
+        ? options.messageCompiler
+        : _compiler;
+    if ((process.env.NODE_ENV !== 'production') &&
+        !false &&
+        !false &&
+        isFunction(options.messageCompiler)) {
+        warnOnce(getWarnMessage(CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER));
+    }
+    const messageResolver = isFunction(options.messageResolver)
+        ? options.messageResolver
+        : _resolver || resolveWithKeyValue;
+    const localeFallbacker = isFunction(options.localeFallbacker)
+        ? options.localeFallbacker
+        : _fallbacker || fallbackWithSimple;
+    const fallbackContext = isObject(options.fallbackContext)
+        ? options.fallbackContext
+        : undefined;
+    // setup internal options
+    const internalOptions = options;
+    const __datetimeFormatters = isObject(internalOptions.__datetimeFormatters)
+            ? internalOptions.__datetimeFormatters
+            : new Map()
+        ;
+    const __numberFormatters = isObject(internalOptions.__numberFormatters)
+            ? internalOptions.__numberFormatters
+            : new Map()
+        ;
+    const __meta = isObject(internalOptions.__meta) ? internalOptions.__meta : {};
+    _cid++;
+    const context = {
+        version,
+        cid: _cid,
+        locale,
+        fallbackLocale,
+        messages,
+        modifiers,
+        pluralRules,
+        missing,
+        missingWarn,
+        fallbackWarn,
+        fallbackFormat,
+        unresolving,
+        postTranslation,
+        processor,
+        warnHtmlMessage,
+        escapeParameter,
+        messageCompiler,
+        messageResolver,
+        localeFallbacker,
+        fallbackContext,
+        onWarn,
+        __meta
+    };
+    {
+        context.datetimeFormats = datetimeFormats;
+        context.numberFormats = numberFormats;
+        context.__datetimeFormatters = __datetimeFormatters;
+        context.__numberFormatters = __numberFormatters;
+    }
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production')) {
+        context.__v_emitter =
+            internalOptions.__v_emitter != null
+                ? internalOptions.__v_emitter
+                : undefined;
+    }
+    // NOTE: experimental !!
+    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {
+        initI18nDevTools(context, version, __meta);
+    }
+    return context;
+}
+/** @internal */
+function isTranslateFallbackWarn(fallback, key) {
+    return fallback instanceof RegExp ? fallback.test(key) : fallback;
+}
+/** @internal */
+function isTranslateMissingWarn(missing, key) {
+    return missing instanceof RegExp ? missing.test(key) : missing;
+}
+/** @internal */
+function handleMissing(context, key, locale, missingWarn, type) {
+    const { missing, onWarn } = context;
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production')) {
+        const emitter = context.__v_emitter;
+        if (emitter) {
+            emitter.emit("missing" /* VueDevToolsTimelineEvents.MISSING */, {
+                locale,
+                key,
+                type,
+                groupId: `${type}:${key}`
+            });
+        }
+    }
+    if (missing !== null) {
+        const ret = missing(context, locale, key, type);
+        return isString(ret) ? ret : key;
+    }
+    else {
+        if ((process.env.NODE_ENV !== 'production') && isTranslateMissingWarn(missingWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.NOT_FOUND_KEY, { key, locale }));
+        }
+        return key;
+    }
+}
+/** @internal */
+function updateFallbackLocale(ctx, locale, fallback) {
+    const context = ctx;
+    context.__localeChainCache = new Map();
+    ctx.localeFallbacker(ctx, fallback, locale);
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+function format(ast) {
+    const msg = (ctx) => formatParts(ctx, ast);
+    return msg;
+}
+function formatParts(ctx, ast) {
+    const body = ast.b || ast.body;
+    if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+        const plural = body;
+        const cases = plural.c || plural.cases;
+        return ctx.plural(cases.reduce((messages, c) => [
+            ...messages,
+            formatMessageParts(ctx, c)
+        ], []));
+    }
+    else {
+        return formatMessageParts(ctx, body);
+    }
+}
+function formatMessageParts(ctx, node) {
+    const _static = node.s || node.static;
+    if (_static) {
+        return ctx.type === 'text'
+            ? _static
+            : ctx.normalize([_static]);
+    }
+    else {
+        const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+        return ctx.normalize(messages);
+    }
+}
+function formatMessagePart(ctx, node) {
+    const type = node.t || node.type;
+    switch (type) {
+        case 3 /* NodeTypes.Text */:
+            const text = node;
+            return (text.v || text.value);
+        case 9 /* NodeTypes.Literal */:
+            const literal = node;
+            return (literal.v || literal.value);
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            return ctx.interpolate(ctx.named(named.k || named.key));
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            const modifier = linked.m || linked.modifier;
+            return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
+        case 7 /* NodeTypes.LinkedKey */:
+            const linkedKey = node;
+            return (linkedKey.v || linkedKey.value);
+        case 8 /* NodeTypes.LinkedModifier */:
+            const linkedModifier = node;
+            return (linkedModifier.v || linkedModifier.value);
+        default:
+            throw new Error(`unhandled node type on format message part: ${type}`);
+    }
+}
+
+const code = CompileErrorCodes.__EXTEND_POINT__;
+const inc = incrementer(code);
+const CoreErrorCodes = {
+    INVALID_ARGUMENT: code,
+    INVALID_DATE_ARGUMENT: inc(),
+    INVALID_ISO_DATE_ARGUMENT: inc(),
+    NOT_SUPPORT_NON_STRING_MESSAGE: inc(),
+    __EXTEND_POINT__: inc() // 22
+};
+function createCoreError(code) {
+    return createCompileError(code, null, (process.env.NODE_ENV !== 'production') ? { messages: errorMessages } : undefined);
+}
+/** @internal */
+const errorMessages = {
+    [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',
+    [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +
+        'Make sure your Date represents a valid date.',
+    [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string',
+    [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]: 'Not support non-string message'
+};
+
+const WARN_MESSAGE = `Detected HTML in '{source}' message. Recommend not using HTML messages to avoid XSS.`;
+function checkHtmlMessage(source, warnHtmlMessage) {
+    if (warnHtmlMessage && detectHtmlTag(source)) {
+        warn(format$1(WARN_MESSAGE, { source }));
+    }
+}
+const defaultOnCacheKey = (message) => message;
+let compileCache = Object.create(null);
+function clearCompileCache() {
+    compileCache = Object.create(null);
+}
+const isMessageAST = (val) => isObject(val) &&
+    (val.t === 0 || val.type === 0) &&
+    ('b' in val || 'body' in val);
+function baseCompile(message, options = {}) {
+    // error detecting on compile
+    let detectError = false;
+    const onError = options.onError || defaultOnError;
+    options.onError = (err) => {
+        detectError = true;
+        onError(err);
+    };
+    // compile with mesasge-compiler
+    return { ...baseCompile$1(message, options), detectError };
+}
+const compileToFunction = /* #__PURE__*/ (message, context) => {
+    if (!isString(message)) {
+        throw createCoreError(CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE);
+    }
+    {
+        // check HTML message
+        const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        (process.env.NODE_ENV !== 'production') && checkHtmlMessage(message, warnHtmlMessage);
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile
+        const { code, detectError } = baseCompile(message, context);
+        // evaluate function
+        const msg = new Function(`return ${code}`)();
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+};
+function compile(message, context) {
+    if (((__INTLIFY_JIT_COMPILATION__ && !__INTLIFY_DROP_MESSAGE_COMPILER__)) &&
+        isString(message)) {
+        // check HTML message
+        const warnHtmlMessage = isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        (process.env.NODE_ENV !== 'production') && checkHtmlMessage(message, warnHtmlMessage);
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile with JIT mode
+        const { ast, detectError } = baseCompile(message, {
+            ...context,
+            location: (process.env.NODE_ENV !== 'production'),
+            jit: true
+        });
+        // compose message function from AST
+        const msg = format(ast);
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+    else {
+        if ((process.env.NODE_ENV !== 'production') && !isMessageAST(message)) {
+            warn(`the message that is resolve with key '${context.key}' is not supported for jit compilation`);
+            return (() => message);
+        }
+        // AST case (passed from bundler)
+        const cacheKey = message.cacheKey;
+        if (cacheKey) {
+            const cached = compileCache[cacheKey];
+            if (cached) {
+                return cached;
+            }
+            // compose message function from message (AST)
+            return (compileCache[cacheKey] =
+                format(message));
+        }
+        else {
+            return format(message);
+        }
+    }
+}
+
+const NOOP_MESSAGE_FUNCTION = () => '';
+const isMessageFunction = (val) => isFunction(val);
+// implementation of `translate` function
+function translate(context, ...args) {
+    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+    const [key, options] = parseTranslateArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const escapeParameter = isBoolean(options.escapeParameter)
+        ? options.escapeParameter
+        : context.escapeParameter;
+    const resolvedMessage = !!options.resolvedMessage;
+    // prettier-ignore
+    const defaultMsgOrKey = isString(options.default) || isBoolean(options.default) // default by function option
+        ? !isBoolean(options.default)
+            ? options.default
+            : (!messageCompiler ? () => key : key)
+        : fallbackFormat // default by `fallbackFormat` option
+            ? (!messageCompiler ? () => key : key)
+            : '';
+    const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';
+    const locale = getLocale(context, options);
+    // escape params
+    escapeParameter && escapeParams(options);
+    // resolve message format
+    // eslint-disable-next-line prefer-const
+    let [formatScope, targetLocale, message] = !resolvedMessage
+        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+        : [
+            key,
+            locale,
+            messages[locale] || {}
+        ];
+    // NOTE:
+    //  Fix to work around `ssrTransfrom` bug in Vite.
+    //  https://github.com/vitejs/vite/issues/4306
+    //  To get around this, use temporary variables.
+    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+    let format = formatScope;
+    // if you use default message, set it as message format!
+    let cacheBaseKey = key;
+    if (!resolvedMessage &&
+        !(isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format))) {
+        if (enableDefaultMsg) {
+            format = defaultMsgOrKey;
+            cacheBaseKey = format;
+        }
+    }
+    // checking message format and target locale
+    if (!resolvedMessage &&
+        (!(isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format)) ||
+            !isString(targetLocale))) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    // TODO: refactor
+    if ((process.env.NODE_ENV !== 'production') && isString(format) && context.messageCompiler == null) {
+        warn(`The message format compilation is not supported in this build. ` +
+            `Because message compiler isn't included. ` +
+            `You need to pre-compilation all message format. ` +
+            `So translate function return '${key}'.`);
+        return key;
+    }
+    // setup compile error detecting
+    let occurred = false;
+    const onError = () => {
+        occurred = true;
+    };
+    // compile message format
+    const msg = !isMessageFunction(format)
+        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
+        : format;
+    // if occurred compile error, return the message format
+    if (occurred) {
+        return format;
+    }
+    // evaluate message with context
+    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+    const msgContext = createMessageContext(ctxOptions);
+    const messaged = evaluateMessage(context, msg, msgContext);
+    // if use post translation option, proceed it with handler
+    const ret = postTranslation
+        ? postTranslation(messaged, key)
+        : messaged;
+    // NOTE: experimental !!
+    if ((process.env.NODE_ENV !== 'production') || __INTLIFY_PROD_DEVTOOLS__) {
+        // prettier-ignore
+        const payloads = {
+            timestamp: Date.now(),
+            key: isString(key)
+                ? key
+                : isMessageFunction(format)
+                    ? format.key
+                    : '',
+            locale: targetLocale || (isMessageFunction(format)
+                ? format.locale
+                : ''),
+            format: isString(format)
+                ? format
+                : isMessageFunction(format)
+                    ? format.source
+                    : '',
+            message: ret
+        };
+        payloads.meta = assign({}, context.__meta, getAdditionalMeta() || {});
+        translateDevTools(payloads);
+    }
+    return ret;
+}
+function escapeParams(options) {
+    if (isArray(options.list)) {
+        options.list = options.list.map(item => isString(item) ? escapeHtml(item) : item);
+    }
+    else if (isObject(options.named)) {
+        Object.keys(options.named).forEach(key => {
+            if (isString(options.named[key])) {
+                options.named[key] = escapeHtml(options.named[key]);
+            }
+        });
+    }
+}
+function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+    let message = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'translate';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if ((process.env.NODE_ENV !== 'production') &&
+            locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_TRANSLATE, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        message =
+            messages[targetLocale] || {};
+        // for vue-devtools timeline event
+        let start = null;
+        let startTag;
+        let endTag;
+        if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+            start = window.performance.now();
+            startTag = 'intlify-message-resolve-start';
+            endTag = 'intlify-message-resolve-end';
+            mark && mark(startTag);
+        }
+        if ((format = resolveValue(message, key)) === null) {
+            // if null, resolve with object key path
+            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+            const end = window.performance.now();
+            const emitter = context.__v_emitter;
+            if (emitter && start && format) {
+                emitter.emit("message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */, {
+                    type: "message-resolve" /* VueDevToolsTimelineEvents.MESSAGE_RESOLVE */,
+                    key,
+                    message: format,
+                    time: end - start,
+                    groupId: `${type}:${key}`
+                });
+            }
+            if (startTag && endTag && mark && measure) {
+                mark(endTag);
+                measure('intlify message resolve', startTag, endTag);
+            }
+        }
+        if (isString(format) || isMessageAST(format) || isMessageFunction(format)) {
+            break;
+        }
+        const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+        key, targetLocale, missingWarn, type);
+        if (missingRet !== key) {
+            format = missingRet;
+        }
+        from = to;
+    }
+    return [format, targetLocale, message];
+}
+function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
+    const { messageCompiler, warnHtmlMessage } = context;
+    if (isMessageFunction(format)) {
+        const msg = format;
+        msg.locale = msg.locale || targetLocale;
+        msg.key = msg.key || key;
+        return msg;
+    }
+    if (messageCompiler == null) {
+        const msg = (() => format);
+        msg.locale = targetLocale;
+        msg.key = key;
+        return msg;
+    }
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-compilation-start';
+        endTag = 'intlify-message-compilation-end';
+        mark && mark(startTag);
+    }
+    const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */, {
+                type: "message-compilation" /* VueDevToolsTimelineEvents.MESSAGE_COMPILATION */,
+                message: format,
+                time: end - start,
+                groupId: `${'translate'}:${key}`
+            });
+        }
+        if (startTag && endTag && mark && measure) {
+            mark(endTag);
+            measure('intlify message compilation', startTag, endTag);
+        }
+    }
+    msg.locale = targetLocale;
+    msg.key = key;
+    msg.source = format;
+    return msg;
+}
+function evaluateMessage(context, msg, msgCtx) {
+    // for vue-devtools timeline event
+    let start = null;
+    let startTag;
+    let endTag;
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        start = window.performance.now();
+        startTag = 'intlify-message-evaluation-start';
+        endTag = 'intlify-message-evaluation-end';
+        mark && mark(startTag);
+    }
+    const messaged = msg(msgCtx);
+    // for vue-devtools timeline event
+    if ((process.env.NODE_ENV !== 'production') && inBrowser) {
+        const end = window.performance.now();
+        const emitter = context.__v_emitter;
+        if (emitter && start) {
+            emitter.emit("message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */, {
+                type: "message-evaluation" /* VueDevToolsTimelineEvents.MESSAGE_EVALUATION */,
+                value: messaged,
+                time: end - start,
+                groupId: `${'translate'}:${msg.key}`
+            });
+        }
+        if (startTag && endTag && mark && measure) {
+            mark(endTag);
+            measure('intlify message evaluation', startTag, endTag);
+        }
+    }
+    return messaged;
+}
+/** @internal */
+function parseTranslateArgs(...args) {
+    const [arg1, arg2, arg3] = args;
+    const options = {};
+    if (!isString(arg1) &&
+        !isNumber(arg1) &&
+        !isMessageFunction(arg1) &&
+        !isMessageAST(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    // prettier-ignore
+    const key = isNumber(arg1)
+        ? String(arg1)
+        : isMessageFunction(arg1)
+            ? arg1
+            : arg1;
+    if (isNumber(arg2)) {
+        options.plural = arg2;
+    }
+    else if (isString(arg2)) {
+        options.default = arg2;
+    }
+    else if (isPlainObject(arg2) && !isEmptyObject(arg2)) {
+        options.named = arg2;
+    }
+    else if (isArray(arg2)) {
+        options.list = arg2;
+    }
+    if (isNumber(arg3)) {
+        options.plural = arg3;
+    }
+    else if (isString(arg3)) {
+        options.default = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        assign(options, arg3);
+    }
+    return [key, options];
+}
+function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
+    return {
+        locale,
+        key,
+        warnHtmlMessage,
+        onError: (err) => {
+            onError && onError(err);
+            if ((process.env.NODE_ENV !== 'production')) {
+                const _source = getSourceForCodeFrame(source);
+                const message = `Message compilation error: ${err.message}`;
+                const codeFrame = err.location &&
+                    _source &&
+                    generateCodeFrame(_source, err.location.start.offset, err.location.end.offset);
+                const emitter = context.__v_emitter;
+                if (emitter && _source) {
+                    emitter.emit("compile-error" /* VueDevToolsTimelineEvents.COMPILE_ERROR */, {
+                        message: _source,
+                        error: err.message,
+                        start: err.location && err.location.start.offset,
+                        end: err.location && err.location.end.offset,
+                        groupId: `${'translate'}:${key}`
+                    });
+                }
+                console.error(codeFrame ? `${message}\n${codeFrame}` : message);
+            }
+            else {
+                throw err;
+            }
+        },
+        onCacheKey: (source) => generateFormatCacheKey(locale, key, source)
+    };
+}
+function getSourceForCodeFrame(source) {
+    if (isString(source)) ;
+    else {
+        if (source.loc?.source) {
+            return source.loc.source;
+        }
+    }
+}
+function getMessageContextOptions(context, locale, message, options) {
+    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+    const resolveMessage = (key) => {
+        let val = resolveValue(message, key);
+        // fallback to root context
+        if (val == null && fallbackContext) {
+            const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
+            val = resolveValue(message, key);
+        }
+        if (isString(val) || isMessageAST(val)) {
+            let occurred = false;
+            const onError = () => {
+                occurred = true;
+            };
+            const msg = compileMessageFormat(context, key, locale, val, key, onError);
+            return !occurred
+                ? msg
+                : NOOP_MESSAGE_FUNCTION;
+        }
+        else if (isMessageFunction(val)) {
+            return val;
+        }
+        else {
+            // TODO: should be implemented warning message
+            return NOOP_MESSAGE_FUNCTION;
+        }
+    };
+    const ctxOptions = {
+        locale,
+        modifiers,
+        pluralRules,
+        messages: resolveMessage
+    };
+    if (context.processor) {
+        ctxOptions.processor = context.processor;
+    }
+    if (options.list) {
+        ctxOptions.list = options.list;
+    }
+    if (options.named) {
+        ctxOptions.named = options.named;
+    }
+    if (isNumber(options.plural)) {
+        ctxOptions.pluralIndex = options.plural;
+    }
+    return ctxOptions;
+}
+
+const intlDefined = typeof Intl !== 'undefined';
+const Availabilities = {
+    dateTimeFormat: intlDefined && typeof Intl.DateTimeFormat !== 'undefined',
+    numberFormat: intlDefined && typeof Intl.NumberFormat !== 'undefined'
+};
+
+// implementation of `datetime` function
+function datetime(context, ...args) {
+    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __datetimeFormatters } = context;
+    if ((process.env.NODE_ENV !== 'production') && !Availabilities.dateTimeFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_DATE));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseDateTimeArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!isString(key) || key === '') {
+        return new Intl.DateTimeFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let datetimeFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'datetime format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if ((process.env.NODE_ENV !== 'production') &&
+            locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_DATE_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        datetimeFormat =
+            datetimeFormats[targetLocale] || {};
+        format = datetimeFormat[key];
+        if (isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!isPlainObject(format) || !isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __datetimeFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(targetLocale, assign({}, format, overrides));
+        __datetimeFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const DATETIME_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+    'formatMatcher',
+    'hour12',
+    'timeZone',
+    'dateStyle',
+    'timeStyle',
+    'calendar',
+    'dayPeriod',
+    'numberingSystem',
+    'hourCycle',
+    'fractionalSecondDigits'
+];
+/** @internal */
+function parseDateTimeArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    let value;
+    if (isString(arg1)) {
+        // Only allow ISO strings - other date formats are often supported,
+        // but may cause different results in different browsers.
+        const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+        if (!matches) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+        // Some browsers can not parse the iso datetime separated by space,
+        // this is a compromise solution by replace the 'T'/' ' with 'T'
+        const dateTime = matches[3]
+            ? matches[3].trim().startsWith('T')
+                ? `${matches[1].trim()}${matches[3].trim()}`
+                : `${matches[1].trim()}T${matches[3].trim()}`
+            : matches[1].trim();
+        value = new Date(dateTime);
+        try {
+            // This will fail if the date is not valid
+            value.toISOString();
+        }
+        catch (e) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+    }
+    else if (isDate(arg1)) {
+        if (isNaN(arg1.getTime())) {
+            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+        }
+        value = arg1;
+    }
+    else if (isNumber(arg1)) {
+        value = arg1;
+    }
+    else {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    if (isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearDateTimeFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__datetimeFormatters.has(id)) {
+            continue;
+        }
+        context.__datetimeFormatters.delete(id);
+    }
+}
+
+// implementation of `number` function
+function number(context, ...args) {
+    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __numberFormatters } = context;
+    if ((process.env.NODE_ENV !== 'production') && !Availabilities.numberFormat) {
+        onWarn(getWarnMessage(CoreWarnCodes.CANNOT_FORMAT_NUMBER));
+        return MISSING_RESOLVE_VALUE;
+    }
+    const [key, value, options, overrides] = parseNumberArgs(...args);
+    const missingWarn = isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!isString(key) || key === '') {
+        return new Intl.NumberFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let numberFormat = {};
+    let targetLocale;
+    let format = null;
+    let from = locale;
+    let to = null;
+    const type = 'number format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = to = locales[i];
+        if ((process.env.NODE_ENV !== 'production') &&
+            locale !== targetLocale &&
+            isTranslateFallbackWarn(fallbackWarn, key)) {
+            onWarn(getWarnMessage(CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT, {
+                key,
+                target: targetLocale
+            }));
+        }
+        // for vue-devtools timeline event
+        if ((process.env.NODE_ENV !== 'production') && locale !== targetLocale) {
+            const emitter = context.__v_emitter;
+            if (emitter) {
+                emitter.emit("fallback" /* VueDevToolsTimelineEvents.FALBACK */, {
+                    type,
+                    key,
+                    from,
+                    to,
+                    groupId: `${type}:${key}`
+                });
+            }
+        }
+        numberFormat =
+            numberFormats[targetLocale] || {};
+        format = numberFormat[key];
+        if (isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+        from = to;
+    }
+    // checking format and target locale
+    if (!isPlainObject(format) || !isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __numberFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(targetLocale, assign({}, format, overrides));
+        __numberFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const NUMBER_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'style',
+    'currency',
+    'currencyDisplay',
+    'currencySign',
+    'useGrouping',
+    'minimumIntegerDigits',
+    'minimumFractionDigits',
+    'maximumFractionDigits',
+    'minimumSignificantDigits',
+    'maximumSignificantDigits',
+    'compactDisplay',
+    'notation',
+    'signDisplay',
+    'unit',
+    'unitDisplay',
+    'roundingMode',
+    'roundingPriority',
+    'roundingIncrement',
+    'trailingZeroDisplay'
+];
+/** @internal */
+function parseNumberArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    if (!isNumber(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    const value = arg1;
+    if (isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearNumberFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__numberFormatters.has(id)) {
+            continue;
+        }
+        context.__numberFormatters.delete(id);
+    }
+}
+
+{
+    initFeatureFlags();
+}
+
+export { CoreErrorCodes, CoreWarnCodes, DATETIME_FORMAT_OPTIONS_KEYS, DEFAULT_LOCALE, DEFAULT_MESSAGE_DATA_TYPE, MISSING_RESOLVE_VALUE, NOT_REOSLVED, NUMBER_FORMAT_OPTIONS_KEYS, VERSION, clearCompileCache, clearDateTimeFormat, clearNumberFormat, compile, compileToFunction, createCoreContext, createCoreError, createMessageContext, datetime, fallbackWithLocaleChain, fallbackWithSimple, getAdditionalMeta, getDevToolsHook, getFallbackContext, getLocale, getWarnMessage, handleMissing, initI18nDevTools, isMessageAST, isMessageFunction, isTranslateFallbackWarn, isTranslateMissingWarn, number, parse, parseDateTimeArgs, parseNumberArgs, parseTranslateArgs, registerLocaleFallbacker, registerMessageCompiler, registerMessageResolver, resolveLocale, resolveValue, resolveWithKeyValue, setAdditionalMeta, setDevToolsHook, setFallbackContext, translate, translateDevTools, updateFallbackLocale };

node_modules/@intlify/core-base/dist/core-base.prod.cjs

@@ -0,0 +1,1517 @@
+/*!
+  * core-base v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+var messageCompiler = require('@intlify/message-compiler');
+var shared = require('@intlify/shared');
+
+const pathStateMachine =  [];
+pathStateMachine[0 /* States.BEFORE_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [0 /* States.BEFORE_PATH */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[1 /* States.IN_PATH */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */]
+};
+pathStateMachine[2 /* States.BEFORE_IDENT */] = {
+    ["w" /* PathCharTypes.WORKSPACE */]: [2 /* States.BEFORE_IDENT */],
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[3 /* States.IN_IDENT */] = {
+    ["i" /* PathCharTypes.IDENT */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["0" /* PathCharTypes.ZERO */]: [3 /* States.IN_IDENT */, 0 /* Actions.APPEND */],
+    ["w" /* PathCharTypes.WORKSPACE */]: [1 /* States.IN_PATH */, 1 /* Actions.PUSH */],
+    ["." /* PathCharTypes.DOT */]: [2 /* States.BEFORE_IDENT */, 1 /* Actions.PUSH */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [4 /* States.IN_SUB_PATH */, 1 /* Actions.PUSH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: [7 /* States.AFTER_PATH */, 1 /* Actions.PUSH */]
+};
+pathStateMachine[4 /* States.IN_SUB_PATH */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */],
+    ["[" /* PathCharTypes.LEFT_BRACKET */]: [
+        4 /* States.IN_SUB_PATH */,
+        2 /* Actions.INC_SUB_PATH_DEPTH */
+    ],
+    ["]" /* PathCharTypes.RIGHT_BRACKET */]: [1 /* States.IN_PATH */, 3 /* Actions.PUSH_SUB_PATH */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[5 /* States.IN_SINGLE_QUOTE */] = {
+    ["'" /* PathCharTypes.SINGLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [5 /* States.IN_SINGLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+pathStateMachine[6 /* States.IN_DOUBLE_QUOTE */] = {
+    ["\"" /* PathCharTypes.DOUBLE_QUOTE */]: [4 /* States.IN_SUB_PATH */, 0 /* Actions.APPEND */],
+    ["o" /* PathCharTypes.END_OF_FAIL */]: 8 /* States.ERROR */,
+    ["l" /* PathCharTypes.ELSE */]: [6 /* States.IN_DOUBLE_QUOTE */, 0 /* Actions.APPEND */]
+};
+/**
+ * Check if an expression is a literal value.
+ */
+const literalValueRE = /^\s?(?:true|false|-?[\d.]+|'[^']*'|"[^"]*")\s?$/;
+function isLiteral(exp) {
+    return literalValueRE.test(exp);
+}
+/**
+ * Strip quotes from a string
+ */
+function stripQuotes(str) {
+    const a = str.charCodeAt(0);
+    const b = str.charCodeAt(str.length - 1);
+    return a === b && (a === 0x22 || a === 0x27) ? str.slice(1, -1) : str;
+}
+/**
+ * Determine the type of a character in a keypath.
+ */
+function getPathCharType(ch) {
+    if (ch === undefined || ch === null) {
+        return "o" /* PathCharTypes.END_OF_FAIL */;
+    }
+    const code = ch.charCodeAt(0);
+    switch (code) {
+        case 0x5b: // [
+        case 0x5d: // ]
+        case 0x2e: // .
+        case 0x22: // "
+        case 0x27: // '
+            return ch;
+        case 0x5f: // _
+        case 0x24: // $
+        case 0x2d: // -
+            return "i" /* PathCharTypes.IDENT */;
+        case 0x09: // Tab (HT)
+        case 0x0a: // Newline (LF)
+        case 0x0d: // Return (CR)
+        case 0xa0: // No-break space (NBSP)
+        case 0xfeff: // Byte Order Mark (BOM)
+        case 0x2028: // Line Separator (LS)
+        case 0x2029: // Paragraph Separator (PS)
+            return "w" /* PathCharTypes.WORKSPACE */;
+    }
+    return "i" /* PathCharTypes.IDENT */;
+}
+/**
+ * Format a subPath, return its plain form if it is
+ * a literal string or number. Otherwise prepend the
+ * dynamic indicator (*).
+ */
+function formatSubPath(path) {
+    const trimmed = path.trim();
+    // invalid leading 0
+    if (path.charAt(0) === '0' && isNaN(parseInt(path))) {
+        return false;
+    }
+    return isLiteral(trimmed)
+        ? stripQuotes(trimmed)
+        : "*" /* PathCharTypes.ASTARISK */ + trimmed;
+}
+/**
+ * Parse a string path into an array of segments
+ */
+function parse(path) {
+    const keys = [];
+    let index = -1;
+    let mode = 0 /* States.BEFORE_PATH */;
+    let subPathDepth = 0;
+    let c;
+    let key; // eslint-disable-line
+    let newChar;
+    let type;
+    let transition;
+    let action;
+    let typeMap;
+    const actions = [];
+    actions[0 /* Actions.APPEND */] = () => {
+        if (key === undefined) {
+            key = newChar;
+        }
+        else {
+            key += newChar;
+        }
+    };
+    actions[1 /* Actions.PUSH */] = () => {
+        if (key !== undefined) {
+            keys.push(key);
+            key = undefined;
+        }
+    };
+    actions[2 /* Actions.INC_SUB_PATH_DEPTH */] = () => {
+        actions[0 /* Actions.APPEND */]();
+        subPathDepth++;
+    };
+    actions[3 /* Actions.PUSH_SUB_PATH */] = () => {
+        if (subPathDepth > 0) {
+            subPathDepth--;
+            mode = 4 /* States.IN_SUB_PATH */;
+            actions[0 /* Actions.APPEND */]();
+        }
+        else {
+            subPathDepth = 0;
+            if (key === undefined) {
+                return false;
+            }
+            key = formatSubPath(key);
+            if (key === false) {
+                return false;
+            }
+            else {
+                actions[1 /* Actions.PUSH */]();
+            }
+        }
+    };
+    function maybeUnescapeQuote() {
+        const nextChar = path[index + 1];
+        if ((mode === 5 /* States.IN_SINGLE_QUOTE */ &&
+            nextChar === "'" /* PathCharTypes.SINGLE_QUOTE */) ||
+            (mode === 6 /* States.IN_DOUBLE_QUOTE */ &&
+                nextChar === "\"" /* PathCharTypes.DOUBLE_QUOTE */)) {
+            index++;
+            newChar = '\\' + nextChar;
+            actions[0 /* Actions.APPEND */]();
+            return true;
+        }
+    }
+    while (mode !== null) {
+        index++;
+        c = path[index];
+        if (c === '\\' && maybeUnescapeQuote()) {
+            continue;
+        }
+        type = getPathCharType(c);
+        typeMap = pathStateMachine[mode];
+        transition = typeMap[type] || typeMap["l" /* PathCharTypes.ELSE */] || 8 /* States.ERROR */;
+        // check parse error
+        if (transition === 8 /* States.ERROR */) {
+            return;
+        }
+        mode = transition[0];
+        if (transition[1] !== undefined) {
+            action = actions[transition[1]];
+            if (action) {
+                newChar = c;
+                if (action() === false) {
+                    return;
+                }
+            }
+        }
+        // check parse finish
+        if (mode === 7 /* States.AFTER_PATH */) {
+            return keys;
+        }
+    }
+}
+// path token cache
+const cache = new Map();
+/**
+ * key-value message resolver
+ *
+ * @remarks
+ * Resolves messages with the key-value structure. Note that messages with a hierarchical structure such as objects cannot be resolved
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveWithKeyValue(obj, path) {
+    return shared.isObject(obj) ? obj[path] : null;
+}
+/**
+ * message resolver
+ *
+ * @remarks
+ * Resolves messages. messages with a hierarchical structure such as objects can be resolved. This resolver is used in VueI18n as default.
+ *
+ * @param obj - A target object to be resolved with path
+ * @param path - A {@link Path | path} to resolve the value of message
+ *
+ * @returns A resolved {@link PathValue | path value}
+ *
+ * @VueI18nGeneral
+ */
+function resolveValue(obj, path) {
+    // check object
+    if (!shared.isObject(obj)) {
+        return null;
+    }
+    // parse path
+    let hit = cache.get(path);
+    if (!hit) {
+        hit = parse(path);
+        if (hit) {
+            cache.set(path, hit);
+        }
+    }
+    // check hit
+    if (!hit) {
+        return null;
+    }
+    // resolve path value
+    const len = hit.length;
+    let last = obj;
+    let i = 0;
+    while (i < len) {
+        const val = last[hit[i]];
+        if (val === undefined) {
+            return null;
+        }
+        last = val;
+        i++;
+    }
+    return last;
+}
+
+const DEFAULT_MODIFIER = (str) => str;
+const DEFAULT_MESSAGE = (ctx) => ''; // eslint-disable-line
+const DEFAULT_MESSAGE_DATA_TYPE = 'text';
+const DEFAULT_NORMALIZE = (values) => values.length === 0 ? '' : shared.join(values);
+const DEFAULT_INTERPOLATE = shared.toDisplayString;
+function pluralDefault(choice, choicesLength) {
+    choice = Math.abs(choice);
+    if (choicesLength === 2) {
+        // prettier-ignore
+        return choice
+            ? choice > 1
+                ? 1
+                : 0
+            : 1;
+    }
+    return choice ? Math.min(choice, 2) : 0;
+}
+function getPluralIndex(options) {
+    // prettier-ignore
+    const index = shared.isNumber(options.pluralIndex)
+        ? options.pluralIndex
+        : -1;
+    // prettier-ignore
+    return options.named && (shared.isNumber(options.named.count) || shared.isNumber(options.named.n))
+        ? shared.isNumber(options.named.count)
+            ? options.named.count
+            : shared.isNumber(options.named.n)
+                ? options.named.n
+                : index
+        : index;
+}
+function normalizeNamed(pluralIndex, props) {
+    if (!props.count) {
+        props.count = pluralIndex;
+    }
+    if (!props.n) {
+        props.n = pluralIndex;
+    }
+}
+function createMessageContext(options = {}) {
+    const locale = options.locale;
+    const pluralIndex = getPluralIndex(options);
+    const pluralRule = shared.isObject(options.pluralRules) &&
+        shared.isString(locale) &&
+        shared.isFunction(options.pluralRules[locale])
+        ? options.pluralRules[locale]
+        : pluralDefault;
+    const orgPluralRule = shared.isObject(options.pluralRules) &&
+        shared.isString(locale) &&
+        shared.isFunction(options.pluralRules[locale])
+        ? pluralDefault
+        : undefined;
+    const plural = (messages) => {
+        return messages[pluralRule(pluralIndex, messages.length, orgPluralRule)];
+    };
+    const _list = options.list || [];
+    const list = (index) => _list[index];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const _named = options.named || {};
+    shared.isNumber(options.pluralIndex) && normalizeNamed(pluralIndex, _named);
+    const named = (key) => _named[key];
+    function message(key) {
+        // prettier-ignore
+        const msg = shared.isFunction(options.messages)
+            ? options.messages(key)
+            : shared.isObject(options.messages)
+                ? options.messages[key]
+                : false;
+        return !msg
+            ? options.parent
+                ? options.parent.message(key) // resolve from parent messages
+                : DEFAULT_MESSAGE
+            : msg;
+    }
+    const _modifier = (name) => options.modifiers
+        ? options.modifiers[name]
+        : DEFAULT_MODIFIER;
+    const normalize = shared.isPlainObject(options.processor) && shared.isFunction(options.processor.normalize)
+        ? options.processor.normalize
+        : DEFAULT_NORMALIZE;
+    const interpolate = shared.isPlainObject(options.processor) &&
+        shared.isFunction(options.processor.interpolate)
+        ? options.processor.interpolate
+        : DEFAULT_INTERPOLATE;
+    const type = shared.isPlainObject(options.processor) && shared.isString(options.processor.type)
+        ? options.processor.type
+        : DEFAULT_MESSAGE_DATA_TYPE;
+    const linked = (key, ...args) => {
+        const [arg1, arg2] = args;
+        let type = 'text';
+        let modifier = '';
+        if (args.length === 1) {
+            if (shared.isObject(arg1)) {
+                modifier = arg1.modifier || modifier;
+                type = arg1.type || type;
+            }
+            else if (shared.isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+        }
+        else if (args.length === 2) {
+            if (shared.isString(arg1)) {
+                modifier = arg1 || modifier;
+            }
+            if (shared.isString(arg2)) {
+                type = arg2 || type;
+            }
+        }
+        const ret = message(key)(ctx);
+        const msg = 
+        // The message in vnode resolved with linked are returned as an array by processor.nomalize
+        type === 'vnode' && shared.isArray(ret) && modifier
+            ? ret[0]
+            : ret;
+        return modifier ? _modifier(modifier)(msg, type) : msg;
+    };
+    const ctx = {
+        ["list" /* HelperNameMap.LIST */]: list,
+        ["named" /* HelperNameMap.NAMED */]: named,
+        ["plural" /* HelperNameMap.PLURAL */]: plural,
+        ["linked" /* HelperNameMap.LINKED */]: linked,
+        ["message" /* HelperNameMap.MESSAGE */]: message,
+        ["type" /* HelperNameMap.TYPE */]: type,
+        ["interpolate" /* HelperNameMap.INTERPOLATE */]: interpolate,
+        ["normalize" /* HelperNameMap.NORMALIZE */]: normalize,
+        ["values" /* HelperNameMap.VALUES */]: shared.assign({}, _list, _named)
+    };
+    return ctx;
+}
+
+let devtools = null;
+function setDevToolsHook(hook) {
+    devtools = hook;
+}
+function getDevToolsHook() {
+    return devtools;
+}
+function initI18nDevTools(i18n, version, meta) {
+    // TODO: queue if devtools is undefined
+    devtools &&
+        devtools.emit("i18n:init" /* IntlifyDevToolsHooks.I18nInit */, {
+            timestamp: Date.now(),
+            i18n,
+            version,
+            meta
+        });
+}
+const translateDevTools = /* #__PURE__*/ createDevToolsHook("function:translate" /* IntlifyDevToolsHooks.FunctionTranslate */);
+function createDevToolsHook(hook) {
+    return (payloads) => devtools && devtools.emit(hook, payloads);
+}
+
+const CoreWarnCodes = {
+    NOT_FOUND_KEY: 1,
+    FALLBACK_TO_TRANSLATE: 2,
+    CANNOT_FORMAT_NUMBER: 3,
+    FALLBACK_TO_NUMBER_FORMAT: 4,
+    CANNOT_FORMAT_DATE: 5,
+    FALLBACK_TO_DATE_FORMAT: 6,
+    EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER: 7,
+    __EXTEND_POINT__: 8
+};
+/** @internal */
+const warnMessages = {
+    [CoreWarnCodes.NOT_FOUND_KEY]: `Not found '{key}' key in '{locale}' locale messages.`,
+    [CoreWarnCodes.FALLBACK_TO_TRANSLATE]: `Fall back to translate '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_NUMBER]: `Cannot format a number value due to not supported Intl.NumberFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_NUMBER_FORMAT]: `Fall back to number format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.CANNOT_FORMAT_DATE]: `Cannot format a date value due to not supported Intl.DateTimeFormat.`,
+    [CoreWarnCodes.FALLBACK_TO_DATE_FORMAT]: `Fall back to datetime format '{key}' key with '{target}' locale.`,
+    [CoreWarnCodes.EXPERIMENTAL_CUSTOM_MESSAGE_COMPILER]: `This project is using Custom Message Compiler, which is an experimental feature. It may receive breaking changes or be removed in the future.`
+};
+function getWarnMessage(code, ...args) {
+    return shared.format(warnMessages[code], ...args);
+}
+
+/** @internal */
+function getLocale(context, options) {
+    return options.locale != null
+        ? resolveLocale(options.locale)
+        : resolveLocale(context.locale);
+}
+let _resolveLocale;
+/** @internal */
+function resolveLocale(locale) {
+    // prettier-ignore
+    return shared.isString(locale)
+        ? locale
+        : _resolveLocale != null && locale.resolvedOnce
+            ? _resolveLocale
+            : (_resolveLocale = locale());
+}
+/**
+ * Fallback with simple implemenation
+ *
+ * @remarks
+ * A fallback locale function implemented with a simple fallback algorithm.
+ *
+ * Basically, it returns the value as specified in the `fallbackLocale` props, and is processed with the fallback inside intlify.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithSimple(ctx, fallback, start // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
+    // prettier-ignore
+    return [...new Set([
+            start,
+            ...(shared.isArray(fallback)
+                ? fallback
+                : shared.isObject(fallback)
+                    ? Object.keys(fallback)
+                    : shared.isString(fallback)
+                        ? [fallback]
+                        : [start])
+        ])];
+}
+/**
+ * Fallback with locale chain
+ *
+ * @remarks
+ * A fallback locale function implemented with a fallback chain algorithm. It's used in VueI18n as default.
+ *
+ * @param ctx - A {@link CoreContext | context}
+ * @param fallback - A {@link FallbackLocale | fallback locale}
+ * @param start - A starting {@link Locale | locale}
+ *
+ * @returns Fallback locales
+ *
+ * @VueI18nSee [Fallbacking](../guide/essentials/fallback)
+ *
+ * @VueI18nGeneral
+ */
+function fallbackWithLocaleChain(ctx, fallback, start) {
+    const startLocale = shared.isString(start) ? start : DEFAULT_LOCALE;
+    const context = ctx;
+    if (!context.__localeChainCache) {
+        context.__localeChainCache = new Map();
+    }
+    let chain = context.__localeChainCache.get(startLocale);
+    if (!chain) {
+        chain = [];
+        // first block defined by start
+        let block = [start];
+        // while any intervening block found
+        while (shared.isArray(block)) {
+            block = appendBlockToChain(chain, block, fallback);
+        }
+        // prettier-ignore
+        // last block defined by default
+        const defaults = shared.isArray(fallback) || !shared.isPlainObject(fallback)
+            ? fallback
+            : fallback['default']
+                ? fallback['default']
+                : null;
+        // convert defaults to array
+        block = shared.isString(defaults) ? [defaults] : defaults;
+        if (shared.isArray(block)) {
+            appendBlockToChain(chain, block, false);
+        }
+        context.__localeChainCache.set(startLocale, chain);
+    }
+    return chain;
+}
+function appendBlockToChain(chain, block, blocks) {
+    let follow = true;
+    for (let i = 0; i < block.length && shared.isBoolean(follow); i++) {
+        const locale = block[i];
+        if (shared.isString(locale)) {
+            follow = appendLocaleToChain(chain, block[i], blocks);
+        }
+    }
+    return follow;
+}
+function appendLocaleToChain(chain, locale, blocks) {
+    let follow;
+    const tokens = locale.split('-');
+    do {
+        const target = tokens.join('-');
+        follow = appendItemToChain(chain, target, blocks);
+        tokens.splice(-1, 1);
+    } while (tokens.length && follow === true);
+    return follow;
+}
+function appendItemToChain(chain, target, blocks) {
+    let follow = false;
+    if (!chain.includes(target)) {
+        follow = true;
+        if (target) {
+            follow = target[target.length - 1] !== '!';
+            const locale = target.replace(/!/g, '');
+            chain.push(locale);
+            if ((shared.isArray(blocks) || shared.isPlainObject(blocks)) &&
+                blocks[locale] // eslint-disable-line @typescript-eslint/no-explicit-any
+            ) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                follow = blocks[locale];
+            }
+        }
+    }
+    return follow;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Intlify core-base version
+ * @internal
+ */
+const VERSION = '9.5.0';
+const NOT_REOSLVED = -1;
+const DEFAULT_LOCALE = 'en-US';
+const MISSING_RESOLVE_VALUE = '';
+const capitalize = (str) => `${str.charAt(0).toLocaleUpperCase()}${str.substr(1)}`;
+function getDefaultLinkedModifiers() {
+    return {
+        upper: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && shared.isString(val)
+                ? val.toUpperCase()
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? val.children.toUpperCase()
+                    : val;
+        },
+        lower: (val, type) => {
+            // prettier-ignore
+            return type === 'text' && shared.isString(val)
+                ? val.toLowerCase()
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? val.children.toLowerCase()
+                    : val;
+        },
+        capitalize: (val, type) => {
+            // prettier-ignore
+            return (type === 'text' && shared.isString(val)
+                ? capitalize(val)
+                : type === 'vnode' && shared.isObject(val) && '__v_isVNode' in val
+                    ? capitalize(val.children)
+                    : val);
+        }
+    };
+}
+let _compiler;
+function registerMessageCompiler(compiler) {
+    _compiler = compiler;
+}
+let _resolver;
+/**
+ * Register the message resolver
+ *
+ * @param resolver - A {@link MessageResolver} function
+ *
+ * @VueI18nGeneral
+ */
+function registerMessageResolver(resolver) {
+    _resolver = resolver;
+}
+let _fallbacker;
+/**
+ * Register the locale fallbacker
+ *
+ * @param fallbacker - A {@link LocaleFallbacker} function
+ *
+ * @VueI18nGeneral
+ */
+function registerLocaleFallbacker(fallbacker) {
+    _fallbacker = fallbacker;
+}
+// Additional Meta for Intlify DevTools
+let _additionalMeta =  null;
+const setAdditionalMeta = /* #__PURE__*/ (meta) => {
+    _additionalMeta = meta;
+};
+const getAdditionalMeta = /* #__PURE__*/ () => _additionalMeta;
+let _fallbackContext = null;
+const setFallbackContext = (context) => {
+    _fallbackContext = context;
+};
+const getFallbackContext = () => _fallbackContext;
+// ID for CoreContext
+let _cid = 0;
+function createCoreContext(options = {}) {
+    // setup options
+    const onWarn = shared.isFunction(options.onWarn) ? options.onWarn : shared.warn;
+    const version = shared.isString(options.version) ? options.version : VERSION;
+    const locale = shared.isString(options.locale) || shared.isFunction(options.locale)
+        ? options.locale
+        : DEFAULT_LOCALE;
+    const _locale = shared.isFunction(locale) ? DEFAULT_LOCALE : locale;
+    const fallbackLocale = shared.isArray(options.fallbackLocale) ||
+        shared.isPlainObject(options.fallbackLocale) ||
+        shared.isString(options.fallbackLocale) ||
+        options.fallbackLocale === false
+        ? options.fallbackLocale
+        : _locale;
+    const messages = shared.isPlainObject(options.messages)
+        ? options.messages
+        : { [_locale]: {} };
+    const datetimeFormats = shared.isPlainObject(options.datetimeFormats)
+            ? options.datetimeFormats
+            : { [_locale]: {} }
+        ;
+    const numberFormats = shared.isPlainObject(options.numberFormats)
+            ? options.numberFormats
+            : { [_locale]: {} }
+        ;
+    const modifiers = shared.assign({}, options.modifiers || {}, getDefaultLinkedModifiers());
+    const pluralRules = options.pluralRules || {};
+    const missing = shared.isFunction(options.missing) ? options.missing : null;
+    const missingWarn = shared.isBoolean(options.missingWarn) || shared.isRegExp(options.missingWarn)
+        ? options.missingWarn
+        : true;
+    const fallbackWarn = shared.isBoolean(options.fallbackWarn) || shared.isRegExp(options.fallbackWarn)
+        ? options.fallbackWarn
+        : true;
+    const fallbackFormat = !!options.fallbackFormat;
+    const unresolving = !!options.unresolving;
+    const postTranslation = shared.isFunction(options.postTranslation)
+        ? options.postTranslation
+        : null;
+    const processor = shared.isPlainObject(options.processor) ? options.processor : null;
+    const warnHtmlMessage = shared.isBoolean(options.warnHtmlMessage)
+        ? options.warnHtmlMessage
+        : true;
+    const escapeParameter = !!options.escapeParameter;
+    const messageCompiler = shared.isFunction(options.messageCompiler)
+        ? options.messageCompiler
+        : _compiler;
+    const messageResolver = shared.isFunction(options.messageResolver)
+        ? options.messageResolver
+        : _resolver || resolveWithKeyValue;
+    const localeFallbacker = shared.isFunction(options.localeFallbacker)
+        ? options.localeFallbacker
+        : _fallbacker || fallbackWithSimple;
+    const fallbackContext = shared.isObject(options.fallbackContext)
+        ? options.fallbackContext
+        : undefined;
+    // setup internal options
+    const internalOptions = options;
+    const __datetimeFormatters = shared.isObject(internalOptions.__datetimeFormatters)
+            ? internalOptions.__datetimeFormatters
+            : new Map()
+        ;
+    const __numberFormatters = shared.isObject(internalOptions.__numberFormatters)
+            ? internalOptions.__numberFormatters
+            : new Map()
+        ;
+    const __meta = shared.isObject(internalOptions.__meta) ? internalOptions.__meta : {};
+    _cid++;
+    const context = {
+        version,
+        cid: _cid,
+        locale,
+        fallbackLocale,
+        messages,
+        modifiers,
+        pluralRules,
+        missing,
+        missingWarn,
+        fallbackWarn,
+        fallbackFormat,
+        unresolving,
+        postTranslation,
+        processor,
+        warnHtmlMessage,
+        escapeParameter,
+        messageCompiler,
+        messageResolver,
+        localeFallbacker,
+        fallbackContext,
+        onWarn,
+        __meta
+    };
+    {
+        context.datetimeFormats = datetimeFormats;
+        context.numberFormats = numberFormats;
+        context.__datetimeFormatters = __datetimeFormatters;
+        context.__numberFormatters = __numberFormatters;
+    }
+    return context;
+}
+/** @internal */
+function isTranslateFallbackWarn(fallback, key) {
+    return fallback instanceof RegExp ? fallback.test(key) : fallback;
+}
+/** @internal */
+function isTranslateMissingWarn(missing, key) {
+    return missing instanceof RegExp ? missing.test(key) : missing;
+}
+/** @internal */
+function handleMissing(context, key, locale, missingWarn, type) {
+    const { missing, onWarn } = context;
+    if (missing !== null) {
+        const ret = missing(context, locale, key, type);
+        return shared.isString(ret) ? ret : key;
+    }
+    else {
+        return key;
+    }
+}
+/** @internal */
+function updateFallbackLocale(ctx, locale, fallback) {
+    const context = ctx;
+    context.__localeChainCache = new Map();
+    ctx.localeFallbacker(ctx, fallback, locale);
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+function format(ast) {
+    const msg = (ctx) => formatParts(ctx, ast);
+    return msg;
+}
+function formatParts(ctx, ast) {
+    const body = ast.b || ast.body;
+    if ((body.t || body.type) === 1 /* NodeTypes.Plural */) {
+        const plural = body;
+        const cases = plural.c || plural.cases;
+        return ctx.plural(cases.reduce((messages, c) => [
+            ...messages,
+            formatMessageParts(ctx, c)
+        ], []));
+    }
+    else {
+        return formatMessageParts(ctx, body);
+    }
+}
+function formatMessageParts(ctx, node) {
+    const _static = node.s || node.static;
+    if (_static) {
+        return ctx.type === 'text'
+            ? _static
+            : ctx.normalize([_static]);
+    }
+    else {
+        const messages = (node.i || node.items).reduce((acm, c) => [...acm, formatMessagePart(ctx, c)], []);
+        return ctx.normalize(messages);
+    }
+}
+function formatMessagePart(ctx, node) {
+    const type = node.t || node.type;
+    switch (type) {
+        case 3 /* NodeTypes.Text */:
+            const text = node;
+            return (text.v || text.value);
+        case 9 /* NodeTypes.Literal */:
+            const literal = node;
+            return (literal.v || literal.value);
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            return ctx.interpolate(ctx.named(named.k || named.key));
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            return ctx.interpolate(ctx.list(list.i != null ? list.i : list.index));
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            const modifier = linked.m || linked.modifier;
+            return ctx.linked(formatMessagePart(ctx, linked.k || linked.key), modifier ? formatMessagePart(ctx, modifier) : undefined, ctx.type);
+        case 7 /* NodeTypes.LinkedKey */:
+            const linkedKey = node;
+            return (linkedKey.v || linkedKey.value);
+        case 8 /* NodeTypes.LinkedModifier */:
+            const linkedModifier = node;
+            return (linkedModifier.v || linkedModifier.value);
+        default:
+            throw new Error(`unhandled node type on format message part: ${type}`);
+    }
+}
+
+const code = messageCompiler.CompileErrorCodes.__EXTEND_POINT__;
+const inc = shared.incrementer(code);
+const CoreErrorCodes = {
+    INVALID_ARGUMENT: code,
+    INVALID_DATE_ARGUMENT: inc(),
+    INVALID_ISO_DATE_ARGUMENT: inc(),
+    NOT_SUPPORT_NON_STRING_MESSAGE: inc(),
+    __EXTEND_POINT__: inc() // 22
+};
+function createCoreError(code) {
+    return messageCompiler.createCompileError(code, null, undefined);
+}
+/** @internal */
+({
+    [CoreErrorCodes.INVALID_ARGUMENT]: 'Invalid arguments',
+    [CoreErrorCodes.INVALID_DATE_ARGUMENT]: 'The date provided is an invalid Date object.' +
+        'Make sure your Date represents a valid date.',
+    [CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT]: 'The argument provided is not a valid ISO date string',
+    [CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE]: 'Not support non-string message'
+});
+
+const defaultOnCacheKey = (message) => message;
+let compileCache = Object.create(null);
+function clearCompileCache() {
+    compileCache = Object.create(null);
+}
+const isMessageAST = (val) => shared.isObject(val) &&
+    (val.t === 0 || val.type === 0) &&
+    ('b' in val || 'body' in val);
+function baseCompile(message, options = {}) {
+    // error detecting on compile
+    let detectError = false;
+    const onError = options.onError || messageCompiler.defaultOnError;
+    options.onError = (err) => {
+        detectError = true;
+        onError(err);
+    };
+    // compile with mesasge-compiler
+    return { ...messageCompiler.baseCompile(message, options), detectError };
+}
+const compileToFunction = /* #__PURE__*/ (message, context) => {
+    if (!shared.isString(message)) {
+        throw createCoreError(CoreErrorCodes.NOT_SUPPORT_NON_STRING_MESSAGE);
+    }
+    {
+        // check HTML message
+        shared.isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile
+        const { code, detectError } = baseCompile(message, context);
+        // evaluate function
+        const msg = new Function(`return ${code}`)();
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+};
+function compile(message, context) {
+    if (shared.isString(message)) {
+        // check HTML message
+        shared.isBoolean(context.warnHtmlMessage)
+            ? context.warnHtmlMessage
+            : true;
+        // check caches
+        const onCacheKey = context.onCacheKey || defaultOnCacheKey;
+        const cacheKey = onCacheKey(message);
+        const cached = compileCache[cacheKey];
+        if (cached) {
+            return cached;
+        }
+        // compile with JIT mode
+        const { ast, detectError } = baseCompile(message, {
+            ...context,
+            location: false,
+            jit: true
+        });
+        // compose message function from AST
+        const msg = format(ast);
+        // if occurred compile error, don't cache
+        return !detectError
+            ? (compileCache[cacheKey] = msg)
+            : msg;
+    }
+    else {
+        // AST case (passed from bundler)
+        const cacheKey = message.cacheKey;
+        if (cacheKey) {
+            const cached = compileCache[cacheKey];
+            if (cached) {
+                return cached;
+            }
+            // compose message function from message (AST)
+            return (compileCache[cacheKey] =
+                format(message));
+        }
+        else {
+            return format(message);
+        }
+    }
+}
+
+const NOOP_MESSAGE_FUNCTION = () => '';
+const isMessageFunction = (val) => shared.isFunction(val);
+// implementation of `translate` function
+function translate(context, ...args) {
+    const { fallbackFormat, postTranslation, unresolving, messageCompiler, fallbackLocale, messages } = context;
+    const [key, options] = parseTranslateArgs(...args);
+    const missingWarn = shared.isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    const fallbackWarn = shared.isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const escapeParameter = shared.isBoolean(options.escapeParameter)
+        ? options.escapeParameter
+        : context.escapeParameter;
+    const resolvedMessage = !!options.resolvedMessage;
+    // prettier-ignore
+    const defaultMsgOrKey = shared.isString(options.default) || shared.isBoolean(options.default) // default by function option
+        ? !shared.isBoolean(options.default)
+            ? options.default
+            : (!messageCompiler ? () => key : key)
+        : fallbackFormat // default by `fallbackFormat` option
+            ? (!messageCompiler ? () => key : key)
+            : '';
+    const enableDefaultMsg = fallbackFormat || defaultMsgOrKey !== '';
+    const locale = getLocale(context, options);
+    // escape params
+    escapeParameter && escapeParams(options);
+    // resolve message format
+    // eslint-disable-next-line prefer-const
+    let [formatScope, targetLocale, message] = !resolvedMessage
+        ? resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn)
+        : [
+            key,
+            locale,
+            messages[locale] || {}
+        ];
+    // NOTE:
+    //  Fix to work around `ssrTransfrom` bug in Vite.
+    //  https://github.com/vitejs/vite/issues/4306
+    //  To get around this, use temporary variables.
+    //  https://github.com/nuxt/framework/issues/1461#issuecomment-954606243
+    let format = formatScope;
+    // if you use default message, set it as message format!
+    let cacheBaseKey = key;
+    if (!resolvedMessage &&
+        !(shared.isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format))) {
+        if (enableDefaultMsg) {
+            format = defaultMsgOrKey;
+            cacheBaseKey = format;
+        }
+    }
+    // checking message format and target locale
+    if (!resolvedMessage &&
+        (!(shared.isString(format) ||
+            isMessageAST(format) ||
+            isMessageFunction(format)) ||
+            !shared.isString(targetLocale))) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    // setup compile error detecting
+    let occurred = false;
+    const onError = () => {
+        occurred = true;
+    };
+    // compile message format
+    const msg = !isMessageFunction(format)
+        ? compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError)
+        : format;
+    // if occurred compile error, return the message format
+    if (occurred) {
+        return format;
+    }
+    // evaluate message with context
+    const ctxOptions = getMessageContextOptions(context, targetLocale, message, options);
+    const msgContext = createMessageContext(ctxOptions);
+    const messaged = evaluateMessage(context, msg, msgContext);
+    // if use post translation option, proceed it with handler
+    const ret = postTranslation
+        ? postTranslation(messaged, key)
+        : messaged;
+    return ret;
+}
+function escapeParams(options) {
+    if (shared.isArray(options.list)) {
+        options.list = options.list.map(item => shared.isString(item) ? shared.escapeHtml(item) : item);
+    }
+    else if (shared.isObject(options.named)) {
+        Object.keys(options.named).forEach(key => {
+            if (shared.isString(options.named[key])) {
+                options.named[key] = shared.escapeHtml(options.named[key]);
+            }
+        });
+    }
+}
+function resolveMessageFormat(context, key, locale, fallbackLocale, fallbackWarn, missingWarn) {
+    const { messages, onWarn, messageResolver: resolveValue, localeFallbacker } = context;
+    const locales = localeFallbacker(context, fallbackLocale, locale); // eslint-disable-line @typescript-eslint/no-explicit-any
+    let message = {};
+    let targetLocale;
+    let format = null;
+    const type = 'translate';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = locales[i];
+        message =
+            messages[targetLocale] || {};
+        if ((format = resolveValue(message, key)) === null) {
+            // if null, resolve with object key path
+            format = message[key]; // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        if (shared.isString(format) || isMessageAST(format) || isMessageFunction(format)) {
+            break;
+        }
+        const missingRet = handleMissing(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+        key, targetLocale, missingWarn, type);
+        if (missingRet !== key) {
+            format = missingRet;
+        }
+    }
+    return [format, targetLocale, message];
+}
+function compileMessageFormat(context, key, targetLocale, format, cacheBaseKey, onError) {
+    const { messageCompiler, warnHtmlMessage } = context;
+    if (isMessageFunction(format)) {
+        const msg = format;
+        msg.locale = msg.locale || targetLocale;
+        msg.key = msg.key || key;
+        return msg;
+    }
+    if (messageCompiler == null) {
+        const msg = (() => format);
+        msg.locale = targetLocale;
+        msg.key = key;
+        return msg;
+    }
+    const msg = messageCompiler(format, getCompileContext(context, targetLocale, cacheBaseKey, format, warnHtmlMessage, onError));
+    msg.locale = targetLocale;
+    msg.key = key;
+    msg.source = format;
+    return msg;
+}
+function evaluateMessage(context, msg, msgCtx) {
+    const messaged = msg(msgCtx);
+    return messaged;
+}
+/** @internal */
+function parseTranslateArgs(...args) {
+    const [arg1, arg2, arg3] = args;
+    const options = {};
+    if (!shared.isString(arg1) &&
+        !shared.isNumber(arg1) &&
+        !isMessageFunction(arg1) &&
+        !isMessageAST(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    // prettier-ignore
+    const key = shared.isNumber(arg1)
+        ? String(arg1)
+        : isMessageFunction(arg1)
+            ? arg1
+            : arg1;
+    if (shared.isNumber(arg2)) {
+        options.plural = arg2;
+    }
+    else if (shared.isString(arg2)) {
+        options.default = arg2;
+    }
+    else if (shared.isPlainObject(arg2) && !shared.isEmptyObject(arg2)) {
+        options.named = arg2;
+    }
+    else if (shared.isArray(arg2)) {
+        options.list = arg2;
+    }
+    if (shared.isNumber(arg3)) {
+        options.plural = arg3;
+    }
+    else if (shared.isString(arg3)) {
+        options.default = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        shared.assign(options, arg3);
+    }
+    return [key, options];
+}
+function getCompileContext(context, locale, key, source, warnHtmlMessage, onError) {
+    return {
+        locale,
+        key,
+        warnHtmlMessage,
+        onError: (err) => {
+            onError && onError(err);
+            {
+                throw err;
+            }
+        },
+        onCacheKey: (source) => shared.generateFormatCacheKey(locale, key, source)
+    };
+}
+function getMessageContextOptions(context, locale, message, options) {
+    const { modifiers, pluralRules, messageResolver: resolveValue, fallbackLocale, fallbackWarn, missingWarn, fallbackContext } = context;
+    const resolveMessage = (key) => {
+        let val = resolveValue(message, key);
+        // fallback to root context
+        if (val == null && fallbackContext) {
+            const [, , message] = resolveMessageFormat(fallbackContext, key, locale, fallbackLocale, fallbackWarn, missingWarn);
+            val = resolveValue(message, key);
+        }
+        if (shared.isString(val) || isMessageAST(val)) {
+            let occurred = false;
+            const onError = () => {
+                occurred = true;
+            };
+            const msg = compileMessageFormat(context, key, locale, val, key, onError);
+            return !occurred
+                ? msg
+                : NOOP_MESSAGE_FUNCTION;
+        }
+        else if (isMessageFunction(val)) {
+            return val;
+        }
+        else {
+            // TODO: should be implemented warning message
+            return NOOP_MESSAGE_FUNCTION;
+        }
+    };
+    const ctxOptions = {
+        locale,
+        modifiers,
+        pluralRules,
+        messages: resolveMessage
+    };
+    if (context.processor) {
+        ctxOptions.processor = context.processor;
+    }
+    if (options.list) {
+        ctxOptions.list = options.list;
+    }
+    if (options.named) {
+        ctxOptions.named = options.named;
+    }
+    if (shared.isNumber(options.plural)) {
+        ctxOptions.pluralIndex = options.plural;
+    }
+    return ctxOptions;
+}
+
+// implementation of `datetime` function
+function datetime(context, ...args) {
+    const { datetimeFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __datetimeFormatters } = context;
+    const [key, value, options, overrides] = parseDateTimeArgs(...args);
+    const missingWarn = shared.isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    shared.isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!shared.isString(key) || key === '') {
+        return new Intl.DateTimeFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let datetimeFormat = {};
+    let targetLocale;
+    let format = null;
+    const type = 'datetime format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = locales[i];
+        datetimeFormat =
+            datetimeFormats[targetLocale] || {};
+        format = datetimeFormat[key];
+        if (shared.isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+    }
+    // checking format and target locale
+    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!shared.isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __datetimeFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat(targetLocale, shared.assign({}, format, overrides));
+        __datetimeFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const DATETIME_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'weekday',
+    'era',
+    'year',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'timeZoneName',
+    'formatMatcher',
+    'hour12',
+    'timeZone',
+    'dateStyle',
+    'timeStyle',
+    'calendar',
+    'dayPeriod',
+    'numberingSystem',
+    'hourCycle',
+    'fractionalSecondDigits'
+];
+/** @internal */
+function parseDateTimeArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    let value;
+    if (shared.isString(arg1)) {
+        // Only allow ISO strings - other date formats are often supported,
+        // but may cause different results in different browsers.
+        const matches = arg1.match(/(\d{4}-\d{2}-\d{2})(T|\s)?(.*)/);
+        if (!matches) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+        // Some browsers can not parse the iso datetime separated by space,
+        // this is a compromise solution by replace the 'T'/' ' with 'T'
+        const dateTime = matches[3]
+            ? matches[3].trim().startsWith('T')
+                ? `${matches[1].trim()}${matches[3].trim()}`
+                : `${matches[1].trim()}T${matches[3].trim()}`
+            : matches[1].trim();
+        value = new Date(dateTime);
+        try {
+            // This will fail if the date is not valid
+            value.toISOString();
+        }
+        catch (e) {
+            throw createCoreError(CoreErrorCodes.INVALID_ISO_DATE_ARGUMENT);
+        }
+    }
+    else if (shared.isDate(arg1)) {
+        if (isNaN(arg1.getTime())) {
+            throw createCoreError(CoreErrorCodes.INVALID_DATE_ARGUMENT);
+        }
+        value = arg1;
+    }
+    else if (shared.isNumber(arg1)) {
+        value = arg1;
+    }
+    else {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    if (shared.isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (shared.isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (DATETIME_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (shared.isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (shared.isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearDateTimeFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__datetimeFormatters.has(id)) {
+            continue;
+        }
+        context.__datetimeFormatters.delete(id);
+    }
+}
+
+// implementation of `number` function
+function number(context, ...args) {
+    const { numberFormats, unresolving, fallbackLocale, onWarn, localeFallbacker } = context;
+    const { __numberFormatters } = context;
+    const [key, value, options, overrides] = parseNumberArgs(...args);
+    const missingWarn = shared.isBoolean(options.missingWarn)
+        ? options.missingWarn
+        : context.missingWarn;
+    shared.isBoolean(options.fallbackWarn)
+        ? options.fallbackWarn
+        : context.fallbackWarn;
+    const part = !!options.part;
+    const locale = getLocale(context, options);
+    const locales = localeFallbacker(context, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fallbackLocale, locale);
+    if (!shared.isString(key) || key === '') {
+        return new Intl.NumberFormat(locale, overrides).format(value);
+    }
+    // resolve format
+    let numberFormat = {};
+    let targetLocale;
+    let format = null;
+    const type = 'number format';
+    for (let i = 0; i < locales.length; i++) {
+        targetLocale = locales[i];
+        numberFormat =
+            numberFormats[targetLocale] || {};
+        format = numberFormat[key];
+        if (shared.isPlainObject(format))
+            break;
+        handleMissing(context, key, targetLocale, missingWarn, type); // eslint-disable-line @typescript-eslint/no-explicit-any
+    }
+    // checking format and target locale
+    if (!shared.isPlainObject(format) || !shared.isString(targetLocale)) {
+        return unresolving ? NOT_REOSLVED : key;
+    }
+    let id = `${targetLocale}__${key}`;
+    if (!shared.isEmptyObject(overrides)) {
+        id = `${id}__${JSON.stringify(overrides)}`;
+    }
+    let formatter = __numberFormatters.get(id);
+    if (!formatter) {
+        formatter = new Intl.NumberFormat(targetLocale, shared.assign({}, format, overrides));
+        __numberFormatters.set(id, formatter);
+    }
+    return !part ? formatter.format(value) : formatter.formatToParts(value);
+}
+/** @internal */
+const NUMBER_FORMAT_OPTIONS_KEYS = [
+    'localeMatcher',
+    'style',
+    'currency',
+    'currencyDisplay',
+    'currencySign',
+    'useGrouping',
+    'minimumIntegerDigits',
+    'minimumFractionDigits',
+    'maximumFractionDigits',
+    'minimumSignificantDigits',
+    'maximumSignificantDigits',
+    'compactDisplay',
+    'notation',
+    'signDisplay',
+    'unit',
+    'unitDisplay',
+    'roundingMode',
+    'roundingPriority',
+    'roundingIncrement',
+    'trailingZeroDisplay'
+];
+/** @internal */
+function parseNumberArgs(...args) {
+    const [arg1, arg2, arg3, arg4] = args;
+    const options = {};
+    let overrides = {};
+    if (!shared.isNumber(arg1)) {
+        throw createCoreError(CoreErrorCodes.INVALID_ARGUMENT);
+    }
+    const value = arg1;
+    if (shared.isString(arg2)) {
+        options.key = arg2;
+    }
+    else if (shared.isPlainObject(arg2)) {
+        Object.keys(arg2).forEach(key => {
+            if (NUMBER_FORMAT_OPTIONS_KEYS.includes(key)) {
+                overrides[key] = arg2[key];
+            }
+            else {
+                options[key] = arg2[key];
+            }
+        });
+    }
+    if (shared.isString(arg3)) {
+        options.locale = arg3;
+    }
+    else if (shared.isPlainObject(arg3)) {
+        overrides = arg3;
+    }
+    if (shared.isPlainObject(arg4)) {
+        overrides = arg4;
+    }
+    return [options.key || '', value, options, overrides];
+}
+/** @internal */
+function clearNumberFormat(ctx, locale, format) {
+    const context = ctx;
+    for (const key in format) {
+        const id = `${locale}__${key}`;
+        if (!context.__numberFormatters.has(id)) {
+            continue;
+        }
+        context.__numberFormatters.delete(id);
+    }
+}
+
+exports.CompileErrorCodes = messageCompiler.CompileErrorCodes;
+exports.createCompileError = messageCompiler.createCompileError;
+exports.CoreErrorCodes = CoreErrorCodes;
+exports.CoreWarnCodes = CoreWarnCodes;
+exports.DATETIME_FORMAT_OPTIONS_KEYS = DATETIME_FORMAT_OPTIONS_KEYS;
+exports.DEFAULT_LOCALE = DEFAULT_LOCALE;
+exports.DEFAULT_MESSAGE_DATA_TYPE = DEFAULT_MESSAGE_DATA_TYPE;
+exports.MISSING_RESOLVE_VALUE = MISSING_RESOLVE_VALUE;
+exports.NOT_REOSLVED = NOT_REOSLVED;
+exports.NUMBER_FORMAT_OPTIONS_KEYS = NUMBER_FORMAT_OPTIONS_KEYS;
+exports.VERSION = VERSION;
+exports.clearCompileCache = clearCompileCache;
+exports.clearDateTimeFormat = clearDateTimeFormat;
+exports.clearNumberFormat = clearNumberFormat;
+exports.compile = compile;
+exports.compileToFunction = compileToFunction;
+exports.createCoreContext = createCoreContext;
+exports.createCoreError = createCoreError;
+exports.createMessageContext = createMessageContext;
+exports.datetime = datetime;
+exports.fallbackWithLocaleChain = fallbackWithLocaleChain;
+exports.fallbackWithSimple = fallbackWithSimple;
+exports.getAdditionalMeta = getAdditionalMeta;
+exports.getDevToolsHook = getDevToolsHook;
+exports.getFallbackContext = getFallbackContext;
+exports.getLocale = getLocale;
+exports.getWarnMessage = getWarnMessage;
+exports.handleMissing = handleMissing;
+exports.initI18nDevTools = initI18nDevTools;
+exports.isMessageAST = isMessageAST;
+exports.isMessageFunction = isMessageFunction;
+exports.isTranslateFallbackWarn = isTranslateFallbackWarn;
+exports.isTranslateMissingWarn = isTranslateMissingWarn;
+exports.number = number;
+exports.parse = parse;
+exports.parseDateTimeArgs = parseDateTimeArgs;
+exports.parseNumberArgs = parseNumberArgs;
+exports.parseTranslateArgs = parseTranslateArgs;
+exports.registerLocaleFallbacker = registerLocaleFallbacker;
+exports.registerMessageCompiler = registerMessageCompiler;
+exports.registerMessageResolver = registerMessageResolver;
+exports.resolveLocale = resolveLocale;
+exports.resolveValue = resolveValue;
+exports.resolveWithKeyValue = resolveWithKeyValue;
+exports.setAdditionalMeta = setAdditionalMeta;
+exports.setDevToolsHook = setDevToolsHook;
+exports.setFallbackContext = setFallbackContext;
+exports.translate = translate;
+exports.translateDevTools = translateDevTools;
+exports.updateFallbackLocale = updateFallbackLocale;

node_modules/@intlify/core-base/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/core-base.prod.cjs')
+} else {
+  module.exports = require('./dist/core-base.cjs')
+}

node_modules/@intlify/core-base/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@intlify/core-base",
+  "version": "9.5.0",
+  "description": "@intlify/core-base",
+  "keywords": [
+    "core",
+    "fundamental",
+    "i18n",
+    "internationalization",
+    "intlify"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/core-base#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/core-base.mjs",
+  "unpkg": "dist/core-base.global.js",
+  "jsdelivr": "dist/core-base.global.js",
+  "types": "dist/core-base.d.ts",
+  "dependencies": {
+    "@intlify/message-compiler": "9.5.0",
+    "@intlify/shared": "9.5.0"
+  },
+  "devDependencies": {
+    "@intlify/devtools-if": "9.5.0",
+    "@intlify/vue-devtools": "9.5.0"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "buildOptions": {
+    "name": "IntlifyCoreBase",
+    "formats": [
+      "mjs",
+      "browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/core-base.d.ts",
+      "import": "./dist/core-base.mjs",
+      "browser": "./dist/core-base.esm-browser.js",
+      "node": {
+        "import": {
+          "production": "./dist/core-base.prod.cjs",
+          "development": "./dist/core-base.mjs",
+          "default": "./dist/core-base.mjs"
+        },
+        "require": {
+          "production": "./dist/core-base.prod.cjs",
+          "development": "./dist/core-base.cjs",
+          "default": "./index.js"
+        }
+      }
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "funding": "https://github.com/sponsors/kazupon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

node_modules/@intlify/message-compiler/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kazuya kawaguchi
+
+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.

node_modules/@intlify/message-compiler/README.md

@@ -0,0 +1,7 @@
+# @intlify/message-compiler
+
+The message compiler for intlify project
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

node_modules/@intlify/message-compiler/dist/message-compiler.cjs

@@ -0,0 +1,1596 @@
+/*!
+  * message-compiler v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+var shared = require('@intlify/shared');
+var sourceMapJs = require('source-map-js');
+
+const LOCATION_STUB = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 }
+};
+function createPosition(line, column, offset) {
+    return { line, column, offset };
+}
+function createLocation(start, end, source) {
+    const loc = { start, end };
+    if (source != null) {
+        loc.source = source;
+    }
+    return loc;
+}
+
+const CompileErrorCodes = {
+    // tokenizer error codes
+    EXPECTED_TOKEN: 1,
+    INVALID_TOKEN_IN_PLACEHOLDER: 2,
+    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+    UNKNOWN_ESCAPE_SEQUENCE: 4,
+    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+    UNBALANCED_CLOSING_BRACE: 6,
+    UNTERMINATED_CLOSING_BRACE: 7,
+    EMPTY_PLACEHOLDER: 8,
+    NOT_ALLOW_NEST_PLACEHOLDER: 9,
+    INVALID_LINKED_FORMAT: 10,
+    // parser error codes
+    MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+    UNEXPECTED_EMPTY_LINKED_KEY: 13,
+    UNEXPECTED_LEXICAL_ANALYSIS: 14,
+    // generator error codes
+    UNHANDLED_CODEGEN_NODE_TYPE: 15,
+    // minifier error codes
+    UNHANDLED_MINIFIER_NODE_TYPE: 16,
+    // Special value for higher-order compilers to pick up the last code
+    // to avoid collision of error codes. This should always be kept as the last
+    // item.
+    __EXTEND_POINT__: 17
+};
+/** @internal */
+const errorMessages = {
+    // tokenizer error messages
+    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+    // parser error messages
+    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+    // generator error messages
+    [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+    // minimizer error messages
+    [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+};
+function createCompileError(code, loc, options = {}) {
+    const { domain, messages, args } = options;
+    const msg = shared.format((messages || errorMessages)[code] || '', ...(args || []))
+        ;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    if (loc) {
+        error.location = loc;
+    }
+    error.domain = domain;
+    return error;
+}
+/** @internal */
+function defaultOnError(error) {
+    throw error;
+}
+
+const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+const CHAR_SP = ' ';
+const CHAR_CR = '\r';
+const CHAR_LF = '\n';
+const CHAR_LS = String.fromCharCode(0x2028);
+const CHAR_PS = String.fromCharCode(0x2029);
+function createScanner(str) {
+    const _buf = str;
+    let _index = 0;
+    let _line = 1;
+    let _column = 1;
+    let _peekOffset = 0;
+    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+    const isLF = (index) => _buf[index] === CHAR_LF;
+    const isPS = (index) => _buf[index] === CHAR_PS;
+    const isLS = (index) => _buf[index] === CHAR_LS;
+    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+    const index = () => _index;
+    const line = () => _line;
+    const column = () => _column;
+    const peekOffset = () => _peekOffset;
+    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+    const currentChar = () => charAt(_index);
+    const currentPeek = () => charAt(_index + _peekOffset);
+    function next() {
+        _peekOffset = 0;
+        if (isLineEnd(_index)) {
+            _line++;
+            _column = 0;
+        }
+        if (isCRLF(_index)) {
+            _index++;
+        }
+        _index++;
+        _column++;
+        return _buf[_index];
+    }
+    function peek() {
+        if (isCRLF(_index + _peekOffset)) {
+            _peekOffset++;
+        }
+        _peekOffset++;
+        return _buf[_index + _peekOffset];
+    }
+    function reset() {
+        _index = 0;
+        _line = 1;
+        _column = 1;
+        _peekOffset = 0;
+    }
+    function resetPeek(offset = 0) {
+        _peekOffset = offset;
+    }
+    function skipToPeek() {
+        const target = _index + _peekOffset;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (target !== _index) {
+            next();
+        }
+        _peekOffset = 0;
+    }
+    return {
+        index,
+        line,
+        column,
+        peekOffset,
+        charAt,
+        currentChar,
+        currentPeek,
+        next,
+        peek,
+        reset,
+        resetPeek,
+        skipToPeek
+    };
+}
+
+const EOF = undefined;
+const DOT = '.';
+const LITERAL_DELIMITER = "'";
+const ERROR_DOMAIN$3 = 'tokenizer';
+function createTokenizer(source, options = {}) {
+    const location = options.location !== false;
+    const _scnr = createScanner(source);
+    const currentOffset = () => _scnr.index();
+    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+    const _initLoc = currentPosition();
+    const _initOffset = currentOffset();
+    const _context = {
+        currentType: 14 /* TokenTypes.EOF */,
+        offset: _initOffset,
+        startLoc: _initLoc,
+        endLoc: _initLoc,
+        lastType: 14 /* TokenTypes.EOF */,
+        lastOffset: _initOffset,
+        lastStartLoc: _initLoc,
+        lastEndLoc: _initLoc,
+        braceNest: 0,
+        inLinked: false,
+        text: ''
+    };
+    const context = () => _context;
+    const { onError } = options;
+    function emitError(code, pos, offset, ...args) {
+        const ctx = context();
+        pos.column += offset;
+        pos.offset += offset;
+        if (onError) {
+            const loc = location ? createLocation(ctx.startLoc, pos) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$3,
+                args
+            });
+            onError(err);
+        }
+    }
+    function getToken(context, type, value) {
+        context.endLoc = currentPosition();
+        context.currentType = type;
+        const token = { type };
+        if (location) {
+            token.loc = createLocation(context.startLoc, context.endLoc);
+        }
+        if (value != null) {
+            token.value = value;
+        }
+        return token;
+    }
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    function eat(scnr, ch) {
+        if (scnr.currentChar() === ch) {
+            scnr.next();
+            return ch;
+        }
+        else {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+            return '';
+        }
+    }
+    function peekSpaces(scnr) {
+        let buf = '';
+        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+            buf += scnr.currentPeek();
+            scnr.peek();
+        }
+        return buf;
+    }
+    function skipSpaces(scnr) {
+        const buf = peekSpaces(scnr);
+        scnr.skipToPeek();
+        return buf;
+    }
+    function isIdentifierStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return ((cc >= 97 && cc <= 122) || // a-z
+            (cc >= 65 && cc <= 90) || // A-Z
+            cc === 95 // _
+        );
+    }
+    function isNumberStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return cc >= 48 && cc <= 57; // 0-9
+    }
+    function isNamedIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isListIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+        const ret = isNumberStart(ch);
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLiteralStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDotStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedModifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDelimiterStart(scnr, context) {
+        const { currentType } = context;
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedReferStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+            return false;
+        }
+        const fn = () => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return isIdentifierStart(scnr.peek());
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
+                ch === CHAR_SP ||
+                !ch) {
+                return false;
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn();
+            }
+            else {
+                // other characters
+                return isIdentifierStart(ch);
+            }
+        };
+        const ret = fn();
+        scnr.resetPeek();
+        return ret;
+    }
+    function isPluralStart(scnr) {
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function detectModuloStart(scnr) {
+        const spaces = peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
+        scnr.resetPeek();
+        return {
+            isModulo: ret,
+            hasSpace: spaces.length > 0
+        };
+    }
+    function isTextStart(scnr, reset = true) {
+        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                scnr.peek();
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+            }
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                    ? true
+                    : !(prev === CHAR_SP || prev === CHAR_LF);
+            }
+            else if (ch === CHAR_SP) {
+                scnr.peek();
+                return fn(true, CHAR_SP, detectModulo);
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn(true, CHAR_LF, detectModulo);
+            }
+            else {
+                return true;
+            }
+        };
+        const ret = fn();
+        reset && scnr.resetPeek();
+        return ret;
+    }
+    function takeChar(scnr, fn) {
+        const ch = scnr.currentChar();
+        if (ch === EOF) {
+            return EOF;
+        }
+        if (fn(ch)) {
+            scnr.next();
+            return ch;
+        }
+        return null;
+    }
+    function takeIdentifierChar(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 97 && cc <= 122) || // a-z
+                (cc >= 65 && cc <= 90) || // A-Z
+                (cc >= 48 && cc <= 57) || // 0-9
+                cc === 95 || // _
+                cc === 36 // $
+            );
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return cc >= 48 && cc <= 57; // 0-9
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeHexDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 48 && cc <= 57) || // 0-9
+                (cc >= 65 && cc <= 70) || // A-F
+                (cc >= 97 && cc <= 102)); // a-f
+        };
+        return takeChar(scnr, closure);
+    }
+    function getDigits(scnr) {
+        let ch = '';
+        let num = '';
+        while ((ch = takeDigit(scnr))) {
+            num += ch;
+        }
+        return num;
+    }
+    function readModulo(scnr) {
+        skipSpaces(scnr);
+        const ch = scnr.currentChar();
+        if (ch !== "%" /* TokenChars.Modulo */) {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+        }
+        scnr.next();
+        return "%" /* TokenChars.Modulo */;
+    }
+    function readText(scnr) {
+        let buf = '';
+        while (true) {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                !ch) {
+                break;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === CHAR_SP || ch === CHAR_LF) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else if (isPluralStart(scnr)) {
+                    break;
+                }
+                else {
+                    buf += ch;
+                    scnr.next();
+                }
+            }
+            else {
+                buf += ch;
+                scnr.next();
+            }
+        }
+        return buf;
+    }
+    function readNamedIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return name;
+    }
+    function readListIdentifier(scnr) {
+        skipSpaces(scnr);
+        let value = '';
+        if (scnr.currentChar() === '-') {
+            scnr.next();
+            value += `-${getDigits(scnr)}`;
+        }
+        else {
+            value += getDigits(scnr);
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return value;
+    }
+    function readLiteral(scnr) {
+        skipSpaces(scnr);
+        eat(scnr, `\'`);
+        let ch = '';
+        let literal = '';
+        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+        while ((ch = takeChar(scnr, fn))) {
+            if (ch === '\\') {
+                literal += readEscapeSequence(scnr);
+            }
+            else {
+                literal += ch;
+            }
+        }
+        const current = scnr.currentChar();
+        if (current === CHAR_LF || current === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+            // TODO: Is it correct really?
+            if (current === CHAR_LF) {
+                scnr.next();
+                eat(scnr, `\'`);
+            }
+            return literal;
+        }
+        eat(scnr, `\'`);
+        return literal;
+    }
+    function readEscapeSequence(scnr) {
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case '\\':
+            case `\'`:
+                scnr.next();
+                return `\\${ch}`;
+            case 'u':
+                return readUnicodeEscapeSequence(scnr, ch, 4);
+            case 'U':
+                return readUnicodeEscapeSequence(scnr, ch, 6);
+            default:
+                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                return '';
+        }
+    }
+    function readUnicodeEscapeSequence(scnr, unicode, digits) {
+        eat(scnr, unicode);
+        let sequence = '';
+        for (let i = 0; i < digits; i++) {
+            const ch = takeHexDigit(scnr);
+            if (!ch) {
+                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                break;
+            }
+            sequence += ch;
+        }
+        return `\\${unicode}${sequence}`;
+    }
+    function readInvalidIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let identifiers = '';
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
+            ch !== CHAR_SP &&
+            ch !== CHAR_LF;
+        while ((ch = takeChar(scnr, closure))) {
+            identifiers += ch;
+        }
+        return identifiers;
+    }
+    function readLinkedModifier(scnr) {
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        return name;
+    }
+    function readLinkedRefer(scnr) {
+        const fn = (detect = false, buf) => {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === "(" /* TokenChars.ParenLeft */ ||
+                ch === ")" /* TokenChars.ParenRight */ ||
+                !ch) {
+                return buf;
+            }
+            else if (ch === CHAR_SP) {
+                return buf;
+            }
+            else if (ch === CHAR_LF || ch === DOT) {
+                buf += ch;
+                scnr.next();
+                return fn(detect, buf);
+            }
+            else {
+                buf += ch;
+                scnr.next();
+                return fn(true, buf);
+            }
+        };
+        return fn(false, '');
+    }
+    function readPlural(scnr) {
+        skipSpaces(scnr);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+        skipSpaces(scnr);
+        return plural;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInPlaceholder(scnr, context) {
+        let token = null;
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                if (context.braceNest >= 1) {
+                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                skipSpaces(scnr);
+                context.braceNest++;
+                return token;
+            case "}" /* TokenChars.BraceRight */:
+                if (context.braceNest > 0 &&
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                context.braceNest--;
+                context.braceNest > 0 && skipSpaces(scnr);
+                if (context.inLinked && context.braceNest === 0) {
+                    context.inLinked = false;
+                }
+                return token;
+            case "@" /* TokenChars.LinkedAlias */:
+                if (context.braceNest > 0) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                }
+                token = readTokenInLinked(scnr, context) || getEndToken(context);
+                context.braceNest = 0;
+                return token;
+            default:
+                let validNamedIdentifier = true;
+                let validListIdentifier = true;
+                let validLiteral = true;
+                if (isPluralStart(scnr)) {
+                    if (context.braceNest > 0) {
+                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    }
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (context.braceNest > 0 &&
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    context.braceNest = 0;
+                    return readToken(scnr, context);
+                }
+                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validLiteral = isLiteralStart(scnr, context))) {
+                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                    skipSpaces(scnr);
+                    return token;
+                }
+                break;
+        }
+        return token;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInLinked(scnr, context) {
+        const { currentType } = context;
+        let token = null;
+        const ch = scnr.currentChar();
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+            (ch === CHAR_LF || ch === CHAR_SP)) {
+            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+        }
+        switch (ch) {
+            case "@" /* TokenChars.LinkedAlias */:
+                scnr.next();
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                context.inLinked = true;
+                return token;
+            case "." /* TokenChars.LinkedDot */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (isLinkedDotStart(scnr, context) ||
+                    isLinkedDelimiterStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return readTokenInLinked(scnr, context);
+                }
+                if (isLinkedModifierStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                }
+                if (isLinkedReferStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
+                        // scan the placeholder
+                        return readTokenInPlaceholder(scnr, context) || token;
+                    }
+                    else {
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                    }
+                }
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                }
+                context.braceNest = 0;
+                context.inLinked = false;
+                return readToken(scnr, context);
+        }
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readToken(scnr, context) {
+        let token = { type: 14 /* TokenTypes.EOF */ };
+        if (context.braceNest > 0) {
+            return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+        }
+        if (context.inLinked) {
+            return readTokenInLinked(scnr, context) || getEndToken(context);
+        }
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+            case "}" /* TokenChars.BraceRight */:
+                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                scnr.next();
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
+                return readTokenInLinked(scnr, context) || getEndToken(context);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                const { isModulo, hasSpace } = detectModuloStart(scnr);
+                if (isModulo) {
+                    return hasSpace
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                }
+                if (isTextStart(scnr)) {
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                }
+                break;
+        }
+        return token;
+    }
+    function nextToken() {
+        const { currentType, offset, startLoc, endLoc } = _context;
+        _context.lastType = currentType;
+        _context.lastOffset = offset;
+        _context.lastStartLoc = startLoc;
+        _context.lastEndLoc = endLoc;
+        _context.offset = currentOffset();
+        _context.startLoc = currentPosition();
+        if (_scnr.currentChar() === EOF) {
+            return getToken(_context, 14 /* TokenTypes.EOF */);
+        }
+        return readToken(_scnr, _context);
+    }
+    return {
+        nextToken,
+        currentOffset,
+        currentPosition,
+        context
+    };
+}
+
+const ERROR_DOMAIN$2 = 'parser';
+// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+function fromEscapeSequence(match, codePoint4, codePoint6) {
+    switch (match) {
+        case `\\\\`:
+            return `\\`;
+        case `\\\'`:
+            return `\'`;
+        default: {
+            const codePoint = parseInt(codePoint4 || codePoint6, 16);
+            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                return String.fromCodePoint(codePoint);
+            }
+            // invalid ...
+            // Replace them with U+FFFD REPLACEMENT CHARACTER.
+            return '�';
+        }
+    }
+}
+function createParser(options = {}) {
+    const location = options.location !== false;
+    const { onError } = options;
+    function emitError(tokenzer, code, start, offset, ...args) {
+        const end = tokenzer.currentPosition();
+        end.offset += offset;
+        end.column += offset;
+        if (onError) {
+            const loc = location ? createLocation(start, end) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$2,
+                args
+            });
+            onError(err);
+        }
+    }
+    function startNode(type, offset, loc) {
+        const node = { type };
+        if (location) {
+            node.start = offset;
+            node.end = offset;
+            node.loc = { start: loc, end: loc };
+        }
+        return node;
+    }
+    function endNode(node, offset, pos, type) {
+        if (type) {
+            node.type = type;
+        }
+        if (location) {
+            node.end = offset;
+            if (node.loc) {
+                node.loc.end = pos;
+            }
+        }
+    }
+    function parseText(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseList(tokenizer, index) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
+        node.index = parseInt(index, 10);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseNamed(tokenizer, key) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+        node.key = key;
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLiteral(tokenizer, value) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinkedModifier(tokenizer) {
+        const token = tokenizer.nextToken();
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+            // empty modifier
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+            node.value = '';
+            endNode(node, offset, loc);
+            return {
+                nextConsumeToken: token,
+                node
+            };
+        }
+        // check token
+        if (token.value == null) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        node.value = token.value || '';
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node
+        };
+    }
+    function parseLinkedKey(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinked(tokenizer) {
+        const context = tokenizer.context();
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+        let token = tokenizer.nextToken();
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+            const parsed = parseLinkedModifier(tokenizer);
+            linkedNode.modifier = parsed.node;
+            token = parsed.nextConsumeToken || tokenizer.nextToken();
+        }
+        // asset check token
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        token = tokenizer.nextToken();
+        // skip brace left
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
+            token = tokenizer.nextToken();
+        }
+        switch (token.type) {
+            case 11 /* TokenTypes.LinkedKey */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                break;
+            case 5 /* TokenTypes.Named */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseNamed(tokenizer, token.value || '');
+                break;
+            case 6 /* TokenTypes.List */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseList(tokenizer, token.value || '');
+                break;
+            case 7 /* TokenTypes.Literal */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                break;
+            default:
+                // empty key
+                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                const nextContext = tokenizer.context();
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                emptyLinkedKeyNode.value = '';
+                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                linkedNode.key = emptyLinkedKeyNode;
+                endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                return {
+                    nextConsumeToken: token,
+                    node: linkedNode
+                };
+        }
+        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node: linkedNode
+        };
+    }
+    function parseMessage(tokenizer) {
+        const context = tokenizer.context();
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? tokenizer.currentOffset()
+            : context.offset;
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.endLoc
+            : context.startLoc;
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+        node.items = [];
+        let nextToken = null;
+        do {
+            const token = nextToken || tokenizer.nextToken();
+            nextToken = null;
+            switch (token.type) {
+                case 0 /* TokenTypes.Text */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseText(tokenizer, token.value || ''));
+                    break;
+                case 6 /* TokenTypes.List */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseList(tokenizer, token.value || ''));
+                    break;
+                case 5 /* TokenTypes.Named */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
+                    break;
+                case 7 /* TokenTypes.Literal */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseLiteral(tokenizer, token.value || ''));
+                    break;
+                case 8 /* TokenTypes.LinkedAlias */:
+                    const parsed = parseLinked(tokenizer);
+                    node.items.push(parsed.node);
+                    nextToken = parsed.nextConsumeToken || null;
+                    break;
+            }
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
+        // adjust message node loc
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastOffset
+            : tokenizer.currentOffset();
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastEndLoc
+            : tokenizer.currentPosition();
+        endNode(node, endOffset, endLoc);
+        return node;
+    }
+    function parsePlural(tokenizer, offset, loc, msgNode) {
+        const context = tokenizer.context();
+        let hasEmptyMessage = msgNode.items.length === 0;
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+        node.cases = [];
+        node.cases.push(msgNode);
+        do {
+            const msg = parseMessage(tokenizer);
+            if (!hasEmptyMessage) {
+                hasEmptyMessage = msg.items.length === 0;
+            }
+            node.cases.push(msg);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        if (hasEmptyMessage) {
+            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseResource(tokenizer) {
+        const context = tokenizer.context();
+        const { offset, startLoc } = context;
+        const msgNode = parseMessage(tokenizer);
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
+            return msgNode;
+        }
+        else {
+            return parsePlural(tokenizer, offset, startLoc, msgNode);
+        }
+    }
+    function parse(source) {
+        const tokenizer = createTokenizer(source, shared.assign({}, options));
+        const context = tokenizer.context();
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+        if (location && node.loc) {
+            node.loc.source = source;
+        }
+        node.body = parseResource(tokenizer);
+        if (options.onCacheKey) {
+            node.cacheKey = options.onCacheKey(source);
+        }
+        // assert whether achieved to EOF
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    return { parse };
+}
+function getTokenCaption(token) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
+        return 'EOF';
+    }
+    const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+    return name.length > 10 ? name.slice(0, 9) + '…' : name;
+}
+
+function createTransformer(ast, options = {} // eslint-disable-line
+) {
+    const _context = {
+        ast,
+        helpers: new Set()
+    };
+    const context = () => _context;
+    const helper = (name) => {
+        _context.helpers.add(name);
+        return name;
+    };
+    return { context, helper };
+}
+function traverseNodes(nodes, transformer) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], transformer);
+    }
+}
+function traverseNode(node, transformer) {
+    // TODO: if we need pre-hook of transform, should be implemented to here
+    switch (node.type) {
+        case 1 /* NodeTypes.Plural */:
+            traverseNodes(node.cases, transformer);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
+            break;
+        case 2 /* NodeTypes.Message */:
+            traverseNodes(node.items, transformer);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            traverseNode(linked.key, transformer);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
+            break;
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
+            break;
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
+            break;
+    }
+    // TODO: if we need post-hook of transform, should be implemented to here
+}
+// transform AST
+function transform(ast, options = {} // eslint-disable-line
+) {
+    const transformer = createTransformer(ast);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+    // traverse
+    ast.body && traverseNode(ast.body, transformer);
+    // set meta information
+    const context = transformer.context();
+    ast.helpers = Array.from(context.helpers);
+}
+
+function optimize(ast) {
+    const body = ast.body;
+    if (body.type === 2 /* NodeTypes.Message */) {
+        optimizeMessageNode(body);
+    }
+    else {
+        body.cases.forEach(c => optimizeMessageNode(c));
+    }
+    return ast;
+}
+function optimizeMessageNode(message) {
+    if (message.items.length === 1) {
+        const item = message.items[0];
+        if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+            message.static = item.value;
+            delete item.value; // optimization for size
+        }
+    }
+    else {
+        const values = [];
+        for (let i = 0; i < message.items.length; i++) {
+            const item = message.items[i];
+            if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                break;
+            }
+            if (item.value == null) {
+                break;
+            }
+            values.push(item.value);
+        }
+        if (values.length === message.items.length) {
+            message.static = shared.join(values);
+            for (let i = 0; i < message.items.length; i++) {
+                const item = message.items[i];
+                if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                    delete item.value; // optimization for size
+                }
+            }
+        }
+    }
+}
+
+const ERROR_DOMAIN$1 = 'minifier';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function minify(node) {
+    node.t = node.type;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            const resource = node;
+            minify(resource.body);
+            resource.b = resource.body;
+            delete resource.body;
+            break;
+        case 1 /* NodeTypes.Plural */:
+            const plural = node;
+            const cases = plural.cases;
+            for (let i = 0; i < cases.length; i++) {
+                minify(cases[i]);
+            }
+            plural.c = cases;
+            delete plural.cases;
+            break;
+        case 2 /* NodeTypes.Message */:
+            const message = node;
+            const items = message.items;
+            for (let i = 0; i < items.length; i++) {
+                minify(items[i]);
+            }
+            message.i = items;
+            delete message.items;
+            if (message.static) {
+                message.s = message.static;
+                delete message.static;
+            }
+            break;
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            const valueNode = node;
+            if (valueNode.value) {
+                valueNode.v = valueNode.value;
+                delete valueNode.value;
+            }
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            minify(linked.key);
+            linked.k = linked.key;
+            delete linked.key;
+            if (linked.modifier) {
+                minify(linked.modifier);
+                linked.m = linked.modifier;
+                delete linked.modifier;
+            }
+            break;
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            list.i = list.index;
+            delete list.index;
+            break;
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            named.k = named.key;
+            delete named.key;
+            break;
+        default:
+            {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN$1,
+                    args: [node.type]
+                });
+            }
+    }
+    delete node.type;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const ERROR_DOMAIN = 'parser';
+function createCodeGenerator(ast, options) {
+    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+    const location = options.location !== false;
+    const _context = {
+        filename,
+        code: '',
+        column: 1,
+        line: 1,
+        offset: 0,
+        map: undefined,
+        breakLineCode,
+        needIndent: _needIndent,
+        indentLevel: 0
+    };
+    if (location && ast.loc) {
+        _context.source = ast.loc.source;
+    }
+    const context = () => _context;
+    function push(code, node) {
+        _context.code += code;
+        if (_context.map) {
+            if (node && node.loc && node.loc !== LOCATION_STUB) {
+                addMapping(node.loc.start, getMappingName(node));
+            }
+            advancePositionWithSource(_context, code);
+        }
+    }
+    function _newline(n, withBreakLine = true) {
+        const _breakLineCode = withBreakLine ? breakLineCode : '';
+        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+    }
+    function indent(withNewLine = true) {
+        const level = ++_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function deindent(withNewLine = true) {
+        const level = --_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function newline() {
+        _newline(_context.indentLevel);
+    }
+    const helper = (key) => `_${key}`;
+    const needIndent = () => _context.needIndent;
+    function addMapping(loc, name) {
+        _context.map.addMapping({
+            name,
+            source: _context.filename,
+            original: {
+                line: loc.line,
+                column: loc.column - 1
+            },
+            generated: {
+                line: _context.line,
+                column: _context.column - 1
+            }
+        });
+    }
+    if (location && sourceMap) {
+        _context.map = new sourceMapJs.SourceMapGenerator();
+        _context.map.setSourceContent(filename, _context.source);
+    }
+    return {
+        context,
+        push,
+        indent,
+        deindent,
+        newline,
+        helper,
+        needIndent
+    };
+}
+function generateLinkedNode(generator, node) {
+    const { helper } = generator;
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+    generateNode(generator, node.key);
+    if (node.modifier) {
+        generator.push(`, `);
+        generateNode(generator, node.modifier);
+        generator.push(`, _type`);
+    }
+    else {
+        generator.push(`, undefined, _type`);
+    }
+    generator.push(`)`);
+}
+function generateMessageNode(generator, node) {
+    const { helper, needIndent } = generator;
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+    generator.indent(needIndent());
+    const length = node.items.length;
+    for (let i = 0; i < length; i++) {
+        generateNode(generator, node.items[i]);
+        if (i === length - 1) {
+            break;
+        }
+        generator.push(', ');
+    }
+    generator.deindent(needIndent());
+    generator.push('])');
+}
+function generatePluralNode(generator, node) {
+    const { helper, needIndent } = generator;
+    if (node.cases.length > 1) {
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+        generator.indent(needIndent());
+        const length = node.cases.length;
+        for (let i = 0; i < length; i++) {
+            generateNode(generator, node.cases[i]);
+            if (i === length - 1) {
+                break;
+            }
+            generator.push(', ');
+        }
+        generator.deindent(needIndent());
+        generator.push(`])`);
+    }
+}
+function generateResource(generator, node) {
+    if (node.body) {
+        generateNode(generator, node.body);
+    }
+    else {
+        generator.push('null');
+    }
+}
+function generateNode(generator, node) {
+    const { helper } = generator;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            generateResource(generator, node);
+            break;
+        case 1 /* NodeTypes.Plural */:
+            generatePluralNode(generator, node);
+            break;
+        case 2 /* NodeTypes.Message */:
+            generateMessageNode(generator, node);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            generateLinkedNode(generator, node);
+            break;
+        case 8 /* NodeTypes.LinkedModifier */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 7 /* NodeTypes.LinkedKey */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+            break;
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+            break;
+        case 9 /* NodeTypes.Literal */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 3 /* NodeTypes.Text */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        default:
+            {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN,
+                    args: [node.type]
+                });
+            }
+    }
+}
+// generate code from AST
+const generate = (ast, options = {} // eslint-disable-line
+) => {
+    const mode = shared.isString(options.mode) ? options.mode : 'normal';
+    const filename = shared.isString(options.filename)
+        ? options.filename
+        : 'message.intl';
+    const sourceMap = !!options.sourceMap;
+    // prettier-ignore
+    const breakLineCode = options.breakLineCode != null
+        ? options.breakLineCode
+        : mode === 'arrow'
+            ? ';'
+            : '\n';
+    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+    const helpers = ast.helpers || [];
+    const generator = createCodeGenerator(ast, {
+        mode,
+        filename,
+        sourceMap,
+        breakLineCode,
+        needIndent
+    });
+    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+    generator.indent(needIndent);
+    if (helpers.length > 0) {
+        generator.push(`const { ${shared.join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+        generator.newline();
+    }
+    generator.push(`return `);
+    generateNode(generator, ast);
+    generator.deindent(needIndent);
+    generator.push(`}`);
+    delete ast.helpers;
+    const { code, map } = generator.context();
+    return {
+        ast,
+        code,
+        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+    };
+};
+function getMappingName(node) {
+    switch (node.type) {
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            return node.value;
+        case 5 /* NodeTypes.List */:
+            return node.index.toString();
+        case 4 /* NodeTypes.Named */:
+            return node.key;
+        default:
+            return undefined;
+    }
+}
+function advancePositionWithSource(pos, source, numberOfCharacters = source.length) {
+    let linesCount = 0;
+    let lastNewLinePos = -1;
+    for (let i = 0; i < numberOfCharacters; i++) {
+        if (source.charCodeAt(i) === 10 /* newline char code */) {
+            linesCount++;
+            lastNewLinePos = i;
+        }
+    }
+    pos.offset += numberOfCharacters;
+    pos.line += linesCount;
+    pos.column =
+        lastNewLinePos === -1
+            ? pos.column + numberOfCharacters
+            : numberOfCharacters - lastNewLinePos;
+    return pos;
+}
+
+function baseCompile(source, options = {}) {
+    const assignedOptions = shared.assign({}, options);
+    const jit = !!assignedOptions.jit;
+    const enalbeMinify = !!assignedOptions.minify;
+    const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+    // parse source codes
+    const parser = createParser(assignedOptions);
+    const ast = parser.parse(source);
+    if (!jit) {
+        // transform ASTs
+        transform(ast, assignedOptions);
+        // generate javascript codes
+        return generate(ast, assignedOptions);
+    }
+    else {
+        // optimize ASTs
+        enambeOptimize && optimize(ast);
+        // minimize ASTs
+        enalbeMinify && minify(ast);
+        // In JIT mode, no ast transform, no code generation.
+        return { ast, code: '' };
+    }
+}
+
+exports.CompileErrorCodes = CompileErrorCodes;
+exports.ERROR_DOMAIN = ERROR_DOMAIN$2;
+exports.LOCATION_STUB = LOCATION_STUB;
+exports.baseCompile = baseCompile;
+exports.createCompileError = createCompileError;
+exports.createLocation = createLocation;
+exports.createParser = createParser;
+exports.createPosition = createPosition;
+exports.defaultOnError = defaultOnError;
+exports.detectHtmlTag = detectHtmlTag;
+exports.errorMessages = errorMessages;

node_modules/@intlify/message-compiler/dist/message-compiler.cjs.js

@@ -0,0 +1 @@
+module.exports = require('../dist/message-compiler.cjs')

node_modules/@intlify/message-compiler/dist/message-compiler.cjs.prod.js

@@ -0,0 +1 @@
+module.exports = require('../dist/message-compiler.prod.cjs')

node_modules/@intlify/message-compiler/dist/message-compiler.d.ts

@@ -0,0 +1,224 @@
+import type { BaseError } from '@intlify/shared';
+import type { RawSourceMap } from 'source-map-js';
+
+export declare function baseCompile(source: string, options?: CompileOptions): CompilerResult;
+
+export declare type CacheKeyHandler = (source: string) => string;
+
+export declare interface CodeGenOptions {
+    location?: boolean;
+    mode?: 'normal' | 'arrow';
+    breakLineCode?: '\n' | ';';
+    needIndent?: boolean;
+    onError?: CompileErrorHandler;
+    sourceMap?: boolean;
+    filename?: string;
+}
+
+declare interface CodeGenResult {
+    code: string;
+    ast: ResourceNode;
+    map?: RawSourceMap;
+}
+
+export declare type CompileDomain = 'tokenizer' | 'parser' | 'generator' | 'transformer' | 'optimizer' | 'minifier';
+
+export declare interface CompileError extends BaseError, SyntaxError {
+    domain?: CompileDomain;
+    location?: SourceLocation;
+}
+
+export declare const CompileErrorCodes: {
+    readonly EXPECTED_TOKEN: 1;
+    readonly INVALID_TOKEN_IN_PLACEHOLDER: 2;
+    readonly UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3;
+    readonly UNKNOWN_ESCAPE_SEQUENCE: 4;
+    readonly INVALID_UNICODE_ESCAPE_SEQUENCE: 5;
+    readonly UNBALANCED_CLOSING_BRACE: 6;
+    readonly UNTERMINATED_CLOSING_BRACE: 7;
+    readonly EMPTY_PLACEHOLDER: 8;
+    readonly NOT_ALLOW_NEST_PLACEHOLDER: 9;
+    readonly INVALID_LINKED_FORMAT: 10;
+    readonly MUST_HAVE_MESSAGES_IN_PLURAL: 11;
+    readonly UNEXPECTED_EMPTY_LINKED_MODIFIER: 12;
+    readonly UNEXPECTED_EMPTY_LINKED_KEY: 13;
+    readonly UNEXPECTED_LEXICAL_ANALYSIS: 14;
+    readonly UNHANDLED_CODEGEN_NODE_TYPE: 15;
+    readonly UNHANDLED_MINIFIER_NODE_TYPE: 16;
+    readonly __EXTEND_POINT__: 17;
+};
+
+export declare type CompileErrorCodes = (typeof CompileErrorCodes)[keyof typeof CompileErrorCodes];
+
+export declare type CompileErrorHandler = (error: CompileError) => void;
+
+export declare interface CompileErrorOptions {
+    domain?: CompileDomain;
+    messages?: {
+        [code: number]: string;
+    };
+    args?: unknown[];
+}
+
+export declare type CompileOptions = {
+    optimize?: boolean;
+    minify?: boolean;
+    jit?: boolean;
+} & TransformOptions & CodeGenOptions & ParserOptions & TokenizeOptions;
+
+export declare type CompilerResult = CodeGenResult;
+
+export declare function createCompileError<T extends number>(code: T, loc: SourceLocation | null, options?: CompileErrorOptions): CompileError;
+
+export declare function createLocation(start: Position, end: Position, source?: string): SourceLocation;
+
+export declare function createParser(options?: ParserOptions): Parser;
+
+export declare function createPosition(line: number, column: number, offset: number): Position;
+
+/* Excluded from this release type: defaultOnError */
+
+export declare const detectHtmlTag: (source: string) => boolean;
+
+export declare const ERROR_DOMAIN = "parser";
+
+/* Excluded from this release type: errorMessages */
+
+export declare const enum HelperNameMap {
+    LIST = "list",
+    NAMED = "named",
+    PLURAL = "plural",
+    LINKED = "linked",
+    MESSAGE = "message",
+    TYPE = "type",
+    INTERPOLATE = "interpolate",
+    NORMALIZE = "normalize",
+    VALUES = "values"
+}
+
+export declare type Identifier = string;
+
+export declare interface LinkedKeyNode extends Node_2 {
+    type: NodeTypes.LinkedKey;
+    value: string;
+    /* Excluded from this release type: v */
+}
+
+export declare interface LinkedModifierNode extends Node_2 {
+    type: NodeTypes.LinkedModifier;
+    value: Identifier;
+    /* Excluded from this release type: v */
+}
+
+export declare interface LinkedNode extends Node_2 {
+    type: NodeTypes.Linked;
+    modifier?: LinkedModifierNode;
+    /* Excluded from this release type: m */
+    key: LinkedKeyNode | NamedNode | ListNode | LiteralNode;
+    /* Excluded from this release type: k */
+}
+
+export declare interface ListNode extends Node_2 {
+    type: NodeTypes.List;
+    index: number;
+    /* Excluded from this release type: i */
+}
+
+export declare interface LiteralNode extends Node_2 {
+    type: NodeTypes.Literal;
+    value?: string;
+    /* Excluded from this release type: v */
+}
+
+export declare const LOCATION_STUB: SourceLocation;
+
+declare type MessageElementNode = TextNode | NamedNode | ListNode | LiteralNode | LinkedNode;
+
+export declare interface MessageNode extends Node_2 {
+    type: NodeTypes.Message;
+    static?: string;
+    /* Excluded from this release type: s */
+    items: MessageElementNode[];
+    /* Excluded from this release type: i */
+}
+
+export declare interface NamedNode extends Node_2 {
+    type: NodeTypes.Named;
+    key: Identifier;
+    /* Excluded from this release type: k */
+}
+
+declare interface Node_2 {
+    type: NodeTypes;
+    /* Excluded from this release type: t */
+    start?: number;
+    end?: number;
+    loc?: SourceLocation;
+}
+export { Node_2 as Node }
+
+export declare const enum NodeTypes {
+    Resource = 0,
+    Plural = 1,
+    Message = 2,
+    Text = 3,
+    Named = 4,
+    List = 5,
+    Linked = 6,
+    LinkedKey = 7,
+    LinkedModifier = 8,
+    Literal = 9
+}
+
+export declare interface Parser {
+    parse(source: string): ResourceNode;
+}
+
+export declare interface ParserOptions {
+    location?: boolean;
+    onCacheKey?: (source: string) => string;
+    onError?: CompileErrorHandler;
+}
+
+export declare interface PluralNode extends Node_2 {
+    type: NodeTypes.Plural;
+    cases: MessageNode[];
+    /* Excluded from this release type: c */
+}
+
+export declare interface Position {
+    offset: number;
+    line: number;
+    column: number;
+}
+
+export declare interface ResourceNode extends Node_2 {
+    type: NodeTypes.Resource;
+    body: MessageNode | PluralNode;
+    /* Excluded from this release type: b */
+    cacheKey?: string;
+    helpers?: string[];
+}
+
+export declare interface SourceLocation {
+    start: Position;
+    end: Position;
+    source?: string;
+}
+
+export declare interface TextNode extends Node_2 {
+    type: NodeTypes.Text;
+    value?: string;
+    /* Excluded from this release type: v */
+}
+
+export declare interface TokenizeOptions {
+    location?: boolean;
+    onError?: CompileErrorHandler;
+}
+
+export declare interface TransformOptions {
+    onError?: CompileErrorHandler;
+}
+
+export { }

node_modules/@intlify/message-compiler/dist/message-compiler.esm-browser.js

@@ -0,0 +1,1550 @@
+/*!
+  * message-compiler v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+const LOCATION_STUB = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 }
+};
+function createPosition(line, column, offset) {
+    return { line, column, offset };
+}
+function createLocation(start, end, source) {
+    const loc = { start, end };
+    if (source != null) {
+        loc.source = source;
+    }
+    return loc;
+}
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const assign = Object.assign;
+const isString = (val) => typeof val === 'string';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+
+const CompileErrorCodes = {
+    // tokenizer error codes
+    EXPECTED_TOKEN: 1,
+    INVALID_TOKEN_IN_PLACEHOLDER: 2,
+    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+    UNKNOWN_ESCAPE_SEQUENCE: 4,
+    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+    UNBALANCED_CLOSING_BRACE: 6,
+    UNTERMINATED_CLOSING_BRACE: 7,
+    EMPTY_PLACEHOLDER: 8,
+    NOT_ALLOW_NEST_PLACEHOLDER: 9,
+    INVALID_LINKED_FORMAT: 10,
+    // parser error codes
+    MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+    UNEXPECTED_EMPTY_LINKED_KEY: 13,
+    UNEXPECTED_LEXICAL_ANALYSIS: 14,
+    // generator error codes
+    UNHANDLED_CODEGEN_NODE_TYPE: 15,
+    // minifier error codes
+    UNHANDLED_MINIFIER_NODE_TYPE: 16,
+    // Special value for higher-order compilers to pick up the last code
+    // to avoid collision of error codes. This should always be kept as the last
+    // item.
+    __EXTEND_POINT__: 17
+};
+/** @internal */
+const errorMessages = {
+    // tokenizer error messages
+    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+    // parser error messages
+    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+    // generator error messages
+    [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+    // minimizer error messages
+    [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+};
+function createCompileError(code, loc, options = {}) {
+    const { domain, messages, args } = options;
+    const msg = format((messages || errorMessages)[code] || '', ...(args || []))
+        ;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    if (loc) {
+        error.location = loc;
+    }
+    error.domain = domain;
+    return error;
+}
+/** @internal */
+function defaultOnError(error) {
+    throw error;
+}
+
+const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+const CHAR_SP = ' ';
+const CHAR_CR = '\r';
+const CHAR_LF = '\n';
+const CHAR_LS = String.fromCharCode(0x2028);
+const CHAR_PS = String.fromCharCode(0x2029);
+function createScanner(str) {
+    const _buf = str;
+    let _index = 0;
+    let _line = 1;
+    let _column = 1;
+    let _peekOffset = 0;
+    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+    const isLF = (index) => _buf[index] === CHAR_LF;
+    const isPS = (index) => _buf[index] === CHAR_PS;
+    const isLS = (index) => _buf[index] === CHAR_LS;
+    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+    const index = () => _index;
+    const line = () => _line;
+    const column = () => _column;
+    const peekOffset = () => _peekOffset;
+    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+    const currentChar = () => charAt(_index);
+    const currentPeek = () => charAt(_index + _peekOffset);
+    function next() {
+        _peekOffset = 0;
+        if (isLineEnd(_index)) {
+            _line++;
+            _column = 0;
+        }
+        if (isCRLF(_index)) {
+            _index++;
+        }
+        _index++;
+        _column++;
+        return _buf[_index];
+    }
+    function peek() {
+        if (isCRLF(_index + _peekOffset)) {
+            _peekOffset++;
+        }
+        _peekOffset++;
+        return _buf[_index + _peekOffset];
+    }
+    function reset() {
+        _index = 0;
+        _line = 1;
+        _column = 1;
+        _peekOffset = 0;
+    }
+    function resetPeek(offset = 0) {
+        _peekOffset = offset;
+    }
+    function skipToPeek() {
+        const target = _index + _peekOffset;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (target !== _index) {
+            next();
+        }
+        _peekOffset = 0;
+    }
+    return {
+        index,
+        line,
+        column,
+        peekOffset,
+        charAt,
+        currentChar,
+        currentPeek,
+        next,
+        peek,
+        reset,
+        resetPeek,
+        skipToPeek
+    };
+}
+
+const EOF = undefined;
+const DOT = '.';
+const LITERAL_DELIMITER = "'";
+const ERROR_DOMAIN$3 = 'tokenizer';
+function createTokenizer(source, options = {}) {
+    const location = options.location !== false;
+    const _scnr = createScanner(source);
+    const currentOffset = () => _scnr.index();
+    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+    const _initLoc = currentPosition();
+    const _initOffset = currentOffset();
+    const _context = {
+        currentType: 14 /* TokenTypes.EOF */,
+        offset: _initOffset,
+        startLoc: _initLoc,
+        endLoc: _initLoc,
+        lastType: 14 /* TokenTypes.EOF */,
+        lastOffset: _initOffset,
+        lastStartLoc: _initLoc,
+        lastEndLoc: _initLoc,
+        braceNest: 0,
+        inLinked: false,
+        text: ''
+    };
+    const context = () => _context;
+    const { onError } = options;
+    function emitError(code, pos, offset, ...args) {
+        const ctx = context();
+        pos.column += offset;
+        pos.offset += offset;
+        if (onError) {
+            const loc = location ? createLocation(ctx.startLoc, pos) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$3,
+                args
+            });
+            onError(err);
+        }
+    }
+    function getToken(context, type, value) {
+        context.endLoc = currentPosition();
+        context.currentType = type;
+        const token = { type };
+        if (location) {
+            token.loc = createLocation(context.startLoc, context.endLoc);
+        }
+        if (value != null) {
+            token.value = value;
+        }
+        return token;
+    }
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    function eat(scnr, ch) {
+        if (scnr.currentChar() === ch) {
+            scnr.next();
+            return ch;
+        }
+        else {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+            return '';
+        }
+    }
+    function peekSpaces(scnr) {
+        let buf = '';
+        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+            buf += scnr.currentPeek();
+            scnr.peek();
+        }
+        return buf;
+    }
+    function skipSpaces(scnr) {
+        const buf = peekSpaces(scnr);
+        scnr.skipToPeek();
+        return buf;
+    }
+    function isIdentifierStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return ((cc >= 97 && cc <= 122) || // a-z
+            (cc >= 65 && cc <= 90) || // A-Z
+            cc === 95 // _
+        );
+    }
+    function isNumberStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return cc >= 48 && cc <= 57; // 0-9
+    }
+    function isNamedIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isListIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+        const ret = isNumberStart(ch);
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLiteralStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDotStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedModifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDelimiterStart(scnr, context) {
+        const { currentType } = context;
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedReferStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+            return false;
+        }
+        const fn = () => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return isIdentifierStart(scnr.peek());
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
+                ch === CHAR_SP ||
+                !ch) {
+                return false;
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn();
+            }
+            else {
+                // other characters
+                return isIdentifierStart(ch);
+            }
+        };
+        const ret = fn();
+        scnr.resetPeek();
+        return ret;
+    }
+    function isPluralStart(scnr) {
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function detectModuloStart(scnr) {
+        const spaces = peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
+        scnr.resetPeek();
+        return {
+            isModulo: ret,
+            hasSpace: spaces.length > 0
+        };
+    }
+    function isTextStart(scnr, reset = true) {
+        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                scnr.peek();
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+            }
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                    ? true
+                    : !(prev === CHAR_SP || prev === CHAR_LF);
+            }
+            else if (ch === CHAR_SP) {
+                scnr.peek();
+                return fn(true, CHAR_SP, detectModulo);
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn(true, CHAR_LF, detectModulo);
+            }
+            else {
+                return true;
+            }
+        };
+        const ret = fn();
+        reset && scnr.resetPeek();
+        return ret;
+    }
+    function takeChar(scnr, fn) {
+        const ch = scnr.currentChar();
+        if (ch === EOF) {
+            return EOF;
+        }
+        if (fn(ch)) {
+            scnr.next();
+            return ch;
+        }
+        return null;
+    }
+    function takeIdentifierChar(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 97 && cc <= 122) || // a-z
+                (cc >= 65 && cc <= 90) || // A-Z
+                (cc >= 48 && cc <= 57) || // 0-9
+                cc === 95 || // _
+                cc === 36 // $
+            );
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return cc >= 48 && cc <= 57; // 0-9
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeHexDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 48 && cc <= 57) || // 0-9
+                (cc >= 65 && cc <= 70) || // A-F
+                (cc >= 97 && cc <= 102)); // a-f
+        };
+        return takeChar(scnr, closure);
+    }
+    function getDigits(scnr) {
+        let ch = '';
+        let num = '';
+        while ((ch = takeDigit(scnr))) {
+            num += ch;
+        }
+        return num;
+    }
+    function readModulo(scnr) {
+        skipSpaces(scnr);
+        const ch = scnr.currentChar();
+        if (ch !== "%" /* TokenChars.Modulo */) {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+        }
+        scnr.next();
+        return "%" /* TokenChars.Modulo */;
+    }
+    function readText(scnr) {
+        let buf = '';
+        while (true) {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                !ch) {
+                break;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === CHAR_SP || ch === CHAR_LF) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else if (isPluralStart(scnr)) {
+                    break;
+                }
+                else {
+                    buf += ch;
+                    scnr.next();
+                }
+            }
+            else {
+                buf += ch;
+                scnr.next();
+            }
+        }
+        return buf;
+    }
+    function readNamedIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return name;
+    }
+    function readListIdentifier(scnr) {
+        skipSpaces(scnr);
+        let value = '';
+        if (scnr.currentChar() === '-') {
+            scnr.next();
+            value += `-${getDigits(scnr)}`;
+        }
+        else {
+            value += getDigits(scnr);
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return value;
+    }
+    function readLiteral(scnr) {
+        skipSpaces(scnr);
+        eat(scnr, `\'`);
+        let ch = '';
+        let literal = '';
+        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+        while ((ch = takeChar(scnr, fn))) {
+            if (ch === '\\') {
+                literal += readEscapeSequence(scnr);
+            }
+            else {
+                literal += ch;
+            }
+        }
+        const current = scnr.currentChar();
+        if (current === CHAR_LF || current === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+            // TODO: Is it correct really?
+            if (current === CHAR_LF) {
+                scnr.next();
+                eat(scnr, `\'`);
+            }
+            return literal;
+        }
+        eat(scnr, `\'`);
+        return literal;
+    }
+    function readEscapeSequence(scnr) {
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case '\\':
+            case `\'`:
+                scnr.next();
+                return `\\${ch}`;
+            case 'u':
+                return readUnicodeEscapeSequence(scnr, ch, 4);
+            case 'U':
+                return readUnicodeEscapeSequence(scnr, ch, 6);
+            default:
+                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                return '';
+        }
+    }
+    function readUnicodeEscapeSequence(scnr, unicode, digits) {
+        eat(scnr, unicode);
+        let sequence = '';
+        for (let i = 0; i < digits; i++) {
+            const ch = takeHexDigit(scnr);
+            if (!ch) {
+                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                break;
+            }
+            sequence += ch;
+        }
+        return `\\${unicode}${sequence}`;
+    }
+    function readInvalidIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let identifiers = '';
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
+            ch !== CHAR_SP &&
+            ch !== CHAR_LF;
+        while ((ch = takeChar(scnr, closure))) {
+            identifiers += ch;
+        }
+        return identifiers;
+    }
+    function readLinkedModifier(scnr) {
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        return name;
+    }
+    function readLinkedRefer(scnr) {
+        const fn = (detect = false, buf) => {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === "(" /* TokenChars.ParenLeft */ ||
+                ch === ")" /* TokenChars.ParenRight */ ||
+                !ch) {
+                return buf;
+            }
+            else if (ch === CHAR_SP) {
+                return buf;
+            }
+            else if (ch === CHAR_LF || ch === DOT) {
+                buf += ch;
+                scnr.next();
+                return fn(detect, buf);
+            }
+            else {
+                buf += ch;
+                scnr.next();
+                return fn(true, buf);
+            }
+        };
+        return fn(false, '');
+    }
+    function readPlural(scnr) {
+        skipSpaces(scnr);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+        skipSpaces(scnr);
+        return plural;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInPlaceholder(scnr, context) {
+        let token = null;
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                if (context.braceNest >= 1) {
+                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                skipSpaces(scnr);
+                context.braceNest++;
+                return token;
+            case "}" /* TokenChars.BraceRight */:
+                if (context.braceNest > 0 &&
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                context.braceNest--;
+                context.braceNest > 0 && skipSpaces(scnr);
+                if (context.inLinked && context.braceNest === 0) {
+                    context.inLinked = false;
+                }
+                return token;
+            case "@" /* TokenChars.LinkedAlias */:
+                if (context.braceNest > 0) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                }
+                token = readTokenInLinked(scnr, context) || getEndToken(context);
+                context.braceNest = 0;
+                return token;
+            default:
+                let validNamedIdentifier = true;
+                let validListIdentifier = true;
+                let validLiteral = true;
+                if (isPluralStart(scnr)) {
+                    if (context.braceNest > 0) {
+                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    }
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (context.braceNest > 0 &&
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    context.braceNest = 0;
+                    return readToken(scnr, context);
+                }
+                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validLiteral = isLiteralStart(scnr, context))) {
+                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                    skipSpaces(scnr);
+                    return token;
+                }
+                break;
+        }
+        return token;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInLinked(scnr, context) {
+        const { currentType } = context;
+        let token = null;
+        const ch = scnr.currentChar();
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+            (ch === CHAR_LF || ch === CHAR_SP)) {
+            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+        }
+        switch (ch) {
+            case "@" /* TokenChars.LinkedAlias */:
+                scnr.next();
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                context.inLinked = true;
+                return token;
+            case "." /* TokenChars.LinkedDot */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (isLinkedDotStart(scnr, context) ||
+                    isLinkedDelimiterStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return readTokenInLinked(scnr, context);
+                }
+                if (isLinkedModifierStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                }
+                if (isLinkedReferStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
+                        // scan the placeholder
+                        return readTokenInPlaceholder(scnr, context) || token;
+                    }
+                    else {
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                    }
+                }
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                }
+                context.braceNest = 0;
+                context.inLinked = false;
+                return readToken(scnr, context);
+        }
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readToken(scnr, context) {
+        let token = { type: 14 /* TokenTypes.EOF */ };
+        if (context.braceNest > 0) {
+            return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+        }
+        if (context.inLinked) {
+            return readTokenInLinked(scnr, context) || getEndToken(context);
+        }
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+            case "}" /* TokenChars.BraceRight */:
+                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                scnr.next();
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
+                return readTokenInLinked(scnr, context) || getEndToken(context);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                const { isModulo, hasSpace } = detectModuloStart(scnr);
+                if (isModulo) {
+                    return hasSpace
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                }
+                if (isTextStart(scnr)) {
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                }
+                break;
+        }
+        return token;
+    }
+    function nextToken() {
+        const { currentType, offset, startLoc, endLoc } = _context;
+        _context.lastType = currentType;
+        _context.lastOffset = offset;
+        _context.lastStartLoc = startLoc;
+        _context.lastEndLoc = endLoc;
+        _context.offset = currentOffset();
+        _context.startLoc = currentPosition();
+        if (_scnr.currentChar() === EOF) {
+            return getToken(_context, 14 /* TokenTypes.EOF */);
+        }
+        return readToken(_scnr, _context);
+    }
+    return {
+        nextToken,
+        currentOffset,
+        currentPosition,
+        context
+    };
+}
+
+const ERROR_DOMAIN$2 = 'parser';
+// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+function fromEscapeSequence(match, codePoint4, codePoint6) {
+    switch (match) {
+        case `\\\\`:
+            return `\\`;
+        case `\\\'`:
+            return `\'`;
+        default: {
+            const codePoint = parseInt(codePoint4 || codePoint6, 16);
+            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                return String.fromCodePoint(codePoint);
+            }
+            // invalid ...
+            // Replace them with U+FFFD REPLACEMENT CHARACTER.
+            return '�';
+        }
+    }
+}
+function createParser(options = {}) {
+    const location = options.location !== false;
+    const { onError } = options;
+    function emitError(tokenzer, code, start, offset, ...args) {
+        const end = tokenzer.currentPosition();
+        end.offset += offset;
+        end.column += offset;
+        if (onError) {
+            const loc = location ? createLocation(start, end) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$2,
+                args
+            });
+            onError(err);
+        }
+    }
+    function startNode(type, offset, loc) {
+        const node = { type };
+        if (location) {
+            node.start = offset;
+            node.end = offset;
+            node.loc = { start: loc, end: loc };
+        }
+        return node;
+    }
+    function endNode(node, offset, pos, type) {
+        if (type) {
+            node.type = type;
+        }
+        if (location) {
+            node.end = offset;
+            if (node.loc) {
+                node.loc.end = pos;
+            }
+        }
+    }
+    function parseText(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseList(tokenizer, index) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
+        node.index = parseInt(index, 10);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseNamed(tokenizer, key) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+        node.key = key;
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLiteral(tokenizer, value) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinkedModifier(tokenizer) {
+        const token = tokenizer.nextToken();
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+            // empty modifier
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+            node.value = '';
+            endNode(node, offset, loc);
+            return {
+                nextConsumeToken: token,
+                node
+            };
+        }
+        // check token
+        if (token.value == null) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        node.value = token.value || '';
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node
+        };
+    }
+    function parseLinkedKey(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinked(tokenizer) {
+        const context = tokenizer.context();
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+        let token = tokenizer.nextToken();
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+            const parsed = parseLinkedModifier(tokenizer);
+            linkedNode.modifier = parsed.node;
+            token = parsed.nextConsumeToken || tokenizer.nextToken();
+        }
+        // asset check token
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        token = tokenizer.nextToken();
+        // skip brace left
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
+            token = tokenizer.nextToken();
+        }
+        switch (token.type) {
+            case 11 /* TokenTypes.LinkedKey */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                break;
+            case 5 /* TokenTypes.Named */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseNamed(tokenizer, token.value || '');
+                break;
+            case 6 /* TokenTypes.List */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseList(tokenizer, token.value || '');
+                break;
+            case 7 /* TokenTypes.Literal */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                break;
+            default:
+                // empty key
+                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                const nextContext = tokenizer.context();
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                emptyLinkedKeyNode.value = '';
+                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                linkedNode.key = emptyLinkedKeyNode;
+                endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                return {
+                    nextConsumeToken: token,
+                    node: linkedNode
+                };
+        }
+        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node: linkedNode
+        };
+    }
+    function parseMessage(tokenizer) {
+        const context = tokenizer.context();
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? tokenizer.currentOffset()
+            : context.offset;
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.endLoc
+            : context.startLoc;
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+        node.items = [];
+        let nextToken = null;
+        do {
+            const token = nextToken || tokenizer.nextToken();
+            nextToken = null;
+            switch (token.type) {
+                case 0 /* TokenTypes.Text */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseText(tokenizer, token.value || ''));
+                    break;
+                case 6 /* TokenTypes.List */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseList(tokenizer, token.value || ''));
+                    break;
+                case 5 /* TokenTypes.Named */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
+                    break;
+                case 7 /* TokenTypes.Literal */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseLiteral(tokenizer, token.value || ''));
+                    break;
+                case 8 /* TokenTypes.LinkedAlias */:
+                    const parsed = parseLinked(tokenizer);
+                    node.items.push(parsed.node);
+                    nextToken = parsed.nextConsumeToken || null;
+                    break;
+            }
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
+        // adjust message node loc
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastOffset
+            : tokenizer.currentOffset();
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastEndLoc
+            : tokenizer.currentPosition();
+        endNode(node, endOffset, endLoc);
+        return node;
+    }
+    function parsePlural(tokenizer, offset, loc, msgNode) {
+        const context = tokenizer.context();
+        let hasEmptyMessage = msgNode.items.length === 0;
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+        node.cases = [];
+        node.cases.push(msgNode);
+        do {
+            const msg = parseMessage(tokenizer);
+            if (!hasEmptyMessage) {
+                hasEmptyMessage = msg.items.length === 0;
+            }
+            node.cases.push(msg);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        if (hasEmptyMessage) {
+            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseResource(tokenizer) {
+        const context = tokenizer.context();
+        const { offset, startLoc } = context;
+        const msgNode = parseMessage(tokenizer);
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
+            return msgNode;
+        }
+        else {
+            return parsePlural(tokenizer, offset, startLoc, msgNode);
+        }
+    }
+    function parse(source) {
+        const tokenizer = createTokenizer(source, assign({}, options));
+        const context = tokenizer.context();
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+        if (location && node.loc) {
+            node.loc.source = source;
+        }
+        node.body = parseResource(tokenizer);
+        if (options.onCacheKey) {
+            node.cacheKey = options.onCacheKey(source);
+        }
+        // assert whether achieved to EOF
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    return { parse };
+}
+function getTokenCaption(token) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
+        return 'EOF';
+    }
+    const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+    return name.length > 10 ? name.slice(0, 9) + '…' : name;
+}
+
+function createTransformer(ast, options = {} // eslint-disable-line
+) {
+    const _context = {
+        ast,
+        helpers: new Set()
+    };
+    const context = () => _context;
+    const helper = (name) => {
+        _context.helpers.add(name);
+        return name;
+    };
+    return { context, helper };
+}
+function traverseNodes(nodes, transformer) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], transformer);
+    }
+}
+function traverseNode(node, transformer) {
+    // TODO: if we need pre-hook of transform, should be implemented to here
+    switch (node.type) {
+        case 1 /* NodeTypes.Plural */:
+            traverseNodes(node.cases, transformer);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
+            break;
+        case 2 /* NodeTypes.Message */:
+            traverseNodes(node.items, transformer);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            traverseNode(linked.key, transformer);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
+            break;
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
+            break;
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
+            break;
+    }
+    // TODO: if we need post-hook of transform, should be implemented to here
+}
+// transform AST
+function transform(ast, options = {} // eslint-disable-line
+) {
+    const transformer = createTransformer(ast);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+    // traverse
+    ast.body && traverseNode(ast.body, transformer);
+    // set meta information
+    const context = transformer.context();
+    ast.helpers = Array.from(context.helpers);
+}
+
+function optimize(ast) {
+    const body = ast.body;
+    if (body.type === 2 /* NodeTypes.Message */) {
+        optimizeMessageNode(body);
+    }
+    else {
+        body.cases.forEach(c => optimizeMessageNode(c));
+    }
+    return ast;
+}
+function optimizeMessageNode(message) {
+    if (message.items.length === 1) {
+        const item = message.items[0];
+        if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+            message.static = item.value;
+            delete item.value; // optimization for size
+        }
+    }
+    else {
+        const values = [];
+        for (let i = 0; i < message.items.length; i++) {
+            const item = message.items[i];
+            if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                break;
+            }
+            if (item.value == null) {
+                break;
+            }
+            values.push(item.value);
+        }
+        if (values.length === message.items.length) {
+            message.static = join(values);
+            for (let i = 0; i < message.items.length; i++) {
+                const item = message.items[i];
+                if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                    delete item.value; // optimization for size
+                }
+            }
+        }
+    }
+}
+
+const ERROR_DOMAIN$1 = 'minifier';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function minify(node) {
+    node.t = node.type;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            const resource = node;
+            minify(resource.body);
+            resource.b = resource.body;
+            delete resource.body;
+            break;
+        case 1 /* NodeTypes.Plural */:
+            const plural = node;
+            const cases = plural.cases;
+            for (let i = 0; i < cases.length; i++) {
+                minify(cases[i]);
+            }
+            plural.c = cases;
+            delete plural.cases;
+            break;
+        case 2 /* NodeTypes.Message */:
+            const message = node;
+            const items = message.items;
+            for (let i = 0; i < items.length; i++) {
+                minify(items[i]);
+            }
+            message.i = items;
+            delete message.items;
+            if (message.static) {
+                message.s = message.static;
+                delete message.static;
+            }
+            break;
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            const valueNode = node;
+            if (valueNode.value) {
+                valueNode.v = valueNode.value;
+                delete valueNode.value;
+            }
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            minify(linked.key);
+            linked.k = linked.key;
+            delete linked.key;
+            if (linked.modifier) {
+                minify(linked.modifier);
+                linked.m = linked.modifier;
+                delete linked.modifier;
+            }
+            break;
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            list.i = list.index;
+            delete list.index;
+            break;
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            named.k = named.key;
+            delete named.key;
+            break;
+        default:
+            {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN$1,
+                    args: [node.type]
+                });
+            }
+    }
+    delete node.type;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const ERROR_DOMAIN = 'parser';
+function createCodeGenerator(ast, options) {
+    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+    const location = options.location !== false;
+    const _context = {
+        filename,
+        code: '',
+        column: 1,
+        line: 1,
+        offset: 0,
+        map: undefined,
+        breakLineCode,
+        needIndent: _needIndent,
+        indentLevel: 0
+    };
+    if (location && ast.loc) {
+        _context.source = ast.loc.source;
+    }
+    const context = () => _context;
+    function push(code, node) {
+        _context.code += code;
+    }
+    function _newline(n, withBreakLine = true) {
+        const _breakLineCode = withBreakLine ? breakLineCode : '';
+        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+    }
+    function indent(withNewLine = true) {
+        const level = ++_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function deindent(withNewLine = true) {
+        const level = --_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function newline() {
+        _newline(_context.indentLevel);
+    }
+    const helper = (key) => `_${key}`;
+    const needIndent = () => _context.needIndent;
+    return {
+        context,
+        push,
+        indent,
+        deindent,
+        newline,
+        helper,
+        needIndent
+    };
+}
+function generateLinkedNode(generator, node) {
+    const { helper } = generator;
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+    generateNode(generator, node.key);
+    if (node.modifier) {
+        generator.push(`, `);
+        generateNode(generator, node.modifier);
+        generator.push(`, _type`);
+    }
+    else {
+        generator.push(`, undefined, _type`);
+    }
+    generator.push(`)`);
+}
+function generateMessageNode(generator, node) {
+    const { helper, needIndent } = generator;
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+    generator.indent(needIndent());
+    const length = node.items.length;
+    for (let i = 0; i < length; i++) {
+        generateNode(generator, node.items[i]);
+        if (i === length - 1) {
+            break;
+        }
+        generator.push(', ');
+    }
+    generator.deindent(needIndent());
+    generator.push('])');
+}
+function generatePluralNode(generator, node) {
+    const { helper, needIndent } = generator;
+    if (node.cases.length > 1) {
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+        generator.indent(needIndent());
+        const length = node.cases.length;
+        for (let i = 0; i < length; i++) {
+            generateNode(generator, node.cases[i]);
+            if (i === length - 1) {
+                break;
+            }
+            generator.push(', ');
+        }
+        generator.deindent(needIndent());
+        generator.push(`])`);
+    }
+}
+function generateResource(generator, node) {
+    if (node.body) {
+        generateNode(generator, node.body);
+    }
+    else {
+        generator.push('null');
+    }
+}
+function generateNode(generator, node) {
+    const { helper } = generator;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            generateResource(generator, node);
+            break;
+        case 1 /* NodeTypes.Plural */:
+            generatePluralNode(generator, node);
+            break;
+        case 2 /* NodeTypes.Message */:
+            generateMessageNode(generator, node);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            generateLinkedNode(generator, node);
+            break;
+        case 8 /* NodeTypes.LinkedModifier */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 7 /* NodeTypes.LinkedKey */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+            break;
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+            break;
+        case 9 /* NodeTypes.Literal */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 3 /* NodeTypes.Text */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        default:
+            {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN,
+                    args: [node.type]
+                });
+            }
+    }
+}
+// generate code from AST
+const generate = (ast, options = {} // eslint-disable-line
+) => {
+    const mode = isString(options.mode) ? options.mode : 'normal';
+    const filename = isString(options.filename)
+        ? options.filename
+        : 'message.intl';
+    const sourceMap = !!options.sourceMap;
+    // prettier-ignore
+    const breakLineCode = options.breakLineCode != null
+        ? options.breakLineCode
+        : mode === 'arrow'
+            ? ';'
+            : '\n';
+    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+    const helpers = ast.helpers || [];
+    const generator = createCodeGenerator(ast, {
+        mode,
+        filename,
+        sourceMap,
+        breakLineCode,
+        needIndent
+    });
+    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+    generator.indent(needIndent);
+    if (helpers.length > 0) {
+        generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+        generator.newline();
+    }
+    generator.push(`return `);
+    generateNode(generator, ast);
+    generator.deindent(needIndent);
+    generator.push(`}`);
+    delete ast.helpers;
+    const { code, map } = generator.context();
+    return {
+        ast,
+        code,
+        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+    };
+};
+
+function baseCompile(source, options = {}) {
+    const assignedOptions = assign({}, options);
+    const jit = !!assignedOptions.jit;
+    const enalbeMinify = !!assignedOptions.minify;
+    const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+    // parse source codes
+    const parser = createParser(assignedOptions);
+    const ast = parser.parse(source);
+    if (!jit) {
+        // transform ASTs
+        transform(ast, assignedOptions);
+        // generate javascript codes
+        return generate(ast, assignedOptions);
+    }
+    else {
+        // optimize ASTs
+        enambeOptimize && optimize(ast);
+        // minimize ASTs
+        enalbeMinify && minify(ast);
+        // In JIT mode, no ast transform, no code generation.
+        return { ast, code: '' };
+    }
+}
+
+export { CompileErrorCodes, ERROR_DOMAIN$2 as ERROR_DOMAIN, LOCATION_STUB, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, detectHtmlTag, errorMessages };

node_modules/@intlify/message-compiler/dist/message-compiler.esm-bundler.js

@@ -0,0 +1 @@
+export * from '../dist/message-compiler.mjs'

node_modules/@intlify/message-compiler/dist/message-compiler.global.js

@@ -0,0 +1,1567 @@
+/*!
+  * message-compiler v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+var IntlifyMessageCompiler = (function (exports) {
+  'use strict';
+
+  const LOCATION_STUB = {
+      start: { line: 1, column: 1, offset: 0 },
+      end: { line: 1, column: 1, offset: 0 }
+  };
+  function createPosition(line, column, offset) {
+      return { line, column, offset };
+  }
+  function createLocation(start, end, source) {
+      const loc = { start, end };
+      if (source != null) {
+          loc.source = source;
+      }
+      return loc;
+  }
+
+  /**
+   * Original Utilities
+   * written by kazuya kawaguchi
+   */
+  const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+  /* eslint-disable */
+  function format(message, ...args) {
+      if (args.length === 1 && isObject(args[0])) {
+          args = args[0];
+      }
+      if (!args || !args.hasOwnProperty) {
+          args = {};
+      }
+      return message.replace(RE_ARGS, (match, identifier) => {
+          return args.hasOwnProperty(identifier) ? args[identifier] : '';
+      });
+  }
+  const assign = Object.assign;
+  const isString = (val) => typeof val === 'string';
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const isObject = (val) => val !== null && typeof val === 'object';
+  function join(items, separator = '') {
+      return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+  }
+
+  const CompileErrorCodes = {
+      // tokenizer error codes
+      EXPECTED_TOKEN: 1,
+      INVALID_TOKEN_IN_PLACEHOLDER: 2,
+      UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+      UNKNOWN_ESCAPE_SEQUENCE: 4,
+      INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+      UNBALANCED_CLOSING_BRACE: 6,
+      UNTERMINATED_CLOSING_BRACE: 7,
+      EMPTY_PLACEHOLDER: 8,
+      NOT_ALLOW_NEST_PLACEHOLDER: 9,
+      INVALID_LINKED_FORMAT: 10,
+      // parser error codes
+      MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+      UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+      UNEXPECTED_EMPTY_LINKED_KEY: 13,
+      UNEXPECTED_LEXICAL_ANALYSIS: 14,
+      // generator error codes
+      UNHANDLED_CODEGEN_NODE_TYPE: 15,
+      // minifier error codes
+      UNHANDLED_MINIFIER_NODE_TYPE: 16,
+      // Special value for higher-order compilers to pick up the last code
+      // to avoid collision of error codes. This should always be kept as the last
+      // item.
+      __EXTEND_POINT__: 17
+  };
+  /** @internal */
+  const errorMessages = {
+      // tokenizer error messages
+      [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+      [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+      [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+      [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+      [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+      [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+      [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+      [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+      [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+      [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+      // parser error messages
+      [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+      [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+      [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+      [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+      // generator error messages
+      [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+      // minimizer error messages
+      [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+  };
+  function createCompileError(code, loc, options = {}) {
+      const { domain, messages, args } = options;
+      const msg = format((messages || errorMessages)[code] || '', ...(args || []))
+          ;
+      const error = new SyntaxError(String(msg));
+      error.code = code;
+      if (loc) {
+          error.location = loc;
+      }
+      error.domain = domain;
+      return error;
+  }
+  /** @internal */
+  function defaultOnError(error) {
+      throw error;
+  }
+
+  const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+  const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+  const CHAR_SP = ' ';
+  const CHAR_CR = '\r';
+  const CHAR_LF = '\n';
+  const CHAR_LS = String.fromCharCode(0x2028);
+  const CHAR_PS = String.fromCharCode(0x2029);
+  function createScanner(str) {
+      const _buf = str;
+      let _index = 0;
+      let _line = 1;
+      let _column = 1;
+      let _peekOffset = 0;
+      const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+      const isLF = (index) => _buf[index] === CHAR_LF;
+      const isPS = (index) => _buf[index] === CHAR_PS;
+      const isLS = (index) => _buf[index] === CHAR_LS;
+      const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+      const index = () => _index;
+      const line = () => _line;
+      const column = () => _column;
+      const peekOffset = () => _peekOffset;
+      const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+      const currentChar = () => charAt(_index);
+      const currentPeek = () => charAt(_index + _peekOffset);
+      function next() {
+          _peekOffset = 0;
+          if (isLineEnd(_index)) {
+              _line++;
+              _column = 0;
+          }
+          if (isCRLF(_index)) {
+              _index++;
+          }
+          _index++;
+          _column++;
+          return _buf[_index];
+      }
+      function peek() {
+          if (isCRLF(_index + _peekOffset)) {
+              _peekOffset++;
+          }
+          _peekOffset++;
+          return _buf[_index + _peekOffset];
+      }
+      function reset() {
+          _index = 0;
+          _line = 1;
+          _column = 1;
+          _peekOffset = 0;
+      }
+      function resetPeek(offset = 0) {
+          _peekOffset = offset;
+      }
+      function skipToPeek() {
+          const target = _index + _peekOffset;
+          // eslint-disable-next-line no-unmodified-loop-condition
+          while (target !== _index) {
+              next();
+          }
+          _peekOffset = 0;
+      }
+      return {
+          index,
+          line,
+          column,
+          peekOffset,
+          charAt,
+          currentChar,
+          currentPeek,
+          next,
+          peek,
+          reset,
+          resetPeek,
+          skipToPeek
+      };
+  }
+
+  const EOF = undefined;
+  const DOT = '.';
+  const LITERAL_DELIMITER = "'";
+  const ERROR_DOMAIN$3 = 'tokenizer';
+  function createTokenizer(source, options = {}) {
+      const location = options.location !== false;
+      const _scnr = createScanner(source);
+      const currentOffset = () => _scnr.index();
+      const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+      const _initLoc = currentPosition();
+      const _initOffset = currentOffset();
+      const _context = {
+          currentType: 14 /* TokenTypes.EOF */,
+          offset: _initOffset,
+          startLoc: _initLoc,
+          endLoc: _initLoc,
+          lastType: 14 /* TokenTypes.EOF */,
+          lastOffset: _initOffset,
+          lastStartLoc: _initLoc,
+          lastEndLoc: _initLoc,
+          braceNest: 0,
+          inLinked: false,
+          text: ''
+      };
+      const context = () => _context;
+      const { onError } = options;
+      function emitError(code, pos, offset, ...args) {
+          const ctx = context();
+          pos.column += offset;
+          pos.offset += offset;
+          if (onError) {
+              const loc = location ? createLocation(ctx.startLoc, pos) : null;
+              const err = createCompileError(code, loc, {
+                  domain: ERROR_DOMAIN$3,
+                  args
+              });
+              onError(err);
+          }
+      }
+      function getToken(context, type, value) {
+          context.endLoc = currentPosition();
+          context.currentType = type;
+          const token = { type };
+          if (location) {
+              token.loc = createLocation(context.startLoc, context.endLoc);
+          }
+          if (value != null) {
+              token.value = value;
+          }
+          return token;
+      }
+      const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+      function eat(scnr, ch) {
+          if (scnr.currentChar() === ch) {
+              scnr.next();
+              return ch;
+          }
+          else {
+              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+              return '';
+          }
+      }
+      function peekSpaces(scnr) {
+          let buf = '';
+          while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+              buf += scnr.currentPeek();
+              scnr.peek();
+          }
+          return buf;
+      }
+      function skipSpaces(scnr) {
+          const buf = peekSpaces(scnr);
+          scnr.skipToPeek();
+          return buf;
+      }
+      function isIdentifierStart(ch) {
+          if (ch === EOF) {
+              return false;
+          }
+          const cc = ch.charCodeAt(0);
+          return ((cc >= 97 && cc <= 122) || // a-z
+              (cc >= 65 && cc <= 90) || // A-Z
+              cc === 95 // _
+          );
+      }
+      function isNumberStart(ch) {
+          if (ch === EOF) {
+              return false;
+          }
+          const cc = ch.charCodeAt(0);
+          return cc >= 48 && cc <= 57; // 0-9
+      }
+      function isNamedIdentifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = isIdentifierStart(scnr.currentPeek());
+          scnr.resetPeek();
+          return ret;
+      }
+      function isListIdentifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+          const ret = isNumberStart(ch);
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLiteralStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedDotStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedModifierStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = isIdentifierStart(scnr.currentPeek());
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedDelimiterStart(scnr, context) {
+          const { currentType } = context;
+          if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+              currentType === 12 /* TokenTypes.LinkedModifier */)) {
+              return false;
+          }
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function isLinkedReferStart(scnr, context) {
+          const { currentType } = context;
+          if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+              return false;
+          }
+          const fn = () => {
+              const ch = scnr.currentPeek();
+              if (ch === "{" /* TokenChars.BraceLeft */) {
+                  return isIdentifierStart(scnr.peek());
+              }
+              else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "%" /* TokenChars.Modulo */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                  ch === "." /* TokenChars.LinkedDot */ ||
+                  ch === CHAR_SP ||
+                  !ch) {
+                  return false;
+              }
+              else if (ch === CHAR_LF) {
+                  scnr.peek();
+                  return fn();
+              }
+              else {
+                  // other characters
+                  return isIdentifierStart(ch);
+              }
+          };
+          const ret = fn();
+          scnr.resetPeek();
+          return ret;
+      }
+      function isPluralStart(scnr) {
+          peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+          scnr.resetPeek();
+          return ret;
+      }
+      function detectModuloStart(scnr) {
+          const spaces = peekSpaces(scnr);
+          const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+              scnr.peek() === "{" /* TokenChars.BraceLeft */;
+          scnr.resetPeek();
+          return {
+              isModulo: ret,
+              hasSpace: spaces.length > 0
+          };
+      }
+      function isTextStart(scnr, reset = true) {
+          const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+              const ch = scnr.currentPeek();
+              if (ch === "{" /* TokenChars.BraceLeft */) {
+                  return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+              }
+              else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                  return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+              }
+              else if (ch === "%" /* TokenChars.Modulo */) {
+                  scnr.peek();
+                  return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+              }
+              else if (ch === "|" /* TokenChars.Pipe */) {
+                  return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                      ? true
+                      : !(prev === CHAR_SP || prev === CHAR_LF);
+              }
+              else if (ch === CHAR_SP) {
+                  scnr.peek();
+                  return fn(true, CHAR_SP, detectModulo);
+              }
+              else if (ch === CHAR_LF) {
+                  scnr.peek();
+                  return fn(true, CHAR_LF, detectModulo);
+              }
+              else {
+                  return true;
+              }
+          };
+          const ret = fn();
+          reset && scnr.resetPeek();
+          return ret;
+      }
+      function takeChar(scnr, fn) {
+          const ch = scnr.currentChar();
+          if (ch === EOF) {
+              return EOF;
+          }
+          if (fn(ch)) {
+              scnr.next();
+              return ch;
+          }
+          return null;
+      }
+      function takeIdentifierChar(scnr) {
+          const closure = (ch) => {
+              const cc = ch.charCodeAt(0);
+              return ((cc >= 97 && cc <= 122) || // a-z
+                  (cc >= 65 && cc <= 90) || // A-Z
+                  (cc >= 48 && cc <= 57) || // 0-9
+                  cc === 95 || // _
+                  cc === 36 // $
+              );
+          };
+          return takeChar(scnr, closure);
+      }
+      function takeDigit(scnr) {
+          const closure = (ch) => {
+              const cc = ch.charCodeAt(0);
+              return cc >= 48 && cc <= 57; // 0-9
+          };
+          return takeChar(scnr, closure);
+      }
+      function takeHexDigit(scnr) {
+          const closure = (ch) => {
+              const cc = ch.charCodeAt(0);
+              return ((cc >= 48 && cc <= 57) || // 0-9
+                  (cc >= 65 && cc <= 70) || // A-F
+                  (cc >= 97 && cc <= 102)); // a-f
+          };
+          return takeChar(scnr, closure);
+      }
+      function getDigits(scnr) {
+          let ch = '';
+          let num = '';
+          while ((ch = takeDigit(scnr))) {
+              num += ch;
+          }
+          return num;
+      }
+      function readModulo(scnr) {
+          skipSpaces(scnr);
+          const ch = scnr.currentChar();
+          if (ch !== "%" /* TokenChars.Modulo */) {
+              emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+          }
+          scnr.next();
+          return "%" /* TokenChars.Modulo */;
+      }
+      function readText(scnr) {
+          let buf = '';
+          while (true) {
+              const ch = scnr.currentChar();
+              if (ch === "{" /* TokenChars.BraceLeft */ ||
+                  ch === "}" /* TokenChars.BraceRight */ ||
+                  ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  !ch) {
+                  break;
+              }
+              else if (ch === "%" /* TokenChars.Modulo */) {
+                  if (isTextStart(scnr)) {
+                      buf += ch;
+                      scnr.next();
+                  }
+                  else {
+                      break;
+                  }
+              }
+              else if (ch === CHAR_SP || ch === CHAR_LF) {
+                  if (isTextStart(scnr)) {
+                      buf += ch;
+                      scnr.next();
+                  }
+                  else if (isPluralStart(scnr)) {
+                      break;
+                  }
+                  else {
+                      buf += ch;
+                      scnr.next();
+                  }
+              }
+              else {
+                  buf += ch;
+                  scnr.next();
+              }
+          }
+          return buf;
+      }
+      function readNamedIdentifier(scnr) {
+          skipSpaces(scnr);
+          let ch = '';
+          let name = '';
+          while ((ch = takeIdentifierChar(scnr))) {
+              name += ch;
+          }
+          if (scnr.currentChar() === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+          }
+          return name;
+      }
+      function readListIdentifier(scnr) {
+          skipSpaces(scnr);
+          let value = '';
+          if (scnr.currentChar() === '-') {
+              scnr.next();
+              value += `-${getDigits(scnr)}`;
+          }
+          else {
+              value += getDigits(scnr);
+          }
+          if (scnr.currentChar() === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+          }
+          return value;
+      }
+      function readLiteral(scnr) {
+          skipSpaces(scnr);
+          eat(scnr, `\'`);
+          let ch = '';
+          let literal = '';
+          const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+          while ((ch = takeChar(scnr, fn))) {
+              if (ch === '\\') {
+                  literal += readEscapeSequence(scnr);
+              }
+              else {
+                  literal += ch;
+              }
+          }
+          const current = scnr.currentChar();
+          if (current === CHAR_LF || current === EOF) {
+              emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+              // TODO: Is it correct really?
+              if (current === CHAR_LF) {
+                  scnr.next();
+                  eat(scnr, `\'`);
+              }
+              return literal;
+          }
+          eat(scnr, `\'`);
+          return literal;
+      }
+      function readEscapeSequence(scnr) {
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case '\\':
+              case `\'`:
+                  scnr.next();
+                  return `\\${ch}`;
+              case 'u':
+                  return readUnicodeEscapeSequence(scnr, ch, 4);
+              case 'U':
+                  return readUnicodeEscapeSequence(scnr, ch, 6);
+              default:
+                  emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                  return '';
+          }
+      }
+      function readUnicodeEscapeSequence(scnr, unicode, digits) {
+          eat(scnr, unicode);
+          let sequence = '';
+          for (let i = 0; i < digits; i++) {
+              const ch = takeHexDigit(scnr);
+              if (!ch) {
+                  emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                  break;
+              }
+              sequence += ch;
+          }
+          return `\\${unicode}${sequence}`;
+      }
+      function readInvalidIdentifier(scnr) {
+          skipSpaces(scnr);
+          let ch = '';
+          let identifiers = '';
+          const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+              ch !== "}" /* TokenChars.BraceRight */ &&
+              ch !== CHAR_SP &&
+              ch !== CHAR_LF;
+          while ((ch = takeChar(scnr, closure))) {
+              identifiers += ch;
+          }
+          return identifiers;
+      }
+      function readLinkedModifier(scnr) {
+          let ch = '';
+          let name = '';
+          while ((ch = takeIdentifierChar(scnr))) {
+              name += ch;
+          }
+          return name;
+      }
+      function readLinkedRefer(scnr) {
+          const fn = (detect = false, buf) => {
+              const ch = scnr.currentChar();
+              if (ch === "{" /* TokenChars.BraceLeft */ ||
+                  ch === "%" /* TokenChars.Modulo */ ||
+                  ch === "@" /* TokenChars.LinkedAlias */ ||
+                  ch === "|" /* TokenChars.Pipe */ ||
+                  ch === "(" /* TokenChars.ParenLeft */ ||
+                  ch === ")" /* TokenChars.ParenRight */ ||
+                  !ch) {
+                  return buf;
+              }
+              else if (ch === CHAR_SP) {
+                  return buf;
+              }
+              else if (ch === CHAR_LF || ch === DOT) {
+                  buf += ch;
+                  scnr.next();
+                  return fn(detect, buf);
+              }
+              else {
+                  buf += ch;
+                  scnr.next();
+                  return fn(true, buf);
+              }
+          };
+          return fn(false, '');
+      }
+      function readPlural(scnr) {
+          skipSpaces(scnr);
+          const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+          skipSpaces(scnr);
+          return plural;
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readTokenInPlaceholder(scnr, context) {
+          let token = null;
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case "{" /* TokenChars.BraceLeft */:
+                  if (context.braceNest >= 1) {
+                      emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                  }
+                  scnr.next();
+                  token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                  skipSpaces(scnr);
+                  context.braceNest++;
+                  return token;
+              case "}" /* TokenChars.BraceRight */:
+                  if (context.braceNest > 0 &&
+                      context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                      emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                  }
+                  scnr.next();
+                  token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                  context.braceNest--;
+                  context.braceNest > 0 && skipSpaces(scnr);
+                  if (context.inLinked && context.braceNest === 0) {
+                      context.inLinked = false;
+                  }
+                  return token;
+              case "@" /* TokenChars.LinkedAlias */:
+                  if (context.braceNest > 0) {
+                      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                  }
+                  token = readTokenInLinked(scnr, context) || getEndToken(context);
+                  context.braceNest = 0;
+                  return token;
+              default:
+                  let validNamedIdentifier = true;
+                  let validListIdentifier = true;
+                  let validLiteral = true;
+                  if (isPluralStart(scnr)) {
+                      if (context.braceNest > 0) {
+                          emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                      }
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  if (context.braceNest > 0 &&
+                      (context.currentType === 5 /* TokenTypes.Named */ ||
+                          context.currentType === 6 /* TokenTypes.List */ ||
+                          context.currentType === 7 /* TokenTypes.Literal */)) {
+                      emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                      context.braceNest = 0;
+                      return readToken(scnr, context);
+                  }
+                  if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                      token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                      token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if ((validLiteral = isLiteralStart(scnr, context))) {
+                      token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                      // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                      token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                      emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                      skipSpaces(scnr);
+                      return token;
+                  }
+                  break;
+          }
+          return token;
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readTokenInLinked(scnr, context) {
+          const { currentType } = context;
+          let token = null;
+          const ch = scnr.currentChar();
+          if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+              currentType === 9 /* TokenTypes.LinkedDot */ ||
+              currentType === 12 /* TokenTypes.LinkedModifier */ ||
+              currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+              (ch === CHAR_LF || ch === CHAR_SP)) {
+              emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+          }
+          switch (ch) {
+              case "@" /* TokenChars.LinkedAlias */:
+                  scnr.next();
+                  token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                  context.inLinked = true;
+                  return token;
+              case "." /* TokenChars.LinkedDot */:
+                  skipSpaces(scnr);
+                  scnr.next();
+                  return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+              case ":" /* TokenChars.LinkedDelimiter */:
+                  skipSpaces(scnr);
+                  scnr.next();
+                  return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+              default:
+                  if (isPluralStart(scnr)) {
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  if (isLinkedDotStart(scnr, context) ||
+                      isLinkedDelimiterStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      return readTokenInLinked(scnr, context);
+                  }
+                  if (isLinkedModifierStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                  }
+                  if (isLinkedReferStart(scnr, context)) {
+                      skipSpaces(scnr);
+                      if (ch === "{" /* TokenChars.BraceLeft */) {
+                          // scan the placeholder
+                          return readTokenInPlaceholder(scnr, context) || token;
+                      }
+                      else {
+                          return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                      }
+                  }
+                  if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                      emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                  }
+                  context.braceNest = 0;
+                  context.inLinked = false;
+                  return readToken(scnr, context);
+          }
+      }
+      // TODO: We need refactoring of token parsing ...
+      function readToken(scnr, context) {
+          let token = { type: 14 /* TokenTypes.EOF */ };
+          if (context.braceNest > 0) {
+              return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+          }
+          if (context.inLinked) {
+              return readTokenInLinked(scnr, context) || getEndToken(context);
+          }
+          const ch = scnr.currentChar();
+          switch (ch) {
+              case "{" /* TokenChars.BraceLeft */:
+                  return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+              case "}" /* TokenChars.BraceRight */:
+                  emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                  scnr.next();
+                  return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+              case "@" /* TokenChars.LinkedAlias */:
+                  return readTokenInLinked(scnr, context) || getEndToken(context);
+              default:
+                  if (isPluralStart(scnr)) {
+                      token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                      // reset
+                      context.braceNest = 0;
+                      context.inLinked = false;
+                      return token;
+                  }
+                  const { isModulo, hasSpace } = detectModuloStart(scnr);
+                  if (isModulo) {
+                      return hasSpace
+                          ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                          : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                  }
+                  if (isTextStart(scnr)) {
+                      return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                  }
+                  break;
+          }
+          return token;
+      }
+      function nextToken() {
+          const { currentType, offset, startLoc, endLoc } = _context;
+          _context.lastType = currentType;
+          _context.lastOffset = offset;
+          _context.lastStartLoc = startLoc;
+          _context.lastEndLoc = endLoc;
+          _context.offset = currentOffset();
+          _context.startLoc = currentPosition();
+          if (_scnr.currentChar() === EOF) {
+              return getToken(_context, 14 /* TokenTypes.EOF */);
+          }
+          return readToken(_scnr, _context);
+      }
+      return {
+          nextToken,
+          currentOffset,
+          currentPosition,
+          context
+      };
+  }
+
+  const ERROR_DOMAIN$2 = 'parser';
+  // Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+  const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+  function fromEscapeSequence(match, codePoint4, codePoint6) {
+      switch (match) {
+          case `\\\\`:
+              return `\\`;
+          case `\\\'`:
+              return `\'`;
+          default: {
+              const codePoint = parseInt(codePoint4 || codePoint6, 16);
+              if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                  return String.fromCodePoint(codePoint);
+              }
+              // invalid ...
+              // Replace them with U+FFFD REPLACEMENT CHARACTER.
+              return '�';
+          }
+      }
+  }
+  function createParser(options = {}) {
+      const location = options.location !== false;
+      const { onError } = options;
+      function emitError(tokenzer, code, start, offset, ...args) {
+          const end = tokenzer.currentPosition();
+          end.offset += offset;
+          end.column += offset;
+          if (onError) {
+              const loc = location ? createLocation(start, end) : null;
+              const err = createCompileError(code, loc, {
+                  domain: ERROR_DOMAIN$2,
+                  args
+              });
+              onError(err);
+          }
+      }
+      function startNode(type, offset, loc) {
+          const node = { type };
+          if (location) {
+              node.start = offset;
+              node.end = offset;
+              node.loc = { start: loc, end: loc };
+          }
+          return node;
+      }
+      function endNode(node, offset, pos, type) {
+          if (type) {
+              node.type = type;
+          }
+          if (location) {
+              node.end = offset;
+              if (node.loc) {
+                  node.loc.end = pos;
+              }
+          }
+      }
+      function parseText(tokenizer, value) {
+          const context = tokenizer.context();
+          const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+          node.value = value;
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseList(tokenizer, index) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(5 /* NodeTypes.List */, offset, loc);
+          node.index = parseInt(index, 10);
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseNamed(tokenizer, key) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+          node.key = key;
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLiteral(tokenizer, value) {
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+          const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+          node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+          tokenizer.nextToken(); // skip brach right
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLinkedModifier(tokenizer) {
+          const token = tokenizer.nextToken();
+          const context = tokenizer.context();
+          const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+          const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+          if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+              // empty modifier
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+              node.value = '';
+              endNode(node, offset, loc);
+              return {
+                  nextConsumeToken: token,
+                  node
+              };
+          }
+          // check token
+          if (token.value == null) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+          }
+          node.value = token.value || '';
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return {
+              node
+          };
+      }
+      function parseLinkedKey(tokenizer, value) {
+          const context = tokenizer.context();
+          const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+          node.value = value;
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseLinked(tokenizer) {
+          const context = tokenizer.context();
+          const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+          let token = tokenizer.nextToken();
+          if (token.type === 9 /* TokenTypes.LinkedDot */) {
+              const parsed = parseLinkedModifier(tokenizer);
+              linkedNode.modifier = parsed.node;
+              token = parsed.nextConsumeToken || tokenizer.nextToken();
+          }
+          // asset check token
+          if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+          }
+          token = tokenizer.nextToken();
+          // skip brace left
+          if (token.type === 2 /* TokenTypes.BraceLeft */) {
+              token = tokenizer.nextToken();
+          }
+          switch (token.type) {
+              case 11 /* TokenTypes.LinkedKey */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                  break;
+              case 5 /* TokenTypes.Named */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseNamed(tokenizer, token.value || '');
+                  break;
+              case 6 /* TokenTypes.List */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseList(tokenizer, token.value || '');
+                  break;
+              case 7 /* TokenTypes.Literal */:
+                  if (token.value == null) {
+                      emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                  }
+                  linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                  break;
+              default:
+                  // empty key
+                  emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                  const nextContext = tokenizer.context();
+                  const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                  emptyLinkedKeyNode.value = '';
+                  endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                  linkedNode.key = emptyLinkedKeyNode;
+                  endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                  return {
+                      nextConsumeToken: token,
+                      node: linkedNode
+                  };
+          }
+          endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return {
+              node: linkedNode
+          };
+      }
+      function parseMessage(tokenizer) {
+          const context = tokenizer.context();
+          const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+              ? tokenizer.currentOffset()
+              : context.offset;
+          const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.endLoc
+              : context.startLoc;
+          const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+          node.items = [];
+          let nextToken = null;
+          do {
+              const token = nextToken || tokenizer.nextToken();
+              nextToken = null;
+              switch (token.type) {
+                  case 0 /* TokenTypes.Text */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseText(tokenizer, token.value || ''));
+                      break;
+                  case 6 /* TokenTypes.List */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseList(tokenizer, token.value || ''));
+                      break;
+                  case 5 /* TokenTypes.Named */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseNamed(tokenizer, token.value || ''));
+                      break;
+                  case 7 /* TokenTypes.Literal */:
+                      if (token.value == null) {
+                          emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                      }
+                      node.items.push(parseLiteral(tokenizer, token.value || ''));
+                      break;
+                  case 8 /* TokenTypes.LinkedAlias */:
+                      const parsed = parseLinked(tokenizer);
+                      node.items.push(parsed.node);
+                      nextToken = parsed.nextConsumeToken || null;
+                      break;
+              }
+          } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+              context.currentType !== 1 /* TokenTypes.Pipe */);
+          // adjust message node loc
+          const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.lastOffset
+              : tokenizer.currentOffset();
+          const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+              ? context.lastEndLoc
+              : tokenizer.currentPosition();
+          endNode(node, endOffset, endLoc);
+          return node;
+      }
+      function parsePlural(tokenizer, offset, loc, msgNode) {
+          const context = tokenizer.context();
+          let hasEmptyMessage = msgNode.items.length === 0;
+          const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+          node.cases = [];
+          node.cases.push(msgNode);
+          do {
+              const msg = parseMessage(tokenizer);
+              if (!hasEmptyMessage) {
+                  hasEmptyMessage = msg.items.length === 0;
+              }
+              node.cases.push(msg);
+          } while (context.currentType !== 14 /* TokenTypes.EOF */);
+          if (hasEmptyMessage) {
+              emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+          }
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      function parseResource(tokenizer) {
+          const context = tokenizer.context();
+          const { offset, startLoc } = context;
+          const msgNode = parseMessage(tokenizer);
+          if (context.currentType === 14 /* TokenTypes.EOF */) {
+              return msgNode;
+          }
+          else {
+              return parsePlural(tokenizer, offset, startLoc, msgNode);
+          }
+      }
+      function parse(source) {
+          const tokenizer = createTokenizer(source, assign({}, options));
+          const context = tokenizer.context();
+          const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+          if (location && node.loc) {
+              node.loc.source = source;
+          }
+          node.body = parseResource(tokenizer);
+          if (options.onCacheKey) {
+              node.cacheKey = options.onCacheKey(source);
+          }
+          // assert whether achieved to EOF
+          if (context.currentType !== 14 /* TokenTypes.EOF */) {
+              emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+          }
+          endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+          return node;
+      }
+      return { parse };
+  }
+  function getTokenCaption(token) {
+      if (token.type === 14 /* TokenTypes.EOF */) {
+          return 'EOF';
+      }
+      const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+      return name.length > 10 ? name.slice(0, 9) + '…' : name;
+  }
+
+  function createTransformer(ast, options = {} // eslint-disable-line
+  ) {
+      const _context = {
+          ast,
+          helpers: new Set()
+      };
+      const context = () => _context;
+      const helper = (name) => {
+          _context.helpers.add(name);
+          return name;
+      };
+      return { context, helper };
+  }
+  function traverseNodes(nodes, transformer) {
+      for (let i = 0; i < nodes.length; i++) {
+          traverseNode(nodes[i], transformer);
+      }
+  }
+  function traverseNode(node, transformer) {
+      // TODO: if we need pre-hook of transform, should be implemented to here
+      switch (node.type) {
+          case 1 /* NodeTypes.Plural */:
+              traverseNodes(node.cases, transformer);
+              transformer.helper("plural" /* HelperNameMap.PLURAL */);
+              break;
+          case 2 /* NodeTypes.Message */:
+              traverseNodes(node.items, transformer);
+              break;
+          case 6 /* NodeTypes.Linked */:
+              const linked = node;
+              traverseNode(linked.key, transformer);
+              transformer.helper("linked" /* HelperNameMap.LINKED */);
+              transformer.helper("type" /* HelperNameMap.TYPE */);
+              break;
+          case 5 /* NodeTypes.List */:
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("list" /* HelperNameMap.LIST */);
+              break;
+          case 4 /* NodeTypes.Named */:
+              transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+              transformer.helper("named" /* HelperNameMap.NAMED */);
+              break;
+      }
+      // TODO: if we need post-hook of transform, should be implemented to here
+  }
+  // transform AST
+  function transform(ast, options = {} // eslint-disable-line
+  ) {
+      const transformer = createTransformer(ast);
+      transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+      // traverse
+      ast.body && traverseNode(ast.body, transformer);
+      // set meta information
+      const context = transformer.context();
+      ast.helpers = Array.from(context.helpers);
+  }
+
+  function optimize(ast) {
+      const body = ast.body;
+      if (body.type === 2 /* NodeTypes.Message */) {
+          optimizeMessageNode(body);
+      }
+      else {
+          body.cases.forEach(c => optimizeMessageNode(c));
+      }
+      return ast;
+  }
+  function optimizeMessageNode(message) {
+      if (message.items.length === 1) {
+          const item = message.items[0];
+          if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+              message.static = item.value;
+              delete item.value; // optimization for size
+          }
+      }
+      else {
+          const values = [];
+          for (let i = 0; i < message.items.length; i++) {
+              const item = message.items[i];
+              if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                  break;
+              }
+              if (item.value == null) {
+                  break;
+              }
+              values.push(item.value);
+          }
+          if (values.length === message.items.length) {
+              message.static = join(values);
+              for (let i = 0; i < message.items.length; i++) {
+                  const item = message.items[i];
+                  if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                      delete item.value; // optimization for size
+                  }
+              }
+          }
+      }
+  }
+
+  const ERROR_DOMAIN$1 = 'minifier';
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  function minify(node) {
+      node.t = node.type;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */:
+              const resource = node;
+              minify(resource.body);
+              resource.b = resource.body;
+              delete resource.body;
+              break;
+          case 1 /* NodeTypes.Plural */:
+              const plural = node;
+              const cases = plural.cases;
+              for (let i = 0; i < cases.length; i++) {
+                  minify(cases[i]);
+              }
+              plural.c = cases;
+              delete plural.cases;
+              break;
+          case 2 /* NodeTypes.Message */:
+              const message = node;
+              const items = message.items;
+              for (let i = 0; i < items.length; i++) {
+                  minify(items[i]);
+              }
+              message.i = items;
+              delete message.items;
+              if (message.static) {
+                  message.s = message.static;
+                  delete message.static;
+              }
+              break;
+          case 3 /* NodeTypes.Text */:
+          case 9 /* NodeTypes.Literal */:
+          case 8 /* NodeTypes.LinkedModifier */:
+          case 7 /* NodeTypes.LinkedKey */:
+              const valueNode = node;
+              if (valueNode.value) {
+                  valueNode.v = valueNode.value;
+                  delete valueNode.value;
+              }
+              break;
+          case 6 /* NodeTypes.Linked */:
+              const linked = node;
+              minify(linked.key);
+              linked.k = linked.key;
+              delete linked.key;
+              if (linked.modifier) {
+                  minify(linked.modifier);
+                  linked.m = linked.modifier;
+                  delete linked.modifier;
+              }
+              break;
+          case 5 /* NodeTypes.List */:
+              const list = node;
+              list.i = list.index;
+              delete list.index;
+              break;
+          case 4 /* NodeTypes.Named */:
+              const named = node;
+              named.k = named.key;
+              delete named.key;
+              break;
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN$1,
+                      args: [node.type]
+                  });
+              }
+      }
+      delete node.type;
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+
+  const ERROR_DOMAIN = 'parser';
+  function createCodeGenerator(ast, options) {
+      const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+      const location = options.location !== false;
+      const _context = {
+          filename,
+          code: '',
+          column: 1,
+          line: 1,
+          offset: 0,
+          map: undefined,
+          breakLineCode,
+          needIndent: _needIndent,
+          indentLevel: 0
+      };
+      if (location && ast.loc) {
+          _context.source = ast.loc.source;
+      }
+      const context = () => _context;
+      function push(code, node) {
+          _context.code += code;
+      }
+      function _newline(n, withBreakLine = true) {
+          const _breakLineCode = withBreakLine ? breakLineCode : '';
+          push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+      }
+      function indent(withNewLine = true) {
+          const level = ++_context.indentLevel;
+          withNewLine && _newline(level);
+      }
+      function deindent(withNewLine = true) {
+          const level = --_context.indentLevel;
+          withNewLine && _newline(level);
+      }
+      function newline() {
+          _newline(_context.indentLevel);
+      }
+      const helper = (key) => `_${key}`;
+      const needIndent = () => _context.needIndent;
+      return {
+          context,
+          push,
+          indent,
+          deindent,
+          newline,
+          helper,
+          needIndent
+      };
+  }
+  function generateLinkedNode(generator, node) {
+      const { helper } = generator;
+      generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+      generateNode(generator, node.key);
+      if (node.modifier) {
+          generator.push(`, `);
+          generateNode(generator, node.modifier);
+          generator.push(`, _type`);
+      }
+      else {
+          generator.push(`, undefined, _type`);
+      }
+      generator.push(`)`);
+  }
+  function generateMessageNode(generator, node) {
+      const { helper, needIndent } = generator;
+      generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+      generator.indent(needIndent());
+      const length = node.items.length;
+      for (let i = 0; i < length; i++) {
+          generateNode(generator, node.items[i]);
+          if (i === length - 1) {
+              break;
+          }
+          generator.push(', ');
+      }
+      generator.deindent(needIndent());
+      generator.push('])');
+  }
+  function generatePluralNode(generator, node) {
+      const { helper, needIndent } = generator;
+      if (node.cases.length > 1) {
+          generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+          generator.indent(needIndent());
+          const length = node.cases.length;
+          for (let i = 0; i < length; i++) {
+              generateNode(generator, node.cases[i]);
+              if (i === length - 1) {
+                  break;
+              }
+              generator.push(', ');
+          }
+          generator.deindent(needIndent());
+          generator.push(`])`);
+      }
+  }
+  function generateResource(generator, node) {
+      if (node.body) {
+          generateNode(generator, node.body);
+      }
+      else {
+          generator.push('null');
+      }
+  }
+  function generateNode(generator, node) {
+      const { helper } = generator;
+      switch (node.type) {
+          case 0 /* NodeTypes.Resource */:
+              generateResource(generator, node);
+              break;
+          case 1 /* NodeTypes.Plural */:
+              generatePluralNode(generator, node);
+              break;
+          case 2 /* NodeTypes.Message */:
+              generateMessageNode(generator, node);
+              break;
+          case 6 /* NodeTypes.Linked */:
+              generateLinkedNode(generator, node);
+              break;
+          case 8 /* NodeTypes.LinkedModifier */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 7 /* NodeTypes.LinkedKey */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 5 /* NodeTypes.List */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+              break;
+          case 4 /* NodeTypes.Named */:
+              generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+              break;
+          case 9 /* NodeTypes.Literal */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          case 3 /* NodeTypes.Text */:
+              generator.push(JSON.stringify(node.value), node);
+              break;
+          default:
+              {
+                  throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                      domain: ERROR_DOMAIN,
+                      args: [node.type]
+                  });
+              }
+      }
+  }
+  // generate code from AST
+  const generate = (ast, options = {} // eslint-disable-line
+  ) => {
+      const mode = isString(options.mode) ? options.mode : 'normal';
+      const filename = isString(options.filename)
+          ? options.filename
+          : 'message.intl';
+      const sourceMap = !!options.sourceMap;
+      // prettier-ignore
+      const breakLineCode = options.breakLineCode != null
+          ? options.breakLineCode
+          : mode === 'arrow'
+              ? ';'
+              : '\n';
+      const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+      const helpers = ast.helpers || [];
+      const generator = createCodeGenerator(ast, {
+          mode,
+          filename,
+          sourceMap,
+          breakLineCode,
+          needIndent
+      });
+      generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+      generator.indent(needIndent);
+      if (helpers.length > 0) {
+          generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+          generator.newline();
+      }
+      generator.push(`return `);
+      generateNode(generator, ast);
+      generator.deindent(needIndent);
+      generator.push(`}`);
+      delete ast.helpers;
+      const { code, map } = generator.context();
+      return {
+          ast,
+          code,
+          map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+      };
+  };
+
+  function baseCompile(source, options = {}) {
+      const assignedOptions = assign({}, options);
+      const jit = !!assignedOptions.jit;
+      const enalbeMinify = !!assignedOptions.minify;
+      const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+      // parse source codes
+      const parser = createParser(assignedOptions);
+      const ast = parser.parse(source);
+      if (!jit) {
+          // transform ASTs
+          transform(ast, assignedOptions);
+          // generate javascript codes
+          return generate(ast, assignedOptions);
+      }
+      else {
+          // optimize ASTs
+          enambeOptimize && optimize(ast);
+          // minimize ASTs
+          enalbeMinify && minify(ast);
+          // In JIT mode, no ast transform, no code generation.
+          return { ast, code: '' };
+      }
+  }
+
+  exports.CompileErrorCodes = CompileErrorCodes;
+  exports.ERROR_DOMAIN = ERROR_DOMAIN$2;
+  exports.LOCATION_STUB = LOCATION_STUB;
+  exports.baseCompile = baseCompile;
+  exports.createCompileError = createCompileError;
+  exports.createLocation = createLocation;
+  exports.createParser = createParser;
+  exports.createPosition = createPosition;
+  exports.defaultOnError = defaultOnError;
+  exports.detectHtmlTag = detectHtmlTag;
+  exports.errorMessages = errorMessages;
+
+  return exports;
+
+})({});

node_modules/@intlify/message-compiler/dist/message-compiler.mjs

@@ -0,0 +1,1528 @@
+/*!
+  * message-compiler v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+import { format, assign, join, isString } from '@intlify/shared';
+
+const LOCATION_STUB = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 }
+};
+function createPosition(line, column, offset) {
+    return { line, column, offset };
+}
+function createLocation(start, end, source) {
+    const loc = { start, end };
+    if (source != null) {
+        loc.source = source;
+    }
+    return loc;
+}
+
+const CompileErrorCodes = {
+    // tokenizer error codes
+    EXPECTED_TOKEN: 1,
+    INVALID_TOKEN_IN_PLACEHOLDER: 2,
+    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+    UNKNOWN_ESCAPE_SEQUENCE: 4,
+    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+    UNBALANCED_CLOSING_BRACE: 6,
+    UNTERMINATED_CLOSING_BRACE: 7,
+    EMPTY_PLACEHOLDER: 8,
+    NOT_ALLOW_NEST_PLACEHOLDER: 9,
+    INVALID_LINKED_FORMAT: 10,
+    // parser error codes
+    MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+    UNEXPECTED_EMPTY_LINKED_KEY: 13,
+    UNEXPECTED_LEXICAL_ANALYSIS: 14,
+    // generator error codes
+    UNHANDLED_CODEGEN_NODE_TYPE: 15,
+    // minifier error codes
+    UNHANDLED_MINIFIER_NODE_TYPE: 16,
+    // Special value for higher-order compilers to pick up the last code
+    // to avoid collision of error codes. This should always be kept as the last
+    // item.
+    __EXTEND_POINT__: 17
+};
+/** @internal */
+const errorMessages = {
+    // tokenizer error messages
+    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+    // parser error messages
+    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+    // generator error messages
+    [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+    // minimizer error messages
+    [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+};
+function createCompileError(code, loc, options = {}) {
+    const { domain, messages, args } = options;
+    const msg = (process.env.NODE_ENV !== 'production')
+        ? format((messages || errorMessages)[code] || '', ...(args || []))
+        : code;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    if (loc) {
+        error.location = loc;
+    }
+    error.domain = domain;
+    return error;
+}
+/** @internal */
+function defaultOnError(error) {
+    throw error;
+}
+
+const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+const CHAR_SP = ' ';
+const CHAR_CR = '\r';
+const CHAR_LF = '\n';
+const CHAR_LS = String.fromCharCode(0x2028);
+const CHAR_PS = String.fromCharCode(0x2029);
+function createScanner(str) {
+    const _buf = str;
+    let _index = 0;
+    let _line = 1;
+    let _column = 1;
+    let _peekOffset = 0;
+    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+    const isLF = (index) => _buf[index] === CHAR_LF;
+    const isPS = (index) => _buf[index] === CHAR_PS;
+    const isLS = (index) => _buf[index] === CHAR_LS;
+    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+    const index = () => _index;
+    const line = () => _line;
+    const column = () => _column;
+    const peekOffset = () => _peekOffset;
+    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+    const currentChar = () => charAt(_index);
+    const currentPeek = () => charAt(_index + _peekOffset);
+    function next() {
+        _peekOffset = 0;
+        if (isLineEnd(_index)) {
+            _line++;
+            _column = 0;
+        }
+        if (isCRLF(_index)) {
+            _index++;
+        }
+        _index++;
+        _column++;
+        return _buf[_index];
+    }
+    function peek() {
+        if (isCRLF(_index + _peekOffset)) {
+            _peekOffset++;
+        }
+        _peekOffset++;
+        return _buf[_index + _peekOffset];
+    }
+    function reset() {
+        _index = 0;
+        _line = 1;
+        _column = 1;
+        _peekOffset = 0;
+    }
+    function resetPeek(offset = 0) {
+        _peekOffset = offset;
+    }
+    function skipToPeek() {
+        const target = _index + _peekOffset;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (target !== _index) {
+            next();
+        }
+        _peekOffset = 0;
+    }
+    return {
+        index,
+        line,
+        column,
+        peekOffset,
+        charAt,
+        currentChar,
+        currentPeek,
+        next,
+        peek,
+        reset,
+        resetPeek,
+        skipToPeek
+    };
+}
+
+const EOF = undefined;
+const DOT = '.';
+const LITERAL_DELIMITER = "'";
+const ERROR_DOMAIN$3 = 'tokenizer';
+function createTokenizer(source, options = {}) {
+    const location = options.location !== false;
+    const _scnr = createScanner(source);
+    const currentOffset = () => _scnr.index();
+    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+    const _initLoc = currentPosition();
+    const _initOffset = currentOffset();
+    const _context = {
+        currentType: 14 /* TokenTypes.EOF */,
+        offset: _initOffset,
+        startLoc: _initLoc,
+        endLoc: _initLoc,
+        lastType: 14 /* TokenTypes.EOF */,
+        lastOffset: _initOffset,
+        lastStartLoc: _initLoc,
+        lastEndLoc: _initLoc,
+        braceNest: 0,
+        inLinked: false,
+        text: ''
+    };
+    const context = () => _context;
+    const { onError } = options;
+    function emitError(code, pos, offset, ...args) {
+        const ctx = context();
+        pos.column += offset;
+        pos.offset += offset;
+        if (onError) {
+            const loc = location ? createLocation(ctx.startLoc, pos) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$3,
+                args
+            });
+            onError(err);
+        }
+    }
+    function getToken(context, type, value) {
+        context.endLoc = currentPosition();
+        context.currentType = type;
+        const token = { type };
+        if (location) {
+            token.loc = createLocation(context.startLoc, context.endLoc);
+        }
+        if (value != null) {
+            token.value = value;
+        }
+        return token;
+    }
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    function eat(scnr, ch) {
+        if (scnr.currentChar() === ch) {
+            scnr.next();
+            return ch;
+        }
+        else {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+            return '';
+        }
+    }
+    function peekSpaces(scnr) {
+        let buf = '';
+        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+            buf += scnr.currentPeek();
+            scnr.peek();
+        }
+        return buf;
+    }
+    function skipSpaces(scnr) {
+        const buf = peekSpaces(scnr);
+        scnr.skipToPeek();
+        return buf;
+    }
+    function isIdentifierStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return ((cc >= 97 && cc <= 122) || // a-z
+            (cc >= 65 && cc <= 90) || // A-Z
+            cc === 95 // _
+        );
+    }
+    function isNumberStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return cc >= 48 && cc <= 57; // 0-9
+    }
+    function isNamedIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isListIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+        const ret = isNumberStart(ch);
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLiteralStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDotStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedModifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDelimiterStart(scnr, context) {
+        const { currentType } = context;
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedReferStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+            return false;
+        }
+        const fn = () => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return isIdentifierStart(scnr.peek());
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
+                ch === CHAR_SP ||
+                !ch) {
+                return false;
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn();
+            }
+            else {
+                // other characters
+                return isIdentifierStart(ch);
+            }
+        };
+        const ret = fn();
+        scnr.resetPeek();
+        return ret;
+    }
+    function isPluralStart(scnr) {
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function detectModuloStart(scnr) {
+        const spaces = peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
+        scnr.resetPeek();
+        return {
+            isModulo: ret,
+            hasSpace: spaces.length > 0
+        };
+    }
+    function isTextStart(scnr, reset = true) {
+        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                scnr.peek();
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+            }
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                    ? true
+                    : !(prev === CHAR_SP || prev === CHAR_LF);
+            }
+            else if (ch === CHAR_SP) {
+                scnr.peek();
+                return fn(true, CHAR_SP, detectModulo);
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn(true, CHAR_LF, detectModulo);
+            }
+            else {
+                return true;
+            }
+        };
+        const ret = fn();
+        reset && scnr.resetPeek();
+        return ret;
+    }
+    function takeChar(scnr, fn) {
+        const ch = scnr.currentChar();
+        if (ch === EOF) {
+            return EOF;
+        }
+        if (fn(ch)) {
+            scnr.next();
+            return ch;
+        }
+        return null;
+    }
+    function takeIdentifierChar(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 97 && cc <= 122) || // a-z
+                (cc >= 65 && cc <= 90) || // A-Z
+                (cc >= 48 && cc <= 57) || // 0-9
+                cc === 95 || // _
+                cc === 36 // $
+            );
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return cc >= 48 && cc <= 57; // 0-9
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeHexDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 48 && cc <= 57) || // 0-9
+                (cc >= 65 && cc <= 70) || // A-F
+                (cc >= 97 && cc <= 102)); // a-f
+        };
+        return takeChar(scnr, closure);
+    }
+    function getDigits(scnr) {
+        let ch = '';
+        let num = '';
+        while ((ch = takeDigit(scnr))) {
+            num += ch;
+        }
+        return num;
+    }
+    function readModulo(scnr) {
+        skipSpaces(scnr);
+        const ch = scnr.currentChar();
+        if (ch !== "%" /* TokenChars.Modulo */) {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+        }
+        scnr.next();
+        return "%" /* TokenChars.Modulo */;
+    }
+    function readText(scnr) {
+        let buf = '';
+        while (true) {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                !ch) {
+                break;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === CHAR_SP || ch === CHAR_LF) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else if (isPluralStart(scnr)) {
+                    break;
+                }
+                else {
+                    buf += ch;
+                    scnr.next();
+                }
+            }
+            else {
+                buf += ch;
+                scnr.next();
+            }
+        }
+        return buf;
+    }
+    function readNamedIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return name;
+    }
+    function readListIdentifier(scnr) {
+        skipSpaces(scnr);
+        let value = '';
+        if (scnr.currentChar() === '-') {
+            scnr.next();
+            value += `-${getDigits(scnr)}`;
+        }
+        else {
+            value += getDigits(scnr);
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return value;
+    }
+    function readLiteral(scnr) {
+        skipSpaces(scnr);
+        eat(scnr, `\'`);
+        let ch = '';
+        let literal = '';
+        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+        while ((ch = takeChar(scnr, fn))) {
+            if (ch === '\\') {
+                literal += readEscapeSequence(scnr);
+            }
+            else {
+                literal += ch;
+            }
+        }
+        const current = scnr.currentChar();
+        if (current === CHAR_LF || current === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+            // TODO: Is it correct really?
+            if (current === CHAR_LF) {
+                scnr.next();
+                eat(scnr, `\'`);
+            }
+            return literal;
+        }
+        eat(scnr, `\'`);
+        return literal;
+    }
+    function readEscapeSequence(scnr) {
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case '\\':
+            case `\'`:
+                scnr.next();
+                return `\\${ch}`;
+            case 'u':
+                return readUnicodeEscapeSequence(scnr, ch, 4);
+            case 'U':
+                return readUnicodeEscapeSequence(scnr, ch, 6);
+            default:
+                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                return '';
+        }
+    }
+    function readUnicodeEscapeSequence(scnr, unicode, digits) {
+        eat(scnr, unicode);
+        let sequence = '';
+        for (let i = 0; i < digits; i++) {
+            const ch = takeHexDigit(scnr);
+            if (!ch) {
+                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                break;
+            }
+            sequence += ch;
+        }
+        return `\\${unicode}${sequence}`;
+    }
+    function readInvalidIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let identifiers = '';
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
+            ch !== CHAR_SP &&
+            ch !== CHAR_LF;
+        while ((ch = takeChar(scnr, closure))) {
+            identifiers += ch;
+        }
+        return identifiers;
+    }
+    function readLinkedModifier(scnr) {
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        return name;
+    }
+    function readLinkedRefer(scnr) {
+        const fn = (detect = false, buf) => {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === "(" /* TokenChars.ParenLeft */ ||
+                ch === ")" /* TokenChars.ParenRight */ ||
+                !ch) {
+                return buf;
+            }
+            else if (ch === CHAR_SP) {
+                return buf;
+            }
+            else if (ch === CHAR_LF || ch === DOT) {
+                buf += ch;
+                scnr.next();
+                return fn(detect, buf);
+            }
+            else {
+                buf += ch;
+                scnr.next();
+                return fn(true, buf);
+            }
+        };
+        return fn(false, '');
+    }
+    function readPlural(scnr) {
+        skipSpaces(scnr);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+        skipSpaces(scnr);
+        return plural;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInPlaceholder(scnr, context) {
+        let token = null;
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                if (context.braceNest >= 1) {
+                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                skipSpaces(scnr);
+                context.braceNest++;
+                return token;
+            case "}" /* TokenChars.BraceRight */:
+                if (context.braceNest > 0 &&
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                context.braceNest--;
+                context.braceNest > 0 && skipSpaces(scnr);
+                if (context.inLinked && context.braceNest === 0) {
+                    context.inLinked = false;
+                }
+                return token;
+            case "@" /* TokenChars.LinkedAlias */:
+                if (context.braceNest > 0) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                }
+                token = readTokenInLinked(scnr, context) || getEndToken(context);
+                context.braceNest = 0;
+                return token;
+            default:
+                let validNamedIdentifier = true;
+                let validListIdentifier = true;
+                let validLiteral = true;
+                if (isPluralStart(scnr)) {
+                    if (context.braceNest > 0) {
+                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    }
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (context.braceNest > 0 &&
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    context.braceNest = 0;
+                    return readToken(scnr, context);
+                }
+                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validLiteral = isLiteralStart(scnr, context))) {
+                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                    skipSpaces(scnr);
+                    return token;
+                }
+                break;
+        }
+        return token;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInLinked(scnr, context) {
+        const { currentType } = context;
+        let token = null;
+        const ch = scnr.currentChar();
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+            (ch === CHAR_LF || ch === CHAR_SP)) {
+            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+        }
+        switch (ch) {
+            case "@" /* TokenChars.LinkedAlias */:
+                scnr.next();
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                context.inLinked = true;
+                return token;
+            case "." /* TokenChars.LinkedDot */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (isLinkedDotStart(scnr, context) ||
+                    isLinkedDelimiterStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return readTokenInLinked(scnr, context);
+                }
+                if (isLinkedModifierStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                }
+                if (isLinkedReferStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
+                        // scan the placeholder
+                        return readTokenInPlaceholder(scnr, context) || token;
+                    }
+                    else {
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                    }
+                }
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                }
+                context.braceNest = 0;
+                context.inLinked = false;
+                return readToken(scnr, context);
+        }
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readToken(scnr, context) {
+        let token = { type: 14 /* TokenTypes.EOF */ };
+        if (context.braceNest > 0) {
+            return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+        }
+        if (context.inLinked) {
+            return readTokenInLinked(scnr, context) || getEndToken(context);
+        }
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+            case "}" /* TokenChars.BraceRight */:
+                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                scnr.next();
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
+                return readTokenInLinked(scnr, context) || getEndToken(context);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                const { isModulo, hasSpace } = detectModuloStart(scnr);
+                if (isModulo) {
+                    return hasSpace
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                }
+                if (isTextStart(scnr)) {
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                }
+                break;
+        }
+        return token;
+    }
+    function nextToken() {
+        const { currentType, offset, startLoc, endLoc } = _context;
+        _context.lastType = currentType;
+        _context.lastOffset = offset;
+        _context.lastStartLoc = startLoc;
+        _context.lastEndLoc = endLoc;
+        _context.offset = currentOffset();
+        _context.startLoc = currentPosition();
+        if (_scnr.currentChar() === EOF) {
+            return getToken(_context, 14 /* TokenTypes.EOF */);
+        }
+        return readToken(_scnr, _context);
+    }
+    return {
+        nextToken,
+        currentOffset,
+        currentPosition,
+        context
+    };
+}
+
+const ERROR_DOMAIN$2 = 'parser';
+// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+function fromEscapeSequence(match, codePoint4, codePoint6) {
+    switch (match) {
+        case `\\\\`:
+            return `\\`;
+        case `\\\'`:
+            return `\'`;
+        default: {
+            const codePoint = parseInt(codePoint4 || codePoint6, 16);
+            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                return String.fromCodePoint(codePoint);
+            }
+            // invalid ...
+            // Replace them with U+FFFD REPLACEMENT CHARACTER.
+            return '�';
+        }
+    }
+}
+function createParser(options = {}) {
+    const location = options.location !== false;
+    const { onError } = options;
+    function emitError(tokenzer, code, start, offset, ...args) {
+        const end = tokenzer.currentPosition();
+        end.offset += offset;
+        end.column += offset;
+        if (onError) {
+            const loc = location ? createLocation(start, end) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$2,
+                args
+            });
+            onError(err);
+        }
+    }
+    function startNode(type, offset, loc) {
+        const node = { type };
+        if (location) {
+            node.start = offset;
+            node.end = offset;
+            node.loc = { start: loc, end: loc };
+        }
+        return node;
+    }
+    function endNode(node, offset, pos, type) {
+        if (type) {
+            node.type = type;
+        }
+        if (location) {
+            node.end = offset;
+            if (node.loc) {
+                node.loc.end = pos;
+            }
+        }
+    }
+    function parseText(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseList(tokenizer, index) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
+        node.index = parseInt(index, 10);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseNamed(tokenizer, key) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+        node.key = key;
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLiteral(tokenizer, value) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinkedModifier(tokenizer) {
+        const token = tokenizer.nextToken();
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+            // empty modifier
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+            node.value = '';
+            endNode(node, offset, loc);
+            return {
+                nextConsumeToken: token,
+                node
+            };
+        }
+        // check token
+        if (token.value == null) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        node.value = token.value || '';
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node
+        };
+    }
+    function parseLinkedKey(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinked(tokenizer) {
+        const context = tokenizer.context();
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+        let token = tokenizer.nextToken();
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+            const parsed = parseLinkedModifier(tokenizer);
+            linkedNode.modifier = parsed.node;
+            token = parsed.nextConsumeToken || tokenizer.nextToken();
+        }
+        // asset check token
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        token = tokenizer.nextToken();
+        // skip brace left
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
+            token = tokenizer.nextToken();
+        }
+        switch (token.type) {
+            case 11 /* TokenTypes.LinkedKey */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                break;
+            case 5 /* TokenTypes.Named */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseNamed(tokenizer, token.value || '');
+                break;
+            case 6 /* TokenTypes.List */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseList(tokenizer, token.value || '');
+                break;
+            case 7 /* TokenTypes.Literal */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                break;
+            default:
+                // empty key
+                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                const nextContext = tokenizer.context();
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                emptyLinkedKeyNode.value = '';
+                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                linkedNode.key = emptyLinkedKeyNode;
+                endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                return {
+                    nextConsumeToken: token,
+                    node: linkedNode
+                };
+        }
+        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node: linkedNode
+        };
+    }
+    function parseMessage(tokenizer) {
+        const context = tokenizer.context();
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? tokenizer.currentOffset()
+            : context.offset;
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.endLoc
+            : context.startLoc;
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+        node.items = [];
+        let nextToken = null;
+        do {
+            const token = nextToken || tokenizer.nextToken();
+            nextToken = null;
+            switch (token.type) {
+                case 0 /* TokenTypes.Text */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseText(tokenizer, token.value || ''));
+                    break;
+                case 6 /* TokenTypes.List */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseList(tokenizer, token.value || ''));
+                    break;
+                case 5 /* TokenTypes.Named */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
+                    break;
+                case 7 /* TokenTypes.Literal */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseLiteral(tokenizer, token.value || ''));
+                    break;
+                case 8 /* TokenTypes.LinkedAlias */:
+                    const parsed = parseLinked(tokenizer);
+                    node.items.push(parsed.node);
+                    nextToken = parsed.nextConsumeToken || null;
+                    break;
+            }
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
+        // adjust message node loc
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastOffset
+            : tokenizer.currentOffset();
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastEndLoc
+            : tokenizer.currentPosition();
+        endNode(node, endOffset, endLoc);
+        return node;
+    }
+    function parsePlural(tokenizer, offset, loc, msgNode) {
+        const context = tokenizer.context();
+        let hasEmptyMessage = msgNode.items.length === 0;
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+        node.cases = [];
+        node.cases.push(msgNode);
+        do {
+            const msg = parseMessage(tokenizer);
+            if (!hasEmptyMessage) {
+                hasEmptyMessage = msg.items.length === 0;
+            }
+            node.cases.push(msg);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        if (hasEmptyMessage) {
+            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseResource(tokenizer) {
+        const context = tokenizer.context();
+        const { offset, startLoc } = context;
+        const msgNode = parseMessage(tokenizer);
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
+            return msgNode;
+        }
+        else {
+            return parsePlural(tokenizer, offset, startLoc, msgNode);
+        }
+    }
+    function parse(source) {
+        const tokenizer = createTokenizer(source, assign({}, options));
+        const context = tokenizer.context();
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+        if (location && node.loc) {
+            node.loc.source = source;
+        }
+        node.body = parseResource(tokenizer);
+        if (options.onCacheKey) {
+            node.cacheKey = options.onCacheKey(source);
+        }
+        // assert whether achieved to EOF
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    return { parse };
+}
+function getTokenCaption(token) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
+        return 'EOF';
+    }
+    const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+    return name.length > 10 ? name.slice(0, 9) + '…' : name;
+}
+
+function createTransformer(ast, options = {} // eslint-disable-line
+) {
+    const _context = {
+        ast,
+        helpers: new Set()
+    };
+    const context = () => _context;
+    const helper = (name) => {
+        _context.helpers.add(name);
+        return name;
+    };
+    return { context, helper };
+}
+function traverseNodes(nodes, transformer) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], transformer);
+    }
+}
+function traverseNode(node, transformer) {
+    // TODO: if we need pre-hook of transform, should be implemented to here
+    switch (node.type) {
+        case 1 /* NodeTypes.Plural */:
+            traverseNodes(node.cases, transformer);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
+            break;
+        case 2 /* NodeTypes.Message */:
+            traverseNodes(node.items, transformer);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            traverseNode(linked.key, transformer);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
+            break;
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
+            break;
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
+            break;
+    }
+    // TODO: if we need post-hook of transform, should be implemented to here
+}
+// transform AST
+function transform(ast, options = {} // eslint-disable-line
+) {
+    const transformer = createTransformer(ast);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+    // traverse
+    ast.body && traverseNode(ast.body, transformer);
+    // set meta information
+    const context = transformer.context();
+    ast.helpers = Array.from(context.helpers);
+}
+
+function optimize(ast) {
+    const body = ast.body;
+    if (body.type === 2 /* NodeTypes.Message */) {
+        optimizeMessageNode(body);
+    }
+    else {
+        body.cases.forEach(c => optimizeMessageNode(c));
+    }
+    return ast;
+}
+function optimizeMessageNode(message) {
+    if (message.items.length === 1) {
+        const item = message.items[0];
+        if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+            message.static = item.value;
+            delete item.value; // optimization for size
+        }
+    }
+    else {
+        const values = [];
+        for (let i = 0; i < message.items.length; i++) {
+            const item = message.items[i];
+            if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                break;
+            }
+            if (item.value == null) {
+                break;
+            }
+            values.push(item.value);
+        }
+        if (values.length === message.items.length) {
+            message.static = join(values);
+            for (let i = 0; i < message.items.length; i++) {
+                const item = message.items[i];
+                if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                    delete item.value; // optimization for size
+                }
+            }
+        }
+    }
+}
+
+const ERROR_DOMAIN$1 = 'minifier';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function minify(node) {
+    node.t = node.type;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            const resource = node;
+            minify(resource.body);
+            resource.b = resource.body;
+            delete resource.body;
+            break;
+        case 1 /* NodeTypes.Plural */:
+            const plural = node;
+            const cases = plural.cases;
+            for (let i = 0; i < cases.length; i++) {
+                minify(cases[i]);
+            }
+            plural.c = cases;
+            delete plural.cases;
+            break;
+        case 2 /* NodeTypes.Message */:
+            const message = node;
+            const items = message.items;
+            for (let i = 0; i < items.length; i++) {
+                minify(items[i]);
+            }
+            message.i = items;
+            delete message.items;
+            if (message.static) {
+                message.s = message.static;
+                delete message.static;
+            }
+            break;
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            const valueNode = node;
+            if (valueNode.value) {
+                valueNode.v = valueNode.value;
+                delete valueNode.value;
+            }
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            minify(linked.key);
+            linked.k = linked.key;
+            delete linked.key;
+            if (linked.modifier) {
+                minify(linked.modifier);
+                linked.m = linked.modifier;
+                delete linked.modifier;
+            }
+            break;
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            list.i = list.index;
+            delete list.index;
+            break;
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            named.k = named.key;
+            delete named.key;
+            break;
+        default:
+            if ((process.env.NODE_ENV !== 'production')) {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN$1,
+                    args: [node.type]
+                });
+            }
+    }
+    delete node.type;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const ERROR_DOMAIN = 'parser';
+function createCodeGenerator(ast, options) {
+    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+    const location = options.location !== false;
+    const _context = {
+        filename,
+        code: '',
+        column: 1,
+        line: 1,
+        offset: 0,
+        map: undefined,
+        breakLineCode,
+        needIndent: _needIndent,
+        indentLevel: 0
+    };
+    if (location && ast.loc) {
+        _context.source = ast.loc.source;
+    }
+    const context = () => _context;
+    function push(code, node) {
+        _context.code += code;
+    }
+    function _newline(n, withBreakLine = true) {
+        const _breakLineCode = withBreakLine ? breakLineCode : '';
+        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+    }
+    function indent(withNewLine = true) {
+        const level = ++_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function deindent(withNewLine = true) {
+        const level = --_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function newline() {
+        _newline(_context.indentLevel);
+    }
+    const helper = (key) => `_${key}`;
+    const needIndent = () => _context.needIndent;
+    return {
+        context,
+        push,
+        indent,
+        deindent,
+        newline,
+        helper,
+        needIndent
+    };
+}
+function generateLinkedNode(generator, node) {
+    const { helper } = generator;
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+    generateNode(generator, node.key);
+    if (node.modifier) {
+        generator.push(`, `);
+        generateNode(generator, node.modifier);
+        generator.push(`, _type`);
+    }
+    else {
+        generator.push(`, undefined, _type`);
+    }
+    generator.push(`)`);
+}
+function generateMessageNode(generator, node) {
+    const { helper, needIndent } = generator;
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+    generator.indent(needIndent());
+    const length = node.items.length;
+    for (let i = 0; i < length; i++) {
+        generateNode(generator, node.items[i]);
+        if (i === length - 1) {
+            break;
+        }
+        generator.push(', ');
+    }
+    generator.deindent(needIndent());
+    generator.push('])');
+}
+function generatePluralNode(generator, node) {
+    const { helper, needIndent } = generator;
+    if (node.cases.length > 1) {
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+        generator.indent(needIndent());
+        const length = node.cases.length;
+        for (let i = 0; i < length; i++) {
+            generateNode(generator, node.cases[i]);
+            if (i === length - 1) {
+                break;
+            }
+            generator.push(', ');
+        }
+        generator.deindent(needIndent());
+        generator.push(`])`);
+    }
+}
+function generateResource(generator, node) {
+    if (node.body) {
+        generateNode(generator, node.body);
+    }
+    else {
+        generator.push('null');
+    }
+}
+function generateNode(generator, node) {
+    const { helper } = generator;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            generateResource(generator, node);
+            break;
+        case 1 /* NodeTypes.Plural */:
+            generatePluralNode(generator, node);
+            break;
+        case 2 /* NodeTypes.Message */:
+            generateMessageNode(generator, node);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            generateLinkedNode(generator, node);
+            break;
+        case 8 /* NodeTypes.LinkedModifier */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 7 /* NodeTypes.LinkedKey */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+            break;
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+            break;
+        case 9 /* NodeTypes.Literal */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 3 /* NodeTypes.Text */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        default:
+            if ((process.env.NODE_ENV !== 'production')) {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN,
+                    args: [node.type]
+                });
+            }
+    }
+}
+// generate code from AST
+const generate = (ast, options = {} // eslint-disable-line
+) => {
+    const mode = isString(options.mode) ? options.mode : 'normal';
+    const filename = isString(options.filename)
+        ? options.filename
+        : 'message.intl';
+    const sourceMap = !!options.sourceMap;
+    // prettier-ignore
+    const breakLineCode = options.breakLineCode != null
+        ? options.breakLineCode
+        : mode === 'arrow'
+            ? ';'
+            : '\n';
+    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+    const helpers = ast.helpers || [];
+    const generator = createCodeGenerator(ast, {
+        mode,
+        filename,
+        sourceMap,
+        breakLineCode,
+        needIndent
+    });
+    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+    generator.indent(needIndent);
+    if (helpers.length > 0) {
+        generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+        generator.newline();
+    }
+    generator.push(`return `);
+    generateNode(generator, ast);
+    generator.deindent(needIndent);
+    generator.push(`}`);
+    delete ast.helpers;
+    const { code, map } = generator.context();
+    return {
+        ast,
+        code,
+        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+    };
+};
+
+function baseCompile(source, options = {}) {
+    const assignedOptions = assign({}, options);
+    const jit = !!assignedOptions.jit;
+    const enalbeMinify = !!assignedOptions.minify;
+    const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+    // parse source codes
+    const parser = createParser(assignedOptions);
+    const ast = parser.parse(source);
+    if (!jit) {
+        // transform ASTs
+        transform(ast, assignedOptions);
+        // generate javascript codes
+        return generate(ast, assignedOptions);
+    }
+    else {
+        // optimize ASTs
+        enambeOptimize && optimize(ast);
+        // minimize ASTs
+        enalbeMinify && minify(ast);
+        // In JIT mode, no ast transform, no code generation.
+        return { ast, code: '' };
+    }
+}
+
+export { CompileErrorCodes, ERROR_DOMAIN$2 as ERROR_DOMAIN, LOCATION_STUB, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, detectHtmlTag, errorMessages };

node_modules/@intlify/message-compiler/dist/message-compiler.node.mjs

@@ -0,0 +1,1585 @@
+/*!
+  * message-compiler v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+import { format, assign, join, isString } from '@intlify/shared';
+import { SourceMapGenerator } from 'source-map-js';
+
+const LOCATION_STUB = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 }
+};
+function createPosition(line, column, offset) {
+    return { line, column, offset };
+}
+function createLocation(start, end, source) {
+    const loc = { start, end };
+    if (source != null) {
+        loc.source = source;
+    }
+    return loc;
+}
+
+const CompileErrorCodes = {
+    // tokenizer error codes
+    EXPECTED_TOKEN: 1,
+    INVALID_TOKEN_IN_PLACEHOLDER: 2,
+    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+    UNKNOWN_ESCAPE_SEQUENCE: 4,
+    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+    UNBALANCED_CLOSING_BRACE: 6,
+    UNTERMINATED_CLOSING_BRACE: 7,
+    EMPTY_PLACEHOLDER: 8,
+    NOT_ALLOW_NEST_PLACEHOLDER: 9,
+    INVALID_LINKED_FORMAT: 10,
+    // parser error codes
+    MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+    UNEXPECTED_EMPTY_LINKED_KEY: 13,
+    UNEXPECTED_LEXICAL_ANALYSIS: 14,
+    // generator error codes
+    UNHANDLED_CODEGEN_NODE_TYPE: 15,
+    // minifier error codes
+    UNHANDLED_MINIFIER_NODE_TYPE: 16,
+    // Special value for higher-order compilers to pick up the last code
+    // to avoid collision of error codes. This should always be kept as the last
+    // item.
+    __EXTEND_POINT__: 17
+};
+/** @internal */
+const errorMessages = {
+    // tokenizer error messages
+    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+    // parser error messages
+    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+    // generator error messages
+    [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+    // minimizer error messages
+    [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+};
+function createCompileError(code, loc, options = {}) {
+    const { domain, messages, args } = options;
+    const msg = (process.env.NODE_ENV !== 'production')
+        ? format((messages || errorMessages)[code] || '', ...(args || []))
+        : code;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    if (loc) {
+        error.location = loc;
+    }
+    error.domain = domain;
+    return error;
+}
+/** @internal */
+function defaultOnError(error) {
+    throw error;
+}
+
+const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+const CHAR_SP = ' ';
+const CHAR_CR = '\r';
+const CHAR_LF = '\n';
+const CHAR_LS = String.fromCharCode(0x2028);
+const CHAR_PS = String.fromCharCode(0x2029);
+function createScanner(str) {
+    const _buf = str;
+    let _index = 0;
+    let _line = 1;
+    let _column = 1;
+    let _peekOffset = 0;
+    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+    const isLF = (index) => _buf[index] === CHAR_LF;
+    const isPS = (index) => _buf[index] === CHAR_PS;
+    const isLS = (index) => _buf[index] === CHAR_LS;
+    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+    const index = () => _index;
+    const line = () => _line;
+    const column = () => _column;
+    const peekOffset = () => _peekOffset;
+    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+    const currentChar = () => charAt(_index);
+    const currentPeek = () => charAt(_index + _peekOffset);
+    function next() {
+        _peekOffset = 0;
+        if (isLineEnd(_index)) {
+            _line++;
+            _column = 0;
+        }
+        if (isCRLF(_index)) {
+            _index++;
+        }
+        _index++;
+        _column++;
+        return _buf[_index];
+    }
+    function peek() {
+        if (isCRLF(_index + _peekOffset)) {
+            _peekOffset++;
+        }
+        _peekOffset++;
+        return _buf[_index + _peekOffset];
+    }
+    function reset() {
+        _index = 0;
+        _line = 1;
+        _column = 1;
+        _peekOffset = 0;
+    }
+    function resetPeek(offset = 0) {
+        _peekOffset = offset;
+    }
+    function skipToPeek() {
+        const target = _index + _peekOffset;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (target !== _index) {
+            next();
+        }
+        _peekOffset = 0;
+    }
+    return {
+        index,
+        line,
+        column,
+        peekOffset,
+        charAt,
+        currentChar,
+        currentPeek,
+        next,
+        peek,
+        reset,
+        resetPeek,
+        skipToPeek
+    };
+}
+
+const EOF = undefined;
+const DOT = '.';
+const LITERAL_DELIMITER = "'";
+const ERROR_DOMAIN$3 = 'tokenizer';
+function createTokenizer(source, options = {}) {
+    const location = options.location !== false;
+    const _scnr = createScanner(source);
+    const currentOffset = () => _scnr.index();
+    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+    const _initLoc = currentPosition();
+    const _initOffset = currentOffset();
+    const _context = {
+        currentType: 14 /* TokenTypes.EOF */,
+        offset: _initOffset,
+        startLoc: _initLoc,
+        endLoc: _initLoc,
+        lastType: 14 /* TokenTypes.EOF */,
+        lastOffset: _initOffset,
+        lastStartLoc: _initLoc,
+        lastEndLoc: _initLoc,
+        braceNest: 0,
+        inLinked: false,
+        text: ''
+    };
+    const context = () => _context;
+    const { onError } = options;
+    function emitError(code, pos, offset, ...args) {
+        const ctx = context();
+        pos.column += offset;
+        pos.offset += offset;
+        if (onError) {
+            const loc = location ? createLocation(ctx.startLoc, pos) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$3,
+                args
+            });
+            onError(err);
+        }
+    }
+    function getToken(context, type, value) {
+        context.endLoc = currentPosition();
+        context.currentType = type;
+        const token = { type };
+        if (location) {
+            token.loc = createLocation(context.startLoc, context.endLoc);
+        }
+        if (value != null) {
+            token.value = value;
+        }
+        return token;
+    }
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    function eat(scnr, ch) {
+        if (scnr.currentChar() === ch) {
+            scnr.next();
+            return ch;
+        }
+        else {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+            return '';
+        }
+    }
+    function peekSpaces(scnr) {
+        let buf = '';
+        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+            buf += scnr.currentPeek();
+            scnr.peek();
+        }
+        return buf;
+    }
+    function skipSpaces(scnr) {
+        const buf = peekSpaces(scnr);
+        scnr.skipToPeek();
+        return buf;
+    }
+    function isIdentifierStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return ((cc >= 97 && cc <= 122) || // a-z
+            (cc >= 65 && cc <= 90) || // A-Z
+            cc === 95 // _
+        );
+    }
+    function isNumberStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return cc >= 48 && cc <= 57; // 0-9
+    }
+    function isNamedIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isListIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+        const ret = isNumberStart(ch);
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLiteralStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDotStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedModifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDelimiterStart(scnr, context) {
+        const { currentType } = context;
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedReferStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+            return false;
+        }
+        const fn = () => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return isIdentifierStart(scnr.peek());
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
+                ch === CHAR_SP ||
+                !ch) {
+                return false;
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn();
+            }
+            else {
+                // other characters
+                return isIdentifierStart(ch);
+            }
+        };
+        const ret = fn();
+        scnr.resetPeek();
+        return ret;
+    }
+    function isPluralStart(scnr) {
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function detectModuloStart(scnr) {
+        const spaces = peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
+        scnr.resetPeek();
+        return {
+            isModulo: ret,
+            hasSpace: spaces.length > 0
+        };
+    }
+    function isTextStart(scnr, reset = true) {
+        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                scnr.peek();
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+            }
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                    ? true
+                    : !(prev === CHAR_SP || prev === CHAR_LF);
+            }
+            else if (ch === CHAR_SP) {
+                scnr.peek();
+                return fn(true, CHAR_SP, detectModulo);
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn(true, CHAR_LF, detectModulo);
+            }
+            else {
+                return true;
+            }
+        };
+        const ret = fn();
+        reset && scnr.resetPeek();
+        return ret;
+    }
+    function takeChar(scnr, fn) {
+        const ch = scnr.currentChar();
+        if (ch === EOF) {
+            return EOF;
+        }
+        if (fn(ch)) {
+            scnr.next();
+            return ch;
+        }
+        return null;
+    }
+    function takeIdentifierChar(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 97 && cc <= 122) || // a-z
+                (cc >= 65 && cc <= 90) || // A-Z
+                (cc >= 48 && cc <= 57) || // 0-9
+                cc === 95 || // _
+                cc === 36 // $
+            );
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return cc >= 48 && cc <= 57; // 0-9
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeHexDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 48 && cc <= 57) || // 0-9
+                (cc >= 65 && cc <= 70) || // A-F
+                (cc >= 97 && cc <= 102)); // a-f
+        };
+        return takeChar(scnr, closure);
+    }
+    function getDigits(scnr) {
+        let ch = '';
+        let num = '';
+        while ((ch = takeDigit(scnr))) {
+            num += ch;
+        }
+        return num;
+    }
+    function readModulo(scnr) {
+        skipSpaces(scnr);
+        const ch = scnr.currentChar();
+        if (ch !== "%" /* TokenChars.Modulo */) {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+        }
+        scnr.next();
+        return "%" /* TokenChars.Modulo */;
+    }
+    function readText(scnr) {
+        let buf = '';
+        while (true) {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                !ch) {
+                break;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === CHAR_SP || ch === CHAR_LF) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else if (isPluralStart(scnr)) {
+                    break;
+                }
+                else {
+                    buf += ch;
+                    scnr.next();
+                }
+            }
+            else {
+                buf += ch;
+                scnr.next();
+            }
+        }
+        return buf;
+    }
+    function readNamedIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return name;
+    }
+    function readListIdentifier(scnr) {
+        skipSpaces(scnr);
+        let value = '';
+        if (scnr.currentChar() === '-') {
+            scnr.next();
+            value += `-${getDigits(scnr)}`;
+        }
+        else {
+            value += getDigits(scnr);
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return value;
+    }
+    function readLiteral(scnr) {
+        skipSpaces(scnr);
+        eat(scnr, `\'`);
+        let ch = '';
+        let literal = '';
+        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+        while ((ch = takeChar(scnr, fn))) {
+            if (ch === '\\') {
+                literal += readEscapeSequence(scnr);
+            }
+            else {
+                literal += ch;
+            }
+        }
+        const current = scnr.currentChar();
+        if (current === CHAR_LF || current === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+            // TODO: Is it correct really?
+            if (current === CHAR_LF) {
+                scnr.next();
+                eat(scnr, `\'`);
+            }
+            return literal;
+        }
+        eat(scnr, `\'`);
+        return literal;
+    }
+    function readEscapeSequence(scnr) {
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case '\\':
+            case `\'`:
+                scnr.next();
+                return `\\${ch}`;
+            case 'u':
+                return readUnicodeEscapeSequence(scnr, ch, 4);
+            case 'U':
+                return readUnicodeEscapeSequence(scnr, ch, 6);
+            default:
+                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                return '';
+        }
+    }
+    function readUnicodeEscapeSequence(scnr, unicode, digits) {
+        eat(scnr, unicode);
+        let sequence = '';
+        for (let i = 0; i < digits; i++) {
+            const ch = takeHexDigit(scnr);
+            if (!ch) {
+                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                break;
+            }
+            sequence += ch;
+        }
+        return `\\${unicode}${sequence}`;
+    }
+    function readInvalidIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let identifiers = '';
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
+            ch !== CHAR_SP &&
+            ch !== CHAR_LF;
+        while ((ch = takeChar(scnr, closure))) {
+            identifiers += ch;
+        }
+        return identifiers;
+    }
+    function readLinkedModifier(scnr) {
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        return name;
+    }
+    function readLinkedRefer(scnr) {
+        const fn = (detect = false, buf) => {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === "(" /* TokenChars.ParenLeft */ ||
+                ch === ")" /* TokenChars.ParenRight */ ||
+                !ch) {
+                return buf;
+            }
+            else if (ch === CHAR_SP) {
+                return buf;
+            }
+            else if (ch === CHAR_LF || ch === DOT) {
+                buf += ch;
+                scnr.next();
+                return fn(detect, buf);
+            }
+            else {
+                buf += ch;
+                scnr.next();
+                return fn(true, buf);
+            }
+        };
+        return fn(false, '');
+    }
+    function readPlural(scnr) {
+        skipSpaces(scnr);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+        skipSpaces(scnr);
+        return plural;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInPlaceholder(scnr, context) {
+        let token = null;
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                if (context.braceNest >= 1) {
+                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                skipSpaces(scnr);
+                context.braceNest++;
+                return token;
+            case "}" /* TokenChars.BraceRight */:
+                if (context.braceNest > 0 &&
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                context.braceNest--;
+                context.braceNest > 0 && skipSpaces(scnr);
+                if (context.inLinked && context.braceNest === 0) {
+                    context.inLinked = false;
+                }
+                return token;
+            case "@" /* TokenChars.LinkedAlias */:
+                if (context.braceNest > 0) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                }
+                token = readTokenInLinked(scnr, context) || getEndToken(context);
+                context.braceNest = 0;
+                return token;
+            default:
+                let validNamedIdentifier = true;
+                let validListIdentifier = true;
+                let validLiteral = true;
+                if (isPluralStart(scnr)) {
+                    if (context.braceNest > 0) {
+                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    }
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (context.braceNest > 0 &&
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    context.braceNest = 0;
+                    return readToken(scnr, context);
+                }
+                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validLiteral = isLiteralStart(scnr, context))) {
+                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                    skipSpaces(scnr);
+                    return token;
+                }
+                break;
+        }
+        return token;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInLinked(scnr, context) {
+        const { currentType } = context;
+        let token = null;
+        const ch = scnr.currentChar();
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+            (ch === CHAR_LF || ch === CHAR_SP)) {
+            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+        }
+        switch (ch) {
+            case "@" /* TokenChars.LinkedAlias */:
+                scnr.next();
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                context.inLinked = true;
+                return token;
+            case "." /* TokenChars.LinkedDot */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (isLinkedDotStart(scnr, context) ||
+                    isLinkedDelimiterStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return readTokenInLinked(scnr, context);
+                }
+                if (isLinkedModifierStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                }
+                if (isLinkedReferStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
+                        // scan the placeholder
+                        return readTokenInPlaceholder(scnr, context) || token;
+                    }
+                    else {
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                    }
+                }
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                }
+                context.braceNest = 0;
+                context.inLinked = false;
+                return readToken(scnr, context);
+        }
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readToken(scnr, context) {
+        let token = { type: 14 /* TokenTypes.EOF */ };
+        if (context.braceNest > 0) {
+            return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+        }
+        if (context.inLinked) {
+            return readTokenInLinked(scnr, context) || getEndToken(context);
+        }
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+            case "}" /* TokenChars.BraceRight */:
+                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                scnr.next();
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
+                return readTokenInLinked(scnr, context) || getEndToken(context);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                const { isModulo, hasSpace } = detectModuloStart(scnr);
+                if (isModulo) {
+                    return hasSpace
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                }
+                if (isTextStart(scnr)) {
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                }
+                break;
+        }
+        return token;
+    }
+    function nextToken() {
+        const { currentType, offset, startLoc, endLoc } = _context;
+        _context.lastType = currentType;
+        _context.lastOffset = offset;
+        _context.lastStartLoc = startLoc;
+        _context.lastEndLoc = endLoc;
+        _context.offset = currentOffset();
+        _context.startLoc = currentPosition();
+        if (_scnr.currentChar() === EOF) {
+            return getToken(_context, 14 /* TokenTypes.EOF */);
+        }
+        return readToken(_scnr, _context);
+    }
+    return {
+        nextToken,
+        currentOffset,
+        currentPosition,
+        context
+    };
+}
+
+const ERROR_DOMAIN$2 = 'parser';
+// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+function fromEscapeSequence(match, codePoint4, codePoint6) {
+    switch (match) {
+        case `\\\\`:
+            return `\\`;
+        case `\\\'`:
+            return `\'`;
+        default: {
+            const codePoint = parseInt(codePoint4 || codePoint6, 16);
+            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                return String.fromCodePoint(codePoint);
+            }
+            // invalid ...
+            // Replace them with U+FFFD REPLACEMENT CHARACTER.
+            return '�';
+        }
+    }
+}
+function createParser(options = {}) {
+    const location = options.location !== false;
+    const { onError } = options;
+    function emitError(tokenzer, code, start, offset, ...args) {
+        const end = tokenzer.currentPosition();
+        end.offset += offset;
+        end.column += offset;
+        if (onError) {
+            const loc = location ? createLocation(start, end) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$2,
+                args
+            });
+            onError(err);
+        }
+    }
+    function startNode(type, offset, loc) {
+        const node = { type };
+        if (location) {
+            node.start = offset;
+            node.end = offset;
+            node.loc = { start: loc, end: loc };
+        }
+        return node;
+    }
+    function endNode(node, offset, pos, type) {
+        if (type) {
+            node.type = type;
+        }
+        if (location) {
+            node.end = offset;
+            if (node.loc) {
+                node.loc.end = pos;
+            }
+        }
+    }
+    function parseText(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseList(tokenizer, index) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
+        node.index = parseInt(index, 10);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseNamed(tokenizer, key) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+        node.key = key;
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLiteral(tokenizer, value) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinkedModifier(tokenizer) {
+        const token = tokenizer.nextToken();
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+            // empty modifier
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+            node.value = '';
+            endNode(node, offset, loc);
+            return {
+                nextConsumeToken: token,
+                node
+            };
+        }
+        // check token
+        if (token.value == null) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        node.value = token.value || '';
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node
+        };
+    }
+    function parseLinkedKey(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinked(tokenizer) {
+        const context = tokenizer.context();
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+        let token = tokenizer.nextToken();
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+            const parsed = parseLinkedModifier(tokenizer);
+            linkedNode.modifier = parsed.node;
+            token = parsed.nextConsumeToken || tokenizer.nextToken();
+        }
+        // asset check token
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        token = tokenizer.nextToken();
+        // skip brace left
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
+            token = tokenizer.nextToken();
+        }
+        switch (token.type) {
+            case 11 /* TokenTypes.LinkedKey */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                break;
+            case 5 /* TokenTypes.Named */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseNamed(tokenizer, token.value || '');
+                break;
+            case 6 /* TokenTypes.List */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseList(tokenizer, token.value || '');
+                break;
+            case 7 /* TokenTypes.Literal */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                break;
+            default:
+                // empty key
+                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                const nextContext = tokenizer.context();
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                emptyLinkedKeyNode.value = '';
+                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                linkedNode.key = emptyLinkedKeyNode;
+                endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                return {
+                    nextConsumeToken: token,
+                    node: linkedNode
+                };
+        }
+        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node: linkedNode
+        };
+    }
+    function parseMessage(tokenizer) {
+        const context = tokenizer.context();
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? tokenizer.currentOffset()
+            : context.offset;
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.endLoc
+            : context.startLoc;
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+        node.items = [];
+        let nextToken = null;
+        do {
+            const token = nextToken || tokenizer.nextToken();
+            nextToken = null;
+            switch (token.type) {
+                case 0 /* TokenTypes.Text */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseText(tokenizer, token.value || ''));
+                    break;
+                case 6 /* TokenTypes.List */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseList(tokenizer, token.value || ''));
+                    break;
+                case 5 /* TokenTypes.Named */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
+                    break;
+                case 7 /* TokenTypes.Literal */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseLiteral(tokenizer, token.value || ''));
+                    break;
+                case 8 /* TokenTypes.LinkedAlias */:
+                    const parsed = parseLinked(tokenizer);
+                    node.items.push(parsed.node);
+                    nextToken = parsed.nextConsumeToken || null;
+                    break;
+            }
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
+        // adjust message node loc
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastOffset
+            : tokenizer.currentOffset();
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastEndLoc
+            : tokenizer.currentPosition();
+        endNode(node, endOffset, endLoc);
+        return node;
+    }
+    function parsePlural(tokenizer, offset, loc, msgNode) {
+        const context = tokenizer.context();
+        let hasEmptyMessage = msgNode.items.length === 0;
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+        node.cases = [];
+        node.cases.push(msgNode);
+        do {
+            const msg = parseMessage(tokenizer);
+            if (!hasEmptyMessage) {
+                hasEmptyMessage = msg.items.length === 0;
+            }
+            node.cases.push(msg);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        if (hasEmptyMessage) {
+            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseResource(tokenizer) {
+        const context = tokenizer.context();
+        const { offset, startLoc } = context;
+        const msgNode = parseMessage(tokenizer);
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
+            return msgNode;
+        }
+        else {
+            return parsePlural(tokenizer, offset, startLoc, msgNode);
+        }
+    }
+    function parse(source) {
+        const tokenizer = createTokenizer(source, assign({}, options));
+        const context = tokenizer.context();
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+        if (location && node.loc) {
+            node.loc.source = source;
+        }
+        node.body = parseResource(tokenizer);
+        if (options.onCacheKey) {
+            node.cacheKey = options.onCacheKey(source);
+        }
+        // assert whether achieved to EOF
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    return { parse };
+}
+function getTokenCaption(token) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
+        return 'EOF';
+    }
+    const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+    return name.length > 10 ? name.slice(0, 9) + '…' : name;
+}
+
+function createTransformer(ast, options = {} // eslint-disable-line
+) {
+    const _context = {
+        ast,
+        helpers: new Set()
+    };
+    const context = () => _context;
+    const helper = (name) => {
+        _context.helpers.add(name);
+        return name;
+    };
+    return { context, helper };
+}
+function traverseNodes(nodes, transformer) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], transformer);
+    }
+}
+function traverseNode(node, transformer) {
+    // TODO: if we need pre-hook of transform, should be implemented to here
+    switch (node.type) {
+        case 1 /* NodeTypes.Plural */:
+            traverseNodes(node.cases, transformer);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
+            break;
+        case 2 /* NodeTypes.Message */:
+            traverseNodes(node.items, transformer);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            traverseNode(linked.key, transformer);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
+            break;
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
+            break;
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
+            break;
+    }
+    // TODO: if we need post-hook of transform, should be implemented to here
+}
+// transform AST
+function transform(ast, options = {} // eslint-disable-line
+) {
+    const transformer = createTransformer(ast);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+    // traverse
+    ast.body && traverseNode(ast.body, transformer);
+    // set meta information
+    const context = transformer.context();
+    ast.helpers = Array.from(context.helpers);
+}
+
+function optimize(ast) {
+    const body = ast.body;
+    if (body.type === 2 /* NodeTypes.Message */) {
+        optimizeMessageNode(body);
+    }
+    else {
+        body.cases.forEach(c => optimizeMessageNode(c));
+    }
+    return ast;
+}
+function optimizeMessageNode(message) {
+    if (message.items.length === 1) {
+        const item = message.items[0];
+        if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+            message.static = item.value;
+            delete item.value; // optimization for size
+        }
+    }
+    else {
+        const values = [];
+        for (let i = 0; i < message.items.length; i++) {
+            const item = message.items[i];
+            if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                break;
+            }
+            if (item.value == null) {
+                break;
+            }
+            values.push(item.value);
+        }
+        if (values.length === message.items.length) {
+            message.static = join(values);
+            for (let i = 0; i < message.items.length; i++) {
+                const item = message.items[i];
+                if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                    delete item.value; // optimization for size
+                }
+            }
+        }
+    }
+}
+
+const ERROR_DOMAIN$1 = 'minifier';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function minify(node) {
+    node.t = node.type;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            const resource = node;
+            minify(resource.body);
+            resource.b = resource.body;
+            delete resource.body;
+            break;
+        case 1 /* NodeTypes.Plural */:
+            const plural = node;
+            const cases = plural.cases;
+            for (let i = 0; i < cases.length; i++) {
+                minify(cases[i]);
+            }
+            plural.c = cases;
+            delete plural.cases;
+            break;
+        case 2 /* NodeTypes.Message */:
+            const message = node;
+            const items = message.items;
+            for (let i = 0; i < items.length; i++) {
+                minify(items[i]);
+            }
+            message.i = items;
+            delete message.items;
+            if (message.static) {
+                message.s = message.static;
+                delete message.static;
+            }
+            break;
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            const valueNode = node;
+            if (valueNode.value) {
+                valueNode.v = valueNode.value;
+                delete valueNode.value;
+            }
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            minify(linked.key);
+            linked.k = linked.key;
+            delete linked.key;
+            if (linked.modifier) {
+                minify(linked.modifier);
+                linked.m = linked.modifier;
+                delete linked.modifier;
+            }
+            break;
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            list.i = list.index;
+            delete list.index;
+            break;
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            named.k = named.key;
+            delete named.key;
+            break;
+        default:
+            if ((process.env.NODE_ENV !== 'production')) {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN$1,
+                    args: [node.type]
+                });
+            }
+    }
+    delete node.type;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+const ERROR_DOMAIN = 'parser';
+function createCodeGenerator(ast, options) {
+    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+    const location = options.location !== false;
+    const _context = {
+        filename,
+        code: '',
+        column: 1,
+        line: 1,
+        offset: 0,
+        map: undefined,
+        breakLineCode,
+        needIndent: _needIndent,
+        indentLevel: 0
+    };
+    if (location && ast.loc) {
+        _context.source = ast.loc.source;
+    }
+    const context = () => _context;
+    function push(code, node) {
+        _context.code += code;
+        if (_context.map) {
+            if (node && node.loc && node.loc !== LOCATION_STUB) {
+                addMapping(node.loc.start, getMappingName(node));
+            }
+            advancePositionWithSource(_context, code);
+        }
+    }
+    function _newline(n, withBreakLine = true) {
+        const _breakLineCode = withBreakLine ? breakLineCode : '';
+        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+    }
+    function indent(withNewLine = true) {
+        const level = ++_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function deindent(withNewLine = true) {
+        const level = --_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function newline() {
+        _newline(_context.indentLevel);
+    }
+    const helper = (key) => `_${key}`;
+    const needIndent = () => _context.needIndent;
+    function addMapping(loc, name) {
+        _context.map.addMapping({
+            name,
+            source: _context.filename,
+            original: {
+                line: loc.line,
+                column: loc.column - 1
+            },
+            generated: {
+                line: _context.line,
+                column: _context.column - 1
+            }
+        });
+    }
+    if (location && sourceMap) {
+        _context.map = new SourceMapGenerator();
+        _context.map.setSourceContent(filename, _context.source);
+    }
+    return {
+        context,
+        push,
+        indent,
+        deindent,
+        newline,
+        helper,
+        needIndent
+    };
+}
+function generateLinkedNode(generator, node) {
+    const { helper } = generator;
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+    generateNode(generator, node.key);
+    if (node.modifier) {
+        generator.push(`, `);
+        generateNode(generator, node.modifier);
+        generator.push(`, _type`);
+    }
+    else {
+        generator.push(`, undefined, _type`);
+    }
+    generator.push(`)`);
+}
+function generateMessageNode(generator, node) {
+    const { helper, needIndent } = generator;
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+    generator.indent(needIndent());
+    const length = node.items.length;
+    for (let i = 0; i < length; i++) {
+        generateNode(generator, node.items[i]);
+        if (i === length - 1) {
+            break;
+        }
+        generator.push(', ');
+    }
+    generator.deindent(needIndent());
+    generator.push('])');
+}
+function generatePluralNode(generator, node) {
+    const { helper, needIndent } = generator;
+    if (node.cases.length > 1) {
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+        generator.indent(needIndent());
+        const length = node.cases.length;
+        for (let i = 0; i < length; i++) {
+            generateNode(generator, node.cases[i]);
+            if (i === length - 1) {
+                break;
+            }
+            generator.push(', ');
+        }
+        generator.deindent(needIndent());
+        generator.push(`])`);
+    }
+}
+function generateResource(generator, node) {
+    if (node.body) {
+        generateNode(generator, node.body);
+    }
+    else {
+        generator.push('null');
+    }
+}
+function generateNode(generator, node) {
+    const { helper } = generator;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            generateResource(generator, node);
+            break;
+        case 1 /* NodeTypes.Plural */:
+            generatePluralNode(generator, node);
+            break;
+        case 2 /* NodeTypes.Message */:
+            generateMessageNode(generator, node);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            generateLinkedNode(generator, node);
+            break;
+        case 8 /* NodeTypes.LinkedModifier */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 7 /* NodeTypes.LinkedKey */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+            break;
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+            break;
+        case 9 /* NodeTypes.Literal */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 3 /* NodeTypes.Text */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        default:
+            if ((process.env.NODE_ENV !== 'production')) {
+                throw createCompileError(CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE, null, {
+                    domain: ERROR_DOMAIN,
+                    args: [node.type]
+                });
+            }
+    }
+}
+// generate code from AST
+const generate = (ast, options = {} // eslint-disable-line
+) => {
+    const mode = isString(options.mode) ? options.mode : 'normal';
+    const filename = isString(options.filename)
+        ? options.filename
+        : 'message.intl';
+    const sourceMap = !!options.sourceMap;
+    // prettier-ignore
+    const breakLineCode = options.breakLineCode != null
+        ? options.breakLineCode
+        : mode === 'arrow'
+            ? ';'
+            : '\n';
+    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+    const helpers = ast.helpers || [];
+    const generator = createCodeGenerator(ast, {
+        mode,
+        filename,
+        sourceMap,
+        breakLineCode,
+        needIndent
+    });
+    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+    generator.indent(needIndent);
+    if (helpers.length > 0) {
+        generator.push(`const { ${join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+        generator.newline();
+    }
+    generator.push(`return `);
+    generateNode(generator, ast);
+    generator.deindent(needIndent);
+    generator.push(`}`);
+    delete ast.helpers;
+    const { code, map } = generator.context();
+    return {
+        ast,
+        code,
+        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+    };
+};
+function getMappingName(node) {
+    switch (node.type) {
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            return node.value;
+        case 5 /* NodeTypes.List */:
+            return node.index.toString();
+        case 4 /* NodeTypes.Named */:
+            return node.key;
+        default:
+            return undefined;
+    }
+}
+function advancePositionWithSource(pos, source, numberOfCharacters = source.length) {
+    let linesCount = 0;
+    let lastNewLinePos = -1;
+    for (let i = 0; i < numberOfCharacters; i++) {
+        if (source.charCodeAt(i) === 10 /* newline char code */) {
+            linesCount++;
+            lastNewLinePos = i;
+        }
+    }
+    pos.offset += numberOfCharacters;
+    pos.line += linesCount;
+    pos.column =
+        lastNewLinePos === -1
+            ? pos.column + numberOfCharacters
+            : numberOfCharacters - lastNewLinePos;
+    return pos;
+}
+
+function baseCompile(source, options = {}) {
+    const assignedOptions = assign({}, options);
+    const jit = !!assignedOptions.jit;
+    const enalbeMinify = !!assignedOptions.minify;
+    const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+    // parse source codes
+    const parser = createParser(assignedOptions);
+    const ast = parser.parse(source);
+    if (!jit) {
+        // transform ASTs
+        transform(ast, assignedOptions);
+        // generate javascript codes
+        return generate(ast, assignedOptions);
+    }
+    else {
+        // optimize ASTs
+        enambeOptimize && optimize(ast);
+        // minimize ASTs
+        enalbeMinify && minify(ast);
+        // In JIT mode, no ast transform, no code generation.
+        return { ast, code: '' };
+    }
+}
+
+export { CompileErrorCodes, ERROR_DOMAIN$2 as ERROR_DOMAIN, LOCATION_STUB, baseCompile, createCompileError, createLocation, createParser, createPosition, defaultOnError, detectHtmlTag, errorMessages };

node_modules/@intlify/message-compiler/dist/message-compiler.prod.cjs

@@ -0,0 +1,1579 @@
+/*!
+  * message-compiler v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+var shared = require('@intlify/shared');
+var sourceMapJs = require('source-map-js');
+
+const LOCATION_STUB = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 }
+};
+function createPosition(line, column, offset) {
+    return { line, column, offset };
+}
+function createLocation(start, end, source) {
+    const loc = { start, end };
+    if (source != null) {
+        loc.source = source;
+    }
+    return loc;
+}
+
+const CompileErrorCodes = {
+    // tokenizer error codes
+    EXPECTED_TOKEN: 1,
+    INVALID_TOKEN_IN_PLACEHOLDER: 2,
+    UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER: 3,
+    UNKNOWN_ESCAPE_SEQUENCE: 4,
+    INVALID_UNICODE_ESCAPE_SEQUENCE: 5,
+    UNBALANCED_CLOSING_BRACE: 6,
+    UNTERMINATED_CLOSING_BRACE: 7,
+    EMPTY_PLACEHOLDER: 8,
+    NOT_ALLOW_NEST_PLACEHOLDER: 9,
+    INVALID_LINKED_FORMAT: 10,
+    // parser error codes
+    MUST_HAVE_MESSAGES_IN_PLURAL: 11,
+    UNEXPECTED_EMPTY_LINKED_MODIFIER: 12,
+    UNEXPECTED_EMPTY_LINKED_KEY: 13,
+    UNEXPECTED_LEXICAL_ANALYSIS: 14,
+    // generator error codes
+    UNHANDLED_CODEGEN_NODE_TYPE: 15,
+    // minifier error codes
+    UNHANDLED_MINIFIER_NODE_TYPE: 16,
+    // Special value for higher-order compilers to pick up the last code
+    // to avoid collision of error codes. This should always be kept as the last
+    // item.
+    __EXTEND_POINT__: 17
+};
+/** @internal */
+const errorMessages = {
+    // tokenizer error messages
+    [CompileErrorCodes.EXPECTED_TOKEN]: `Expected token: '{0}'`,
+    [CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER]: `Invalid token in placeholder: '{0}'`,
+    [CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER]: `Unterminated single quote in placeholder`,
+    [CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE]: `Unknown escape sequence: \\{0}`,
+    [CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE]: `Invalid unicode escape sequence: {0}`,
+    [CompileErrorCodes.UNBALANCED_CLOSING_BRACE]: `Unbalanced closing brace`,
+    [CompileErrorCodes.UNTERMINATED_CLOSING_BRACE]: `Unterminated closing brace`,
+    [CompileErrorCodes.EMPTY_PLACEHOLDER]: `Empty placeholder`,
+    [CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER]: `Not allowed nest placeholder`,
+    [CompileErrorCodes.INVALID_LINKED_FORMAT]: `Invalid linked format`,
+    // parser error messages
+    [CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL]: `Plural must have messages`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER]: `Unexpected empty linked modifier`,
+    [CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY]: `Unexpected empty linked key`,
+    [CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS]: `Unexpected lexical analysis in token: '{0}'`,
+    // generator error messages
+    [CompileErrorCodes.UNHANDLED_CODEGEN_NODE_TYPE]: `unhandled codegen node type: '{0}'`,
+    // minimizer error messages
+    [CompileErrorCodes.UNHANDLED_MINIFIER_NODE_TYPE]: `unhandled mimifier node type: '{0}'`
+};
+function createCompileError(code, loc, options = {}) {
+    const { domain, messages, args } = options;
+    const msg = code;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    if (loc) {
+        error.location = loc;
+    }
+    error.domain = domain;
+    return error;
+}
+/** @internal */
+function defaultOnError(error) {
+    throw error;
+}
+
+const RE_HTML_TAG = /<\/?[\w\s="/.':;#-\/]+>/;
+const detectHtmlTag = (source) => RE_HTML_TAG.test(source);
+
+const CHAR_SP = ' ';
+const CHAR_CR = '\r';
+const CHAR_LF = '\n';
+const CHAR_LS = String.fromCharCode(0x2028);
+const CHAR_PS = String.fromCharCode(0x2029);
+function createScanner(str) {
+    const _buf = str;
+    let _index = 0;
+    let _line = 1;
+    let _column = 1;
+    let _peekOffset = 0;
+    const isCRLF = (index) => _buf[index] === CHAR_CR && _buf[index + 1] === CHAR_LF;
+    const isLF = (index) => _buf[index] === CHAR_LF;
+    const isPS = (index) => _buf[index] === CHAR_PS;
+    const isLS = (index) => _buf[index] === CHAR_LS;
+    const isLineEnd = (index) => isCRLF(index) || isLF(index) || isPS(index) || isLS(index);
+    const index = () => _index;
+    const line = () => _line;
+    const column = () => _column;
+    const peekOffset = () => _peekOffset;
+    const charAt = (offset) => isCRLF(offset) || isPS(offset) || isLS(offset) ? CHAR_LF : _buf[offset];
+    const currentChar = () => charAt(_index);
+    const currentPeek = () => charAt(_index + _peekOffset);
+    function next() {
+        _peekOffset = 0;
+        if (isLineEnd(_index)) {
+            _line++;
+            _column = 0;
+        }
+        if (isCRLF(_index)) {
+            _index++;
+        }
+        _index++;
+        _column++;
+        return _buf[_index];
+    }
+    function peek() {
+        if (isCRLF(_index + _peekOffset)) {
+            _peekOffset++;
+        }
+        _peekOffset++;
+        return _buf[_index + _peekOffset];
+    }
+    function reset() {
+        _index = 0;
+        _line = 1;
+        _column = 1;
+        _peekOffset = 0;
+    }
+    function resetPeek(offset = 0) {
+        _peekOffset = offset;
+    }
+    function skipToPeek() {
+        const target = _index + _peekOffset;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (target !== _index) {
+            next();
+        }
+        _peekOffset = 0;
+    }
+    return {
+        index,
+        line,
+        column,
+        peekOffset,
+        charAt,
+        currentChar,
+        currentPeek,
+        next,
+        peek,
+        reset,
+        resetPeek,
+        skipToPeek
+    };
+}
+
+const EOF = undefined;
+const DOT = '.';
+const LITERAL_DELIMITER = "'";
+const ERROR_DOMAIN$1 = 'tokenizer';
+function createTokenizer(source, options = {}) {
+    const location = options.location !== false;
+    const _scnr = createScanner(source);
+    const currentOffset = () => _scnr.index();
+    const currentPosition = () => createPosition(_scnr.line(), _scnr.column(), _scnr.index());
+    const _initLoc = currentPosition();
+    const _initOffset = currentOffset();
+    const _context = {
+        currentType: 14 /* TokenTypes.EOF */,
+        offset: _initOffset,
+        startLoc: _initLoc,
+        endLoc: _initLoc,
+        lastType: 14 /* TokenTypes.EOF */,
+        lastOffset: _initOffset,
+        lastStartLoc: _initLoc,
+        lastEndLoc: _initLoc,
+        braceNest: 0,
+        inLinked: false,
+        text: ''
+    };
+    const context = () => _context;
+    const { onError } = options;
+    function emitError(code, pos, offset, ...args) {
+        const ctx = context();
+        pos.column += offset;
+        pos.offset += offset;
+        if (onError) {
+            const loc = location ? createLocation(ctx.startLoc, pos) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN$1,
+                args
+            });
+            onError(err);
+        }
+    }
+    function getToken(context, type, value) {
+        context.endLoc = currentPosition();
+        context.currentType = type;
+        const token = { type };
+        if (location) {
+            token.loc = createLocation(context.startLoc, context.endLoc);
+        }
+        if (value != null) {
+            token.value = value;
+        }
+        return token;
+    }
+    const getEndToken = (context) => getToken(context, 14 /* TokenTypes.EOF */);
+    function eat(scnr, ch) {
+        if (scnr.currentChar() === ch) {
+            scnr.next();
+            return ch;
+        }
+        else {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+            return '';
+        }
+    }
+    function peekSpaces(scnr) {
+        let buf = '';
+        while (scnr.currentPeek() === CHAR_SP || scnr.currentPeek() === CHAR_LF) {
+            buf += scnr.currentPeek();
+            scnr.peek();
+        }
+        return buf;
+    }
+    function skipSpaces(scnr) {
+        const buf = peekSpaces(scnr);
+        scnr.skipToPeek();
+        return buf;
+    }
+    function isIdentifierStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return ((cc >= 97 && cc <= 122) || // a-z
+            (cc >= 65 && cc <= 90) || // A-Z
+            cc === 95 // _
+        );
+    }
+    function isNumberStart(ch) {
+        if (ch === EOF) {
+            return false;
+        }
+        const cc = ch.charCodeAt(0);
+        return cc >= 48 && cc <= 57; // 0-9
+    }
+    function isNamedIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isListIdentifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ch = scnr.currentPeek() === '-' ? scnr.peek() : scnr.currentPeek();
+        const ret = isNumberStart(ch);
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLiteralStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 2 /* TokenTypes.BraceLeft */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === LITERAL_DELIMITER;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDotStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 8 /* TokenTypes.LinkedAlias */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "." /* TokenChars.LinkedDot */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedModifierStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 9 /* TokenTypes.LinkedDot */) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = isIdentifierStart(scnr.currentPeek());
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedDelimiterStart(scnr, context) {
+        const { currentType } = context;
+        if (!(currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */)) {
+            return false;
+        }
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === ":" /* TokenChars.LinkedDelimiter */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function isLinkedReferStart(scnr, context) {
+        const { currentType } = context;
+        if (currentType !== 10 /* TokenTypes.LinkedDelimiter */) {
+            return false;
+        }
+        const fn = () => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return isIdentifierStart(scnr.peek());
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === ":" /* TokenChars.LinkedDelimiter */ ||
+                ch === "." /* TokenChars.LinkedDot */ ||
+                ch === CHAR_SP ||
+                !ch) {
+                return false;
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn();
+            }
+            else {
+                // other characters
+                return isIdentifierStart(ch);
+            }
+        };
+        const ret = fn();
+        scnr.resetPeek();
+        return ret;
+    }
+    function isPluralStart(scnr) {
+        peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "|" /* TokenChars.Pipe */;
+        scnr.resetPeek();
+        return ret;
+    }
+    function detectModuloStart(scnr) {
+        const spaces = peekSpaces(scnr);
+        const ret = scnr.currentPeek() === "%" /* TokenChars.Modulo */ &&
+            scnr.peek() === "{" /* TokenChars.BraceLeft */;
+        scnr.resetPeek();
+        return {
+            isModulo: ret,
+            hasSpace: spaces.length > 0
+        };
+    }
+    function isTextStart(scnr, reset = true) {
+        const fn = (hasSpace = false, prev = '', detectModulo = false) => {
+            const ch = scnr.currentPeek();
+            if (ch === "{" /* TokenChars.BraceLeft */) {
+                return prev === "%" /* TokenChars.Modulo */ ? false : hasSpace;
+            }
+            else if (ch === "@" /* TokenChars.LinkedAlias */ || !ch) {
+                return prev === "%" /* TokenChars.Modulo */ ? true : hasSpace;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                scnr.peek();
+                return fn(hasSpace, "%" /* TokenChars.Modulo */, true);
+            }
+            else if (ch === "|" /* TokenChars.Pipe */) {
+                return prev === "%" /* TokenChars.Modulo */ || detectModulo
+                    ? true
+                    : !(prev === CHAR_SP || prev === CHAR_LF);
+            }
+            else if (ch === CHAR_SP) {
+                scnr.peek();
+                return fn(true, CHAR_SP, detectModulo);
+            }
+            else if (ch === CHAR_LF) {
+                scnr.peek();
+                return fn(true, CHAR_LF, detectModulo);
+            }
+            else {
+                return true;
+            }
+        };
+        const ret = fn();
+        reset && scnr.resetPeek();
+        return ret;
+    }
+    function takeChar(scnr, fn) {
+        const ch = scnr.currentChar();
+        if (ch === EOF) {
+            return EOF;
+        }
+        if (fn(ch)) {
+            scnr.next();
+            return ch;
+        }
+        return null;
+    }
+    function takeIdentifierChar(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 97 && cc <= 122) || // a-z
+                (cc >= 65 && cc <= 90) || // A-Z
+                (cc >= 48 && cc <= 57) || // 0-9
+                cc === 95 || // _
+                cc === 36 // $
+            );
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return cc >= 48 && cc <= 57; // 0-9
+        };
+        return takeChar(scnr, closure);
+    }
+    function takeHexDigit(scnr) {
+        const closure = (ch) => {
+            const cc = ch.charCodeAt(0);
+            return ((cc >= 48 && cc <= 57) || // 0-9
+                (cc >= 65 && cc <= 70) || // A-F
+                (cc >= 97 && cc <= 102)); // a-f
+        };
+        return takeChar(scnr, closure);
+    }
+    function getDigits(scnr) {
+        let ch = '';
+        let num = '';
+        while ((ch = takeDigit(scnr))) {
+            num += ch;
+        }
+        return num;
+    }
+    function readModulo(scnr) {
+        skipSpaces(scnr);
+        const ch = scnr.currentChar();
+        if (ch !== "%" /* TokenChars.Modulo */) {
+            emitError(CompileErrorCodes.EXPECTED_TOKEN, currentPosition(), 0, ch);
+        }
+        scnr.next();
+        return "%" /* TokenChars.Modulo */;
+    }
+    function readText(scnr) {
+        let buf = '';
+        while (true) {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "}" /* TokenChars.BraceRight */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                !ch) {
+                break;
+            }
+            else if (ch === "%" /* TokenChars.Modulo */) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else {
+                    break;
+                }
+            }
+            else if (ch === CHAR_SP || ch === CHAR_LF) {
+                if (isTextStart(scnr)) {
+                    buf += ch;
+                    scnr.next();
+                }
+                else if (isPluralStart(scnr)) {
+                    break;
+                }
+                else {
+                    buf += ch;
+                    scnr.next();
+                }
+            }
+            else {
+                buf += ch;
+                scnr.next();
+            }
+        }
+        return buf;
+    }
+    function readNamedIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return name;
+    }
+    function readListIdentifier(scnr) {
+        skipSpaces(scnr);
+        let value = '';
+        if (scnr.currentChar() === '-') {
+            scnr.next();
+            value += `-${getDigits(scnr)}`;
+        }
+        else {
+            value += getDigits(scnr);
+        }
+        if (scnr.currentChar() === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+        }
+        return value;
+    }
+    function readLiteral(scnr) {
+        skipSpaces(scnr);
+        eat(scnr, `\'`);
+        let ch = '';
+        let literal = '';
+        const fn = (x) => x !== LITERAL_DELIMITER && x !== CHAR_LF;
+        while ((ch = takeChar(scnr, fn))) {
+            if (ch === '\\') {
+                literal += readEscapeSequence(scnr);
+            }
+            else {
+                literal += ch;
+            }
+        }
+        const current = scnr.currentChar();
+        if (current === CHAR_LF || current === EOF) {
+            emitError(CompileErrorCodes.UNTERMINATED_SINGLE_QUOTE_IN_PLACEHOLDER, currentPosition(), 0);
+            // TODO: Is it correct really?
+            if (current === CHAR_LF) {
+                scnr.next();
+                eat(scnr, `\'`);
+            }
+            return literal;
+        }
+        eat(scnr, `\'`);
+        return literal;
+    }
+    function readEscapeSequence(scnr) {
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case '\\':
+            case `\'`:
+                scnr.next();
+                return `\\${ch}`;
+            case 'u':
+                return readUnicodeEscapeSequence(scnr, ch, 4);
+            case 'U':
+                return readUnicodeEscapeSequence(scnr, ch, 6);
+            default:
+                emitError(CompileErrorCodes.UNKNOWN_ESCAPE_SEQUENCE, currentPosition(), 0, ch);
+                return '';
+        }
+    }
+    function readUnicodeEscapeSequence(scnr, unicode, digits) {
+        eat(scnr, unicode);
+        let sequence = '';
+        for (let i = 0; i < digits; i++) {
+            const ch = takeHexDigit(scnr);
+            if (!ch) {
+                emitError(CompileErrorCodes.INVALID_UNICODE_ESCAPE_SEQUENCE, currentPosition(), 0, `\\${unicode}${sequence}${scnr.currentChar()}`);
+                break;
+            }
+            sequence += ch;
+        }
+        return `\\${unicode}${sequence}`;
+    }
+    function readInvalidIdentifier(scnr) {
+        skipSpaces(scnr);
+        let ch = '';
+        let identifiers = '';
+        const closure = (ch) => ch !== "{" /* TokenChars.BraceLeft */ &&
+            ch !== "}" /* TokenChars.BraceRight */ &&
+            ch !== CHAR_SP &&
+            ch !== CHAR_LF;
+        while ((ch = takeChar(scnr, closure))) {
+            identifiers += ch;
+        }
+        return identifiers;
+    }
+    function readLinkedModifier(scnr) {
+        let ch = '';
+        let name = '';
+        while ((ch = takeIdentifierChar(scnr))) {
+            name += ch;
+        }
+        return name;
+    }
+    function readLinkedRefer(scnr) {
+        const fn = (detect = false, buf) => {
+            const ch = scnr.currentChar();
+            if (ch === "{" /* TokenChars.BraceLeft */ ||
+                ch === "%" /* TokenChars.Modulo */ ||
+                ch === "@" /* TokenChars.LinkedAlias */ ||
+                ch === "|" /* TokenChars.Pipe */ ||
+                ch === "(" /* TokenChars.ParenLeft */ ||
+                ch === ")" /* TokenChars.ParenRight */ ||
+                !ch) {
+                return buf;
+            }
+            else if (ch === CHAR_SP) {
+                return buf;
+            }
+            else if (ch === CHAR_LF || ch === DOT) {
+                buf += ch;
+                scnr.next();
+                return fn(detect, buf);
+            }
+            else {
+                buf += ch;
+                scnr.next();
+                return fn(true, buf);
+            }
+        };
+        return fn(false, '');
+    }
+    function readPlural(scnr) {
+        skipSpaces(scnr);
+        const plural = eat(scnr, "|" /* TokenChars.Pipe */);
+        skipSpaces(scnr);
+        return plural;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInPlaceholder(scnr, context) {
+        let token = null;
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                if (context.braceNest >= 1) {
+                    emitError(CompileErrorCodes.NOT_ALLOW_NEST_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 2 /* TokenTypes.BraceLeft */, "{" /* TokenChars.BraceLeft */);
+                skipSpaces(scnr);
+                context.braceNest++;
+                return token;
+            case "}" /* TokenChars.BraceRight */:
+                if (context.braceNest > 0 &&
+                    context.currentType === 2 /* TokenTypes.BraceLeft */) {
+                    emitError(CompileErrorCodes.EMPTY_PLACEHOLDER, currentPosition(), 0);
+                }
+                scnr.next();
+                token = getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+                context.braceNest--;
+                context.braceNest > 0 && skipSpaces(scnr);
+                if (context.inLinked && context.braceNest === 0) {
+                    context.inLinked = false;
+                }
+                return token;
+            case "@" /* TokenChars.LinkedAlias */:
+                if (context.braceNest > 0) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                }
+                token = readTokenInLinked(scnr, context) || getEndToken(context);
+                context.braceNest = 0;
+                return token;
+            default:
+                let validNamedIdentifier = true;
+                let validListIdentifier = true;
+                let validLiteral = true;
+                if (isPluralStart(scnr)) {
+                    if (context.braceNest > 0) {
+                        emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    }
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (context.braceNest > 0 &&
+                    (context.currentType === 5 /* TokenTypes.Named */ ||
+                        context.currentType === 6 /* TokenTypes.List */ ||
+                        context.currentType === 7 /* TokenTypes.Literal */)) {
+                    emitError(CompileErrorCodes.UNTERMINATED_CLOSING_BRACE, currentPosition(), 0);
+                    context.braceNest = 0;
+                    return readToken(scnr, context);
+                }
+                if ((validNamedIdentifier = isNamedIdentifierStart(scnr, context))) {
+                    token = getToken(context, 5 /* TokenTypes.Named */, readNamedIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validListIdentifier = isListIdentifierStart(scnr, context))) {
+                    token = getToken(context, 6 /* TokenTypes.List */, readListIdentifier(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if ((validLiteral = isLiteralStart(scnr, context))) {
+                    token = getToken(context, 7 /* TokenTypes.Literal */, readLiteral(scnr));
+                    skipSpaces(scnr);
+                    return token;
+                }
+                if (!validNamedIdentifier && !validListIdentifier && !validLiteral) {
+                    // TODO: we should be re-designed invalid cases, when we will extend message syntax near the future ...
+                    token = getToken(context, 13 /* TokenTypes.InvalidPlace */, readInvalidIdentifier(scnr));
+                    emitError(CompileErrorCodes.INVALID_TOKEN_IN_PLACEHOLDER, currentPosition(), 0, token.value);
+                    skipSpaces(scnr);
+                    return token;
+                }
+                break;
+        }
+        return token;
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readTokenInLinked(scnr, context) {
+        const { currentType } = context;
+        let token = null;
+        const ch = scnr.currentChar();
+        if ((currentType === 8 /* TokenTypes.LinkedAlias */ ||
+            currentType === 9 /* TokenTypes.LinkedDot */ ||
+            currentType === 12 /* TokenTypes.LinkedModifier */ ||
+            currentType === 10 /* TokenTypes.LinkedDelimiter */) &&
+            (ch === CHAR_LF || ch === CHAR_SP)) {
+            emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+        }
+        switch (ch) {
+            case "@" /* TokenChars.LinkedAlias */:
+                scnr.next();
+                token = getToken(context, 8 /* TokenTypes.LinkedAlias */, "@" /* TokenChars.LinkedAlias */);
+                context.inLinked = true;
+                return token;
+            case "." /* TokenChars.LinkedDot */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 9 /* TokenTypes.LinkedDot */, "." /* TokenChars.LinkedDot */);
+            case ":" /* TokenChars.LinkedDelimiter */:
+                skipSpaces(scnr);
+                scnr.next();
+                return getToken(context, 10 /* TokenTypes.LinkedDelimiter */, ":" /* TokenChars.LinkedDelimiter */);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                if (isLinkedDotStart(scnr, context) ||
+                    isLinkedDelimiterStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return readTokenInLinked(scnr, context);
+                }
+                if (isLinkedModifierStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    return getToken(context, 12 /* TokenTypes.LinkedModifier */, readLinkedModifier(scnr));
+                }
+                if (isLinkedReferStart(scnr, context)) {
+                    skipSpaces(scnr);
+                    if (ch === "{" /* TokenChars.BraceLeft */) {
+                        // scan the placeholder
+                        return readTokenInPlaceholder(scnr, context) || token;
+                    }
+                    else {
+                        return getToken(context, 11 /* TokenTypes.LinkedKey */, readLinkedRefer(scnr));
+                    }
+                }
+                if (currentType === 8 /* TokenTypes.LinkedAlias */) {
+                    emitError(CompileErrorCodes.INVALID_LINKED_FORMAT, currentPosition(), 0);
+                }
+                context.braceNest = 0;
+                context.inLinked = false;
+                return readToken(scnr, context);
+        }
+    }
+    // TODO: We need refactoring of token parsing ...
+    function readToken(scnr, context) {
+        let token = { type: 14 /* TokenTypes.EOF */ };
+        if (context.braceNest > 0) {
+            return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+        }
+        if (context.inLinked) {
+            return readTokenInLinked(scnr, context) || getEndToken(context);
+        }
+        const ch = scnr.currentChar();
+        switch (ch) {
+            case "{" /* TokenChars.BraceLeft */:
+                return readTokenInPlaceholder(scnr, context) || getEndToken(context);
+            case "}" /* TokenChars.BraceRight */:
+                emitError(CompileErrorCodes.UNBALANCED_CLOSING_BRACE, currentPosition(), 0);
+                scnr.next();
+                return getToken(context, 3 /* TokenTypes.BraceRight */, "}" /* TokenChars.BraceRight */);
+            case "@" /* TokenChars.LinkedAlias */:
+                return readTokenInLinked(scnr, context) || getEndToken(context);
+            default:
+                if (isPluralStart(scnr)) {
+                    token = getToken(context, 1 /* TokenTypes.Pipe */, readPlural(scnr));
+                    // reset
+                    context.braceNest = 0;
+                    context.inLinked = false;
+                    return token;
+                }
+                const { isModulo, hasSpace } = detectModuloStart(scnr);
+                if (isModulo) {
+                    return hasSpace
+                        ? getToken(context, 0 /* TokenTypes.Text */, readText(scnr))
+                        : getToken(context, 4 /* TokenTypes.Modulo */, readModulo(scnr));
+                }
+                if (isTextStart(scnr)) {
+                    return getToken(context, 0 /* TokenTypes.Text */, readText(scnr));
+                }
+                break;
+        }
+        return token;
+    }
+    function nextToken() {
+        const { currentType, offset, startLoc, endLoc } = _context;
+        _context.lastType = currentType;
+        _context.lastOffset = offset;
+        _context.lastStartLoc = startLoc;
+        _context.lastEndLoc = endLoc;
+        _context.offset = currentOffset();
+        _context.startLoc = currentPosition();
+        if (_scnr.currentChar() === EOF) {
+            return getToken(_context, 14 /* TokenTypes.EOF */);
+        }
+        return readToken(_scnr, _context);
+    }
+    return {
+        nextToken,
+        currentOffset,
+        currentPosition,
+        context
+    };
+}
+
+const ERROR_DOMAIN = 'parser';
+// Backslash backslash, backslash quote, uHHHH, UHHHHHH.
+const KNOWN_ESCAPES = /(?:\\\\|\\'|\\u([0-9a-fA-F]{4})|\\U([0-9a-fA-F]{6}))/g;
+function fromEscapeSequence(match, codePoint4, codePoint6) {
+    switch (match) {
+        case `\\\\`:
+            return `\\`;
+        case `\\\'`:
+            return `\'`;
+        default: {
+            const codePoint = parseInt(codePoint4 || codePoint6, 16);
+            if (codePoint <= 0xd7ff || codePoint >= 0xe000) {
+                return String.fromCodePoint(codePoint);
+            }
+            // invalid ...
+            // Replace them with U+FFFD REPLACEMENT CHARACTER.
+            return '�';
+        }
+    }
+}
+function createParser(options = {}) {
+    const location = options.location !== false;
+    const { onError } = options;
+    function emitError(tokenzer, code, start, offset, ...args) {
+        const end = tokenzer.currentPosition();
+        end.offset += offset;
+        end.column += offset;
+        if (onError) {
+            const loc = location ? createLocation(start, end) : null;
+            const err = createCompileError(code, loc, {
+                domain: ERROR_DOMAIN,
+                args
+            });
+            onError(err);
+        }
+    }
+    function startNode(type, offset, loc) {
+        const node = { type };
+        if (location) {
+            node.start = offset;
+            node.end = offset;
+            node.loc = { start: loc, end: loc };
+        }
+        return node;
+    }
+    function endNode(node, offset, pos, type) {
+        if (type) {
+            node.type = type;
+        }
+        if (location) {
+            node.end = offset;
+            if (node.loc) {
+                node.loc.end = pos;
+            }
+        }
+    }
+    function parseText(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(3 /* NodeTypes.Text */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseList(tokenizer, index) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(5 /* NodeTypes.List */, offset, loc);
+        node.index = parseInt(index, 10);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseNamed(tokenizer, key) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(4 /* NodeTypes.Named */, offset, loc);
+        node.key = key;
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLiteral(tokenizer, value) {
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get brace left loc
+        const node = startNode(9 /* NodeTypes.Literal */, offset, loc);
+        node.value = value.replace(KNOWN_ESCAPES, fromEscapeSequence);
+        tokenizer.nextToken(); // skip brach right
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinkedModifier(tokenizer) {
+        const token = tokenizer.nextToken();
+        const context = tokenizer.context();
+        const { lastOffset: offset, lastStartLoc: loc } = context; // get linked dot loc
+        const node = startNode(8 /* NodeTypes.LinkedModifier */, offset, loc);
+        if (token.type !== 12 /* TokenTypes.LinkedModifier */) {
+            // empty modifier
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_MODIFIER, context.lastStartLoc, 0);
+            node.value = '';
+            endNode(node, offset, loc);
+            return {
+                nextConsumeToken: token,
+                node
+            };
+        }
+        // check token
+        if (token.value == null) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        node.value = token.value || '';
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node
+        };
+    }
+    function parseLinkedKey(tokenizer, value) {
+        const context = tokenizer.context();
+        const node = startNode(7 /* NodeTypes.LinkedKey */, context.offset, context.startLoc);
+        node.value = value;
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseLinked(tokenizer) {
+        const context = tokenizer.context();
+        const linkedNode = startNode(6 /* NodeTypes.Linked */, context.offset, context.startLoc);
+        let token = tokenizer.nextToken();
+        if (token.type === 9 /* TokenTypes.LinkedDot */) {
+            const parsed = parseLinkedModifier(tokenizer);
+            linkedNode.modifier = parsed.node;
+            token = parsed.nextConsumeToken || tokenizer.nextToken();
+        }
+        // asset check token
+        if (token.type !== 10 /* TokenTypes.LinkedDelimiter */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+        }
+        token = tokenizer.nextToken();
+        // skip brace left
+        if (token.type === 2 /* TokenTypes.BraceLeft */) {
+            token = tokenizer.nextToken();
+        }
+        switch (token.type) {
+            case 11 /* TokenTypes.LinkedKey */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLinkedKey(tokenizer, token.value || '');
+                break;
+            case 5 /* TokenTypes.Named */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseNamed(tokenizer, token.value || '');
+                break;
+            case 6 /* TokenTypes.List */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseList(tokenizer, token.value || '');
+                break;
+            case 7 /* TokenTypes.Literal */:
+                if (token.value == null) {
+                    emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                }
+                linkedNode.key = parseLiteral(tokenizer, token.value || '');
+                break;
+            default:
+                // empty key
+                emitError(tokenizer, CompileErrorCodes.UNEXPECTED_EMPTY_LINKED_KEY, context.lastStartLoc, 0);
+                const nextContext = tokenizer.context();
+                const emptyLinkedKeyNode = startNode(7 /* NodeTypes.LinkedKey */, nextContext.offset, nextContext.startLoc);
+                emptyLinkedKeyNode.value = '';
+                endNode(emptyLinkedKeyNode, nextContext.offset, nextContext.startLoc);
+                linkedNode.key = emptyLinkedKeyNode;
+                endNode(linkedNode, nextContext.offset, nextContext.startLoc);
+                return {
+                    nextConsumeToken: token,
+                    node: linkedNode
+                };
+        }
+        endNode(linkedNode, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return {
+            node: linkedNode
+        };
+    }
+    function parseMessage(tokenizer) {
+        const context = tokenizer.context();
+        const startOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? tokenizer.currentOffset()
+            : context.offset;
+        const startLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.endLoc
+            : context.startLoc;
+        const node = startNode(2 /* NodeTypes.Message */, startOffset, startLoc);
+        node.items = [];
+        let nextToken = null;
+        do {
+            const token = nextToken || tokenizer.nextToken();
+            nextToken = null;
+            switch (token.type) {
+                case 0 /* TokenTypes.Text */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseText(tokenizer, token.value || ''));
+                    break;
+                case 6 /* TokenTypes.List */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseList(tokenizer, token.value || ''));
+                    break;
+                case 5 /* TokenTypes.Named */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseNamed(tokenizer, token.value || ''));
+                    break;
+                case 7 /* TokenTypes.Literal */:
+                    if (token.value == null) {
+                        emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, getTokenCaption(token));
+                    }
+                    node.items.push(parseLiteral(tokenizer, token.value || ''));
+                    break;
+                case 8 /* TokenTypes.LinkedAlias */:
+                    const parsed = parseLinked(tokenizer);
+                    node.items.push(parsed.node);
+                    nextToken = parsed.nextConsumeToken || null;
+                    break;
+            }
+        } while (context.currentType !== 14 /* TokenTypes.EOF */ &&
+            context.currentType !== 1 /* TokenTypes.Pipe */);
+        // adjust message node loc
+        const endOffset = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastOffset
+            : tokenizer.currentOffset();
+        const endLoc = context.currentType === 1 /* TokenTypes.Pipe */
+            ? context.lastEndLoc
+            : tokenizer.currentPosition();
+        endNode(node, endOffset, endLoc);
+        return node;
+    }
+    function parsePlural(tokenizer, offset, loc, msgNode) {
+        const context = tokenizer.context();
+        let hasEmptyMessage = msgNode.items.length === 0;
+        const node = startNode(1 /* NodeTypes.Plural */, offset, loc);
+        node.cases = [];
+        node.cases.push(msgNode);
+        do {
+            const msg = parseMessage(tokenizer);
+            if (!hasEmptyMessage) {
+                hasEmptyMessage = msg.items.length === 0;
+            }
+            node.cases.push(msg);
+        } while (context.currentType !== 14 /* TokenTypes.EOF */);
+        if (hasEmptyMessage) {
+            emitError(tokenizer, CompileErrorCodes.MUST_HAVE_MESSAGES_IN_PLURAL, loc, 0);
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    function parseResource(tokenizer) {
+        const context = tokenizer.context();
+        const { offset, startLoc } = context;
+        const msgNode = parseMessage(tokenizer);
+        if (context.currentType === 14 /* TokenTypes.EOF */) {
+            return msgNode;
+        }
+        else {
+            return parsePlural(tokenizer, offset, startLoc, msgNode);
+        }
+    }
+    function parse(source) {
+        const tokenizer = createTokenizer(source, shared.assign({}, options));
+        const context = tokenizer.context();
+        const node = startNode(0 /* NodeTypes.Resource */, context.offset, context.startLoc);
+        if (location && node.loc) {
+            node.loc.source = source;
+        }
+        node.body = parseResource(tokenizer);
+        if (options.onCacheKey) {
+            node.cacheKey = options.onCacheKey(source);
+        }
+        // assert whether achieved to EOF
+        if (context.currentType !== 14 /* TokenTypes.EOF */) {
+            emitError(tokenizer, CompileErrorCodes.UNEXPECTED_LEXICAL_ANALYSIS, context.lastStartLoc, 0, source[context.offset] || '');
+        }
+        endNode(node, tokenizer.currentOffset(), tokenizer.currentPosition());
+        return node;
+    }
+    return { parse };
+}
+function getTokenCaption(token) {
+    if (token.type === 14 /* TokenTypes.EOF */) {
+        return 'EOF';
+    }
+    const name = (token.value || '').replace(/\r?\n/gu, '\\n');
+    return name.length > 10 ? name.slice(0, 9) + '…' : name;
+}
+
+function createTransformer(ast, options = {} // eslint-disable-line
+) {
+    const _context = {
+        ast,
+        helpers: new Set()
+    };
+    const context = () => _context;
+    const helper = (name) => {
+        _context.helpers.add(name);
+        return name;
+    };
+    return { context, helper };
+}
+function traverseNodes(nodes, transformer) {
+    for (let i = 0; i < nodes.length; i++) {
+        traverseNode(nodes[i], transformer);
+    }
+}
+function traverseNode(node, transformer) {
+    // TODO: if we need pre-hook of transform, should be implemented to here
+    switch (node.type) {
+        case 1 /* NodeTypes.Plural */:
+            traverseNodes(node.cases, transformer);
+            transformer.helper("plural" /* HelperNameMap.PLURAL */);
+            break;
+        case 2 /* NodeTypes.Message */:
+            traverseNodes(node.items, transformer);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            traverseNode(linked.key, transformer);
+            transformer.helper("linked" /* HelperNameMap.LINKED */);
+            transformer.helper("type" /* HelperNameMap.TYPE */);
+            break;
+        case 5 /* NodeTypes.List */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("list" /* HelperNameMap.LIST */);
+            break;
+        case 4 /* NodeTypes.Named */:
+            transformer.helper("interpolate" /* HelperNameMap.INTERPOLATE */);
+            transformer.helper("named" /* HelperNameMap.NAMED */);
+            break;
+    }
+    // TODO: if we need post-hook of transform, should be implemented to here
+}
+// transform AST
+function transform(ast, options = {} // eslint-disable-line
+) {
+    const transformer = createTransformer(ast);
+    transformer.helper("normalize" /* HelperNameMap.NORMALIZE */);
+    // traverse
+    ast.body && traverseNode(ast.body, transformer);
+    // set meta information
+    const context = transformer.context();
+    ast.helpers = Array.from(context.helpers);
+}
+
+function optimize(ast) {
+    const body = ast.body;
+    if (body.type === 2 /* NodeTypes.Message */) {
+        optimizeMessageNode(body);
+    }
+    else {
+        body.cases.forEach(c => optimizeMessageNode(c));
+    }
+    return ast;
+}
+function optimizeMessageNode(message) {
+    if (message.items.length === 1) {
+        const item = message.items[0];
+        if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+            message.static = item.value;
+            delete item.value; // optimization for size
+        }
+    }
+    else {
+        const values = [];
+        for (let i = 0; i < message.items.length; i++) {
+            const item = message.items[i];
+            if (!(item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */)) {
+                break;
+            }
+            if (item.value == null) {
+                break;
+            }
+            values.push(item.value);
+        }
+        if (values.length === message.items.length) {
+            message.static = shared.join(values);
+            for (let i = 0; i < message.items.length; i++) {
+                const item = message.items[i];
+                if (item.type === 3 /* NodeTypes.Text */ || item.type === 9 /* NodeTypes.Literal */) {
+                    delete item.value; // optimization for size
+                }
+            }
+        }
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function minify(node) {
+    node.t = node.type;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            const resource = node;
+            minify(resource.body);
+            resource.b = resource.body;
+            delete resource.body;
+            break;
+        case 1 /* NodeTypes.Plural */:
+            const plural = node;
+            const cases = plural.cases;
+            for (let i = 0; i < cases.length; i++) {
+                minify(cases[i]);
+            }
+            plural.c = cases;
+            delete plural.cases;
+            break;
+        case 2 /* NodeTypes.Message */:
+            const message = node;
+            const items = message.items;
+            for (let i = 0; i < items.length; i++) {
+                minify(items[i]);
+            }
+            message.i = items;
+            delete message.items;
+            if (message.static) {
+                message.s = message.static;
+                delete message.static;
+            }
+            break;
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            const valueNode = node;
+            if (valueNode.value) {
+                valueNode.v = valueNode.value;
+                delete valueNode.value;
+            }
+            break;
+        case 6 /* NodeTypes.Linked */:
+            const linked = node;
+            minify(linked.key);
+            linked.k = linked.key;
+            delete linked.key;
+            if (linked.modifier) {
+                minify(linked.modifier);
+                linked.m = linked.modifier;
+                delete linked.modifier;
+            }
+            break;
+        case 5 /* NodeTypes.List */:
+            const list = node;
+            list.i = list.index;
+            delete list.index;
+            break;
+        case 4 /* NodeTypes.Named */:
+            const named = node;
+            named.k = named.key;
+            delete named.key;
+            break;
+    }
+    delete node.type;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+function createCodeGenerator(ast, options) {
+    const { sourceMap, filename, breakLineCode, needIndent: _needIndent } = options;
+    const location = options.location !== false;
+    const _context = {
+        filename,
+        code: '',
+        column: 1,
+        line: 1,
+        offset: 0,
+        map: undefined,
+        breakLineCode,
+        needIndent: _needIndent,
+        indentLevel: 0
+    };
+    if (location && ast.loc) {
+        _context.source = ast.loc.source;
+    }
+    const context = () => _context;
+    function push(code, node) {
+        _context.code += code;
+        if (_context.map) {
+            if (node && node.loc && node.loc !== LOCATION_STUB) {
+                addMapping(node.loc.start, getMappingName(node));
+            }
+            advancePositionWithSource(_context, code);
+        }
+    }
+    function _newline(n, withBreakLine = true) {
+        const _breakLineCode = withBreakLine ? breakLineCode : '';
+        push(_needIndent ? _breakLineCode + `  `.repeat(n) : _breakLineCode);
+    }
+    function indent(withNewLine = true) {
+        const level = ++_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function deindent(withNewLine = true) {
+        const level = --_context.indentLevel;
+        withNewLine && _newline(level);
+    }
+    function newline() {
+        _newline(_context.indentLevel);
+    }
+    const helper = (key) => `_${key}`;
+    const needIndent = () => _context.needIndent;
+    function addMapping(loc, name) {
+        _context.map.addMapping({
+            name,
+            source: _context.filename,
+            original: {
+                line: loc.line,
+                column: loc.column - 1
+            },
+            generated: {
+                line: _context.line,
+                column: _context.column - 1
+            }
+        });
+    }
+    if (location && sourceMap) {
+        _context.map = new sourceMapJs.SourceMapGenerator();
+        _context.map.setSourceContent(filename, _context.source);
+    }
+    return {
+        context,
+        push,
+        indent,
+        deindent,
+        newline,
+        helper,
+        needIndent
+    };
+}
+function generateLinkedNode(generator, node) {
+    const { helper } = generator;
+    generator.push(`${helper("linked" /* HelperNameMap.LINKED */)}(`);
+    generateNode(generator, node.key);
+    if (node.modifier) {
+        generator.push(`, `);
+        generateNode(generator, node.modifier);
+        generator.push(`, _type`);
+    }
+    else {
+        generator.push(`, undefined, _type`);
+    }
+    generator.push(`)`);
+}
+function generateMessageNode(generator, node) {
+    const { helper, needIndent } = generator;
+    generator.push(`${helper("normalize" /* HelperNameMap.NORMALIZE */)}([`);
+    generator.indent(needIndent());
+    const length = node.items.length;
+    for (let i = 0; i < length; i++) {
+        generateNode(generator, node.items[i]);
+        if (i === length - 1) {
+            break;
+        }
+        generator.push(', ');
+    }
+    generator.deindent(needIndent());
+    generator.push('])');
+}
+function generatePluralNode(generator, node) {
+    const { helper, needIndent } = generator;
+    if (node.cases.length > 1) {
+        generator.push(`${helper("plural" /* HelperNameMap.PLURAL */)}([`);
+        generator.indent(needIndent());
+        const length = node.cases.length;
+        for (let i = 0; i < length; i++) {
+            generateNode(generator, node.cases[i]);
+            if (i === length - 1) {
+                break;
+            }
+            generator.push(', ');
+        }
+        generator.deindent(needIndent());
+        generator.push(`])`);
+    }
+}
+function generateResource(generator, node) {
+    if (node.body) {
+        generateNode(generator, node.body);
+    }
+    else {
+        generator.push('null');
+    }
+}
+function generateNode(generator, node) {
+    const { helper } = generator;
+    switch (node.type) {
+        case 0 /* NodeTypes.Resource */:
+            generateResource(generator, node);
+            break;
+        case 1 /* NodeTypes.Plural */:
+            generatePluralNode(generator, node);
+            break;
+        case 2 /* NodeTypes.Message */:
+            generateMessageNode(generator, node);
+            break;
+        case 6 /* NodeTypes.Linked */:
+            generateLinkedNode(generator, node);
+            break;
+        case 8 /* NodeTypes.LinkedModifier */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 7 /* NodeTypes.LinkedKey */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 5 /* NodeTypes.List */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("list" /* HelperNameMap.LIST */)}(${node.index}))`, node);
+            break;
+        case 4 /* NodeTypes.Named */:
+            generator.push(`${helper("interpolate" /* HelperNameMap.INTERPOLATE */)}(${helper("named" /* HelperNameMap.NAMED */)}(${JSON.stringify(node.key)}))`, node);
+            break;
+        case 9 /* NodeTypes.Literal */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+        case 3 /* NodeTypes.Text */:
+            generator.push(JSON.stringify(node.value), node);
+            break;
+    }
+}
+// generate code from AST
+const generate = (ast, options = {} // eslint-disable-line
+) => {
+    const mode = shared.isString(options.mode) ? options.mode : 'normal';
+    const filename = shared.isString(options.filename)
+        ? options.filename
+        : 'message.intl';
+    const sourceMap = !!options.sourceMap;
+    // prettier-ignore
+    const breakLineCode = options.breakLineCode != null
+        ? options.breakLineCode
+        : mode === 'arrow'
+            ? ';'
+            : '\n';
+    const needIndent = options.needIndent ? options.needIndent : mode !== 'arrow';
+    const helpers = ast.helpers || [];
+    const generator = createCodeGenerator(ast, {
+        mode,
+        filename,
+        sourceMap,
+        breakLineCode,
+        needIndent
+    });
+    generator.push(mode === 'normal' ? `function __msg__ (ctx) {` : `(ctx) => {`);
+    generator.indent(needIndent);
+    if (helpers.length > 0) {
+        generator.push(`const { ${shared.join(helpers.map(s => `${s}: _${s}`), ', ')} } = ctx`);
+        generator.newline();
+    }
+    generator.push(`return `);
+    generateNode(generator, ast);
+    generator.deindent(needIndent);
+    generator.push(`}`);
+    delete ast.helpers;
+    const { code, map } = generator.context();
+    return {
+        ast,
+        code,
+        map: map ? map.toJSON() : undefined // eslint-disable-line @typescript-eslint/no-explicit-any
+    };
+};
+function getMappingName(node) {
+    switch (node.type) {
+        case 3 /* NodeTypes.Text */:
+        case 9 /* NodeTypes.Literal */:
+        case 8 /* NodeTypes.LinkedModifier */:
+        case 7 /* NodeTypes.LinkedKey */:
+            return node.value;
+        case 5 /* NodeTypes.List */:
+            return node.index.toString();
+        case 4 /* NodeTypes.Named */:
+            return node.key;
+        default:
+            return undefined;
+    }
+}
+function advancePositionWithSource(pos, source, numberOfCharacters = source.length) {
+    let linesCount = 0;
+    let lastNewLinePos = -1;
+    for (let i = 0; i < numberOfCharacters; i++) {
+        if (source.charCodeAt(i) === 10 /* newline char code */) {
+            linesCount++;
+            lastNewLinePos = i;
+        }
+    }
+    pos.offset += numberOfCharacters;
+    pos.line += linesCount;
+    pos.column =
+        lastNewLinePos === -1
+            ? pos.column + numberOfCharacters
+            : numberOfCharacters - lastNewLinePos;
+    return pos;
+}
+
+function baseCompile(source, options = {}) {
+    const assignedOptions = shared.assign({}, options);
+    const jit = !!assignedOptions.jit;
+    const enalbeMinify = !!assignedOptions.minify;
+    const enambeOptimize = assignedOptions.optimize == null ? true : assignedOptions.optimize;
+    // parse source codes
+    const parser = createParser(assignedOptions);
+    const ast = parser.parse(source);
+    if (!jit) {
+        // transform ASTs
+        transform(ast, assignedOptions);
+        // generate javascript codes
+        return generate(ast, assignedOptions);
+    }
+    else {
+        // optimize ASTs
+        enambeOptimize && optimize(ast);
+        // minimize ASTs
+        enalbeMinify && minify(ast);
+        // In JIT mode, no ast transform, no code generation.
+        return { ast, code: '' };
+    }
+}
+
+exports.CompileErrorCodes = CompileErrorCodes;
+exports.ERROR_DOMAIN = ERROR_DOMAIN;
+exports.LOCATION_STUB = LOCATION_STUB;
+exports.baseCompile = baseCompile;
+exports.createCompileError = createCompileError;
+exports.createLocation = createLocation;
+exports.createParser = createParser;
+exports.createPosition = createPosition;
+exports.defaultOnError = defaultOnError;
+exports.detectHtmlTag = detectHtmlTag;
+exports.errorMessages = errorMessages;

node_modules/@intlify/message-compiler/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/message-compiler.prod.cjs')
+} else {
+  module.exports = require('./dist/message-compiler.cjs')
+}

node_modules/@intlify/message-compiler/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@intlify/message-compiler",
+  "version": "9.5.0",
+  "description": "@intlify/message-compiler",
+  "keywords": [
+    "compiler",
+    "i18n",
+    "internationalization",
+    "intlify",
+    "message-format"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/message-compiler#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/message-compiler"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/message-compiler.mjs",
+  "unpkg": "dist/message-compiler.global.js",
+  "jsdelivr": "dist/message-compiler.global.js",
+  "types": "dist/message-compiler.d.ts",
+  "dependencies": {
+    "source-map-js": "^1.0.2",
+    "@intlify/shared": "9.5.0"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "buildOptions": {
+    "name": "IntlifyMessageCompiler",
+    "formats": [
+      "mjs",
+      "mjs-node",
+      "browser",
+      "cjs",
+      "global"
+    ],
+    "enableFullBundleForEsmBrowser": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/message-compiler.d.ts",
+      "browser": "./dist/message-compiler.esm-browser.js",
+      "node": {
+        "import": {
+          "production": "./dist/message-compiler.node.mjs",
+          "development": "./dist/message-compiler.node.mjs",
+          "default": "./dist/message-compiler.node.mjs"
+        },
+        "require": {
+          "production": "./dist/message-compiler.prod.cjs",
+          "development": "./dist/message-compiler.cjs",
+          "default": "./index.js"
+        }
+      },
+      "import": "./dist/message-compiler.mjs"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "funding": "https://github.com/sponsors/kazupon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

node_modules/@intlify/shared/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 kazuya kawaguchi
+
+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.

node_modules/@intlify/shared/README.md

@@ -0,0 +1,18 @@
+# @intlify/shared
+
+The shared utility package for intlify project
+
+## Forks
+The implementation of this module is contains code forked from other packages or projects:
+
+- [@vue/shared](https://github.com/vuejs/vue-next/tree/master/packages/shared)
+  - Useful Utilities at `utils.ts`
+    - Author: Evan You
+    - License: MIT
+  - Event Emitter at `emitter.ts` and `emittable.ts`
+    - Author: Jason Miller
+    - License: MIT
+
+## :copyright: License
+
+[MIT](http://opensource.org/licenses/MIT)

node_modules/@intlify/shared/dist/shared.cjs

@@ -0,0 +1,246 @@
+/*!
+  * shared v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+exports.mark = void 0;
+exports.measure = void 0;
+{
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        // @ts-ignore browser compat
+        perf.clearMeasures) {
+        exports.mark = (tag) => {
+            perf.mark(tag);
+        };
+        exports.measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const makeSymbol = (name, shareable = false) => !shareable ? Symbol(name) : Symbol.for(name);
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => {
+    if (!isObject(val))
+        return false;
+    const proto = Object.getPrototypeOf(val);
+    return proto === null || proto.constructor === Object;
+};
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function incrementer(code) {
+    let current = code;
+    return () => ++current;
+}
+
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const hasWarned = {};
+function warnOnce(msg) {
+    if (!hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+exports.assign = assign;
+exports.createEmitter = createEmitter;
+exports.escapeHtml = escapeHtml;
+exports.format = format;
+exports.friendlyJSONstringify = friendlyJSONstringify;
+exports.generateCodeFrame = generateCodeFrame;
+exports.generateFormatCacheKey = generateFormatCacheKey;
+exports.getGlobalThis = getGlobalThis;
+exports.hasOwn = hasOwn;
+exports.inBrowser = inBrowser;
+exports.incrementer = incrementer;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.join = join;
+exports.makeSymbol = makeSymbol;
+exports.objectToString = objectToString;
+exports.toDisplayString = toDisplayString;
+exports.toTypeString = toTypeString;
+exports.warn = warn;
+exports.warnOnce = warnOnce;

node_modules/@intlify/shared/dist/shared.cjs.js

@@ -0,0 +1 @@
+module.exports = require('../dist/shared.cjs')

node_modules/@intlify/shared/dist/shared.cjs.prod.js

@@ -0,0 +1 @@
+module.exports = require('../dist/shared.prod.cjs')

node_modules/@intlify/shared/dist/shared.d.ts

@@ -0,0 +1,155 @@
+
+export declare const assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+
+export declare interface BaseError {
+    code: number;
+}
+
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+export declare function createEmitter<Events extends Record<EventType, unknown>>(): Emittable<Events>;
+
+/**
+ * Event emitter interface
+ */
+export declare interface Emittable<Events extends Record<EventType, unknown> = {}> {
+    /**
+     * A map of event names of registered event handlers
+     */
+    events: EventHandlerMap<Events>;
+    /**
+     * Register an event handler with the event type
+     *
+     * @param event - An {@link EventType}
+     * @param handler - An {@link EventHandler}, or a {@link WildcardEventHandler} if you are specified "*"
+     */
+    on<Key extends keyof Events>(event: Key | '*', handler: EventHandler<Events[keyof Events]> | WildcardEventHandler<Events>): void;
+    /**
+     * Unregister an event handler for the event type
+     *
+     * @param event - An {@link EventType}
+     * @param handler - An {@link EventHandler}, or a {@link WildcardEventHandler} if you are specified "*"
+     */
+    off<Key extends keyof Events>(event: Key | '*', handler: EventHandler<Events[keyof Events]> | WildcardEventHandler<Events>): void;
+    /**
+     * Invoke all handlers with the event type
+     *
+     * @remarks
+     * Note Manually firing "*" handlers should be not supported
+     *
+     * @param event - An {@link EventType}
+     * @param payload - An event payload, optional
+     */
+    emit<Key extends keyof Events>(event: Key, payload?: Events[keyof Events]): void;
+}
+
+export declare function escapeHtml(rawText: string): string;
+
+/**
+ * Event handler
+ */
+export declare type EventHandler<T = unknown> = (payload?: T) => void;
+
+/**
+ * Event handler list
+ */
+export declare type EventHandlerList<T = unknown> = Array<EventHandler<T>>;
+
+/**
+ * Event handler map
+ */
+export declare type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildcardEventHandlerList<Events>>;
+
+/**
+ * Event type
+ */
+export declare type EventType = string | symbol;
+
+export declare function format(message: string, ...args: any): string;
+
+export declare const friendlyJSONstringify: (json: unknown) => string;
+
+export declare function generateCodeFrame(source: string, start?: number, end?: number): string;
+
+export declare const generateFormatCacheKey: (locale: string, key: string, source: string) => string;
+
+export declare const getGlobalThis: () => any;
+
+export declare function hasOwn(obj: object | Array<any>, key: string): boolean;
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+export declare const inBrowser: boolean;
+
+export declare function incrementer(code: number): () => number;
+
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+export declare const isArray: (arg: any) => arg is any[];
+
+export declare const isBoolean: (val: unknown) => val is boolean;
+
+export declare const isDate: (val: unknown) => val is Date;
+
+export declare const isEmptyObject: (val: unknown) => val is boolean;
+
+export declare const isFunction: (val: unknown) => val is Function;
+
+export declare const isNumber: (val: unknown) => val is number;
+
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+
+export declare const isPlainObject: (val: unknown) => val is object;
+
+export declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+
+export declare const isRegExp: (val: unknown) => val is RegExp;
+
+export declare const isString: (val: unknown) => val is string;
+
+export declare const isSymbol: (val: unknown) => val is symbol;
+
+export declare function join(items: string[], separator?: string): string;
+
+export declare const makeSymbol: (name: string, shareable?: boolean) => symbol;
+
+export declare let mark: (tag: string) => void | undefined;
+
+export declare let measure: (name: string, startTag: string, endTag: string) => void | undefined;
+
+export declare const objectToString: () => string;
+
+export declare const toDisplayString: (val: unknown) => string;
+
+export declare const toTypeString: (value: unknown) => string;
+
+export declare function warn(msg: string, err?: Error): void;
+
+export declare function warnOnce(msg: string): void;
+
+/**
+ * Wildcard event handler
+ */
+export declare type WildcardEventHandler<T = Record<string, unknown>> = (event: keyof T, payload?: T[keyof T]) => void;
+
+/**
+ * Wildcard event handler list
+ */
+export declare type WildcardEventHandlerList<T = Record<string, unknown>> = Array<WildcardEventHandler<T>>;
+
+export { }

node_modules/@intlify/shared/dist/shared.esm-browser.js

@@ -0,0 +1,215 @@
+/*!
+  * shared v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+{
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        // @ts-ignore browser compat
+        perf.clearMeasures) {
+        mark = (tag) => {
+            perf.mark(tag);
+        };
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const makeSymbol = (name, shareable = false) => !shareable ? Symbol(name) : Symbol.for(name);
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => {
+    if (!isObject(val))
+        return false;
+    const proto = Object.getPrototypeOf(val);
+    return proto === null || proto.constructor === Object;
+};
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function incrementer(code) {
+    let current = code;
+    return () => ++current;
+}
+
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const hasWarned = {};
+function warnOnce(msg) {
+    if (!hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+export { assign, createEmitter, escapeHtml, format, friendlyJSONstringify, generateCodeFrame, generateFormatCacheKey, getGlobalThis, hasOwn, inBrowser, incrementer, isArray, isBoolean, isDate, isEmptyObject, isFunction, isNumber, isObject, isPlainObject, isPromise, isRegExp, isString, isSymbol, join, makeSymbol, mark, measure, objectToString, toDisplayString, toTypeString, warn, warnOnce };

node_modules/@intlify/shared/dist/shared.esm-bundler.js

@@ -0,0 +1 @@
+export * from '../dist/shared.mjs'

node_modules/@intlify/shared/dist/shared.mjs

@@ -0,0 +1,215 @@
+/*!
+  * shared v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+if ((process.env.NODE_ENV !== 'production')) {
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        // @ts-ignore browser compat
+        perf.clearMeasures) {
+        mark = (tag) => {
+            perf.mark(tag);
+        };
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const makeSymbol = (name, shareable = false) => !shareable ? Symbol(name) : Symbol.for(name);
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => {
+    if (!isObject(val))
+        return false;
+    const proto = Object.getPrototypeOf(val);
+    return proto === null || proto.constructor === Object;
+};
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function incrementer(code) {
+    let current = code;
+    return () => ++current;
+}
+
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const hasWarned = {};
+function warnOnce(msg) {
+    if (!hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+export { assign, createEmitter, escapeHtml, format, friendlyJSONstringify, generateCodeFrame, generateFormatCacheKey, getGlobalThis, hasOwn, inBrowser, incrementer, isArray, isBoolean, isDate, isEmptyObject, isFunction, isNumber, isObject, isPlainObject, isPromise, isRegExp, isString, isSymbol, join, makeSymbol, mark, measure, objectToString, toDisplayString, toTypeString, warn, warnOnce };

node_modules/@intlify/shared/dist/shared.prod.cjs

@@ -0,0 +1,230 @@
+/*!
+  * shared v9.5.0
+  * (c) 2023 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+'use strict';
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const makeSymbol = (name, shareable = false) => !shareable ? Symbol(name) : Symbol.for(name);
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+const assign = Object.assign;
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : {}));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => {
+    if (!isObject(val))
+        return false;
+    const proto = Object.getPrototypeOf(val);
+    return proto === null || proto.constructor === Object;
+};
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function incrementer(code) {
+    let current = code;
+    return () => ++current;
+}
+
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const hasWarned = {};
+function warnOnce(msg) {
+    if (!hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+exports.assign = assign;
+exports.createEmitter = createEmitter;
+exports.escapeHtml = escapeHtml;
+exports.format = format;
+exports.friendlyJSONstringify = friendlyJSONstringify;
+exports.generateCodeFrame = generateCodeFrame;
+exports.generateFormatCacheKey = generateFormatCacheKey;
+exports.getGlobalThis = getGlobalThis;
+exports.hasOwn = hasOwn;
+exports.inBrowser = inBrowser;
+exports.incrementer = incrementer;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmptyObject = isEmptyObject;
+exports.isFunction = isFunction;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.join = join;
+exports.makeSymbol = makeSymbol;
+exports.mark = mark;
+exports.measure = measure;
+exports.objectToString = objectToString;
+exports.toDisplayString = toDisplayString;
+exports.toTypeString = toTypeString;
+exports.warn = warn;
+exports.warnOnce = warnOnce;

node_modules/@intlify/shared/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/shared.prod.cjs')
+} else {
+  module.exports = require('./dist/shared.cjs')
+}

node_modules/@intlify/shared/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@intlify/shared",
+  "version": "9.5.0",
+  "description": "@intlify/shared",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "intlify",
+    "utitlity"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n-next/tree/master/packages/shared#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n-next.git",
+    "directory": "packages/shared"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n-next/issues"
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/shared.mjs",
+  "types": "dist/shared.d.ts",
+  "engines": {
+    "node": ">= 16"
+  },
+  "buildOptions": {
+    "name": "IntlifyShared",
+    "formats": [
+      "mjs",
+      "browser",
+      "cjs"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/shared.d.ts",
+      "import": "./dist/shared.mjs",
+      "browser": "./dist/shared.esm-browser.js",
+      "node": {
+        "import": {
+          "production": "./dist/shared.prod.cjs",
+          "development": "./dist/shared.mjs",
+          "default": "./dist/shared.mjs"
+        },
+        "require": {
+          "production": "./dist/shared.prod.cjs",
+          "development": "./dist/shared.cjs",
+          "default": "./index.js"
+        }
+      }
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "funding": "https://github.com/sponsors/kazupon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}

node_modules/@jridgewell/sourcemap-codec/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 Rich Harris
+
+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.

node_modules/@jridgewell/sourcemap-codec/README.md

@@ -0,0 +1,200 @@
+# @jridgewell/sourcemap-codec
+
+Encode/decode the `mappings` property of a [sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit).
+
+
+## Why?
+
+Sourcemaps are difficult to generate and manipulate, because the `mappings` property – the part that actually links the generated code back to the original source – is encoded using an obscure method called [Variable-length quantity](https://en.wikipedia.org/wiki/Variable-length_quantity). On top of that, each segment in the mapping contains offsets rather than absolute indices, which means that you can't look at a segment in isolation – you have to understand the whole sourcemap.
+
+This package makes the process slightly easier.
+
+
+## Installation
+
+```bash
+npm install @jridgewell/sourcemap-codec
+```
+
+
+## Usage
+
+```js
+import { encode, decode } from '@jridgewell/sourcemap-codec';
+
+var decoded = decode( ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
+
+assert.deepEqual( decoded, [
+	// the first line (of the generated code) has no mappings,
+	// as shown by the starting semi-colon (which separates lines)
+	[],
+
+	// the second line contains four (comma-separated) segments
+	[
+		// segments are encoded as you'd expect:
+		// [ generatedCodeColumn, sourceIndex, sourceCodeLine, sourceCodeColumn, nameIndex ]
+
+		// i.e. the first segment begins at column 2, and maps back to the second column
+		// of the second line (both zero-based) of the 0th source, and uses the 0th
+		// name in the `map.names` array
+		[ 2, 0, 2, 2, 0 ],
+
+		// the remaining segments are 4-length rather than 5-length,
+		// because they don't map a name
+		[ 4, 0, 2, 4 ],
+		[ 6, 0, 2, 5 ],
+		[ 7, 0, 2, 7 ]
+	],
+
+	// the final line contains two segments
+	[
+		[ 2, 1, 10, 19 ],
+		[ 12, 1, 11, 20 ]
+	]
+]);
+
+var encoded = encode( decoded );
+assert.equal( encoded, ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
+```
+
+## Benchmarks
+
+```
+node v18.0.0
+
+amp.js.map - 45120 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec       5479160 bytes
+sourcemap-codec                   5659336 bytes
+source-map-0.6.1                 17144440 bytes
+source-map-0.8.0                  6867424 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 502 ops/sec ±1.03% (90 runs sampled)
+decode: sourcemap-codec x 445 ops/sec ±0.97% (92 runs sampled)
+decode: source-map-0.6.1 x 36.01 ops/sec ±1.64% (49 runs sampled)
+decode: source-map-0.8.0 x 367 ops/sec ±0.04% (95 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec       1261620 bytes
+sourcemap-codec                   9119248 bytes
+source-map-0.6.1                  8968560 bytes
+source-map-0.8.0                  8952952 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 738 ops/sec ±0.42% (98 runs sampled)
+encode: sourcemap-codec x 238 ops/sec ±0.73% (88 runs sampled)
+encode: source-map-0.6.1 x 162 ops/sec ±0.43% (84 runs sampled)
+encode: source-map-0.8.0 x 191 ops/sec ±0.34% (90 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+
+
+***
+
+
+babel.min.js.map - 347793 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec      35338184 bytes
+sourcemap-codec                  35922736 bytes
+source-map-0.6.1                 62366360 bytes
+source-map-0.8.0                 44337416 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 40.35 ops/sec ±4.47% (54 runs sampled)
+decode: sourcemap-codec x 36.76 ops/sec ±3.67% (51 runs sampled)
+decode: source-map-0.6.1 x 4.44 ops/sec ±2.15% (16 runs sampled)
+decode: source-map-0.8.0 x 59.35 ops/sec ±0.05% (78 runs sampled)
+Fastest is decode: source-map-0.8.0
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec       7212604 bytes
+sourcemap-codec                  21421456 bytes
+source-map-0.6.1                 25286888 bytes
+source-map-0.8.0                 25498744 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 112 ops/sec ±0.13% (84 runs sampled)
+encode: sourcemap-codec x 30.23 ops/sec ±2.76% (53 runs sampled)
+encode: source-map-0.6.1 x 19.43 ops/sec ±3.70% (37 runs sampled)
+encode: source-map-0.8.0 x 19.40 ops/sec ±3.26% (37 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+
+
+***
+
+
+preact.js.map - 1992 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec        500272 bytes
+sourcemap-codec                    516864 bytes
+source-map-0.6.1                  1596672 bytes
+source-map-0.8.0                   517272 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 16,137 ops/sec ±0.17% (99 runs sampled)
+decode: sourcemap-codec x 12,139 ops/sec ±0.13% (99 runs sampled)
+decode: source-map-0.6.1 x 1,264 ops/sec ±0.12% (100 runs sampled)
+decode: source-map-0.8.0 x 9,894 ops/sec ±0.08% (101 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec        321026 bytes
+sourcemap-codec                    830832 bytes
+source-map-0.6.1                   586608 bytes
+source-map-0.8.0                   586680 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 19,876 ops/sec ±0.78% (95 runs sampled)
+encode: sourcemap-codec x 6,983 ops/sec ±0.15% (100 runs sampled)
+encode: source-map-0.6.1 x 5,070 ops/sec ±0.12% (102 runs sampled)
+encode: source-map-0.8.0 x 5,641 ops/sec ±0.17% (100 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+
+
+***
+
+
+react.js.map - 5726 segments
+
+Decode Memory Usage:
+@jridgewell/sourcemap-codec        734848 bytes
+sourcemap-codec                    954200 bytes
+source-map-0.6.1                  2276432 bytes
+source-map-0.8.0                   955488 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Decode speed:
+decode: @jridgewell/sourcemap-codec x 5,723 ops/sec ±0.12% (98 runs sampled)
+decode: sourcemap-codec x 4,555 ops/sec ±0.09% (101 runs sampled)
+decode: source-map-0.6.1 x 437 ops/sec ±0.11% (93 runs sampled)
+decode: source-map-0.8.0 x 3,441 ops/sec ±0.15% (100 runs sampled)
+Fastest is decode: @jridgewell/sourcemap-codec
+
+Encode Memory Usage:
+@jridgewell/sourcemap-codec        638672 bytes
+sourcemap-codec                   1109840 bytes
+source-map-0.6.1                  1321224 bytes
+source-map-0.8.0                  1324448 bytes
+Smallest memory usage is @jridgewell/sourcemap-codec
+
+Encode speed:
+encode: @jridgewell/sourcemap-codec x 6,801 ops/sec ±0.48% (98 runs sampled)
+encode: sourcemap-codec x 2,533 ops/sec ±0.13% (101 runs sampled)
+encode: source-map-0.6.1 x 2,248 ops/sec ±0.08% (100 runs sampled)
+encode: source-map-0.8.0 x 2,303 ops/sec ±0.15% (100 runs sampled)
+Fastest is encode: @jridgewell/sourcemap-codec
+```
+
+# License
+
+MIT

node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs

@@ -0,0 +1,164 @@
+const comma = ','.charCodeAt(0);
+const semicolon = ';'.charCodeAt(0);
+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const intToChar = new Uint8Array(64); // 64 possible chars.
+const charToInt = new Uint8Array(128); // z is 122 in ASCII
+for (let i = 0; i < chars.length; i++) {
+    const c = chars.charCodeAt(i);
+    intToChar[i] = c;
+    charToInt[c] = i;
+}
+// Provide a fallback for older environments.
+const td = typeof TextDecoder !== 'undefined'
+    ? /* #__PURE__ */ new TextDecoder()
+    : typeof Buffer !== 'undefined'
+        ? {
+            decode(buf) {
+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                return out.toString();
+            },
+        }
+        : {
+            decode(buf) {
+                let out = '';
+                for (let i = 0; i < buf.length; i++) {
+                    out += String.fromCharCode(buf[i]);
+                }
+                return out;
+            },
+        };
+function decode(mappings) {
+    const state = new Int32Array(5);
+    const decoded = [];
+    let index = 0;
+    do {
+        const semi = indexOf(mappings, index);
+        const line = [];
+        let sorted = true;
+        let lastCol = 0;
+        state[0] = 0;
+        for (let i = index; i < semi; i++) {
+            let seg;
+            i = decodeInteger(mappings, i, state, 0); // genColumn
+            const col = state[0];
+            if (col < lastCol)
+                sorted = false;
+            lastCol = col;
+            if (hasMoreVlq(mappings, i, semi)) {
+                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
+                i = decodeInteger(mappings, i, state, 2); // sourceLine
+                i = decodeInteger(mappings, i, state, 3); // sourceColumn
+                if (hasMoreVlq(mappings, i, semi)) {
+                    i = decodeInteger(mappings, i, state, 4); // namesIndex
+                    seg = [col, state[1], state[2], state[3], state[4]];
+                }
+                else {
+                    seg = [col, state[1], state[2], state[3]];
+                }
+            }
+            else {
+                seg = [col];
+            }
+            line.push(seg);
+        }
+        if (!sorted)
+            sort(line);
+        decoded.push(line);
+        index = semi + 1;
+    } while (index <= mappings.length);
+    return decoded;
+}
+function indexOf(mappings, index) {
+    const idx = mappings.indexOf(';', index);
+    return idx === -1 ? mappings.length : idx;
+}
+function decodeInteger(mappings, pos, state, j) {
+    let value = 0;
+    let shift = 0;
+    let integer = 0;
+    do {
+        const c = mappings.charCodeAt(pos++);
+        integer = charToInt[c];
+        value |= (integer & 31) << shift;
+        shift += 5;
+    } while (integer & 32);
+    const shouldNegate = value & 1;
+    value >>>= 1;
+    if (shouldNegate) {
+        value = -0x80000000 | -value;
+    }
+    state[j] += value;
+    return pos;
+}
+function hasMoreVlq(mappings, i, length) {
+    if (i >= length)
+        return false;
+    return mappings.charCodeAt(i) !== comma;
+}
+function sort(line) {
+    line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+    return a[0] - b[0];
+}
+function encode(decoded) {
+    const state = new Int32Array(5);
+    const bufLength = 1024 * 16;
+    const subLength = bufLength - 36;
+    const buf = new Uint8Array(bufLength);
+    const sub = buf.subarray(0, subLength);
+    let pos = 0;
+    let out = '';
+    for (let i = 0; i < decoded.length; i++) {
+        const line = decoded[i];
+        if (i > 0) {
+            if (pos === bufLength) {
+                out += td.decode(buf);
+                pos = 0;
+            }
+            buf[pos++] = semicolon;
+        }
+        if (line.length === 0)
+            continue;
+        state[0] = 0;
+        for (let j = 0; j < line.length; j++) {
+            const segment = line[j];
+            // We can push up to 5 ints, each int can take at most 7 chars, and we
+            // may push a comma.
+            if (pos > subLength) {
+                out += td.decode(sub);
+                buf.copyWithin(0, subLength, pos);
+                pos -= subLength;
+            }
+            if (j > 0)
+                buf[pos++] = comma;
+            pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+            if (segment.length === 1)
+                continue;
+            pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
+            pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
+            pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            if (segment.length === 4)
+                continue;
+            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+        }
+    }
+    return out + td.decode(buf.subarray(0, pos));
+}
+function encodeInteger(buf, pos, state, segment, j) {
+    const next = segment[j];
+    let num = next - state[j];
+    state[j] = next;
+    num = num < 0 ? (-num << 1) | 1 : num << 1;
+    do {
+        let clamped = num & 0b011111;
+        num >>>= 5;
+        if (num > 0)
+            clamped |= 0b100000;
+        buf[pos++] = intToChar[clamped];
+    } while (num > 0);
+    return pos;
+}
+
+export { decode, encode };
+//# sourceMappingURL=sourcemap-codec.mjs.map

node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js

@@ -0,0 +1,175 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sourcemapCodec = {}));
+})(this, (function (exports) { 'use strict';
+
+    const comma = ','.charCodeAt(0);
+    const semicolon = ';'.charCodeAt(0);
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const intToChar = new Uint8Array(64); // 64 possible chars.
+    const charToInt = new Uint8Array(128); // z is 122 in ASCII
+    for (let i = 0; i < chars.length; i++) {
+        const c = chars.charCodeAt(i);
+        intToChar[i] = c;
+        charToInt[c] = i;
+    }
+    // Provide a fallback for older environments.
+    const td = typeof TextDecoder !== 'undefined'
+        ? /* #__PURE__ */ new TextDecoder()
+        : typeof Buffer !== 'undefined'
+            ? {
+                decode(buf) {
+                    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+                    return out.toString();
+                },
+            }
+            : {
+                decode(buf) {
+                    let out = '';
+                    for (let i = 0; i < buf.length; i++) {
+                        out += String.fromCharCode(buf[i]);
+                    }
+                    return out;
+                },
+            };
+    function decode(mappings) {
+        const state = new Int32Array(5);
+        const decoded = [];
+        let index = 0;
+        do {
+            const semi = indexOf(mappings, index);
+            const line = [];
+            let sorted = true;
+            let lastCol = 0;
+            state[0] = 0;
+            for (let i = index; i < semi; i++) {
+                let seg;
+                i = decodeInteger(mappings, i, state, 0); // genColumn
+                const col = state[0];
+                if (col < lastCol)
+                    sorted = false;
+                lastCol = col;
+                if (hasMoreVlq(mappings, i, semi)) {
+                    i = decodeInteger(mappings, i, state, 1); // sourcesIndex
+                    i = decodeInteger(mappings, i, state, 2); // sourceLine
+                    i = decodeInteger(mappings, i, state, 3); // sourceColumn
+                    if (hasMoreVlq(mappings, i, semi)) {
+                        i = decodeInteger(mappings, i, state, 4); // namesIndex
+                        seg = [col, state[1], state[2], state[3], state[4]];
+                    }
+                    else {
+                        seg = [col, state[1], state[2], state[3]];
+                    }
+                }
+                else {
+                    seg = [col];
+                }
+                line.push(seg);
+            }
+            if (!sorted)
+                sort(line);
+            decoded.push(line);
+            index = semi + 1;
+        } while (index <= mappings.length);
+        return decoded;
+    }
+    function indexOf(mappings, index) {
+        const idx = mappings.indexOf(';', index);
+        return idx === -1 ? mappings.length : idx;
+    }
+    function decodeInteger(mappings, pos, state, j) {
+        let value = 0;
+        let shift = 0;
+        let integer = 0;
+        do {
+            const c = mappings.charCodeAt(pos++);
+            integer = charToInt[c];
+            value |= (integer & 31) << shift;
+            shift += 5;
+        } while (integer & 32);
+        const shouldNegate = value & 1;
+        value >>>= 1;
+        if (shouldNegate) {
+            value = -0x80000000 | -value;
+        }
+        state[j] += value;
+        return pos;
+    }
+    function hasMoreVlq(mappings, i, length) {
+        if (i >= length)
+            return false;
+        return mappings.charCodeAt(i) !== comma;
+    }
+    function sort(line) {
+        line.sort(sortComparator);
+    }
+    function sortComparator(a, b) {
+        return a[0] - b[0];
+    }
+    function encode(decoded) {
+        const state = new Int32Array(5);
+        const bufLength = 1024 * 16;
+        const subLength = bufLength - 36;
+        const buf = new Uint8Array(bufLength);
+        const sub = buf.subarray(0, subLength);
+        let pos = 0;
+        let out = '';
+        for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            if (i > 0) {
+                if (pos === bufLength) {
+                    out += td.decode(buf);
+                    pos = 0;
+                }
+                buf[pos++] = semicolon;
+            }
+            if (line.length === 0)
+                continue;
+            state[0] = 0;
+            for (let j = 0; j < line.length; j++) {
+                const segment = line[j];
+                // We can push up to 5 ints, each int can take at most 7 chars, and we
+                // may push a comma.
+                if (pos > subLength) {
+                    out += td.decode(sub);
+                    buf.copyWithin(0, subLength, pos);
+                    pos -= subLength;
+                }
+                if (j > 0)
+                    buf[pos++] = comma;
+                pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                if (segment.length === 1)
+                    continue;
+                pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
+                pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
+                pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+                if (segment.length === 4)
+                    continue;
+                pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+            }
+        }
+        return out + td.decode(buf.subarray(0, pos));
+    }
+    function encodeInteger(buf, pos, state, segment, j) {
+        const next = segment[j];
+        let num = next - state[j];
+        state[j] = next;
+        num = num < 0 ? (-num << 1) | 1 : num << 1;
+        do {
+            let clamped = num & 0b011111;
+            num >>>= 5;
+            if (num > 0)
+                clamped |= 0b100000;
+            buf[pos++] = intToChar[clamped];
+        } while (num > 0);
+        return pos;
+    }
+
+    exports.decode = decode;
+    exports.encode = encode;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=sourcemap-codec.umd.js.map

node_modules/@jridgewell/sourcemap-codec/dist/types/sourcemap-codec.d.ts

@@ -0,0 +1,6 @@
+export declare type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number];
+export declare type SourceMapLine = SourceMapSegment[];
+export declare type SourceMapMappings = SourceMapLine[];
+export declare function decode(mappings: string): SourceMapMappings;
+export declare function encode(decoded: SourceMapMappings): string;
+export declare function encode(decoded: Readonly<SourceMapMappings>): string;

node_modules/@jridgewell/sourcemap-codec/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@jridgewell/sourcemap-codec",
+  "version": "1.4.15",
+  "description": "Encode/decode sourcemap mappings",
+  "keywords": [
+    "sourcemap",
+    "vlq"
+  ],
+  "main": "dist/sourcemap-codec.umd.js",
+  "module": "dist/sourcemap-codec.mjs",
+  "types": "dist/types/sourcemap-codec.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": [
+      {
+        "types": "./dist/types/sourcemap-codec.d.ts",
+        "browser": "./dist/sourcemap-codec.umd.js",
+        "require": "./dist/sourcemap-codec.umd.js",
+        "import": "./dist/sourcemap-codec.mjs"
+      },
+      "./dist/sourcemap-codec.umd.js"
+    ],
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "benchmark": "run-s build:rollup benchmark:*",
+    "benchmark:install": "cd benchmark && npm install",
+    "benchmark:only": "node --expose-gc benchmark/index.js",
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "prebuild": "rm -rf dist",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build",
+    "pretest": "run-s build:rollup",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "mocha --inspect-brk",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "mocha",
+    "test:coverage": "c8 mocha",
+    "test:watch": "mocha --watch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jridgewell/sourcemap-codec.git"
+  },
+  "author": "Rich Harris",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.0",
+    "@types/node": "17.0.15",
+    "@typescript-eslint/eslint-plugin": "5.10.0",
+    "@typescript-eslint/parser": "5.10.0",
+    "benchmark": "2.1.4",
+    "c8": "7.11.2",
+    "eslint": "8.7.0",
+    "eslint-config-prettier": "8.3.0",
+    "mocha": "9.2.0",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.5.1",
+    "rollup": "2.64.0",
+    "source-map": "0.6.1",
+    "source-map-js": "1.0.2",
+    "sourcemap-codec": "1.4.8",
+    "typescript": "4.5.4"
+  }
+}

node_modules/@messageformat/core/LICENSE

@@ -0,0 +1,20 @@
+Copyright OpenJS Foundation and contributors, https://openjsf.org/
+
+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.

node_modules/@messageformat/core/README.md

@@ -0,0 +1,31 @@
+<div class="main-title">
+<img align="right" width="100" height="100" src="https://messageformat.github.io/messageformat/logo/messageformat.svg">
+<h1>messageformat</h1>
+</div>
+
+The experience and subtlety of your program's text is important.
+The messageformat project provides a complete set of tools for handling all the messages of your application, for both front-end and back-end environments; for both runtime and build-time use.
+It's built around the ICU MessageFormat standard and supports [all the languages](http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html) included in the [Unicode CLDR](http://cldr.unicode.org/), but it can be just as useful if you're dealing with only one of them.
+
+[ICU MessageFormat](https://unicode-org.github.io/icu/userguide/format_parse/messages/) is a mechanism for handling both **pluralization** and **gender** in your applications.
+This is the core compiler of a [JavaScript project](http://messageformat.github.io/) supports and extends all parts of the official Java/C++ implementation, with the exception of the deprecated ChoiceFormat.
+In addition to compiling messages into JavaScript functions, it also provides tooling for making their use easy during both the build and runtime of your site or application.
+
+For more details, please see the project's documentation site: http://messageformat.github.io/
+
+This package was previously named [messageformat](https://www.npmjs.com/package/messageformat).
+
+---
+
+Messageformat is an OpenJS Foundation project, and we follow its [Code of Conduct](https://code-of-conduct.openjsf.org/).
+
+Copyright [OpenJS Foundation](https://openjsf.org) and messageformat contributors. All rights reserved.
+The [OpenJS Foundation](https://openjsf.org) has registered trademarks and uses trademarks.
+For a list of trademarks of the [OpenJS Foundation](https://openjsf.org), please see our [Trademark Policy](https://trademark-policy.openjsf.org/) and [Trademark List](https://trademark-list.openjsf.org/).
+Trademarks and logos not indicated on the [list of OpenJS Foundation trademarks](https://trademark-list.openjsf.org) are trademarks™ or registered® trademarks of their respective holders. Use of them does not imply any affiliation with or endorsement by them.
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 alt="BrowserStack" src="https://messageformat.github.io/messageformat/logo/browserstack.svg" />
+</a>

node_modules/@messageformat/core/compile-module.js

@@ -0,0 +1 @@
+module.exports = require('./lib/compile-module');

node_modules/@messageformat/core/lib/bidi-mark-text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Utility formatter function for enforcing Bidi Structured Text by using UCC
+ *
+ * List inlined from data extracted from CLDR v27 & v28
+ * To verify/recreate, use the following:
+ *
+ *    git clone https://github.com/unicode-cldr/cldr-misc-full.git
+ *    cd cldr-misc-full/main/
+ *    grep characterOrder -r . | tr '"/' '\t' | cut -f2,6 | grep -C4 right-to-left
+ *
+ * @private
+ */
+export declare function biDiMarkText(text: string, locale: string): string;

node_modules/@messageformat/core/lib/compile-module.d.ts

@@ -0,0 +1,61 @@
+import { StringStructure } from './compiler';
+import MessageFormat, { MessageFunction } from './messageformat';
+export { MessageFunction, StringStructure };
+/**
+ * The type of the generated ES module, once executed
+ *
+ * @public
+ * @remarks
+ * Use with `Shape` extending the {@link StringStructure} that was used as
+ * the module source.
+ */
+export type MessageModule<Shape, ReturnType extends 'string' | 'values' = 'string'> = Shape extends string ? MessageFunction<ReturnType> : {
+    [P in keyof Shape]: MessageModule<Shape[P], ReturnType>;
+};
+/**
+ * Compile a collection of messages into an ES module
+ *
+ * @public
+ * @remarks
+ * Available as the default export of `'@messageformat/core/compile-module'`, to
+ * allow for its exclusion from browser builds.
+ *
+ * With `messages` as a hierarchical structure of ICU MessageFormat strings,
+ * the output of `compileModule()` will be the source code of an ES module with
+ * a default export matching the input structure, with each string replaced by
+ * its corresponding JS function. If the input includes anything other than
+ * simple variable replacements, the output ES module will have a dependency on
+ * `'@messageformat/runtime'`.
+ *
+ * If the `messageformat` instance has been initialized with support for more
+ * than one locale, using a key that matches the locale's identifier at any
+ * depth of a `messages` object will set its child elements to use that locale.
+ * To customize this behaviour, see {@link MessageFormatOptions.localeCodeFromKey}.
+ *
+ * @example
+ * ```
+ * import { writeFileSync } from 'fs'
+ * import MessageFormat from '@messageformat/core'
+ * import compileModule from '@messageformat/core/compile-module'
+ *
+ * const mf = new MessageFormat('en')
+ * const msgSet = {
+ *   a: 'A {TYPE} example.',
+ *   b: 'This has {COUNT, plural, one{one member} other{# members}}.',
+ *   c: 'We have {P, number, percent} code coverage.'
+ * }
+ * const msgModule = compileModule(mf, msgSet)
+ * writeFileSync('messages.js', msgModule)
+ *
+ * ...
+ *
+ * import messages from './messages'
+ *
+ * messages.a({ TYPE: 'more complex' })  // 'A more complex example.'
+ * messages.b({ COUNT: 3 })              // 'This has 3 members.'
+ * ```
+ *
+ * @param messageformat - A {@link MessageFormat} instance
+ * @param messages - A hierarchical structure of ICU MessageFormat strings
+ */
+export default function compileModule(messageformat: MessageFormat<'string' | 'values'>, messages: StringStructure): string;

node_modules/@messageformat/core/lib/compile-module.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var safeIdentifier = require('safe-identifier');
+var Compiler = require('./compiler');
+
+function stringifyRuntime(runtime) {
+    const imports = {};
+    const vars = {};
+    for (const [name, fn] of Object.entries(runtime)) {
+        if (fn.module) {
+            const alias = fn.id && fn.id !== name ? `${fn.id} as ${name}` : name;
+            const prev = imports[fn.module];
+            imports[fn.module] = prev ? [...prev, alias] : [alias];
+        }
+        else {
+            vars[name] = String(fn);
+        }
+    }
+    const is = Object.entries(imports).map(([module, names]) => `import { ${names.sort().join(', ')} } from ${JSON.stringify(module)};`);
+    const vs = Object.entries(vars).map(([id, value]) => new RegExp(`^function ${id}\\b`).test(value)
+        ? value
+        : `const ${id} = ${value};`);
+    if (is.length > 0 && vs.length > 0)
+        is.push('');
+    return is.concat(vs).join('\n');
+}
+function stringifyObject(obj, level = 0) {
+    if (typeof obj !== 'object')
+        return obj;
+    const indent = '  '.repeat(level);
+    const o = Object.keys(obj).map(key => {
+        const v = stringifyObject(obj[key], level + 1);
+        return `\n${indent}  ${safeIdentifier.property(null, key)}: ${v}`;
+    });
+    return `{${o.join(',')}\n${indent}}`;
+}
+function compileModule(messageformat, messages) {
+    const { plurals } = messageformat;
+    const cp = {};
+    if (plurals.length > 1)
+        for (const pl of plurals)
+            cp[pl.lc] = cp[pl.locale] = pl;
+    const compiler = new Compiler(messageformat.options);
+    const msgObj = compiler.compile(messages, plurals[0], cp);
+    const msgStr = stringifyObject(msgObj);
+    const rtStr = stringifyRuntime(compiler.runtime);
+    return `${rtStr}\nexport default ${msgStr}`;
+}
+
+module.exports = compileModule;

node_modules/@messageformat/core/lib/compiler.d.ts

@@ -0,0 +1,58 @@
+import { FunctionArg, Select, Token } from '@messageformat/parser';
+import { MessageFormatOptions } from './messageformat';
+import { PluralObject } from './plurals';
+type RuntimeType = 'formatter' | 'locale' | 'runtime';
+interface RuntimeEntry {
+    (...args: any[]): unknown;
+    id?: string | null;
+    module?: string | null;
+    toString?: () => string;
+    type?: RuntimeType;
+}
+export interface RuntimeMap {
+    [key: string]: Required<RuntimeEntry>;
+}
+/**
+ * A hierarchical structure of ICU MessageFormat strings
+ *
+ * @public
+ * @remarks
+ * Used in {@link compileModule} arguments
+ */
+export interface StringStructure {
+    [key: string]: StringStructure | string;
+}
+export default class Compiler {
+    arguments: string[];
+    options: Required<MessageFormatOptions>;
+    plural: PluralObject;
+    runtime: RuntimeMap;
+    constructor(options: Required<MessageFormatOptions>);
+    /**
+     * Recursively compile a string or a tree of strings to JavaScript function
+     * sources
+     *
+     * If `src` is an object with a key that is also present in `plurals`, the key
+     * in question will be used as the locale identifier for its value. To disable
+     * the compile-time checks for plural & selectordinal keys while maintaining
+     * multi-locale support, use falsy values in `plurals`.
+     *
+     * @param src - The source for which the JS code should be generated
+     * @param plural - The default locale
+     * @param plurals - A map of pluralization keys for all available locales
+     */
+    compile(src: string | StringStructure, plural: PluralObject, plurals?: {
+        [key: string]: PluralObject;
+    }): string | StringStructure;
+    cases(token: Select, pluralToken: Select | null): string;
+    concatenate(tokens: string[], root: boolean): string;
+    token(token: Token, pluralToken: Select | null): string;
+    runtimeIncludes(key: string, type: RuntimeType): Required<RuntimeEntry>;
+    setLocale(key: string, ord: boolean): void;
+    setRuntimeFn(key: 'number' | 'plural' | 'select' | 'strictNumber' | 'reqArgs'): void;
+    getFormatterArg({ key, param }: FunctionArg, pluralToken: Select | null): string | null;
+    setFormatter(key: string): void;
+    setDateFormatter({ param }: FunctionArg, args: (number | string)[], plural: Select | null): string;
+    setNumberFormatter({ param }: FunctionArg, args: (number | string)[], plural: Select | null): string;
+}
+export {};

node_modules/@messageformat/core/lib/compiler.js

@@ -0,0 +1,2167 @@
+'use strict';
+
+var parser = require('@messageformat/parser');
+var Runtime = require('@messageformat/runtime');
+var Formatters = require('@messageformat/runtime/lib/formatters');
+var safeIdentifier = require('safe-identifier');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Runtime__namespace = /*#__PURE__*/_interopNamespaceDefault(Runtime);
+var Formatters__namespace = /*#__PURE__*/_interopNamespaceDefault(Formatters);
+
+/**
+ * Parent class for errors.
+ *
+ * @remarks
+ * Errors with `type: "warning"` do not necessarily indicate that the parser
+ * encountered an error. In addition to a human-friendly `message`, may also
+ * includes the `token` at which the error was encountered.
+ *
+ * @public
+ */
+class DateFormatError extends Error {
+    /** @internal */
+    constructor(msg, token, type) {
+        super(msg);
+        this.token = token;
+        this.type = type || 'error';
+    }
+}
+const alpha = (width) => width < 4 ? 'short' : width === 4 ? 'long' : 'narrow';
+const numeric = (width) => (width % 2 === 0 ? '2-digit' : 'numeric');
+function yearOptions(token, onError) {
+    switch (token.char) {
+        case 'y':
+            return { year: numeric(token.width) };
+        case 'r':
+            return { calendar: 'gregory', year: 'numeric' };
+        case 'u':
+        case 'U':
+        case 'Y':
+        default:
+            onError(`${token.desc} is not supported; falling back to year:numeric`, DateFormatError.WARNING);
+            return { year: 'numeric' };
+    }
+}
+function monthStyle(token, onError) {
+    switch (token.width) {
+        case 1:
+            return 'numeric';
+        case 2:
+            return '2-digit';
+        case 3:
+            return 'short';
+        case 4:
+            return 'long';
+        case 5:
+            return 'narrow';
+        default:
+            onError(`${token.desc} is not supported with width ${token.width}`);
+            return undefined;
+    }
+}
+function dayStyle(token, onError) {
+    const { char, desc, width } = token;
+    if (char === 'd')
+        return numeric(width);
+    else {
+        onError(`${desc} is not supported`);
+        return undefined;
+    }
+}
+function weekdayStyle(token, onError) {
+    const { char, desc, width } = token;
+    if ((char === 'c' || char === 'e') && width < 3) {
+        // ignoring stand-alone-ness
+        const msg = `Numeric value is not supported for ${desc}; falling back to weekday:short`;
+        onError(msg, DateFormatError.WARNING);
+    }
+    // merging narrow styles
+    return alpha(width);
+}
+function hourOptions(token) {
+    const hour = numeric(token.width);
+    let hourCycle;
+    switch (token.char) {
+        case 'h':
+            hourCycle = 'h12';
+            break;
+        case 'H':
+            hourCycle = 'h23';
+            break;
+        case 'k':
+            hourCycle = 'h24';
+            break;
+        case 'K':
+            hourCycle = 'h11';
+            break;
+    }
+    return hourCycle ? { hour, hourCycle } : { hour };
+}
+function timeZoneNameStyle(token, onError) {
+    // so much fallback behaviour here
+    const { char, desc, width } = token;
+    switch (char) {
+        case 'v':
+        case 'z':
+            return width === 4 ? 'long' : 'short';
+        case 'V':
+            if (width === 4)
+                return 'long';
+            onError(`${desc} is not supported with width ${width}`);
+            return undefined;
+        case 'X':
+            onError(`${desc} is not supported`);
+            return undefined;
+    }
+    return 'short';
+}
+function compileOptions(token, onError) {
+    switch (token.field) {
+        case 'era':
+            return { era: alpha(token.width) };
+        case 'year':
+            return yearOptions(token, onError);
+        case 'month':
+            return { month: monthStyle(token, onError) };
+        case 'day':
+            return { day: dayStyle(token, onError) };
+        case 'weekday':
+            return { weekday: weekdayStyle(token, onError) };
+        case 'period':
+            return undefined;
+        case 'hour':
+            return hourOptions(token);
+        case 'min':
+            return { minute: numeric(token.width) };
+        case 'sec':
+            return { second: numeric(token.width) };
+        case 'tz':
+            return { timeZoneName: timeZoneNameStyle(token, onError) };
+        case 'quarter':
+        case 'week':
+        case 'sec-frac':
+        case 'ms':
+            onError(`${token.desc} is not supported`);
+    }
+    return undefined;
+}
+function getDateFormatOptions(tokens, onError = error => {
+    throw error;
+}) {
+    const options = {};
+    const fields = [];
+    for (const token of tokens) {
+        const { error, field, str } = token;
+        if (error) {
+            const dte = new DateFormatError(error.message, token);
+            dte.stack = error.stack;
+            onError(dte);
+        }
+        if (str) {
+            const msg = `Ignoring string part: ${str}`;
+            onError(new DateFormatError(msg, token, DateFormatError.WARNING));
+        }
+        if (field) {
+            if (fields.indexOf(field) === -1)
+                fields.push(field);
+            else
+                onError(new DateFormatError(`Duplicate ${field} token`, token));
+        }
+        const opt = compileOptions(token, (msg, isWarning) => onError(new DateFormatError(msg, token, isWarning)));
+        if (opt)
+            Object.assign(options, opt);
+    }
+    return options;
+}
+
+const fields = {
+    G: { field: 'era', desc: 'Era' },
+    y: { field: 'year', desc: 'Year' },
+    Y: { field: 'year', desc: 'Year of "Week of Year"' },
+    u: { field: 'year', desc: 'Extended year' },
+    U: { field: 'year', desc: 'Cyclic year name' },
+    r: { field: 'year', desc: 'Related Gregorian year' },
+    Q: { field: 'quarter', desc: 'Quarter' },
+    q: { field: 'quarter', desc: 'Stand-alone quarter' },
+    M: { field: 'month', desc: 'Month in year' },
+    L: { field: 'month', desc: 'Stand-alone month in year' },
+    w: { field: 'week', desc: 'Week of year' },
+    W: { field: 'week', desc: 'Week of month' },
+    d: { field: 'day', desc: 'Day in month' },
+    D: { field: 'day', desc: 'Day of year' },
+    F: { field: 'day', desc: 'Day of week in month' },
+    g: { field: 'day', desc: 'Modified julian day' },
+    E: { field: 'weekday', desc: 'Day of week' },
+    e: { field: 'weekday', desc: 'Local day of week' },
+    c: { field: 'weekday', desc: 'Stand-alone local day of week' },
+    a: { field: 'period', desc: 'AM/PM marker' },
+    b: { field: 'period', desc: 'AM/PM/noon/midnight marker' },
+    B: { field: 'period', desc: 'Flexible day period' },
+    h: { field: 'hour', desc: 'Hour in AM/PM (1~12)' },
+    H: { field: 'hour', desc: 'Hour in day (0~23)' },
+    k: { field: 'hour', desc: 'Hour in day (1~24)' },
+    K: { field: 'hour', desc: 'Hour in AM/PM (0~11)' },
+    j: { field: 'hour', desc: 'Hour in preferred cycle' },
+    J: { field: 'hour', desc: 'Hour in preferred cycle without marker' },
+    C: { field: 'hour', desc: 'Hour in preferred cycle with flexible marker' },
+    m: { field: 'min', desc: 'Minute in hour' },
+    s: { field: 'sec', desc: 'Second in minute' },
+    S: { field: 'sec-frac', desc: 'Fractional second' },
+    A: { field: 'ms', desc: 'Milliseconds in day' },
+    z: { field: 'tz', desc: 'Time Zone: specific non-location' },
+    Z: { field: 'tz', desc: 'Time Zone' },
+    O: { field: 'tz', desc: 'Time Zone: localized' },
+    v: { field: 'tz', desc: 'Time Zone: generic non-location' },
+    V: { field: 'tz', desc: 'Time Zone: ID' },
+    X: { field: 'tz', desc: 'Time Zone: ISO8601 with Z' },
+    x: { field: 'tz', desc: 'Time Zone: ISO8601' }
+};
+const isLetter = (char) => (char >= 'A' && char <= 'Z') || (char >= 'a' && char <= 'z');
+function readFieldToken(src, pos) {
+    const char = src[pos];
+    let width = 1;
+    while (src[++pos] === char)
+        ++width;
+    const field = fields[char];
+    if (!field) {
+        const msg = `The letter ${char} is not a valid field identifier`;
+        return { char, error: new Error(msg), width };
+    }
+    return { char, field: field.field, desc: field.desc, width };
+}
+function readQuotedToken(src, pos) {
+    let str = src[++pos];
+    let width = 2;
+    if (str === "'")
+        return { char: "'", str, width };
+    while (true) {
+        const next = src[++pos];
+        ++width;
+        if (next === undefined) {
+            const msg = `Unterminated quoted literal in pattern: ${str || src}`;
+            return { char: "'", error: new Error(msg), str, width };
+        }
+        else if (next === "'") {
+            if (src[++pos] !== "'")
+                return { char: "'", str, width };
+            else
+                ++width;
+        }
+        str += next;
+    }
+}
+function readToken(src, pos) {
+    const char = src[pos];
+    if (!char)
+        return null;
+    if (isLetter(char))
+        return readFieldToken(src, pos);
+    if (char === "'")
+        return readQuotedToken(src, pos);
+    let str = char;
+    let width = 1;
+    while (true) {
+        const next = src[++pos];
+        if (!next || isLetter(next) || next === "'")
+            return { char, str, width };
+        str += next;
+        width += 1;
+    }
+}
+/**
+ * Parse an {@link http://userguide.icu-project.org/formatparse/datetime | ICU
+ * DateFormat skeleton} string into a {@link DateToken} array.
+ *
+ * @remarks
+ * Errors will not be thrown, but if encountered are included as the relevant
+ * token's `error` value.
+ *
+ * @public
+ * @param src - The skeleton string
+ *
+ * @example
+ * ```js
+ * import { parseDateTokens } from '@messageformat/date-skeleton'
+ *
+ * parseDateTokens('GrMMMdd', console.error)
+ * // [
+ * //   { char: 'G', field: 'era', desc: 'Era', width: 1 },
+ * //   { char: 'r', field: 'year', desc: 'Related Gregorian year', width: 1 },
+ * //   { char: 'M', field: 'month', desc: 'Month in year', width: 3 },
+ * //   { char: 'd', field: 'day', desc: 'Day in month', width: 2 }
+ * // ]
+ * ```
+ */
+function parseDateTokens(src) {
+    const tokens = [];
+    let pos = 0;
+    while (true) {
+        const token = readToken(src, pos);
+        if (!token)
+            return tokens;
+        tokens.push(token);
+        pos += token.width;
+    }
+}
+
+/**
+ * Returns a date formatter function for the given locales and date skeleton
+ *
+ * @remarks
+ * Uses `Intl.DateTimeFormat` internally.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+ *   `DateToken` tokens
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getDateFormatter } from '@messageformat/date-skeleton'
+ *
+ * // 2006 Jan 2, 15:04:05.789 in local time
+ * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+ *
+ * let fmt = getDateFormatter('en-CA', 'GrMMMdd', console.error)
+ * fmt(date) // 'Jan. 02, 2006 AD'
+ *
+ * fmt = getDateFormatter('en-CA', 'hamszzzz', console.error)
+ * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+ * ```
+ */
+function getDateFormatter(locales, tokens, onError) {
+    if (typeof tokens === 'string')
+        tokens = parseDateTokens(tokens);
+    const opt = getDateFormatOptions(tokens, onError);
+    const dtf = new Intl.DateTimeFormat(locales, opt);
+    return (date) => dtf.format(date);
+}
+/**
+ * Returns a string of JavaScript source that evaluates to a date formatter
+ * function with the same `(date: Date | number) => string` signature as the
+ * function returned by {@link getDateFormatter}.
+ *
+ * @remarks
+ * The returned function will memoize an `Intl.DateTimeFormat` instance.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+ *   `DateToken` tokens
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getDateFormatterSource } from '@messageformat/date-skeleton'
+ *
+ * getDateFormatterSource('en-CA', 'GrMMMdd', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"era":"short","calendar":"gregory","year":"numeric",' +
+ * //      '"month":"short","day":"2-digit"};\n' +
+ * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+ * // '  return function(value) { return dtf.format(value); }\n' +
+ * // '})()'
+ *
+ * const src = getDateFormatterSource('en-CA', 'hamszzzz', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"hour":"numeric","hourCycle":"h12","minute":"numeric",' +
+ * //      '"second":"numeric","timeZoneName":"long"};\n' +
+ * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+ * // '  return function(value) { return dtf.format(value); }\n' +
+ * // '})()'
+ *
+ * const fmt = new Function(`return ${src}`)()
+ * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+ * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+ * ```
+ */
+function getDateFormatterSource(locales, tokens, onError) {
+    if (typeof tokens === 'string')
+        tokens = parseDateTokens(tokens);
+    const opt = getDateFormatOptions(tokens, onError);
+    const lines = [
+        `(function() {`,
+        `var opt = ${JSON.stringify(opt)};`,
+        `var dtf = new Intl.DateTimeFormat(${JSON.stringify(locales)}, opt);`,
+        `return function(value) { return dtf.format(value); }`
+    ];
+    return lines.join('\n  ') + '\n})()';
+}
+
+/**
+ * Base class for errors. In addition to a `code` and a human-friendly
+ * `message`, may also includes the token `stem` as well as other fields.
+ *
+ * @public
+ */
+class NumberFormatError extends Error {
+    /** @internal */
+    constructor(code, msg) {
+        super(msg);
+        this.code = code;
+    }
+}
+/** @internal */
+class BadOptionError extends NumberFormatError {
+    constructor(stem, opt) {
+        super('BAD_OPTION', `Unknown ${stem} option: ${opt}`);
+        this.stem = stem;
+        this.option = opt;
+    }
+}
+/** @internal */
+class BadStemError extends NumberFormatError {
+    constructor(stem) {
+        super('BAD_STEM', `Unknown stem: ${stem}`);
+        this.stem = stem;
+    }
+}
+/** @internal */
+class MaskedValueError extends NumberFormatError {
+    constructor(type, prev) {
+        super('MASKED_VALUE', `Value for ${type} is set multiple times`);
+        this.type = type;
+        this.prev = prev;
+    }
+}
+/** @internal */
+class MissingOptionError extends NumberFormatError {
+    constructor(stem) {
+        super('MISSING_OPTION', `Required option missing for ${stem}`);
+        this.stem = stem;
+    }
+}
+/** @internal */
+class PatternError extends NumberFormatError {
+    constructor(char, msg) {
+        super('BAD_PATTERN', msg);
+        this.char = char;
+    }
+}
+/** @internal */
+class TooManyOptionsError extends NumberFormatError {
+    constructor(stem, options, maxOpt) {
+        const maxOptStr = maxOpt > 1 ? `${maxOpt} options` : 'one option';
+        super('TOO_MANY_OPTIONS', `Token ${stem} only supports ${maxOptStr} (got ${options.length})`);
+        this.stem = stem;
+        this.options = options;
+    }
+}
+/** @internal */
+class UnsupportedError extends NumberFormatError {
+    constructor(stem, source) {
+        super('UNSUPPORTED', `The stem ${stem} is not supported`);
+        this.stem = stem;
+        if (source) {
+            this.message += ` with value ${source}`;
+            this.source = source;
+        }
+    }
+}
+
+/**
+ * Add
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation | numbering-system tags}
+ * to locale identifiers
+ *
+ * @internal
+ */
+function getNumberFormatLocales(locales, { numberingSystem }) {
+    if (!Array.isArray(locales))
+        locales = [locales];
+    return numberingSystem
+        ? locales
+            .map(lc => {
+            const ext = lc.indexOf('-u-') === -1 ? 'u-nu' : 'nu';
+            return `${lc}-${ext}-${numberingSystem}`;
+        })
+            .concat(locales)
+        : locales;
+}
+
+// from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
+function round(x, precision) {
+    const y = +x + precision / 2;
+    return y - (y % +precision);
+}
+function getNumberFormatMultiplier({ scale, unit }) {
+    let mult = typeof scale === 'number' && scale >= 0 ? scale : 1;
+    if (unit && unit.style === 'percent')
+        mult *= 0.01;
+    return mult;
+}
+/**
+ * Determine a modifier for the input value to account for any `scale`,
+ * `percent`, and `precision-increment` tokens in the skeleton.
+ *
+ * @internal
+ * @remarks
+ * With ICU NumberFormatter, the `percent` skeleton would style `25` as "25%".
+ * To achieve the same with `Intl.NumberFormat`, the input value must be `0.25`.
+ */
+function getNumberFormatModifier(skeleton) {
+    const mult = getNumberFormatMultiplier(skeleton);
+    const { precision } = skeleton;
+    if (precision && precision.style === 'precision-increment') {
+        return (n) => round(n, precision.increment) * mult;
+    }
+    else {
+        return (n) => n * mult;
+    }
+}
+/**
+ * Returns a string of JavaScript source that evaluates to a modifier for the
+ * input value to account for any `scale`, `percent`, and `precision-increment`
+ * tokens in the skeleton.
+ *
+ * @internal
+ * @remarks
+ * With ICU NumberFormatter, the `percent` skeleton would style `25` as "25%".
+ * To achieve the same with `Intl.NumberFormat`, the input value must be `0.25`.
+ */
+function getNumberFormatModifierSource(skeleton) {
+    const mult = getNumberFormatMultiplier(skeleton);
+    const { precision } = skeleton;
+    if (precision && precision.style === 'precision-increment') {
+        // see round() above for source
+        const setX = `+n + ${precision.increment / 2}`;
+        let res = `x - (x % +${precision.increment})`;
+        if (mult !== 1)
+            res = `(${res}) * ${mult}`;
+        return `function(n) { var x = ${setX}; return ${res}; }`;
+    }
+    return mult !== 1 ? `function(n) { return n * ${mult}; }` : null;
+}
+
+/**
+ * Given an input ICU NumberFormatter skeleton, does its best to construct a
+ * corresponding `Intl.NumberFormat` options structure.
+ *
+ * @remarks
+ * Some features depend on `Intl.NumberFormat` features defined in ES2020.
+ *
+ * @internal
+ * @param onUnsupported - If defined, called when encountering unsupported (but
+ *   valid) tokens, such as `decimal-always` or `permille`. The error `source`
+ *   may specify the source of an unsupported option.
+ *
+ * @example
+ * ```js
+ * import {
+ *   getNumberFormatOptions,
+ *   parseNumberSkeleton
+ * } from '@messageformat/number-skeleton'
+ *
+ * const src = 'currency/CAD unit-width-narrow'
+ * const skeleton = parseNumberSkeleton(src, console.error)
+ * // {
+ * //   unit: { style: 'currency', currency: 'CAD' },
+ * //   unitWidth: 'unit-width-narrow'
+ * // }
+ *
+ * getNumberFormatOptions(skeleton, console.error)
+ * // {
+ * //   style: 'currency',
+ * //   currency: 'CAD',
+ * //   currencyDisplay: 'narrowSymbol',
+ * //   unitDisplay: 'narrow'
+ * // }
+ *
+ * const sk2 = parseNumberSkeleton('group-min2')
+ * // { group: 'group-min2' }
+ *
+ * getNumberFormatOptions(sk2, console.error)
+ * // Error: The stem group-min2 is not supported
+ * //   at UnsupportedError.NumberFormatError ... {
+ * //     code: 'UNSUPPORTED',
+ * //     stem: 'group-min2'
+ * //   }
+ * // {}
+ * ```
+ */
+function getNumberFormatOptions(skeleton, onUnsupported) {
+    const { decimal, group, integerWidth, notation, precision, roundingMode, sign, unit, unitPer, unitWidth } = skeleton;
+    const fail = (stem, source) => {
+        if (onUnsupported)
+            onUnsupported(new UnsupportedError(stem, source));
+    };
+    const opt = {};
+    if (unit) {
+        switch (unit.style) {
+            case 'base-unit':
+                opt.style = 'decimal';
+                break;
+            case 'currency':
+                opt.style = 'currency';
+                opt.currency = unit.currency;
+                break;
+            case 'measure-unit':
+                opt.style = 'unit';
+                opt.unit = unit.unit.replace(/.*-/, '');
+                if (unitPer)
+                    opt.unit += '-per-' + unitPer.replace(/.*-/, '');
+                break;
+            case 'percent':
+                opt.style = 'percent';
+                break;
+            case 'permille':
+                fail('permille');
+                break;
+        }
+    }
+    switch (unitWidth) {
+        case 'unit-width-full-name':
+            opt.currencyDisplay = 'name';
+            opt.unitDisplay = 'long';
+            break;
+        case 'unit-width-hidden':
+            fail(unitWidth);
+            break;
+        case 'unit-width-iso-code':
+            opt.currencyDisplay = 'code';
+            break;
+        case 'unit-width-narrow':
+            opt.currencyDisplay = 'narrowSymbol';
+            opt.unitDisplay = 'narrow';
+            break;
+        case 'unit-width-short':
+            opt.currencyDisplay = 'symbol';
+            opt.unitDisplay = 'short';
+            break;
+    }
+    switch (group) {
+        case 'group-off':
+            opt.useGrouping = false;
+            break;
+        case 'group-auto':
+            opt.useGrouping = true;
+            break;
+        case 'group-min2':
+        case 'group-on-aligned':
+        case 'group-thousands':
+            fail(group);
+            opt.useGrouping = true;
+            break;
+    }
+    if (precision) {
+        switch (precision.style) {
+            case 'precision-fraction': {
+                const { minFraction: minF, maxFraction: maxF, minSignificant: minS, maxSignificant: maxS, source } = precision;
+                if (typeof minF === 'number') {
+                    opt.minimumFractionDigits = minF;
+                    if (typeof minS === 'number')
+                        fail('precision-fraction', source);
+                }
+                if (typeof maxF === 'number')
+                    opt.maximumFractionDigits = maxF;
+                if (typeof minS === 'number')
+                    opt.minimumSignificantDigits = minS;
+                if (typeof maxS === 'number')
+                    opt.maximumSignificantDigits = maxS;
+                break;
+            }
+            case 'precision-integer':
+                opt.maximumFractionDigits = 0;
+                break;
+            case 'precision-unlimited':
+                opt.maximumFractionDigits = 20;
+                break;
+            case 'precision-increment':
+                break;
+            case 'precision-currency-standard':
+                opt.trailingZeroDisplay = precision.trailingZero;
+                break;
+            case 'precision-currency-cash':
+                fail(precision.style);
+                break;
+        }
+    }
+    if (notation) {
+        switch (notation.style) {
+            case 'compact-short':
+                opt.notation = 'compact';
+                opt.compactDisplay = 'short';
+                break;
+            case 'compact-long':
+                opt.notation = 'compact';
+                opt.compactDisplay = 'long';
+                break;
+            case 'notation-simple':
+                opt.notation = 'standard';
+                break;
+            case 'scientific':
+            case 'engineering': {
+                const { expDigits, expSign, source, style } = notation;
+                opt.notation = style;
+                if ((expDigits && expDigits > 1) ||
+                    (expSign && expSign !== 'sign-auto'))
+                    fail(style, source);
+                break;
+            }
+        }
+    }
+    if (integerWidth) {
+        const { min, max, source } = integerWidth;
+        if (min > 0)
+            opt.minimumIntegerDigits = min;
+        if (Number(max) > 0) {
+            const hasExp = opt.notation === 'engineering' || opt.notation === 'scientific';
+            if (max === 3 && hasExp)
+                opt.notation = 'engineering';
+            else
+                fail('integer-width', source);
+        }
+    }
+    switch (sign) {
+        case 'sign-auto':
+            opt.signDisplay = 'auto';
+            break;
+        case 'sign-always':
+            opt.signDisplay = 'always';
+            break;
+        case 'sign-except-zero':
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore https://github.com/microsoft/TypeScript/issues/46712
+            opt.signDisplay = 'exceptZero';
+            break;
+        case 'sign-never':
+            opt.signDisplay = 'never';
+            break;
+        case 'sign-accounting':
+            opt.currencySign = 'accounting';
+            break;
+        case 'sign-accounting-always':
+            opt.currencySign = 'accounting';
+            opt.signDisplay = 'always';
+            break;
+        case 'sign-accounting-except-zero':
+            opt.currencySign = 'accounting';
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore https://github.com/microsoft/TypeScript/issues/46712
+            opt.signDisplay = 'exceptZero';
+            break;
+    }
+    if (decimal === 'decimal-always')
+        fail(decimal);
+    if (roundingMode)
+        fail(roundingMode);
+    return opt;
+}
+
+function parseAffixToken(src, pos, onError) {
+    const char = src[pos];
+    switch (char) {
+        case '%':
+            return { char: '%', style: 'percent', width: 1 };
+        case '‰':
+            return { char: '%', style: 'permille', width: 1 };
+        case '¤': {
+            let width = 1;
+            while (src[++pos] === '¤')
+                ++width;
+            switch (width) {
+                case 1:
+                    return { char, currency: 'default', width };
+                case 2:
+                    return { char, currency: 'iso-code', width };
+                case 3:
+                    return { char, currency: 'full-name', width };
+                case 5:
+                    return { char, currency: 'narrow', width };
+                default: {
+                    const msg = `Invalid number (${width}) of ¤ chars in pattern`;
+                    onError(new PatternError('¤', msg));
+                    return null;
+                }
+            }
+        }
+        case '*': {
+            const pad = src[pos + 1];
+            if (pad)
+                return { char, pad, width: 2 };
+            break;
+        }
+        case '+':
+        case '-':
+            return { char, width: 1 };
+        case "'": {
+            let str = src[++pos];
+            let width = 2;
+            if (str === "'")
+                return { char, str, width };
+            while (true) {
+                const next = src[++pos];
+                ++width;
+                if (next === undefined) {
+                    const msg = `Unterminated quoted literal in pattern: ${str}`;
+                    onError(new PatternError("'", msg));
+                    return { char, str, width };
+                }
+                else if (next === "'") {
+                    if (src[++pos] !== "'")
+                        return { char, str, width };
+                    else
+                        ++width;
+                }
+                str += next;
+            }
+        }
+    }
+    return null;
+}
+
+const isDigit = (char) => char >= '0' && char <= '9';
+function parseNumberToken(src, pos) {
+    const char = src[pos];
+    if (isDigit(char)) {
+        let digits = char;
+        while (true) {
+            const next = src[++pos];
+            if (isDigit(next))
+                digits += next;
+            else
+                return { char: '0', digits, width: digits.length };
+        }
+    }
+    switch (char) {
+        case '#': {
+            let width = 1;
+            while (src[++pos] === '#')
+                ++width;
+            return { char, width };
+        }
+        case '@': {
+            let min = 1;
+            while (src[++pos] === '@')
+                ++min;
+            let width = min;
+            pos -= 1;
+            while (src[++pos] === '#')
+                ++width;
+            return { char, min, width };
+        }
+        case 'E': {
+            const plus = src[pos + 1] === '+';
+            if (plus)
+                ++pos;
+            let expDigits = 0;
+            while (src[++pos] === '0')
+                ++expDigits;
+            const width = (plus ? 2 : 1) + expDigits;
+            if (expDigits)
+                return { char, expDigits, plus, width };
+            else
+                break;
+        }
+        case '.':
+        case ',':
+            return { char, width: 1 };
+    }
+    return null;
+}
+
+function parseSubpattern(src, pos, onError) {
+    let State;
+    (function (State) {
+        State[State["Prefix"] = 0] = "Prefix";
+        State[State["Number"] = 1] = "Number";
+        State[State["Suffix"] = 2] = "Suffix";
+    })(State || (State = {}));
+    const prefix = [];
+    const number = [];
+    const suffix = [];
+    let state = State.Prefix;
+    let str = '';
+    while (pos < src.length) {
+        const char = src[pos];
+        if (char === ';') {
+            pos += 1;
+            break;
+        }
+        switch (state) {
+            case State.Prefix: {
+                const token = parseAffixToken(src, pos, onError);
+                if (token) {
+                    if (str) {
+                        prefix.push({ char: "'", str, width: str.length });
+                        str = '';
+                    }
+                    prefix.push(token);
+                    pos += token.width;
+                }
+                else {
+                    const token = parseNumberToken(src, pos);
+                    if (token) {
+                        if (str) {
+                            prefix.push({ char: "'", str, width: str.length });
+                            str = '';
+                        }
+                        state = State.Number;
+                        number.push(token);
+                        pos += token.width;
+                    }
+                    else {
+                        str += char;
+                        pos += 1;
+                    }
+                }
+                break;
+            }
+            case State.Number: {
+                const token = parseNumberToken(src, pos);
+                if (token) {
+                    number.push(token);
+                    pos += token.width;
+                }
+                else {
+                    state = State.Suffix;
+                }
+                break;
+            }
+            case State.Suffix: {
+                const token = parseAffixToken(src, pos, onError);
+                if (token) {
+                    if (str) {
+                        suffix.push({ char: "'", str, width: str.length });
+                        str = '';
+                    }
+                    suffix.push(token);
+                    pos += token.width;
+                }
+                else {
+                    str += char;
+                    pos += 1;
+                }
+                break;
+            }
+        }
+    }
+    if (str)
+        suffix.push({ char: "'", str, width: str.length });
+    return { pattern: { prefix, number, suffix }, pos };
+}
+function parseTokens(src, onError) {
+    const { pattern, pos } = parseSubpattern(src, 0, onError);
+    if (pos < src.length) {
+        const { pattern: negative } = parseSubpattern(src, pos, onError);
+        return { tokens: pattern, negative };
+    }
+    return { tokens: pattern };
+}
+
+function parseNumberAsSkeleton(tokens, onError) {
+    const res = {};
+    let hasGroups = false;
+    let hasExponent = false;
+    let intOptional = 0;
+    let intDigits = '';
+    let decimalPos = -1;
+    let fracDigits = '';
+    let fracOptional = 0;
+    for (let pos = 0; pos < tokens.length; ++pos) {
+        const token = tokens[pos];
+        switch (token.char) {
+            case '#': {
+                if (decimalPos === -1) {
+                    if (intDigits) {
+                        const msg = 'Pattern has # after integer digits';
+                        onError(new PatternError('#', msg));
+                    }
+                    intOptional += token.width;
+                }
+                else {
+                    fracOptional += token.width;
+                }
+                break;
+            }
+            case '0': {
+                if (decimalPos === -1) {
+                    intDigits += token.digits;
+                }
+                else {
+                    if (fracOptional) {
+                        const msg = 'Pattern has digits after # in fraction';
+                        onError(new PatternError('0', msg));
+                    }
+                    fracDigits += token.digits;
+                }
+                break;
+            }
+            case '@': {
+                if (res.precision)
+                    onError(new MaskedValueError('precision', res.precision));
+                res.precision = {
+                    style: 'precision-fraction',
+                    minSignificant: token.min,
+                    maxSignificant: token.width
+                };
+                break;
+            }
+            case ',':
+                hasGroups = true;
+                break;
+            case '.':
+                if (decimalPos === 1) {
+                    const msg = 'Pattern has more than one decimal separator';
+                    onError(new PatternError('.', msg));
+                }
+                decimalPos = pos;
+                break;
+            case 'E': {
+                if (hasExponent)
+                    onError(new MaskedValueError('exponent', res.notation));
+                if (hasGroups) {
+                    const msg = 'Exponential patterns may not contain grouping separators';
+                    onError(new PatternError('E', msg));
+                }
+                res.notation = { style: 'scientific' };
+                if (token.expDigits > 1)
+                    res.notation.expDigits = token.expDigits;
+                if (token.plus)
+                    res.notation.expSign = 'sign-always';
+                hasExponent = true;
+            }
+        }
+    }
+    // imprecise mapping due to paradigm differences
+    if (hasGroups)
+        res.group = 'group-auto';
+    else if (intOptional + intDigits.length > 3)
+        res.group = 'group-off';
+    const increment = Number(`${intDigits || '0'}.${fracDigits}`);
+    if (increment)
+        res.precision = { style: 'precision-increment', increment };
+    if (!hasExponent) {
+        if (intDigits.length > 1)
+            res.integerWidth = { min: intDigits.length };
+        if (!res.precision && (fracDigits.length || fracOptional)) {
+            res.precision = {
+                style: 'precision-fraction',
+                minFraction: fracDigits.length,
+                maxFraction: fracDigits.length + fracOptional
+            };
+        }
+    }
+    else {
+        if (!res.precision || increment) {
+            res.integerWidth = intOptional
+                ? { min: 1, max: intOptional + intDigits.length }
+                : { min: Math.max(1, intDigits.length) };
+        }
+        if (res.precision) {
+            if (!increment)
+                res.integerWidth = { min: 1, max: 1 };
+        }
+        else {
+            const dc = intDigits.length + fracDigits.length;
+            if (decimalPos === -1) {
+                if (dc > 0)
+                    res.precision = { style: 'precision-fraction', maxSignificant: dc };
+            }
+            else {
+                res.precision = {
+                    style: 'precision-fraction',
+                    maxSignificant: Math.max(1, dc) + fracOptional
+                };
+                if (dc > 1)
+                    res.precision.minSignificant = dc;
+            }
+        }
+    }
+    return res;
+}
+
+function handleAffix(affixTokens, res, currency, onError, isPrefix) {
+    let inFmt = false;
+    let str = '';
+    for (const token of affixTokens) {
+        switch (token.char) {
+            case '%':
+                res.unit = { style: token.style };
+                if (isPrefix)
+                    inFmt = true;
+                else
+                    str = '';
+                break;
+            case '¤':
+                if (!currency) {
+                    const msg = `The ¤ pattern requires a currency`;
+                    onError(new PatternError('¤', msg));
+                    break;
+                }
+                res.unit = { style: 'currency', currency };
+                switch (token.currency) {
+                    case 'iso-code':
+                        res.unitWidth = 'unit-width-iso-code';
+                        break;
+                    case 'full-name':
+                        res.unitWidth = 'unit-width-full-name';
+                        break;
+                    case 'narrow':
+                        res.unitWidth = 'unit-width-narrow';
+                        break;
+                }
+                if (isPrefix)
+                    inFmt = true;
+                else
+                    str = '';
+                break;
+            case '*':
+                // TODO
+                break;
+            case '+':
+                if (!inFmt)
+                    str += '+';
+                break;
+            case "'":
+                if (!inFmt)
+                    str += token.str;
+                break;
+        }
+    }
+    return str;
+}
+function getNegativeAffix(affixTokens, isPrefix) {
+    let inFmt = false;
+    let str = '';
+    for (const token of affixTokens) {
+        switch (token.char) {
+            case '%':
+            case '¤':
+                if (isPrefix)
+                    inFmt = true;
+                else
+                    str = '';
+                break;
+            case '-':
+                if (!inFmt)
+                    str += '-';
+                break;
+            case "'":
+                if (!inFmt)
+                    str += token.str;
+                break;
+        }
+    }
+    return str;
+}
+/**
+ * Parse an {@link
+ * http://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns |
+ * ICU NumberFormatter pattern} string into a {@link Skeleton} structure.
+ *
+ * @public
+ * @param src - The pattern string
+ * @param currency - If the pattern includes ¤ tokens, their skeleton
+ *   representation requires a three-letter currency code.
+ * @param onError - Called when the parser encounters a syntax error. The
+ *   function will still return a {@link Skeleton}, but it will be incomplete
+ *   and/or inaccurate. If not defined, the error will be thrown instead.
+ *
+ * @remarks
+ * Unlike the skeleton parser, the pattern parser is not able to return partial
+ * results on error, and will instead throw. Output padding is not supported.
+ *
+ * @example
+ * ```js
+ * import { parseNumberPattern } from '@messageformat/number-skeleton'
+ *
+ * parseNumberPattern('#,##0.00 ¤', 'EUR', console.error)
+ * // {
+ * //   group: 'group-auto',
+ * //   precision: {
+ * //     style: 'precision-fraction',
+ * //     minFraction: 2,
+ * //     maxFraction: 2
+ * //   },
+ * //   unit: { style: 'currency', currency: 'EUR' }
+ * // }
+ * ```
+ */
+function parseNumberPattern(src, currency, onError = error => {
+    throw error;
+}) {
+    const { tokens, negative } = parseTokens(src, onError);
+    const res = parseNumberAsSkeleton(tokens.number, onError);
+    const prefix = handleAffix(tokens.prefix, res, currency, onError, true);
+    const suffix = handleAffix(tokens.suffix, res, currency, onError, false);
+    if (negative) {
+        const negPrefix = getNegativeAffix(negative.prefix, true);
+        const negSuffix = getNegativeAffix(negative.suffix, false);
+        res.affix = { pos: [prefix, suffix], neg: [negPrefix, negSuffix] };
+        res.sign = 'sign-never';
+    }
+    else if (prefix || suffix) {
+        res.affix = { pos: [prefix, suffix] };
+    }
+    return res;
+}
+
+/** @internal */
+function isNumberingSystem(ns) {
+    const systems = [
+        'arab',
+        'arabext',
+        'bali',
+        'beng',
+        'deva',
+        'fullwide',
+        'gujr',
+        'guru',
+        'hanidec',
+        'khmr',
+        'knda',
+        'laoo',
+        'latn',
+        'limb',
+        'mlym',
+        'mong',
+        'mymr',
+        'orya',
+        'tamldec',
+        'telu',
+        'thai',
+        'tibt'
+    ];
+    return systems.indexOf(ns) !== -1;
+}
+
+// FIXME: subtype is not checked
+/** @internal */
+function isUnit(unit) {
+    const types = [
+        'acceleration',
+        'angle',
+        'area',
+        'concentr',
+        'consumption',
+        'digital',
+        'duration',
+        'electric',
+        'energy',
+        'force',
+        'frequency',
+        'graphics',
+        'length',
+        'light',
+        'mass',
+        'power',
+        'pressure',
+        'speed',
+        'temperature',
+        'torque',
+        'volume'
+    ];
+    const [type] = unit.split('-', 1);
+    return types.indexOf(type) !== -1;
+}
+
+const maxOptions = {
+    'compact-short': 0,
+    'compact-long': 0,
+    'notation-simple': 0,
+    scientific: 2,
+    engineering: 2,
+    percent: 0,
+    permille: 0,
+    'base-unit': 0,
+    currency: 1,
+    'measure-unit': 1,
+    'per-measure-unit': 1,
+    'unit-width-narrow': 0,
+    'unit-width-short': 0,
+    'unit-width-full-name': 0,
+    'unit-width-iso-code': 0,
+    'unit-width-hidden': 0,
+    'precision-integer': 0,
+    'precision-unlimited': 0,
+    'precision-currency-standard': 1,
+    'precision-currency-cash': 0,
+    'precision-increment': 1,
+    'rounding-mode-ceiling': 0,
+    'rounding-mode-floor': 0,
+    'rounding-mode-down': 0,
+    'rounding-mode-up': 0,
+    'rounding-mode-half-even': 0,
+    'rounding-mode-half-down': 0,
+    'rounding-mode-half-up': 0,
+    'rounding-mode-unnecessary': 0,
+    'integer-width': 1,
+    scale: 1,
+    'group-off': 0,
+    'group-min2': 0,
+    'group-auto': 0,
+    'group-on-aligned': 0,
+    'group-thousands': 0,
+    latin: 0,
+    'numbering-system': 1,
+    'sign-auto': 0,
+    'sign-always': 0,
+    'sign-never': 0,
+    'sign-accounting': 0,
+    'sign-accounting-always': 0,
+    'sign-except-zero': 0,
+    'sign-accounting-except-zero': 0,
+    'decimal-auto': 0,
+    'decimal-always': 0
+};
+const minOptions = {
+    currency: 1,
+    'integer-width': 1,
+    'measure-unit': 1,
+    'numbering-system': 1,
+    'per-measure-unit': 1,
+    'precision-increment': 1,
+    scale: 1
+};
+function hasMaxOption(stem) {
+    return stem in maxOptions;
+}
+function hasMinOption(stem) {
+    return stem in minOptions;
+}
+/** @internal */
+function validOptions(stem, options, onError) {
+    if (hasMaxOption(stem)) {
+        const maxOpt = maxOptions[stem];
+        if (options.length > maxOpt) {
+            if (maxOpt === 0) {
+                for (const opt of options)
+                    onError(new BadOptionError(stem, opt));
+            }
+            else {
+                onError(new TooManyOptionsError(stem, options, maxOpt));
+            }
+            return false;
+        }
+        else if (hasMinOption(stem) && options.length < minOptions[stem]) {
+            onError(new MissingOptionError(stem));
+            return false;
+        }
+    }
+    return true;
+}
+
+function parseBlueprintDigits(src, style) {
+    const re = style === 'fraction' ? /^\.(0*)(\+|#*)$/ : /^(@+)(\+|#*)$/;
+    const match = src && src.match(re);
+    if (match) {
+        const min = match[1].length;
+        switch (match[2].charAt(0)) {
+            case '':
+                return { min, max: min };
+            case '+':
+                return { min, max: null };
+            case '#': {
+                return { min, max: min + match[2].length };
+            }
+        }
+    }
+    return null;
+}
+function parsePrecisionBlueprint(stem, options, onError) {
+    const fd = parseBlueprintDigits(stem, 'fraction');
+    if (fd) {
+        if (options.length > 1)
+            onError(new TooManyOptionsError(stem, options, 1));
+        const res = {
+            style: 'precision-fraction',
+            source: stem,
+            minFraction: fd.min
+        };
+        if (fd.max != null)
+            res.maxFraction = fd.max;
+        const option = options[0];
+        const sd = parseBlueprintDigits(option, 'significant');
+        if (sd) {
+            res.source = `${stem}/${option}`;
+            res.minSignificant = sd.min;
+            if (sd.max != null)
+                res.maxSignificant = sd.max;
+        }
+        else if (option)
+            onError(new BadOptionError(stem, option));
+        return res;
+    }
+    const sd = parseBlueprintDigits(stem, 'significant');
+    if (sd) {
+        for (const opt of options)
+            onError(new BadOptionError(stem, opt));
+        const res = {
+            style: 'precision-fraction',
+            source: stem,
+            minSignificant: sd.min
+        };
+        if (sd.max != null)
+            res.maxSignificant = sd.max;
+        return res;
+    }
+    return null;
+}
+
+/** @internal */
+class TokenParser {
+    constructor(onError) {
+        this.skeleton = {};
+        this.onError = onError;
+    }
+    badOption(stem, opt) {
+        this.onError(new BadOptionError(stem, opt));
+    }
+    assertEmpty(key) {
+        const prev = this.skeleton[key];
+        if (prev)
+            this.onError(new MaskedValueError(key, prev));
+    }
+    parseToken(stem, options) {
+        if (!validOptions(stem, options, this.onError))
+            return;
+        const option = options[0];
+        const res = this.skeleton;
+        switch (stem) {
+            // notation
+            case 'compact-short':
+            case 'compact-long':
+            case 'notation-simple':
+                this.assertEmpty('notation');
+                res.notation = { style: stem };
+                break;
+            case 'scientific':
+            case 'engineering': {
+                let expDigits = null;
+                let expSign = undefined;
+                for (const opt of options) {
+                    switch (opt) {
+                        case 'sign-auto':
+                        case 'sign-always':
+                        case 'sign-never':
+                        case 'sign-accounting':
+                        case 'sign-accounting-always':
+                        case 'sign-except-zero':
+                        case 'sign-accounting-except-zero':
+                            expSign = opt;
+                            break;
+                        default:
+                            if (/^\+e+$/.test(opt))
+                                expDigits = opt.length - 1;
+                            else {
+                                this.badOption(stem, opt);
+                            }
+                    }
+                }
+                this.assertEmpty('notation');
+                const source = options.join('/');
+                res.notation =
+                    expDigits && expSign
+                        ? { style: stem, source, expDigits, expSign }
+                        : expDigits
+                            ? { style: stem, source, expDigits }
+                            : expSign
+                                ? { style: stem, source, expSign }
+                                : { style: stem, source };
+                break;
+            }
+            // unit
+            case 'percent':
+            case 'permille':
+            case 'base-unit':
+                this.assertEmpty('unit');
+                res.unit = { style: stem };
+                break;
+            case 'currency':
+                if (/^[A-Z]{3}$/.test(option)) {
+                    this.assertEmpty('unit');
+                    res.unit = { style: stem, currency: option };
+                }
+                else
+                    this.badOption(stem, option);
+                break;
+            case 'measure-unit': {
+                if (isUnit(option)) {
+                    this.assertEmpty('unit');
+                    res.unit = { style: stem, unit: option };
+                }
+                else
+                    this.badOption(stem, option);
+                break;
+            }
+            // unitPer
+            case 'per-measure-unit': {
+                if (isUnit(option)) {
+                    this.assertEmpty('unitPer');
+                    res.unitPer = option;
+                }
+                else
+                    this.badOption(stem, option);
+                break;
+            }
+            // unitWidth
+            case 'unit-width-narrow':
+            case 'unit-width-short':
+            case 'unit-width-full-name':
+            case 'unit-width-iso-code':
+            case 'unit-width-hidden':
+                this.assertEmpty('unitWidth');
+                res.unitWidth = stem;
+                break;
+            // precision
+            case 'precision-integer':
+            case 'precision-unlimited':
+            case 'precision-currency-cash':
+                this.assertEmpty('precision');
+                res.precision = { style: stem };
+                break;
+            case 'precision-currency-standard':
+                this.assertEmpty('precision');
+                if (option === 'w') {
+                    res.precision = { style: stem, trailingZero: 'stripIfInteger' };
+                }
+                else {
+                    res.precision = { style: stem };
+                }
+                break;
+            case 'precision-increment': {
+                const increment = Number(option);
+                if (increment > 0) {
+                    this.assertEmpty('precision');
+                    res.precision = { style: stem, increment };
+                }
+                else
+                    this.badOption(stem, option);
+                break;
+            }
+            // roundingMode
+            case 'rounding-mode-ceiling':
+            case 'rounding-mode-floor':
+            case 'rounding-mode-down':
+            case 'rounding-mode-up':
+            case 'rounding-mode-half-even':
+            case 'rounding-mode-half-odd':
+            case 'rounding-mode-half-ceiling':
+            case 'rounding-mode-half-floor':
+            case 'rounding-mode-half-down':
+            case 'rounding-mode-half-up':
+            case 'rounding-mode-unnecessary':
+                this.assertEmpty('roundingMode');
+                res.roundingMode = stem;
+                break;
+            // integerWidth
+            case 'integer-width': {
+                if (/^\+0*$/.test(option)) {
+                    this.assertEmpty('integerWidth');
+                    res.integerWidth = { source: option, min: option.length - 1 };
+                }
+                else {
+                    const m = option.match(/^#*(0*)$/);
+                    if (m) {
+                        this.assertEmpty('integerWidth');
+                        res.integerWidth = {
+                            source: option,
+                            min: m[1].length,
+                            max: m[0].length
+                        };
+                    }
+                    else
+                        this.badOption(stem, option);
+                }
+                break;
+            }
+            // scale
+            case 'scale': {
+                const scale = Number(option);
+                if (scale > 0) {
+                    this.assertEmpty('scale');
+                    res.scale = scale;
+                }
+                else
+                    this.badOption(stem, option);
+                break;
+            }
+            // group
+            case 'group-off':
+            case 'group-min2':
+            case 'group-auto':
+            case 'group-on-aligned':
+            case 'group-thousands':
+                this.assertEmpty('group');
+                res.group = stem;
+                break;
+            // numberingSystem
+            case 'latin':
+                this.assertEmpty('numberingSystem');
+                res.numberingSystem = 'latn';
+                break;
+            case 'numbering-system': {
+                if (isNumberingSystem(option)) {
+                    this.assertEmpty('numberingSystem');
+                    res.numberingSystem = option;
+                }
+                else
+                    this.badOption(stem, option);
+                break;
+            }
+            // sign
+            case 'sign-auto':
+            case 'sign-always':
+            case 'sign-never':
+            case 'sign-accounting':
+            case 'sign-accounting-always':
+            case 'sign-except-zero':
+            case 'sign-accounting-except-zero':
+                this.assertEmpty('sign');
+                res.sign = stem;
+                break;
+            // decimal
+            case 'decimal-auto':
+            case 'decimal-always':
+                this.assertEmpty('decimal');
+                res.decimal = stem;
+                break;
+            // precision blueprint
+            default: {
+                const precision = parsePrecisionBlueprint(stem, options, this.onError);
+                if (precision) {
+                    this.assertEmpty('precision');
+                    res.precision = precision;
+                }
+                else {
+                    this.onError(new BadStemError(stem));
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Parse an {@link
+ * https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md
+ * | ICU NumberFormatter skeleton} string into a {@link Skeleton} structure.
+ *
+ * @public
+ * @param src - The skeleton string
+ * @param onError - Called when the parser encounters a syntax error. The
+ *   function will still return a {@link Skeleton}, but it may not contain
+ *   information for all tokens. If not defined, the error will be thrown
+ *   instead.
+ *
+ * @example
+ * ```js
+ * import { parseNumberSkeleton } from '@messageformat/number-skeleton'
+ *
+ * parseNumberSkeleton('compact-short currency/GBP', console.error)
+ * // {
+ * //   notation: { style: 'compact-short' },
+ * //   unit: { style: 'currency', currency: 'GBP' }
+ * // }
+ * ```
+ */
+function parseNumberSkeleton(src, onError = error => {
+    throw error;
+}) {
+    const tokens = [];
+    for (const part of src.split(' ')) {
+        if (part) {
+            const options = part.split('/');
+            const stem = options.shift() || '';
+            tokens.push({ stem, options });
+        }
+    }
+    const parser = new TokenParser(onError);
+    for (const { stem, options } of tokens) {
+        parser.parseToken(stem, options);
+    }
+    return parser.skeleton;
+}
+
+/**
+ * Returns a number formatter function for the given locales and number skeleton
+ *
+ * @remarks
+ * Uses `Intl.NumberFormat` (ES2020) internally.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param skeleton - An ICU NumberFormatter pattern or `::`-prefixed skeleton
+ *   string, or a parsed `Skeleton` structure
+ * @param currency - If `skeleton` is a pattern string that includes ¤ tokens,
+ *   their skeleton representation requires a three-letter currency code.
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getNumberFormatter } from '@messageformat/number-skeleton'
+ *
+ * let src = ':: currency/CAD unit-width-narrow'
+ * let fmt = getNumberFormatter('en-CA', src, console.error)
+ * fmt(42) // '$42.00'
+ *
+ * src = '::percent scale/100'
+ * fmt = getNumberFormatter('en', src, console.error)
+ * fmt(0.3) // '30%'
+ * ```
+ */
+function getNumberFormatter(locales, skeleton, currency, onError) {
+    if (typeof skeleton === 'string') {
+        skeleton =
+            skeleton.indexOf('::') === 0
+                ? parseNumberSkeleton(skeleton.slice(2), onError)
+                : parseNumberPattern(skeleton, currency, onError);
+    }
+    const lc = getNumberFormatLocales(locales, skeleton);
+    const opt = getNumberFormatOptions(skeleton, onError);
+    const mod = getNumberFormatModifier(skeleton);
+    const nf = new Intl.NumberFormat(lc, opt);
+    if (skeleton.affix) {
+        const [p0, p1] = skeleton.affix.pos;
+        const [n0, n1] = skeleton.affix.neg || ['', ''];
+        return (value) => {
+            const n = nf.format(mod(value));
+            return value < 0 ? `${n0}${n}${n1}` : `${p0}${n}${p1}`;
+        };
+    }
+    return (value) => nf.format(mod(value));
+}
+/**
+ * Returns a string of JavaScript source that evaluates to a number formatter
+ * function with the same `(value: number) => string` signature as the function
+ * returned by {@link getNumberFormatter}.
+ *
+ * @remarks
+ * The returned function will memoize an `Intl.NumberFormat` instance.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param skeleton - An ICU NumberFormatter pattern or `::`-prefixed skeleton
+ *   string, or a parsed `Skeleton` structure
+ * @param currency - If `skeleton` is a pattern string that includes ¤ tokens,
+ *   their skeleton representation requires a three-letter currency code.
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getNumberFormatterSource } from '@messageformat/number-skeleton'
+ *
+ * getNumberFormatterSource('en', '::percent', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"style":"percent"};\n' +
+ * // '  var nf = new Intl.NumberFormat(["en"], opt);\n' +
+ * // '  var mod = function(n) { return n * 0.01; };\n' +
+ * // '  return function(value) { return nf.format(mod(value)); }\n' +
+ * // '})()'
+ *
+ * const src = getNumberFormatterSource('en-CA', ':: currency/CAD unit-width-narrow', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"style":"currency","currency":"CAD","currencyDisplay":"narrowSymbol","unitDisplay":"narrow"};\n' +
+ * // '  var nf = new Intl.NumberFormat(["en-CA"], opt);\n'
+ * // '  return function(value) { return nf.format(value); }\n' +
+ * // '})()'
+ * const fmt = new Function(`return ${src}`)()
+ * fmt(42) // '$42.00'
+ * ```
+ */
+function getNumberFormatterSource(locales, skeleton, currency, onError) {
+    if (typeof skeleton === 'string') {
+        skeleton =
+            skeleton.indexOf('::') === 0
+                ? parseNumberSkeleton(skeleton.slice(2), onError)
+                : parseNumberPattern(skeleton, currency, onError);
+    }
+    const lc = getNumberFormatLocales(locales, skeleton);
+    const opt = getNumberFormatOptions(skeleton, onError);
+    const modSrc = getNumberFormatModifierSource(skeleton);
+    const lines = [
+        `(function() {`,
+        `var opt = ${JSON.stringify(opt)};`,
+        `var nf = new Intl.NumberFormat(${JSON.stringify(lc)}, opt);`
+    ];
+    let res = 'nf.format(value)';
+    if (modSrc) {
+        lines.push(`var mod = ${modSrc};`);
+        res = 'nf.format(mod(value))';
+    }
+    if (skeleton.affix) {
+        const [p0, p1] = skeleton.affix.pos.map(s => JSON.stringify(s));
+        if (skeleton.affix.neg) {
+            const [n0, n1] = skeleton.affix.neg.map(s => JSON.stringify(s));
+            res = `value < 0 ? ${n0} + ${res} + ${n1} : ${p0} + ${res} + ${p1}`;
+        }
+        else {
+            res = `${p0} + ${res} + ${p1}`;
+        }
+    }
+    lines.push(`return function(value) { return ${res}; }`);
+    return lines.join('\n  ') + '\n})()';
+}
+
+const rtlLanguages = [
+    'ar',
+    'ckb',
+    'fa',
+    'he',
+    'ks($|[^bfh])',
+    'lrc',
+    'mzn',
+    'pa-Arab',
+    'ps',
+    'ug',
+    'ur',
+    'uz-Arab',
+    'yi'
+];
+const rtlRegExp = new RegExp('^' + rtlLanguages.join('|^'));
+function biDiMarkText(text, locale) {
+    const isLocaleRTL = rtlRegExp.test(locale);
+    const mark = JSON.stringify(isLocaleRTL ? '\u200F' : '\u200E');
+    return `${mark} + ${text} + ${mark}`;
+}
+
+const RUNTIME_MODULE = '@messageformat/runtime';
+const CARDINAL_MODULE = '@messageformat/runtime/lib/cardinals';
+const PLURAL_MODULE = '@messageformat/runtime/lib/plurals';
+const FORMATTER_MODULE = '@messageformat/runtime/lib/formatters';
+class Compiler {
+    constructor(options) {
+        this.arguments = [];
+        this.runtime = {};
+        this.options = options;
+    }
+    compile(src, plural, plurals) {
+        const { localeCodeFromKey, requireAllArguments, strict, strictPluralKeys } = this.options;
+        if (typeof src === 'object') {
+            const result = {};
+            for (const key of Object.keys(src)) {
+                const lc = localeCodeFromKey ? localeCodeFromKey(key) : key;
+                const pl = (plurals && lc && plurals[lc]) || plural;
+                result[key] = this.compile(src[key], pl, plurals);
+            }
+            return result;
+        }
+        this.plural = plural;
+        const parserOptions = {
+            cardinal: plural.cardinals,
+            ordinal: plural.ordinals,
+            strict,
+            strictPluralKeys
+        };
+        this.arguments = [];
+        const r = parser.parse(src, parserOptions).map(token => this.token(token, null));
+        const hasArgs = this.arguments.length > 0;
+        const res = this.concatenate(r, true);
+        if (requireAllArguments && hasArgs) {
+            this.setRuntimeFn('reqArgs');
+            const reqArgs = JSON.stringify(this.arguments);
+            return `(d) => { reqArgs(${reqArgs}, d); return ${res}; }`;
+        }
+        return `(${hasArgs ? 'd' : ''}) => ${res}`;
+    }
+    cases(token, pluralToken) {
+        let needOther = true;
+        const r = token.cases.map(({ key, tokens }) => {
+            if (key === 'other')
+                needOther = false;
+            const s = tokens.map(tok => this.token(tok, pluralToken));
+            return `${safeIdentifier.property(null, key.replace(/^=/, ''))}: ${this.concatenate(s, false)}`;
+        });
+        if (needOther) {
+            const { type } = token;
+            const { cardinals, ordinals } = this.plural;
+            if (type === 'select' ||
+                (type === 'plural' && cardinals.includes('other')) ||
+                (type === 'selectordinal' && ordinals.includes('other')))
+                throw new Error(`No 'other' form found in ${JSON.stringify(token)}`);
+        }
+        return `{ ${r.join(', ')} }`;
+    }
+    concatenate(tokens, root) {
+        const asValues = this.options.returnType === 'values';
+        return asValues && (root || tokens.length > 1)
+            ? '[' + tokens.join(', ') + ']'
+            : tokens.join(' + ') || '""';
+    }
+    token(token, pluralToken) {
+        if (token.type === 'content')
+            return JSON.stringify(token.value);
+        const { id, lc } = this.plural;
+        let args, fn;
+        if ('arg' in token) {
+            this.arguments.push(token.arg);
+            args = [safeIdentifier.property('d', token.arg)];
+        }
+        else
+            args = [];
+        switch (token.type) {
+            case 'argument':
+                return this.options.biDiSupport
+                    ? biDiMarkText(String(args[0]), lc)
+                    : String(args[0]);
+            case 'select':
+                fn = 'select';
+                if (pluralToken && this.options.strict)
+                    pluralToken = null;
+                args.push(this.cases(token, pluralToken));
+                this.setRuntimeFn('select');
+                break;
+            case 'selectordinal':
+                fn = 'plural';
+                args.push(token.pluralOffset || 0, id, this.cases(token, token), 1);
+                this.setLocale(id, true);
+                this.setRuntimeFn('plural');
+                break;
+            case 'plural':
+                fn = 'plural';
+                args.push(token.pluralOffset || 0, id, this.cases(token, token));
+                this.setLocale(id, false);
+                this.setRuntimeFn('plural');
+                break;
+            case 'function':
+                if (!this.options.customFormatters[token.key]) {
+                    if (token.key === 'date') {
+                        fn = this.setDateFormatter(token, args, pluralToken);
+                        break;
+                    }
+                    else if (token.key === 'number') {
+                        fn = this.setNumberFormatter(token, args, pluralToken);
+                        break;
+                    }
+                }
+                args.push(JSON.stringify(this.plural.locale));
+                if (token.param) {
+                    if (pluralToken && this.options.strict)
+                        pluralToken = null;
+                    const arg = this.getFormatterArg(token, pluralToken);
+                    if (arg)
+                        args.push(arg);
+                }
+                fn = token.key;
+                this.setFormatter(fn);
+                break;
+            case 'octothorpe':
+                if (!pluralToken)
+                    return '"#"';
+                args = [
+                    JSON.stringify(this.plural.locale),
+                    safeIdentifier.property('d', pluralToken.arg),
+                    pluralToken.pluralOffset || 0
+                ];
+                if (this.options.strict) {
+                    fn = 'strictNumber';
+                    args.push(JSON.stringify(pluralToken.arg));
+                    this.setRuntimeFn('strictNumber');
+                }
+                else {
+                    fn = 'number';
+                    this.setRuntimeFn('number');
+                }
+                break;
+        }
+        if (!fn)
+            throw new Error('Parser error for token ' + JSON.stringify(token));
+        return `${fn}(${args.join(', ')})`;
+    }
+    runtimeIncludes(key, type) {
+        if (safeIdentifier.identifier(key) !== key)
+            throw new SyntaxError(`Reserved word used as ${type} identifier: ${key}`);
+        const prev = this.runtime[key];
+        if (!prev || prev.type === type)
+            return prev;
+        throw new TypeError(`Cannot override ${prev.type} runtime function as ${type}: ${key}`);
+    }
+    setLocale(key, ord) {
+        const prev = this.runtimeIncludes(key, 'locale');
+        const { getCardinal, getPlural, isDefault } = this.plural;
+        let pf, module, toString;
+        if (!ord && isDefault && getCardinal) {
+            if (prev)
+                return;
+            pf = (n) => getCardinal(n);
+            module = CARDINAL_MODULE;
+            toString = () => String(getCardinal);
+        }
+        else {
+            if (prev && (!isDefault || prev.module === PLURAL_MODULE))
+                return;
+            pf = (n, ord) => getPlural(n, ord);
+            module = isDefault ? PLURAL_MODULE : getPlural.module || null;
+            toString = () => String(getPlural);
+        }
+        this.runtime[key] = Object.assign(pf, {
+            id: key,
+            module,
+            toString,
+            type: 'locale'
+        });
+    }
+    setRuntimeFn(key) {
+        if (this.runtimeIncludes(key, 'runtime'))
+            return;
+        this.runtime[key] = Object.assign(Runtime__namespace[key], {
+            id: key,
+            module: RUNTIME_MODULE,
+            type: 'runtime'
+        });
+    }
+    getFormatterArg({ key, param }, pluralToken) {
+        const fmt = this.options.customFormatters[key] ||
+            (isFormatterKey(key) && Formatters__namespace[key]);
+        if (!fmt || !param)
+            return null;
+        const argShape = ('arg' in fmt && fmt.arg) || 'string';
+        if (argShape === 'options') {
+            let value = '';
+            for (const tok of param) {
+                if (tok.type === 'content')
+                    value += tok.value;
+                else
+                    throw new SyntaxError(`Expected literal options for ${key} formatter`);
+            }
+            const options = {};
+            for (const pair of value.split(',')) {
+                const keyEnd = pair.indexOf(':');
+                if (keyEnd === -1)
+                    options[pair.trim()] = null;
+                else {
+                    const k = pair.substring(0, keyEnd).trim();
+                    const v = pair.substring(keyEnd + 1).trim();
+                    if (v === 'true')
+                        options[k] = true;
+                    else if (v === 'false')
+                        options[k] = false;
+                    else if (v === 'null')
+                        options[k] = null;
+                    else {
+                        const n = Number(v);
+                        options[k] = Number.isFinite(n) ? n : v;
+                    }
+                }
+            }
+            return JSON.stringify(options);
+        }
+        else {
+            const parts = param.map(tok => this.token(tok, pluralToken));
+            if (argShape === 'raw')
+                return `[${parts.join(', ')}]`;
+            const s = parts.join(' + ');
+            return s ? `(${s}).trim()` : '""';
+        }
+    }
+    setFormatter(key) {
+        if (this.runtimeIncludes(key, 'formatter'))
+            return;
+        let cf = this.options.customFormatters[key];
+        if (cf) {
+            if (typeof cf === 'function')
+                cf = { formatter: cf };
+            this.runtime[key] = Object.assign(cf.formatter, { type: 'formatter' }, 'module' in cf && cf.module && cf.id
+                ? { id: safeIdentifier.identifier(cf.id), module: cf.module }
+                : { id: null, module: null });
+        }
+        else if (isFormatterKey(key)) {
+            this.runtime[key] = Object.assign(Formatters__namespace[key], { type: 'formatter' }, { id: key, module: FORMATTER_MODULE });
+        }
+        else {
+            throw new Error(`Formatting function not found: ${key}`);
+        }
+    }
+    setDateFormatter({ param }, args, plural) {
+        const { locale } = this.plural;
+        const argStyle = param && param.length === 1 && param[0];
+        if (argStyle &&
+            argStyle.type === 'content' &&
+            /^\s*::/.test(argStyle.value)) {
+            const argSkeletonText = argStyle.value.trim().substr(2);
+            const key = safeIdentifier.identifier(`date_${locale}_${argSkeletonText}`, true);
+            if (!this.runtimeIncludes(key, 'formatter')) {
+                const fmt = getDateFormatter(locale, argSkeletonText);
+                this.runtime[key] = Object.assign(fmt, {
+                    id: key,
+                    module: null,
+                    toString: () => getDateFormatterSource(locale, argSkeletonText),
+                    type: 'formatter'
+                });
+            }
+            return key;
+        }
+        args.push(JSON.stringify(locale));
+        if (param && param.length > 0) {
+            if (plural && this.options.strict)
+                plural = null;
+            const s = param.map(tok => this.token(tok, plural));
+            args.push('(' + (s.join(' + ') || '""') + ').trim()');
+        }
+        this.setFormatter('date');
+        return 'date';
+    }
+    setNumberFormatter({ param }, args, plural) {
+        const { locale } = this.plural;
+        if (!param || param.length === 0) {
+            args.unshift(JSON.stringify(locale));
+            args.push('0');
+            this.setRuntimeFn('number');
+            return 'number';
+        }
+        args.push(JSON.stringify(locale));
+        if (param.length === 1 && param[0].type === 'content') {
+            const fmtArg = param[0].value.trim();
+            switch (fmtArg) {
+                case 'currency':
+                    args.push(JSON.stringify(this.options.currency));
+                    this.setFormatter('numberCurrency');
+                    return 'numberCurrency';
+                case 'integer':
+                    this.setFormatter('numberInteger');
+                    return 'numberInteger';
+                case 'percent':
+                    this.setFormatter('numberPercent');
+                    return 'numberPercent';
+            }
+            const cm = fmtArg.match(/^currency:([A-Z]+)$/);
+            if (cm) {
+                args.push(JSON.stringify(cm[1]));
+                this.setFormatter('numberCurrency');
+                return 'numberCurrency';
+            }
+            const key = safeIdentifier.identifier(`number_${locale}_${fmtArg}`, true);
+            if (!this.runtimeIncludes(key, 'formatter')) {
+                const { currency } = this.options;
+                const fmt = getNumberFormatter(locale, fmtArg, currency);
+                this.runtime[key] = Object.assign(fmt, {
+                    id: null,
+                    module: null,
+                    toString: () => getNumberFormatterSource(locale, fmtArg, currency),
+                    type: 'formatter'
+                });
+            }
+            return key;
+        }
+        if (plural && this.options.strict)
+            plural = null;
+        const s = param.map(tok => this.token(tok, plural));
+        args.push('(' + (s.join(' + ') || '""') + ').trim()');
+        args.push(JSON.stringify(this.options.currency));
+        this.setFormatter('numberFmt');
+        return 'numberFmt';
+    }
+}
+function isFormatterKey(key) {
+    return key in Formatters__namespace;
+}
+
+module.exports = Compiler;

node_modules/@messageformat/core/lib/messageformat.d.ts

@@ -0,0 +1,207 @@
+import { PluralFunction, PluralObject } from './plurals';
+export { PluralFunction };
+/**
+ * A compiled message function, which may accept an object parameter
+ *
+ * @public
+ */
+export type MessageFunction<ReturnType extends 'string' | 'values'> = (param?: Record<string, unknown> | unknown[]) => ReturnType extends 'string' ? string : unknown[];
+/**
+ * A custom formatter function. See
+ * {@link https://messageformat.github.io/messageformat/custom-formatters/ | Custom Formatters}
+ * for more details.
+ *
+ * @public
+ */
+export type CustomFormatter = (value: unknown, locale: string, arg: string | null) => unknown;
+/**
+ * Options for the MessageFormat constructor
+ *
+ * @public
+ */
+export interface MessageFormatOptions<ReturnType extends 'string' | 'values' = 'string' | 'values'> {
+    /**
+     * Add Unicode control characters to all input parts to preserve the
+     * integrity of the output when mixing LTR and RTL text
+     *
+     * Default: `false`
+     */
+    biDiSupport?: boolean;
+    /**
+     * The currency to use when formatting `{V, number, currency}`
+     *
+     * Default: `USD`
+     */
+    currency?: string;
+    /**
+     * Map of custom formatting functions to include. See
+     * {@link https://messageformat.github.io/messageformat/custom-formatters/ | Custom Formatters}
+     * for more details.
+     */
+    customFormatters?: {
+        [key: string]: CustomFormatter | {
+            formatter: CustomFormatter;
+            arg?: 'string' | 'raw' | 'options';
+            id?: string;
+            module?: string;
+        };
+    };
+    /**
+     * If defined, used by {@link compileModule} to identify and map keys to
+     * the locale identifiers used by formatters and plural rules.
+     * The values returned by the function should match the `locale` argument.
+     *
+     * Default: `undefined`
+     *
+     * @example
+     * ```js
+     * // Support all recognised Unicode locale identifiers
+     * function localeCodeFromKey(key) {
+     *   try {
+     *     // Ignore all language subtags
+     *     return new Intl.Locale(key).language
+     *   } catch {
+     *     return null
+     *   }
+     * }
+     * ```
+     */
+    localeCodeFromKey?: ((key: string) => string | null | undefined) | null;
+    /**
+     * Require all message arguments to be set with a defined value
+     *
+     * Default: `false`
+     */
+    requireAllArguments?: boolean;
+    /**
+     * Return type of compiled functions; either a concatenated `'string'` or an
+     * array (possibly hierarchical) of `'values'`.
+     *
+     * Default: `'string'`
+     */
+    returnType?: ReturnType;
+    /**
+     * Follow the ICU MessageFormat spec more closely, but not allowing custom
+     * formatters and by allowing`#` only directly within a plural or
+     * selectordinal case, rather than in any inner select case as well. See the
+     * {@link http://messageformat.github.io/messageformat/api/parser.parseoptions.strict/ | parser option}
+     * for more details.
+     *
+     * Default: `false`
+     */
+    strict?: boolean;
+    /**
+     * Enable strict checks for plural keys according to
+     * {@link http://cldr.unicode.org/index/cldr-spec/plural-rules | Unicode CLDR}.
+     * When set to `false`, the compiler will also accept any invalid plural keys.
+     * Also see the corresponding {@link @messageformat/parser#ParseOptions | parser option}.
+     *
+     * Default: `true`
+     */
+    strictPluralKeys?: boolean;
+}
+/**
+ * Returned by {@link MessageFormat.resolvedOptions}
+ * @public
+ */
+export interface ResolvedMessageFormatOptions<ReturnType extends 'string' | 'values'> extends Required<MessageFormatOptions<ReturnType>> {
+    /** The default locale */
+    locale: string;
+    /** All of the supported plurals */
+    plurals: PluralObject[];
+}
+/**
+ * The core MessageFormat-to-JavaScript compiler
+ *
+ * @public
+ * @example
+ * ```js
+ * import MessageFormat from '@messageformat/core'
+ * const mf = new MessageFormat('en')
+ *
+ * const msgSrc = `{GENDER, select,
+ *   male {He} female {She} other {They}
+ * } found {RES, plural,
+ *   =0 {no results} one {1 result} other {# results}
+ * }.`;
+ * const msg = mf.compile(msgSrc)
+ *
+ * msg({ GENDER: 'male', RES: 1 })    // 'He found 1 result.'
+ * msg({ GENDER: 'female', RES: 1 })  // 'She found 1 result.'
+ * msg({ GENDER: 'male', RES: 0 })    // 'He found no results.'
+ * msg({ RES: 2 })                    // 'They found 2 results.'
+ * ```
+ */
+export default class MessageFormat<ReturnType extends 'string' | 'values' = 'string'> {
+    /**
+     * Used by the constructor when no `locale` argument is given.
+     * Default: `'en'`
+     */
+    static defaultLocale: string;
+    /**
+     * Escape characaters that may be considered as MessageFormat markup
+     *
+     * @remarks
+     * This surrounds the characters `{`, `}` and optionally `#` with 'quotes'.
+     * This will allow those characters to not be considered as MessageFormat control characters.
+     *
+     * @param str - The input string
+     * @param octothorpe - Also escape `#`
+     * @returns The escaped string
+     */
+    static escape(str: string, octothorpe?: boolean): string;
+    /**
+     * Returns a subset of `locales` consisting of those for which MessageFormat
+     * has built-in plural category support.
+     */
+    static supportedLocalesOf(locales: string | string[]): string[];
+    /** @internal */
+    options: Required<MessageFormatOptions<ReturnType>>;
+    /** @internal */
+    plurals: PluralObject[];
+    /**
+     * Create a new MessageFormat compiler
+     *
+     * @remarks
+     * If given multiple valid locales, the first will be the default.
+     * If `locale` is empty, it will fall back to `MessageFormat.defaultLocale`.
+     *
+     * String `locale` values will be matched to plural categorisation functions provided by the Unicode CLDR.
+     * If defining your own instead, use named functions, optionally providing them with the properties:
+     * `cardinals: string[]`, `ordinals: string[]`, and `module: string`
+     * (to import the formatter as a runtime dependency, rather than inlining its source).
+     *
+     * If `locale` has the special value `'*'`, it will match **all** available locales.
+     * This may be useful if you want your messages to be completely determined by your data,
+     * but may provide surprising results if your input message object includes any 2-3 character keys that are not locale identifiers.
+     *
+     * @param locale - The locale or locales supported by this MessageFormat instance.
+     * @param options - Options for this instance
+     */
+    constructor(locale: string | PluralFunction | Array<string | PluralFunction> | null, options?: MessageFormatOptions<ReturnType>);
+    /**
+     * Returns a new object with properties reflecting the default locale,
+     * plurals, and other options computed during initialization.
+     */
+    resolvedOptions(): ResolvedMessageFormatOptions<ReturnType>;
+    /**
+     * Compile a message into a function
+     *
+     * @remarks
+     * Given a string `message` with ICU MessageFormat declarations, the result is
+     * a function taking a single Object parameter representing each of the
+     * input's defined variables, using the first valid locale.
+     *
+     * @param message - The input message to be compiled, in ICU MessageFormat
+     * @returns The compiled function
+     *
+     * @example
+     * ```js
+     * const mf = new MessageFormat('en')
+     * const msg = mf.compile('A {TYPE} example.')
+     *
+     * msg({ TYPE: 'simple' })  // 'A simple example.'
+     * ```
+     */
+    compile(message: string): MessageFunction<ReturnType>;
+}

node_modules/@messageformat/core/lib/messageformat.js

@@ -0,0 +1,135 @@
+'use strict';
+
+var Compiler = require('./compiler');
+var Cardinals = require('make-plural/cardinals');
+var PluralCategories = require('make-plural/pluralCategories');
+var Plurals = require('make-plural/plurals');
+var safeIdentifier = require('safe-identifier');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var Cardinals__namespace = /*#__PURE__*/_interopNamespaceDefault(Cardinals);
+var PluralCategories__namespace = /*#__PURE__*/_interopNamespaceDefault(PluralCategories);
+var Plurals__namespace = /*#__PURE__*/_interopNamespaceDefault(Plurals);
+
+function normalize(locale) {
+    if (typeof locale !== 'string' || locale.length < 2)
+        throw new RangeError(`Invalid language tag: ${locale}`);
+    if (locale.startsWith('pt-PT'))
+        return 'pt-PT';
+    const m = locale.match(/.+?(?=[-_])/);
+    return m ? m[0] : locale;
+}
+function getPlural(locale) {
+    if (typeof locale === 'function') {
+        const lc = normalize(locale.name);
+        return {
+            isDefault: false,
+            id: safeIdentifier.identifier(lc),
+            lc,
+            locale: locale.name,
+            getPlural: locale,
+            cardinals: locale.cardinals || [],
+            ordinals: locale.ordinals || []
+        };
+    }
+    const lc = normalize(locale);
+    const id = safeIdentifier.identifier(lc);
+    if (isPluralId(id)) {
+        return {
+            isDefault: true,
+            id,
+            lc,
+            locale,
+            getCardinal: Cardinals__namespace[id],
+            getPlural: Plurals__namespace[id],
+            cardinals: PluralCategories__namespace[id].cardinal,
+            ordinals: PluralCategories__namespace[id].ordinal
+        };
+    }
+    return null;
+}
+function getAllPlurals(firstLocale) {
+    const keys = Object.keys(Plurals__namespace).filter(key => key !== firstLocale);
+    keys.unshift(firstLocale);
+    return keys.map(getPlural);
+}
+function hasPlural(locale) {
+    const lc = normalize(locale);
+    return safeIdentifier.identifier(lc) in Plurals__namespace;
+}
+function isPluralId(id) {
+    return id in Plurals__namespace;
+}
+
+class MessageFormat {
+    static escape(str, octothorpe) {
+        const esc = octothorpe ? /[#{}]/g : /[{}]/g;
+        return String(str).replace(esc, "'$&'");
+    }
+    static supportedLocalesOf(locales) {
+        const la = Array.isArray(locales) ? locales : [locales];
+        return la.filter(hasPlural);
+    }
+    constructor(locale, options) {
+        this.plurals = [];
+        this.options = Object.assign({
+            biDiSupport: false,
+            currency: 'USD',
+            customFormatters: {},
+            localeCodeFromKey: null,
+            requireAllArguments: false,
+            returnType: 'string',
+            strict: (options && options.strictNumberSign) || false,
+            strictPluralKeys: true
+        }, options);
+        if (locale === '*') {
+            this.plurals = getAllPlurals(MessageFormat.defaultLocale);
+        }
+        else if (Array.isArray(locale)) {
+            this.plurals = locale.map(getPlural).filter(Boolean);
+        }
+        else if (locale) {
+            const pl = getPlural(locale);
+            if (pl)
+                this.plurals = [pl];
+        }
+        if (this.plurals.length === 0) {
+            const pl = getPlural(MessageFormat.defaultLocale);
+            this.plurals = [pl];
+        }
+    }
+    resolvedOptions() {
+        return Object.assign(Object.assign({}, this.options), { locale: this.plurals[0].locale, plurals: this.plurals });
+    }
+    compile(message) {
+        const compiler = new Compiler(this.options);
+        const fnBody = 'return ' + compiler.compile(message, this.plurals[0]);
+        const nfArgs = [];
+        const fnArgs = [];
+        for (const [key, fmt] of Object.entries(compiler.runtime)) {
+            nfArgs.push(key);
+            fnArgs.push(fmt);
+        }
+        const fn = new Function(...nfArgs, fnBody);
+        return fn(...fnArgs);
+    }
+}
+MessageFormat.defaultLocale = 'en';
+
+module.exports = MessageFormat;

node_modules/@messageformat/core/lib/plurals.d.ts

@@ -0,0 +1,33 @@
+import * as Plurals from 'make-plural/plurals';
+/**
+ * Function used to define the pluralisation for a locale
+ *
+ * @public
+ * @remarks
+ * `(value: number | string, ord?: boolean) => PluralCateogry`
+ *
+ * May be used as a {@link MessageFormat} constructor `locale` argument.
+ */
+export interface PluralFunction {
+    /** Foo bar */
+    (value: number | string, ord?: boolean): Plurals.PluralCategory;
+    /** Which plurals may be returned if `ord` is falsy */
+    cardinals?: Plurals.PluralCategory[];
+    /** Which plurals may be returned if `ord` is true */
+    ordinals?: Plurals.PluralCategory[];
+    /** The name of the module from which this function may be imported */
+    module?: string;
+}
+export interface PluralObject {
+    isDefault: boolean;
+    id: string;
+    lc: string;
+    locale: string;
+    getCardinal?: (value: string | number) => Plurals.PluralCategory;
+    getPlural: PluralFunction;
+    cardinals: Plurals.PluralCategory[];
+    ordinals: Plurals.PluralCategory[];
+}
+export declare function getPlural(locale: string | PluralFunction): PluralObject | null;
+export declare function getAllPlurals(firstLocale: string): PluralObject[];
+export declare function hasPlural(locale: string): boolean;

node_modules/@messageformat/core/lib/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.35.2"
+    }
+  ]
+}

node_modules/@messageformat/core/messageformat.js

@@ -0,0 +1,6285 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.MessageFormat = factory());
+})(this, (function () { 'use strict';
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var __assign = function () {
+      __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    function __values(o) {
+      var s = typeof Symbol === "function" && Symbol.iterator,
+        m = s && o[s],
+        i = 0;
+      if (m) return m.call(o);
+      if (o && typeof o.length === "number") return {
+        next: function () {
+          if (o && i >= o.length) o = void 0;
+          return {
+            value: o && o[i++],
+            done: !o
+          };
+        }
+      };
+      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o),
+        r,
+        ar = [],
+        e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = {
+          error: error
+        };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    }
+    function __spreadArray(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    /**
+     * Parent class for errors.
+     *
+     * @remarks
+     * Errors with `type: "warning"` do not necessarily indicate that the parser
+     * encountered an error. In addition to a human-friendly `message`, may also
+     * includes the `token` at which the error was encountered.
+     *
+     * @public
+     */
+    class DateFormatError extends Error {
+      /** @internal */
+      constructor(msg, token, type) {
+        super(msg);
+        this.token = token;
+        this.type = type || 'error';
+      }
+    }
+    const alpha = width => width < 4 ? 'short' : width === 4 ? 'long' : 'narrow';
+    const numeric = width => width % 2 === 0 ? '2-digit' : 'numeric';
+    function yearOptions(token, onError) {
+      switch (token.char) {
+        case 'y':
+          return {
+            year: numeric(token.width)
+          };
+        case 'r':
+          return {
+            calendar: 'gregory',
+            year: 'numeric'
+          };
+        case 'u':
+        case 'U':
+        case 'Y':
+        default:
+          onError(`${token.desc} is not supported; falling back to year:numeric`, DateFormatError.WARNING);
+          return {
+            year: 'numeric'
+          };
+      }
+    }
+    function monthStyle(token, onError) {
+      switch (token.width) {
+        case 1:
+          return 'numeric';
+        case 2:
+          return '2-digit';
+        case 3:
+          return 'short';
+        case 4:
+          return 'long';
+        case 5:
+          return 'narrow';
+        default:
+          onError(`${token.desc} is not supported with width ${token.width}`);
+          return undefined;
+      }
+    }
+    function dayStyle(token, onError) {
+      const {
+        char,
+        desc,
+        width
+      } = token;
+      if (char === 'd') return numeric(width);else {
+        onError(`${desc} is not supported`);
+        return undefined;
+      }
+    }
+    function weekdayStyle(token, onError) {
+      const {
+        char,
+        desc,
+        width
+      } = token;
+      if ((char === 'c' || char === 'e') && width < 3) {
+        // ignoring stand-alone-ness
+        const msg = `Numeric value is not supported for ${desc}; falling back to weekday:short`;
+        onError(msg, DateFormatError.WARNING);
+      }
+      // merging narrow styles
+      return alpha(width);
+    }
+    function hourOptions(token) {
+      const hour = numeric(token.width);
+      let hourCycle;
+      switch (token.char) {
+        case 'h':
+          hourCycle = 'h12';
+          break;
+        case 'H':
+          hourCycle = 'h23';
+          break;
+        case 'k':
+          hourCycle = 'h24';
+          break;
+        case 'K':
+          hourCycle = 'h11';
+          break;
+      }
+      return hourCycle ? {
+        hour,
+        hourCycle
+      } : {
+        hour
+      };
+    }
+    function timeZoneNameStyle(token, onError) {
+      // so much fallback behaviour here
+      const {
+        char,
+        desc,
+        width
+      } = token;
+      switch (char) {
+        case 'v':
+        case 'z':
+          return width === 4 ? 'long' : 'short';
+        case 'V':
+          if (width === 4) return 'long';
+          onError(`${desc} is not supported with width ${width}`);
+          return undefined;
+        case 'X':
+          onError(`${desc} is not supported`);
+          return undefined;
+      }
+      return 'short';
+    }
+    function compileOptions(token, onError) {
+      switch (token.field) {
+        case 'era':
+          return {
+            era: alpha(token.width)
+          };
+        case 'year':
+          return yearOptions(token, onError);
+        case 'month':
+          return {
+            month: monthStyle(token, onError)
+          };
+        case 'day':
+          return {
+            day: dayStyle(token, onError)
+          };
+        case 'weekday':
+          return {
+            weekday: weekdayStyle(token, onError)
+          };
+        case 'period':
+          return undefined;
+        case 'hour':
+          return hourOptions(token);
+        case 'min':
+          return {
+            minute: numeric(token.width)
+          };
+        case 'sec':
+          return {
+            second: numeric(token.width)
+          };
+        case 'tz':
+          return {
+            timeZoneName: timeZoneNameStyle(token, onError)
+          };
+        case 'quarter':
+        case 'week':
+        case 'sec-frac':
+        case 'ms':
+          onError(`${token.desc} is not supported`);
+      }
+      return undefined;
+    }
+    function getDateFormatOptions(tokens) {
+      let onError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : error => {
+        throw error;
+      };
+      const options = {};
+      const fields = [];
+      for (const token of tokens) {
+        const {
+          error,
+          field,
+          str
+        } = token;
+        if (error) {
+          const dte = new DateFormatError(error.message, token);
+          dte.stack = error.stack;
+          onError(dte);
+        }
+        if (str) {
+          const msg = `Ignoring string part: ${str}`;
+          onError(new DateFormatError(msg, token, DateFormatError.WARNING));
+        }
+        if (field) {
+          if (fields.indexOf(field) === -1) fields.push(field);else onError(new DateFormatError(`Duplicate ${field} token`, token));
+        }
+        const opt = compileOptions(token, (msg, isWarning) => onError(new DateFormatError(msg, token, isWarning)));
+        if (opt) Object.assign(options, opt);
+      }
+      return options;
+    }
+
+    const fields = {
+      G: {
+        field: 'era',
+        desc: 'Era'
+      },
+      y: {
+        field: 'year',
+        desc: 'Year'
+      },
+      Y: {
+        field: 'year',
+        desc: 'Year of "Week of Year"'
+      },
+      u: {
+        field: 'year',
+        desc: 'Extended year'
+      },
+      U: {
+        field: 'year',
+        desc: 'Cyclic year name'
+      },
+      r: {
+        field: 'year',
+        desc: 'Related Gregorian year'
+      },
+      Q: {
+        field: 'quarter',
+        desc: 'Quarter'
+      },
+      q: {
+        field: 'quarter',
+        desc: 'Stand-alone quarter'
+      },
+      M: {
+        field: 'month',
+        desc: 'Month in year'
+      },
+      L: {
+        field: 'month',
+        desc: 'Stand-alone month in year'
+      },
+      w: {
+        field: 'week',
+        desc: 'Week of year'
+      },
+      W: {
+        field: 'week',
+        desc: 'Week of month'
+      },
+      d: {
+        field: 'day',
+        desc: 'Day in month'
+      },
+      D: {
+        field: 'day',
+        desc: 'Day of year'
+      },
+      F: {
+        field: 'day',
+        desc: 'Day of week in month'
+      },
+      g: {
+        field: 'day',
+        desc: 'Modified julian day'
+      },
+      E: {
+        field: 'weekday',
+        desc: 'Day of week'
+      },
+      e: {
+        field: 'weekday',
+        desc: 'Local day of week'
+      },
+      c: {
+        field: 'weekday',
+        desc: 'Stand-alone local day of week'
+      },
+      a: {
+        field: 'period',
+        desc: 'AM/PM marker'
+      },
+      b: {
+        field: 'period',
+        desc: 'AM/PM/noon/midnight marker'
+      },
+      B: {
+        field: 'period',
+        desc: 'Flexible day period'
+      },
+      h: {
+        field: 'hour',
+        desc: 'Hour in AM/PM (1~12)'
+      },
+      H: {
+        field: 'hour',
+        desc: 'Hour in day (0~23)'
+      },
+      k: {
+        field: 'hour',
+        desc: 'Hour in day (1~24)'
+      },
+      K: {
+        field: 'hour',
+        desc: 'Hour in AM/PM (0~11)'
+      },
+      j: {
+        field: 'hour',
+        desc: 'Hour in preferred cycle'
+      },
+      J: {
+        field: 'hour',
+        desc: 'Hour in preferred cycle without marker'
+      },
+      C: {
+        field: 'hour',
+        desc: 'Hour in preferred cycle with flexible marker'
+      },
+      m: {
+        field: 'min',
+        desc: 'Minute in hour'
+      },
+      s: {
+        field: 'sec',
+        desc: 'Second in minute'
+      },
+      S: {
+        field: 'sec-frac',
+        desc: 'Fractional second'
+      },
+      A: {
+        field: 'ms',
+        desc: 'Milliseconds in day'
+      },
+      z: {
+        field: 'tz',
+        desc: 'Time Zone: specific non-location'
+      },
+      Z: {
+        field: 'tz',
+        desc: 'Time Zone'
+      },
+      O: {
+        field: 'tz',
+        desc: 'Time Zone: localized'
+      },
+      v: {
+        field: 'tz',
+        desc: 'Time Zone: generic non-location'
+      },
+      V: {
+        field: 'tz',
+        desc: 'Time Zone: ID'
+      },
+      X: {
+        field: 'tz',
+        desc: 'Time Zone: ISO8601 with Z'
+      },
+      x: {
+        field: 'tz',
+        desc: 'Time Zone: ISO8601'
+      }
+    };
+    const isLetter = char => char >= 'A' && char <= 'Z' || char >= 'a' && char <= 'z';
+    function readFieldToken(src, pos) {
+      const char = src[pos];
+      let width = 1;
+      while (src[++pos] === char) ++width;
+      const field = fields[char];
+      if (!field) {
+        const msg = `The letter ${char} is not a valid field identifier`;
+        return {
+          char,
+          error: new Error(msg),
+          width
+        };
+      }
+      return {
+        char,
+        field: field.field,
+        desc: field.desc,
+        width
+      };
+    }
+    function readQuotedToken(src, pos) {
+      let str = src[++pos];
+      let width = 2;
+      if (str === "'") return {
+        char: "'",
+        str,
+        width
+      };
+      while (true) {
+        const next = src[++pos];
+        ++width;
+        if (next === undefined) {
+          const msg = `Unterminated quoted literal in pattern: ${str || src}`;
+          return {
+            char: "'",
+            error: new Error(msg),
+            str,
+            width
+          };
+        } else if (next === "'") {
+          if (src[++pos] !== "'") return {
+            char: "'",
+            str,
+            width
+          };else ++width;
+        }
+        str += next;
+      }
+    }
+    function readToken(src, pos) {
+      const char = src[pos];
+      if (!char) return null;
+      if (isLetter(char)) return readFieldToken(src, pos);
+      if (char === "'") return readQuotedToken(src, pos);
+      let str = char;
+      let width = 1;
+      while (true) {
+        const next = src[++pos];
+        if (!next || isLetter(next) || next === "'") return {
+          char,
+          str,
+          width
+        };
+        str += next;
+        width += 1;
+      }
+    }
+    /**
+     * Parse an {@link http://userguide.icu-project.org/formatparse/datetime | ICU
+     * DateFormat skeleton} string into a {@link DateToken} array.
+     *
+     * @remarks
+     * Errors will not be thrown, but if encountered are included as the relevant
+     * token's `error` value.
+     *
+     * @public
+     * @param src - The skeleton string
+     *
+     * @example
+     * ```js
+     * import { parseDateTokens } from '@messageformat/date-skeleton'
+     *
+     * parseDateTokens('GrMMMdd', console.error)
+     * // [
+     * //   { char: 'G', field: 'era', desc: 'Era', width: 1 },
+     * //   { char: 'r', field: 'year', desc: 'Related Gregorian year', width: 1 },
+     * //   { char: 'M', field: 'month', desc: 'Month in year', width: 3 },
+     * //   { char: 'd', field: 'day', desc: 'Day in month', width: 2 }
+     * // ]
+     * ```
+     */
+    function parseDateTokens(src) {
+      const tokens = [];
+      let pos = 0;
+      while (true) {
+        const token = readToken(src, pos);
+        if (!token) return tokens;
+        tokens.push(token);
+        pos += token.width;
+      }
+    }
+
+    /**
+     * Returns a date formatter function for the given locales and date skeleton
+     *
+     * @remarks
+     * Uses `Intl.DateTimeFormat` internally.
+     *
+     * @public
+     * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+     * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+     *   `DateToken` tokens
+     * @param onError - If defined, will be called separately for each encountered
+     *   parsing error and unsupported feature.
+     * @example
+     * ```js
+     * import { getDateFormatter } from '@messageformat/date-skeleton'
+     *
+     * // 2006 Jan 2, 15:04:05.789 in local time
+     * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+     *
+     * let fmt = getDateFormatter('en-CA', 'GrMMMdd', console.error)
+     * fmt(date) // 'Jan. 02, 2006 AD'
+     *
+     * fmt = getDateFormatter('en-CA', 'hamszzzz', console.error)
+     * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+     * ```
+     */
+    function getDateFormatter(locales, tokens, onError) {
+      if (typeof tokens === 'string') tokens = parseDateTokens(tokens);
+      const opt = getDateFormatOptions(tokens, onError);
+      const dtf = new Intl.DateTimeFormat(locales, opt);
+      return date => dtf.format(date);
+    }
+    /**
+     * Returns a string of JavaScript source that evaluates to a date formatter
+     * function with the same `(date: Date | number) => string` signature as the
+     * function returned by {@link getDateFormatter}.
+     *
+     * @remarks
+     * The returned function will memoize an `Intl.DateTimeFormat` instance.
+     *
+     * @public
+     * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+     * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+     *   `DateToken` tokens
+     * @param onError - If defined, will be called separately for each encountered
+     *   parsing error and unsupported feature.
+     * @example
+     * ```js
+     * import { getDateFormatterSource } from '@messageformat/date-skeleton'
+     *
+     * getDateFormatterSource('en-CA', 'GrMMMdd', console.error)
+     * // '(function() {\n' +
+     * // '  var opt = {"era":"short","calendar":"gregory","year":"numeric",' +
+     * //      '"month":"short","day":"2-digit"};\n' +
+     * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+     * // '  return function(value) { return dtf.format(value); }\n' +
+     * // '})()'
+     *
+     * const src = getDateFormatterSource('en-CA', 'hamszzzz', console.error)
+     * // '(function() {\n' +
+     * // '  var opt = {"hour":"numeric","hourCycle":"h12","minute":"numeric",' +
+     * //      '"second":"numeric","timeZoneName":"long"};\n' +
+     * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+     * // '  return function(value) { return dtf.format(value); }\n' +
+     * // '})()'
+     *
+     * const fmt = new Function(`return ${src}`)()
+     * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+     * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+     * ```
+     */
+    function getDateFormatterSource(locales, tokens, onError) {
+      if (typeof tokens === 'string') tokens = parseDateTokens(tokens);
+      const opt = getDateFormatOptions(tokens, onError);
+      const lines = [`(function() {`, `var opt = ${JSON.stringify(opt)};`, `var dtf = new Intl.DateTimeFormat(${JSON.stringify(locales)}, opt);`, `return function(value) { return dtf.format(value); }`];
+      return lines.join('\n  ') + '\n})()';
+    }
+
+    /**
+     * Base class for errors. In addition to a `code` and a human-friendly
+     * `message`, may also includes the token `stem` as well as other fields.
+     *
+     * @public
+     */
+    class NumberFormatError extends Error {
+      /** @internal */
+      constructor(code, msg) {
+        super(msg);
+        this.code = code;
+      }
+    }
+    /** @internal */
+    class BadOptionError extends NumberFormatError {
+      constructor(stem, opt) {
+        super('BAD_OPTION', `Unknown ${stem} option: ${opt}`);
+        this.stem = stem;
+        this.option = opt;
+      }
+    }
+    /** @internal */
+    class BadStemError extends NumberFormatError {
+      constructor(stem) {
+        super('BAD_STEM', `Unknown stem: ${stem}`);
+        this.stem = stem;
+      }
+    }
+    /** @internal */
+    class MaskedValueError extends NumberFormatError {
+      constructor(type, prev) {
+        super('MASKED_VALUE', `Value for ${type} is set multiple times`);
+        this.type = type;
+        this.prev = prev;
+      }
+    }
+    /** @internal */
+    class MissingOptionError extends NumberFormatError {
+      constructor(stem) {
+        super('MISSING_OPTION', `Required option missing for ${stem}`);
+        this.stem = stem;
+      }
+    }
+    /** @internal */
+    class PatternError extends NumberFormatError {
+      constructor(char, msg) {
+        super('BAD_PATTERN', msg);
+        this.char = char;
+      }
+    }
+    /** @internal */
+    class TooManyOptionsError extends NumberFormatError {
+      constructor(stem, options, maxOpt) {
+        const maxOptStr = maxOpt > 1 ? `${maxOpt} options` : 'one option';
+        super('TOO_MANY_OPTIONS', `Token ${stem} only supports ${maxOptStr} (got ${options.length})`);
+        this.stem = stem;
+        this.options = options;
+      }
+    }
+    /** @internal */
+    class UnsupportedError extends NumberFormatError {
+      constructor(stem, source) {
+        super('UNSUPPORTED', `The stem ${stem} is not supported`);
+        this.stem = stem;
+        if (source) {
+          this.message += ` with value ${source}`;
+          this.source = source;
+        }
+      }
+    }
+
+    /**
+     * Add
+     * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation | numbering-system tags}
+     * to locale identifiers
+     *
+     * @internal
+     */
+    function getNumberFormatLocales(locales, _ref) {
+      let {
+        numberingSystem
+      } = _ref;
+      if (!Array.isArray(locales)) locales = [locales];
+      return numberingSystem ? locales.map(lc => {
+        const ext = lc.indexOf('-u-') === -1 ? 'u-nu' : 'nu';
+        return `${lc}-${ext}-${numberingSystem}`;
+      }).concat(locales) : locales;
+    }
+
+    // from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
+    function round(x, precision) {
+      const y = +x + precision / 2;
+      return y - y % +precision;
+    }
+    function getNumberFormatMultiplier(_ref) {
+      let {
+        scale,
+        unit
+      } = _ref;
+      let mult = typeof scale === 'number' && scale >= 0 ? scale : 1;
+      if (unit && unit.style === 'percent') mult *= 0.01;
+      return mult;
+    }
+    /**
+     * Determine a modifier for the input value to account for any `scale`,
+     * `percent`, and `precision-increment` tokens in the skeleton.
+     *
+     * @internal
+     * @remarks
+     * With ICU NumberFormatter, the `percent` skeleton would style `25` as "25%".
+     * To achieve the same with `Intl.NumberFormat`, the input value must be `0.25`.
+     */
+    function getNumberFormatModifier(skeleton) {
+      const mult = getNumberFormatMultiplier(skeleton);
+      const {
+        precision
+      } = skeleton;
+      if (precision && precision.style === 'precision-increment') {
+        return n => round(n, precision.increment) * mult;
+      } else {
+        return n => n * mult;
+      }
+    }
+    /**
+     * Returns a string of JavaScript source that evaluates to a modifier for the
+     * input value to account for any `scale`, `percent`, and `precision-increment`
+     * tokens in the skeleton.
+     *
+     * @internal
+     * @remarks
+     * With ICU NumberFormatter, the `percent` skeleton would style `25` as "25%".
+     * To achieve the same with `Intl.NumberFormat`, the input value must be `0.25`.
+     */
+    function getNumberFormatModifierSource(skeleton) {
+      const mult = getNumberFormatMultiplier(skeleton);
+      const {
+        precision
+      } = skeleton;
+      if (precision && precision.style === 'precision-increment') {
+        // see round() above for source
+        const setX = `+n + ${precision.increment / 2}`;
+        let res = `x - (x % +${precision.increment})`;
+        if (mult !== 1) res = `(${res}) * ${mult}`;
+        return `function(n) { var x = ${setX}; return ${res}; }`;
+      }
+      return mult !== 1 ? `function(n) { return n * ${mult}; }` : null;
+    }
+
+    /**
+     * Given an input ICU NumberFormatter skeleton, does its best to construct a
+     * corresponding `Intl.NumberFormat` options structure.
+     *
+     * @remarks
+     * Some features depend on `Intl.NumberFormat` features defined in ES2020.
+     *
+     * @internal
+     * @param onUnsupported - If defined, called when encountering unsupported (but
+     *   valid) tokens, such as `decimal-always` or `permille`. The error `source`
+     *   may specify the source of an unsupported option.
+     *
+     * @example
+     * ```js
+     * import {
+     *   getNumberFormatOptions,
+     *   parseNumberSkeleton
+     * } from '@messageformat/number-skeleton'
+     *
+     * const src = 'currency/CAD unit-width-narrow'
+     * const skeleton = parseNumberSkeleton(src, console.error)
+     * // {
+     * //   unit: { style: 'currency', currency: 'CAD' },
+     * //   unitWidth: 'unit-width-narrow'
+     * // }
+     *
+     * getNumberFormatOptions(skeleton, console.error)
+     * // {
+     * //   style: 'currency',
+     * //   currency: 'CAD',
+     * //   currencyDisplay: 'narrowSymbol',
+     * //   unitDisplay: 'narrow'
+     * // }
+     *
+     * const sk2 = parseNumberSkeleton('group-min2')
+     * // { group: 'group-min2' }
+     *
+     * getNumberFormatOptions(sk2, console.error)
+     * // Error: The stem group-min2 is not supported
+     * //   at UnsupportedError.NumberFormatError ... {
+     * //     code: 'UNSUPPORTED',
+     * //     stem: 'group-min2'
+     * //   }
+     * // {}
+     * ```
+     */
+    function getNumberFormatOptions(skeleton, onUnsupported) {
+      const {
+        decimal,
+        group,
+        integerWidth,
+        notation,
+        precision,
+        roundingMode,
+        sign,
+        unit,
+        unitPer,
+        unitWidth
+      } = skeleton;
+      const fail = (stem, source) => {
+        if (onUnsupported) onUnsupported(new UnsupportedError(stem, source));
+      };
+      const opt = {};
+      if (unit) {
+        switch (unit.style) {
+          case 'base-unit':
+            opt.style = 'decimal';
+            break;
+          case 'currency':
+            opt.style = 'currency';
+            opt.currency = unit.currency;
+            break;
+          case 'measure-unit':
+            opt.style = 'unit';
+            opt.unit = unit.unit.replace(/.*-/, '');
+            if (unitPer) opt.unit += '-per-' + unitPer.replace(/.*-/, '');
+            break;
+          case 'percent':
+            opt.style = 'percent';
+            break;
+          case 'permille':
+            fail('permille');
+            break;
+        }
+      }
+      switch (unitWidth) {
+        case 'unit-width-full-name':
+          opt.currencyDisplay = 'name';
+          opt.unitDisplay = 'long';
+          break;
+        case 'unit-width-hidden':
+          fail(unitWidth);
+          break;
+        case 'unit-width-iso-code':
+          opt.currencyDisplay = 'code';
+          break;
+        case 'unit-width-narrow':
+          opt.currencyDisplay = 'narrowSymbol';
+          opt.unitDisplay = 'narrow';
+          break;
+        case 'unit-width-short':
+          opt.currencyDisplay = 'symbol';
+          opt.unitDisplay = 'short';
+          break;
+      }
+      switch (group) {
+        case 'group-off':
+          opt.useGrouping = false;
+          break;
+        case 'group-auto':
+          opt.useGrouping = true;
+          break;
+        case 'group-min2':
+        case 'group-on-aligned':
+        case 'group-thousands':
+          fail(group);
+          opt.useGrouping = true;
+          break;
+      }
+      if (precision) {
+        switch (precision.style) {
+          case 'precision-fraction':
+            {
+              const {
+                minFraction: minF,
+                maxFraction: maxF,
+                minSignificant: minS,
+                maxSignificant: maxS,
+                source
+              } = precision;
+              if (typeof minF === 'number') {
+                opt.minimumFractionDigits = minF;
+                if (typeof minS === 'number') fail('precision-fraction', source);
+              }
+              if (typeof maxF === 'number') opt.maximumFractionDigits = maxF;
+              if (typeof minS === 'number') opt.minimumSignificantDigits = minS;
+              if (typeof maxS === 'number') opt.maximumSignificantDigits = maxS;
+              break;
+            }
+          case 'precision-integer':
+            opt.maximumFractionDigits = 0;
+            break;
+          case 'precision-unlimited':
+            opt.maximumFractionDigits = 20;
+            break;
+          case 'precision-increment':
+            break;
+          case 'precision-currency-standard':
+            opt.trailingZeroDisplay = precision.trailingZero;
+            break;
+          case 'precision-currency-cash':
+            fail(precision.style);
+            break;
+        }
+      }
+      if (notation) {
+        switch (notation.style) {
+          case 'compact-short':
+            opt.notation = 'compact';
+            opt.compactDisplay = 'short';
+            break;
+          case 'compact-long':
+            opt.notation = 'compact';
+            opt.compactDisplay = 'long';
+            break;
+          case 'notation-simple':
+            opt.notation = 'standard';
+            break;
+          case 'scientific':
+          case 'engineering':
+            {
+              const {
+                expDigits,
+                expSign,
+                source,
+                style
+              } = notation;
+              opt.notation = style;
+              if (expDigits && expDigits > 1 || expSign && expSign !== 'sign-auto') fail(style, source);
+              break;
+            }
+        }
+      }
+      if (integerWidth) {
+        const {
+          min,
+          max,
+          source
+        } = integerWidth;
+        if (min > 0) opt.minimumIntegerDigits = min;
+        if (Number(max) > 0) {
+          const hasExp = opt.notation === 'engineering' || opt.notation === 'scientific';
+          if (max === 3 && hasExp) opt.notation = 'engineering';else fail('integer-width', source);
+        }
+      }
+      switch (sign) {
+        case 'sign-auto':
+          opt.signDisplay = 'auto';
+          break;
+        case 'sign-always':
+          opt.signDisplay = 'always';
+          break;
+        case 'sign-except-zero':
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore https://github.com/microsoft/TypeScript/issues/46712
+          opt.signDisplay = 'exceptZero';
+          break;
+        case 'sign-never':
+          opt.signDisplay = 'never';
+          break;
+        case 'sign-accounting':
+          opt.currencySign = 'accounting';
+          break;
+        case 'sign-accounting-always':
+          opt.currencySign = 'accounting';
+          opt.signDisplay = 'always';
+          break;
+        case 'sign-accounting-except-zero':
+          opt.currencySign = 'accounting';
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore https://github.com/microsoft/TypeScript/issues/46712
+          opt.signDisplay = 'exceptZero';
+          break;
+      }
+      if (decimal === 'decimal-always') fail(decimal);
+      if (roundingMode) fail(roundingMode);
+      return opt;
+    }
+
+    function parseAffixToken(src, pos, onError) {
+      const char = src[pos];
+      switch (char) {
+        case '%':
+          return {
+            char: '%',
+            style: 'percent',
+            width: 1
+          };
+        case '‰':
+          return {
+            char: '%',
+            style: 'permille',
+            width: 1
+          };
+        case '¤':
+          {
+            let width = 1;
+            while (src[++pos] === '¤') ++width;
+            switch (width) {
+              case 1:
+                return {
+                  char,
+                  currency: 'default',
+                  width
+                };
+              case 2:
+                return {
+                  char,
+                  currency: 'iso-code',
+                  width
+                };
+              case 3:
+                return {
+                  char,
+                  currency: 'full-name',
+                  width
+                };
+              case 5:
+                return {
+                  char,
+                  currency: 'narrow',
+                  width
+                };
+              default:
+                {
+                  const msg = `Invalid number (${width}) of ¤ chars in pattern`;
+                  onError(new PatternError('¤', msg));
+                  return null;
+                }
+            }
+          }
+        case '*':
+          {
+            const pad = src[pos + 1];
+            if (pad) return {
+              char,
+              pad,
+              width: 2
+            };
+            break;
+          }
+        case '+':
+        case '-':
+          return {
+            char,
+            width: 1
+          };
+        case "'":
+          {
+            let str = src[++pos];
+            let width = 2;
+            if (str === "'") return {
+              char,
+              str,
+              width
+            };
+            while (true) {
+              const next = src[++pos];
+              ++width;
+              if (next === undefined) {
+                const msg = `Unterminated quoted literal in pattern: ${str}`;
+                onError(new PatternError("'", msg));
+                return {
+                  char,
+                  str,
+                  width
+                };
+              } else if (next === "'") {
+                if (src[++pos] !== "'") return {
+                  char,
+                  str,
+                  width
+                };else ++width;
+              }
+              str += next;
+            }
+          }
+      }
+      return null;
+    }
+
+    const isDigit = char => char >= '0' && char <= '9';
+    function parseNumberToken(src, pos) {
+      const char = src[pos];
+      if (isDigit(char)) {
+        let digits = char;
+        while (true) {
+          const next = src[++pos];
+          if (isDigit(next)) digits += next;else return {
+            char: '0',
+            digits,
+            width: digits.length
+          };
+        }
+      }
+      switch (char) {
+        case '#':
+          {
+            let width = 1;
+            while (src[++pos] === '#') ++width;
+            return {
+              char,
+              width
+            };
+          }
+        case '@':
+          {
+            let min = 1;
+            while (src[++pos] === '@') ++min;
+            let width = min;
+            pos -= 1;
+            while (src[++pos] === '#') ++width;
+            return {
+              char,
+              min,
+              width
+            };
+          }
+        case 'E':
+          {
+            const plus = src[pos + 1] === '+';
+            if (plus) ++pos;
+            let expDigits = 0;
+            while (src[++pos] === '0') ++expDigits;
+            const width = (plus ? 2 : 1) + expDigits;
+            if (expDigits) return {
+              char,
+              expDigits,
+              plus,
+              width
+            };else break;
+          }
+        case '.':
+        case ',':
+          return {
+            char,
+            width: 1
+          };
+      }
+      return null;
+    }
+
+    function parseSubpattern(src, pos, onError) {
+      let State;
+      (function (State) {
+        State[State["Prefix"] = 0] = "Prefix";
+        State[State["Number"] = 1] = "Number";
+        State[State["Suffix"] = 2] = "Suffix";
+      })(State || (State = {}));
+      const prefix = [];
+      const number = [];
+      const suffix = [];
+      let state = State.Prefix;
+      let str = '';
+      while (pos < src.length) {
+        const char = src[pos];
+        if (char === ';') {
+          pos += 1;
+          break;
+        }
+        switch (state) {
+          case State.Prefix:
+            {
+              const token = parseAffixToken(src, pos, onError);
+              if (token) {
+                if (str) {
+                  prefix.push({
+                    char: "'",
+                    str,
+                    width: str.length
+                  });
+                  str = '';
+                }
+                prefix.push(token);
+                pos += token.width;
+              } else {
+                const token = parseNumberToken(src, pos);
+                if (token) {
+                  if (str) {
+                    prefix.push({
+                      char: "'",
+                      str,
+                      width: str.length
+                    });
+                    str = '';
+                  }
+                  state = State.Number;
+                  number.push(token);
+                  pos += token.width;
+                } else {
+                  str += char;
+                  pos += 1;
+                }
+              }
+              break;
+            }
+          case State.Number:
+            {
+              const token = parseNumberToken(src, pos);
+              if (token) {
+                number.push(token);
+                pos += token.width;
+              } else {
+                state = State.Suffix;
+              }
+              break;
+            }
+          case State.Suffix:
+            {
+              const token = parseAffixToken(src, pos, onError);
+              if (token) {
+                if (str) {
+                  suffix.push({
+                    char: "'",
+                    str,
+                    width: str.length
+                  });
+                  str = '';
+                }
+                suffix.push(token);
+                pos += token.width;
+              } else {
+                str += char;
+                pos += 1;
+              }
+              break;
+            }
+        }
+      }
+      if (str) suffix.push({
+        char: "'",
+        str,
+        width: str.length
+      });
+      return {
+        pattern: {
+          prefix,
+          number,
+          suffix
+        },
+        pos
+      };
+    }
+    function parseTokens(src, onError) {
+      const {
+        pattern,
+        pos
+      } = parseSubpattern(src, 0, onError);
+      if (pos < src.length) {
+        const {
+          pattern: negative
+        } = parseSubpattern(src, pos, onError);
+        return {
+          tokens: pattern,
+          negative
+        };
+      }
+      return {
+        tokens: pattern
+      };
+    }
+
+    function parseNumberAsSkeleton(tokens, onError) {
+      const res = {};
+      let hasGroups = false;
+      let hasExponent = false;
+      let intOptional = 0;
+      let intDigits = '';
+      let decimalPos = -1;
+      let fracDigits = '';
+      let fracOptional = 0;
+      for (let pos = 0; pos < tokens.length; ++pos) {
+        const token = tokens[pos];
+        switch (token.char) {
+          case '#':
+            {
+              if (decimalPos === -1) {
+                if (intDigits) {
+                  const msg = 'Pattern has # after integer digits';
+                  onError(new PatternError('#', msg));
+                }
+                intOptional += token.width;
+              } else {
+                fracOptional += token.width;
+              }
+              break;
+            }
+          case '0':
+            {
+              if (decimalPos === -1) {
+                intDigits += token.digits;
+              } else {
+                if (fracOptional) {
+                  const msg = 'Pattern has digits after # in fraction';
+                  onError(new PatternError('0', msg));
+                }
+                fracDigits += token.digits;
+              }
+              break;
+            }
+          case '@':
+            {
+              if (res.precision) onError(new MaskedValueError('precision', res.precision));
+              res.precision = {
+                style: 'precision-fraction',
+                minSignificant: token.min,
+                maxSignificant: token.width
+              };
+              break;
+            }
+          case ',':
+            hasGroups = true;
+            break;
+          case '.':
+            if (decimalPos === 1) {
+              const msg = 'Pattern has more than one decimal separator';
+              onError(new PatternError('.', msg));
+            }
+            decimalPos = pos;
+            break;
+          case 'E':
+            {
+              if (hasExponent) onError(new MaskedValueError('exponent', res.notation));
+              if (hasGroups) {
+                const msg = 'Exponential patterns may not contain grouping separators';
+                onError(new PatternError('E', msg));
+              }
+              res.notation = {
+                style: 'scientific'
+              };
+              if (token.expDigits > 1) res.notation.expDigits = token.expDigits;
+              if (token.plus) res.notation.expSign = 'sign-always';
+              hasExponent = true;
+            }
+        }
+      }
+      // imprecise mapping due to paradigm differences
+      if (hasGroups) res.group = 'group-auto';else if (intOptional + intDigits.length > 3) res.group = 'group-off';
+      const increment = Number(`${intDigits || '0'}.${fracDigits}`);
+      if (increment) res.precision = {
+        style: 'precision-increment',
+        increment
+      };
+      if (!hasExponent) {
+        if (intDigits.length > 1) res.integerWidth = {
+          min: intDigits.length
+        };
+        if (!res.precision && (fracDigits.length || fracOptional)) {
+          res.precision = {
+            style: 'precision-fraction',
+            minFraction: fracDigits.length,
+            maxFraction: fracDigits.length + fracOptional
+          };
+        }
+      } else {
+        if (!res.precision || increment) {
+          res.integerWidth = intOptional ? {
+            min: 1,
+            max: intOptional + intDigits.length
+          } : {
+            min: Math.max(1, intDigits.length)
+          };
+        }
+        if (res.precision) {
+          if (!increment) res.integerWidth = {
+            min: 1,
+            max: 1
+          };
+        } else {
+          const dc = intDigits.length + fracDigits.length;
+          if (decimalPos === -1) {
+            if (dc > 0) res.precision = {
+              style: 'precision-fraction',
+              maxSignificant: dc
+            };
+          } else {
+            res.precision = {
+              style: 'precision-fraction',
+              maxSignificant: Math.max(1, dc) + fracOptional
+            };
+            if (dc > 1) res.precision.minSignificant = dc;
+          }
+        }
+      }
+      return res;
+    }
+
+    function handleAffix(affixTokens, res, currency, onError, isPrefix) {
+      let inFmt = false;
+      let str = '';
+      for (const token of affixTokens) {
+        switch (token.char) {
+          case '%':
+            res.unit = {
+              style: token.style
+            };
+            if (isPrefix) inFmt = true;else str = '';
+            break;
+          case '¤':
+            if (!currency) {
+              const msg = `The ¤ pattern requires a currency`;
+              onError(new PatternError('¤', msg));
+              break;
+            }
+            res.unit = {
+              style: 'currency',
+              currency
+            };
+            switch (token.currency) {
+              case 'iso-code':
+                res.unitWidth = 'unit-width-iso-code';
+                break;
+              case 'full-name':
+                res.unitWidth = 'unit-width-full-name';
+                break;
+              case 'narrow':
+                res.unitWidth = 'unit-width-narrow';
+                break;
+            }
+            if (isPrefix) inFmt = true;else str = '';
+            break;
+          case '*':
+            // TODO
+            break;
+          case '+':
+            if (!inFmt) str += '+';
+            break;
+          case "'":
+            if (!inFmt) str += token.str;
+            break;
+        }
+      }
+      return str;
+    }
+    function getNegativeAffix(affixTokens, isPrefix) {
+      let inFmt = false;
+      let str = '';
+      for (const token of affixTokens) {
+        switch (token.char) {
+          case '%':
+          case '¤':
+            if (isPrefix) inFmt = true;else str = '';
+            break;
+          case '-':
+            if (!inFmt) str += '-';
+            break;
+          case "'":
+            if (!inFmt) str += token.str;
+            break;
+        }
+      }
+      return str;
+    }
+    /**
+     * Parse an {@link
+     * http://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns |
+     * ICU NumberFormatter pattern} string into a {@link Skeleton} structure.
+     *
+     * @public
+     * @param src - The pattern string
+     * @param currency - If the pattern includes ¤ tokens, their skeleton
+     *   representation requires a three-letter currency code.
+     * @param onError - Called when the parser encounters a syntax error. The
+     *   function will still return a {@link Skeleton}, but it will be incomplete
+     *   and/or inaccurate. If not defined, the error will be thrown instead.
+     *
+     * @remarks
+     * Unlike the skeleton parser, the pattern parser is not able to return partial
+     * results on error, and will instead throw. Output padding is not supported.
+     *
+     * @example
+     * ```js
+     * import { parseNumberPattern } from '@messageformat/number-skeleton'
+     *
+     * parseNumberPattern('#,##0.00 ¤', 'EUR', console.error)
+     * // {
+     * //   group: 'group-auto',
+     * //   precision: {
+     * //     style: 'precision-fraction',
+     * //     minFraction: 2,
+     * //     maxFraction: 2
+     * //   },
+     * //   unit: { style: 'currency', currency: 'EUR' }
+     * // }
+     * ```
+     */
+    function parseNumberPattern(src, currency) {
+      let onError = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : error => {
+        throw error;
+      };
+      const {
+        tokens,
+        negative
+      } = parseTokens(src, onError);
+      const res = parseNumberAsSkeleton(tokens.number, onError);
+      const prefix = handleAffix(tokens.prefix, res, currency, onError, true);
+      const suffix = handleAffix(tokens.suffix, res, currency, onError, false);
+      if (negative) {
+        const negPrefix = getNegativeAffix(negative.prefix, true);
+        const negSuffix = getNegativeAffix(negative.suffix, false);
+        res.affix = {
+          pos: [prefix, suffix],
+          neg: [negPrefix, negSuffix]
+        };
+        res.sign = 'sign-never';
+      } else if (prefix || suffix) {
+        res.affix = {
+          pos: [prefix, suffix]
+        };
+      }
+      return res;
+    }
+
+    /** @internal */
+    function isNumberingSystem(ns) {
+      const systems = ['arab', 'arabext', 'bali', 'beng', 'deva', 'fullwide', 'gujr', 'guru', 'hanidec', 'khmr', 'knda', 'laoo', 'latn', 'limb', 'mlym', 'mong', 'mymr', 'orya', 'tamldec', 'telu', 'thai', 'tibt'];
+      return systems.indexOf(ns) !== -1;
+    }
+
+    // FIXME: subtype is not checked
+    /** @internal */
+    function isUnit(unit) {
+      const types = ['acceleration', 'angle', 'area', 'concentr', 'consumption', 'digital', 'duration', 'electric', 'energy', 'force', 'frequency', 'graphics', 'length', 'light', 'mass', 'power', 'pressure', 'speed', 'temperature', 'torque', 'volume'];
+      const [type] = unit.split('-', 1);
+      return types.indexOf(type) !== -1;
+    }
+
+    const maxOptions = {
+      'compact-short': 0,
+      'compact-long': 0,
+      'notation-simple': 0,
+      scientific: 2,
+      engineering: 2,
+      percent: 0,
+      permille: 0,
+      'base-unit': 0,
+      currency: 1,
+      'measure-unit': 1,
+      'per-measure-unit': 1,
+      'unit-width-narrow': 0,
+      'unit-width-short': 0,
+      'unit-width-full-name': 0,
+      'unit-width-iso-code': 0,
+      'unit-width-hidden': 0,
+      'precision-integer': 0,
+      'precision-unlimited': 0,
+      'precision-currency-standard': 1,
+      'precision-currency-cash': 0,
+      'precision-increment': 1,
+      'rounding-mode-ceiling': 0,
+      'rounding-mode-floor': 0,
+      'rounding-mode-down': 0,
+      'rounding-mode-up': 0,
+      'rounding-mode-half-even': 0,
+      'rounding-mode-half-down': 0,
+      'rounding-mode-half-up': 0,
+      'rounding-mode-unnecessary': 0,
+      'integer-width': 1,
+      scale: 1,
+      'group-off': 0,
+      'group-min2': 0,
+      'group-auto': 0,
+      'group-on-aligned': 0,
+      'group-thousands': 0,
+      latin: 0,
+      'numbering-system': 1,
+      'sign-auto': 0,
+      'sign-always': 0,
+      'sign-never': 0,
+      'sign-accounting': 0,
+      'sign-accounting-always': 0,
+      'sign-except-zero': 0,
+      'sign-accounting-except-zero': 0,
+      'decimal-auto': 0,
+      'decimal-always': 0
+    };
+    const minOptions = {
+      currency: 1,
+      'integer-width': 1,
+      'measure-unit': 1,
+      'numbering-system': 1,
+      'per-measure-unit': 1,
+      'precision-increment': 1,
+      scale: 1
+    };
+    function hasMaxOption(stem) {
+      return stem in maxOptions;
+    }
+    function hasMinOption(stem) {
+      return stem in minOptions;
+    }
+    /** @internal */
+    function validOptions(stem, options, onError) {
+      if (hasMaxOption(stem)) {
+        const maxOpt = maxOptions[stem];
+        if (options.length > maxOpt) {
+          if (maxOpt === 0) {
+            for (const opt of options) onError(new BadOptionError(stem, opt));
+          } else {
+            onError(new TooManyOptionsError(stem, options, maxOpt));
+          }
+          return false;
+        } else if (hasMinOption(stem) && options.length < minOptions[stem]) {
+          onError(new MissingOptionError(stem));
+          return false;
+        }
+      }
+      return true;
+    }
+
+    function parseBlueprintDigits(src, style) {
+      const re = style === 'fraction' ? /^\.(0*)(\+|#*)$/ : /^(@+)(\+|#*)$/;
+      const match = src && src.match(re);
+      if (match) {
+        const min = match[1].length;
+        switch (match[2].charAt(0)) {
+          case '':
+            return {
+              min,
+              max: min
+            };
+          case '+':
+            return {
+              min,
+              max: null
+            };
+          case '#':
+            {
+              return {
+                min,
+                max: min + match[2].length
+              };
+            }
+        }
+      }
+      return null;
+    }
+    function parsePrecisionBlueprint(stem, options, onError) {
+      const fd = parseBlueprintDigits(stem, 'fraction');
+      if (fd) {
+        if (options.length > 1) onError(new TooManyOptionsError(stem, options, 1));
+        const res = {
+          style: 'precision-fraction',
+          source: stem,
+          minFraction: fd.min
+        };
+        if (fd.max != null) res.maxFraction = fd.max;
+        const option = options[0];
+        const sd = parseBlueprintDigits(option, 'significant');
+        if (sd) {
+          res.source = `${stem}/${option}`;
+          res.minSignificant = sd.min;
+          if (sd.max != null) res.maxSignificant = sd.max;
+        } else if (option) onError(new BadOptionError(stem, option));
+        return res;
+      }
+      const sd = parseBlueprintDigits(stem, 'significant');
+      if (sd) {
+        for (const opt of options) onError(new BadOptionError(stem, opt));
+        const res = {
+          style: 'precision-fraction',
+          source: stem,
+          minSignificant: sd.min
+        };
+        if (sd.max != null) res.maxSignificant = sd.max;
+        return res;
+      }
+      return null;
+    }
+
+    /** @internal */
+    class TokenParser {
+      constructor(onError) {
+        this.skeleton = {};
+        this.onError = onError;
+      }
+      badOption(stem, opt) {
+        this.onError(new BadOptionError(stem, opt));
+      }
+      assertEmpty(key) {
+        const prev = this.skeleton[key];
+        if (prev) this.onError(new MaskedValueError(key, prev));
+      }
+      parseToken(stem, options) {
+        if (!validOptions(stem, options, this.onError)) return;
+        const option = options[0];
+        const res = this.skeleton;
+        switch (stem) {
+          // notation
+          case 'compact-short':
+          case 'compact-long':
+          case 'notation-simple':
+            this.assertEmpty('notation');
+            res.notation = {
+              style: stem
+            };
+            break;
+          case 'scientific':
+          case 'engineering':
+            {
+              let expDigits = null;
+              let expSign = undefined;
+              for (const opt of options) {
+                switch (opt) {
+                  case 'sign-auto':
+                  case 'sign-always':
+                  case 'sign-never':
+                  case 'sign-accounting':
+                  case 'sign-accounting-always':
+                  case 'sign-except-zero':
+                  case 'sign-accounting-except-zero':
+                    expSign = opt;
+                    break;
+                  default:
+                    if (/^\+e+$/.test(opt)) expDigits = opt.length - 1;else {
+                      this.badOption(stem, opt);
+                    }
+                }
+              }
+              this.assertEmpty('notation');
+              const source = options.join('/');
+              res.notation = expDigits && expSign ? {
+                style: stem,
+                source,
+                expDigits,
+                expSign
+              } : expDigits ? {
+                style: stem,
+                source,
+                expDigits
+              } : expSign ? {
+                style: stem,
+                source,
+                expSign
+              } : {
+                style: stem,
+                source
+              };
+              break;
+            }
+          // unit
+          case 'percent':
+          case 'permille':
+          case 'base-unit':
+            this.assertEmpty('unit');
+            res.unit = {
+              style: stem
+            };
+            break;
+          case 'currency':
+            if (/^[A-Z]{3}$/.test(option)) {
+              this.assertEmpty('unit');
+              res.unit = {
+                style: stem,
+                currency: option
+              };
+            } else this.badOption(stem, option);
+            break;
+          case 'measure-unit':
+            {
+              if (isUnit(option)) {
+                this.assertEmpty('unit');
+                res.unit = {
+                  style: stem,
+                  unit: option
+                };
+              } else this.badOption(stem, option);
+              break;
+            }
+          // unitPer
+          case 'per-measure-unit':
+            {
+              if (isUnit(option)) {
+                this.assertEmpty('unitPer');
+                res.unitPer = option;
+              } else this.badOption(stem, option);
+              break;
+            }
+          // unitWidth
+          case 'unit-width-narrow':
+          case 'unit-width-short':
+          case 'unit-width-full-name':
+          case 'unit-width-iso-code':
+          case 'unit-width-hidden':
+            this.assertEmpty('unitWidth');
+            res.unitWidth = stem;
+            break;
+          // precision
+          case 'precision-integer':
+          case 'precision-unlimited':
+          case 'precision-currency-cash':
+            this.assertEmpty('precision');
+            res.precision = {
+              style: stem
+            };
+            break;
+          case 'precision-currency-standard':
+            this.assertEmpty('precision');
+            if (option === 'w') {
+              res.precision = {
+                style: stem,
+                trailingZero: 'stripIfInteger'
+              };
+            } else {
+              res.precision = {
+                style: stem
+              };
+            }
+            break;
+          case 'precision-increment':
+            {
+              const increment = Number(option);
+              if (increment > 0) {
+                this.assertEmpty('precision');
+                res.precision = {
+                  style: stem,
+                  increment
+                };
+              } else this.badOption(stem, option);
+              break;
+            }
+          // roundingMode
+          case 'rounding-mode-ceiling':
+          case 'rounding-mode-floor':
+          case 'rounding-mode-down':
+          case 'rounding-mode-up':
+          case 'rounding-mode-half-even':
+          case 'rounding-mode-half-odd':
+          case 'rounding-mode-half-ceiling':
+          case 'rounding-mode-half-floor':
+          case 'rounding-mode-half-down':
+          case 'rounding-mode-half-up':
+          case 'rounding-mode-unnecessary':
+            this.assertEmpty('roundingMode');
+            res.roundingMode = stem;
+            break;
+          // integerWidth
+          case 'integer-width':
+            {
+              if (/^\+0*$/.test(option)) {
+                this.assertEmpty('integerWidth');
+                res.integerWidth = {
+                  source: option,
+                  min: option.length - 1
+                };
+              } else {
+                const m = option.match(/^#*(0*)$/);
+                if (m) {
+                  this.assertEmpty('integerWidth');
+                  res.integerWidth = {
+                    source: option,
+                    min: m[1].length,
+                    max: m[0].length
+                  };
+                } else this.badOption(stem, option);
+              }
+              break;
+            }
+          // scale
+          case 'scale':
+            {
+              const scale = Number(option);
+              if (scale > 0) {
+                this.assertEmpty('scale');
+                res.scale = scale;
+              } else this.badOption(stem, option);
+              break;
+            }
+          // group
+          case 'group-off':
+          case 'group-min2':
+          case 'group-auto':
+          case 'group-on-aligned':
+          case 'group-thousands':
+            this.assertEmpty('group');
+            res.group = stem;
+            break;
+          // numberingSystem
+          case 'latin':
+            this.assertEmpty('numberingSystem');
+            res.numberingSystem = 'latn';
+            break;
+          case 'numbering-system':
+            {
+              if (isNumberingSystem(option)) {
+                this.assertEmpty('numberingSystem');
+                res.numberingSystem = option;
+              } else this.badOption(stem, option);
+              break;
+            }
+          // sign
+          case 'sign-auto':
+          case 'sign-always':
+          case 'sign-never':
+          case 'sign-accounting':
+          case 'sign-accounting-always':
+          case 'sign-except-zero':
+          case 'sign-accounting-except-zero':
+            this.assertEmpty('sign');
+            res.sign = stem;
+            break;
+          // decimal
+          case 'decimal-auto':
+          case 'decimal-always':
+            this.assertEmpty('decimal');
+            res.decimal = stem;
+            break;
+          // precision blueprint
+          default:
+            {
+              const precision = parsePrecisionBlueprint(stem, options, this.onError);
+              if (precision) {
+                this.assertEmpty('precision');
+                res.precision = precision;
+              } else {
+                this.onError(new BadStemError(stem));
+              }
+            }
+        }
+      }
+    }
+
+    /**
+     * Parse an {@link
+     * https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md
+     * | ICU NumberFormatter skeleton} string into a {@link Skeleton} structure.
+     *
+     * @public
+     * @param src - The skeleton string
+     * @param onError - Called when the parser encounters a syntax error. The
+     *   function will still return a {@link Skeleton}, but it may not contain
+     *   information for all tokens. If not defined, the error will be thrown
+     *   instead.
+     *
+     * @example
+     * ```js
+     * import { parseNumberSkeleton } from '@messageformat/number-skeleton'
+     *
+     * parseNumberSkeleton('compact-short currency/GBP', console.error)
+     * // {
+     * //   notation: { style: 'compact-short' },
+     * //   unit: { style: 'currency', currency: 'GBP' }
+     * // }
+     * ```
+     */
+    function parseNumberSkeleton(src) {
+      let onError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : error => {
+        throw error;
+      };
+      const tokens = [];
+      for (const part of src.split(' ')) {
+        if (part) {
+          const options = part.split('/');
+          const stem = options.shift() || '';
+          tokens.push({
+            stem,
+            options
+          });
+        }
+      }
+      const parser = new TokenParser(onError);
+      for (const {
+        stem,
+        options
+      } of tokens) {
+        parser.parseToken(stem, options);
+      }
+      return parser.skeleton;
+    }
+
+    /**
+     * Returns a number formatter function for the given locales and number skeleton
+     *
+     * @remarks
+     * Uses `Intl.NumberFormat` (ES2020) internally.
+     *
+     * @public
+     * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+     * @param skeleton - An ICU NumberFormatter pattern or `::`-prefixed skeleton
+     *   string, or a parsed `Skeleton` structure
+     * @param currency - If `skeleton` is a pattern string that includes ¤ tokens,
+     *   their skeleton representation requires a three-letter currency code.
+     * @param onError - If defined, will be called separately for each encountered
+     *   parsing error and unsupported feature.
+     * @example
+     * ```js
+     * import { getNumberFormatter } from '@messageformat/number-skeleton'
+     *
+     * let src = ':: currency/CAD unit-width-narrow'
+     * let fmt = getNumberFormatter('en-CA', src, console.error)
+     * fmt(42) // '$42.00'
+     *
+     * src = '::percent scale/100'
+     * fmt = getNumberFormatter('en', src, console.error)
+     * fmt(0.3) // '30%'
+     * ```
+     */
+    function getNumberFormatter(locales, skeleton, currency, onError) {
+      if (typeof skeleton === 'string') {
+        skeleton = skeleton.indexOf('::') === 0 ? parseNumberSkeleton(skeleton.slice(2), onError) : parseNumberPattern(skeleton, currency, onError);
+      }
+      const lc = getNumberFormatLocales(locales, skeleton);
+      const opt = getNumberFormatOptions(skeleton, onError);
+      const mod = getNumberFormatModifier(skeleton);
+      const nf = new Intl.NumberFormat(lc, opt);
+      if (skeleton.affix) {
+        const [p0, p1] = skeleton.affix.pos;
+        const [n0, n1] = skeleton.affix.neg || ['', ''];
+        return value => {
+          const n = nf.format(mod(value));
+          return value < 0 ? `${n0}${n}${n1}` : `${p0}${n}${p1}`;
+        };
+      }
+      return value => nf.format(mod(value));
+    }
+    /**
+     * Returns a string of JavaScript source that evaluates to a number formatter
+     * function with the same `(value: number) => string` signature as the function
+     * returned by {@link getNumberFormatter}.
+     *
+     * @remarks
+     * The returned function will memoize an `Intl.NumberFormat` instance.
+     *
+     * @public
+     * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+     * @param skeleton - An ICU NumberFormatter pattern or `::`-prefixed skeleton
+     *   string, or a parsed `Skeleton` structure
+     * @param currency - If `skeleton` is a pattern string that includes ¤ tokens,
+     *   their skeleton representation requires a three-letter currency code.
+     * @param onError - If defined, will be called separately for each encountered
+     *   parsing error and unsupported feature.
+     * @example
+     * ```js
+     * import { getNumberFormatterSource } from '@messageformat/number-skeleton'
+     *
+     * getNumberFormatterSource('en', '::percent', console.error)
+     * // '(function() {\n' +
+     * // '  var opt = {"style":"percent"};\n' +
+     * // '  var nf = new Intl.NumberFormat(["en"], opt);\n' +
+     * // '  var mod = function(n) { return n * 0.01; };\n' +
+     * // '  return function(value) { return nf.format(mod(value)); }\n' +
+     * // '})()'
+     *
+     * const src = getNumberFormatterSource('en-CA', ':: currency/CAD unit-width-narrow', console.error)
+     * // '(function() {\n' +
+     * // '  var opt = {"style":"currency","currency":"CAD","currencyDisplay":"narrowSymbol","unitDisplay":"narrow"};\n' +
+     * // '  var nf = new Intl.NumberFormat(["en-CA"], opt);\n'
+     * // '  return function(value) { return nf.format(value); }\n' +
+     * // '})()'
+     * const fmt = new Function(`return ${src}`)()
+     * fmt(42) // '$42.00'
+     * ```
+     */
+    function getNumberFormatterSource(locales, skeleton, currency, onError) {
+      if (typeof skeleton === 'string') {
+        skeleton = skeleton.indexOf('::') === 0 ? parseNumberSkeleton(skeleton.slice(2), onError) : parseNumberPattern(skeleton, currency, onError);
+      }
+      const lc = getNumberFormatLocales(locales, skeleton);
+      const opt = getNumberFormatOptions(skeleton, onError);
+      const modSrc = getNumberFormatModifierSource(skeleton);
+      const lines = [`(function() {`, `var opt = ${JSON.stringify(opt)};`, `var nf = new Intl.NumberFormat(${JSON.stringify(lc)}, opt);`];
+      let res = 'nf.format(value)';
+      if (modSrc) {
+        lines.push(`var mod = ${modSrc};`);
+        res = 'nf.format(mod(value))';
+      }
+      if (skeleton.affix) {
+        const [p0, p1] = skeleton.affix.pos.map(s => JSON.stringify(s));
+        if (skeleton.affix.neg) {
+          const [n0, n1] = skeleton.affix.neg.map(s => JSON.stringify(s));
+          res = `value < 0 ? ${n0} + ${res} + ${n1} : ${p0} + ${res} + ${p1}`;
+        } else {
+          res = `${p0} + ${res} + ${p1}`;
+        }
+      }
+      lines.push(`return function(value) { return ${res}; }`);
+      return lines.join('\n  ') + '\n})()';
+    }
+
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+    var parser = {};
+
+    var lexer = {};
+
+    var mooExports = {};
+    var moo = {
+      get exports(){ return mooExports; },
+      set exports(v){ mooExports = v; },
+    };
+
+    (function (module) {
+      (function (root, factory) {
+        if (module.exports) {
+          module.exports = factory();
+        } else {
+          root.moo = factory();
+        }
+      })(commonjsGlobal, function () {
+
+        var hasOwnProperty = Object.prototype.hasOwnProperty;
+        var toString = Object.prototype.toString;
+        var hasSticky = typeof new RegExp().sticky === 'boolean';
+
+        /***************************************************************************/
+
+        function isRegExp(o) {
+          return o && toString.call(o) === '[object RegExp]';
+        }
+        function isObject(o) {
+          return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o);
+        }
+        function reEscape(s) {
+          return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+        }
+        function reGroups(s) {
+          var re = new RegExp('|' + s);
+          return re.exec('').length - 1;
+        }
+        function reCapture(s) {
+          return '(' + s + ')';
+        }
+        function reUnion(regexps) {
+          if (!regexps.length) return '(?!)';
+          var source = regexps.map(function (s) {
+            return "(?:" + s + ")";
+          }).join('|');
+          return "(?:" + source + ")";
+        }
+        function regexpOrLiteral(obj) {
+          if (typeof obj === 'string') {
+            return '(?:' + reEscape(obj) + ')';
+          } else if (isRegExp(obj)) {
+            // TODO: consider /u support
+            if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed');
+            if (obj.global) throw new Error('RegExp /g flag is implied');
+            if (obj.sticky) throw new Error('RegExp /y flag is implied');
+            if (obj.multiline) throw new Error('RegExp /m flag is implied');
+            return obj.source;
+          } else {
+            throw new Error('Not a pattern: ' + obj);
+          }
+        }
+        function pad(s, length) {
+          if (s.length > length) {
+            return s;
+          }
+          return Array(length - s.length + 1).join(" ") + s;
+        }
+        function lastNLines(string, numLines) {
+          var position = string.length;
+          var lineBreaks = 0;
+          while (true) {
+            var idx = string.lastIndexOf("\n", position - 1);
+            if (idx === -1) {
+              break;
+            } else {
+              lineBreaks++;
+            }
+            position = idx;
+            if (lineBreaks === numLines) {
+              break;
+            }
+            if (position === 0) {
+              break;
+            }
+          }
+          var startPosition = lineBreaks < numLines ? 0 : position + 1;
+          return string.substring(startPosition).split("\n");
+        }
+        function objectToRules(object) {
+          var keys = Object.getOwnPropertyNames(object);
+          var result = [];
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            var thing = object[key];
+            var rules = [].concat(thing);
+            if (key === 'include') {
+              for (var j = 0; j < rules.length; j++) {
+                result.push({
+                  include: rules[j]
+                });
+              }
+              continue;
+            }
+            var match = [];
+            rules.forEach(function (rule) {
+              if (isObject(rule)) {
+                if (match.length) result.push(ruleOptions(key, match));
+                result.push(ruleOptions(key, rule));
+                match = [];
+              } else {
+                match.push(rule);
+              }
+            });
+            if (match.length) result.push(ruleOptions(key, match));
+          }
+          return result;
+        }
+        function arrayToRules(array) {
+          var result = [];
+          for (var i = 0; i < array.length; i++) {
+            var obj = array[i];
+            if (obj.include) {
+              var include = [].concat(obj.include);
+              for (var j = 0; j < include.length; j++) {
+                result.push({
+                  include: include[j]
+                });
+              }
+              continue;
+            }
+            if (!obj.type) {
+              throw new Error('Rule has no type: ' + JSON.stringify(obj));
+            }
+            result.push(ruleOptions(obj.type, obj));
+          }
+          return result;
+        }
+        function ruleOptions(type, obj) {
+          if (!isObject(obj)) {
+            obj = {
+              match: obj
+            };
+          }
+          if (obj.include) {
+            throw new Error('Matching rules cannot also include states');
+          }
+
+          // nb. error and fallback imply lineBreaks
+          var options = {
+            defaultType: type,
+            lineBreaks: !!obj.error || !!obj.fallback,
+            pop: false,
+            next: null,
+            push: null,
+            error: false,
+            fallback: false,
+            value: null,
+            type: null,
+            shouldThrow: false
+          };
+
+          // Avoid Object.assign(), so we support IE9+
+          for (var key in obj) {
+            if (hasOwnProperty.call(obj, key)) {
+              options[key] = obj[key];
+            }
+          }
+
+          // type transform cannot be a string
+          if (typeof options.type === 'string' && type !== options.type) {
+            throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')");
+          }
+
+          // convert to array
+          var match = options.match;
+          options.match = Array.isArray(match) ? match : match ? [match] : [];
+          options.match.sort(function (a, b) {
+            return isRegExp(a) && isRegExp(b) ? 0 : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length;
+          });
+          return options;
+        }
+        function toRules(spec) {
+          return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec);
+        }
+        var defaultErrorRule = ruleOptions('error', {
+          lineBreaks: true,
+          shouldThrow: true
+        });
+        function compileRules(rules, hasStates) {
+          var errorRule = null;
+          var fast = Object.create(null);
+          var fastAllowed = true;
+          var unicodeFlag = null;
+          var groups = [];
+          var parts = [];
+
+          // If there is a fallback rule, then disable fast matching
+          for (var i = 0; i < rules.length; i++) {
+            if (rules[i].fallback) {
+              fastAllowed = false;
+            }
+          }
+          for (var i = 0; i < rules.length; i++) {
+            var options = rules[i];
+            if (options.include) {
+              // all valid inclusions are removed by states() preprocessor
+              throw new Error('Inheritance is not allowed in stateless lexers');
+            }
+            if (options.error || options.fallback) {
+              // errorRule can only be set once
+              if (errorRule) {
+                if (!options.fallback === !errorRule.fallback) {
+                  throw new Error("Multiple " + (options.fallback ? "fallback" : "error") + " rules not allowed (for token '" + options.defaultType + "')");
+                } else {
+                  throw new Error("fallback and error are mutually exclusive (for token '" + options.defaultType + "')");
+                }
+              }
+              errorRule = options;
+            }
+            var match = options.match.slice();
+            if (fastAllowed) {
+              while (match.length && typeof match[0] === 'string' && match[0].length === 1) {
+                var word = match.shift();
+                fast[word.charCodeAt(0)] = options;
+              }
+            }
+
+            // Warn about inappropriate state-switching options
+            if (options.pop || options.push || options.next) {
+              if (!hasStates) {
+                throw new Error("State-switching options are not allowed in stateless lexers (for token '" + options.defaultType + "')");
+              }
+              if (options.fallback) {
+                throw new Error("State-switching options are not allowed on fallback tokens (for token '" + options.defaultType + "')");
+              }
+            }
+
+            // Only rules with a .match are included in the RegExp
+            if (match.length === 0) {
+              continue;
+            }
+            fastAllowed = false;
+            groups.push(options);
+
+            // Check unicode flag is used everywhere or nowhere
+            for (var j = 0; j < match.length; j++) {
+              var obj = match[j];
+              if (!isRegExp(obj)) {
+                continue;
+              }
+              if (unicodeFlag === null) {
+                unicodeFlag = obj.unicode;
+              } else if (unicodeFlag !== obj.unicode && options.fallback === false) {
+                throw new Error('If one rule is /u then all must be');
+              }
+            }
+
+            // convert to RegExp
+            var pat = reUnion(match.map(regexpOrLiteral));
+
+            // validate
+            var regexp = new RegExp(pat);
+            if (regexp.test("")) {
+              throw new Error("RegExp matches empty string: " + regexp);
+            }
+            var groupCount = reGroups(pat);
+            if (groupCount > 0) {
+              throw new Error("RegExp has capture groups: " + regexp + "\nUse (?: … ) instead");
+            }
+
+            // try and detect rules matching newlines
+            if (!options.lineBreaks && regexp.test('\n')) {
+              throw new Error('Rule should declare lineBreaks: ' + regexp);
+            }
+
+            // store regex
+            parts.push(reCapture(pat));
+          }
+
+          // If there's no fallback rule, use the sticky flag so we only look for
+          // matches at the current index.
+          //
+          // If we don't support the sticky flag, then fake it using an irrefutable
+          // match (i.e. an empty pattern).
+          var fallbackRule = errorRule && errorRule.fallback;
+          var flags = hasSticky && !fallbackRule ? 'ym' : 'gm';
+          var suffix = hasSticky || fallbackRule ? '' : '|';
+          if (unicodeFlag === true) flags += "u";
+          var combined = new RegExp(reUnion(parts) + suffix, flags);
+          return {
+            regexp: combined,
+            groups: groups,
+            fast: fast,
+            error: errorRule || defaultErrorRule
+          };
+        }
+        function compile(rules) {
+          var result = compileRules(toRules(rules));
+          return new Lexer({
+            start: result
+          }, 'start');
+        }
+        function checkStateGroup(g, name, map) {
+          var state = g && (g.push || g.next);
+          if (state && !map[state]) {
+            throw new Error("Missing state '" + state + "' (in token '" + g.defaultType + "' of state '" + name + "')");
+          }
+          if (g && g.pop && +g.pop !== 1) {
+            throw new Error("pop must be 1 (in token '" + g.defaultType + "' of state '" + name + "')");
+          }
+        }
+        function compileStates(states, start) {
+          var all = states.$all ? toRules(states.$all) : [];
+          delete states.$all;
+          var keys = Object.getOwnPropertyNames(states);
+          if (!start) start = keys[0];
+          var ruleMap = Object.create(null);
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            ruleMap[key] = toRules(states[key]).concat(all);
+          }
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            var rules = ruleMap[key];
+            var included = Object.create(null);
+            for (var j = 0; j < rules.length; j++) {
+              var rule = rules[j];
+              if (!rule.include) continue;
+              var splice = [j, 1];
+              if (rule.include !== key && !included[rule.include]) {
+                included[rule.include] = true;
+                var newRules = ruleMap[rule.include];
+                if (!newRules) {
+                  throw new Error("Cannot include nonexistent state '" + rule.include + "' (in state '" + key + "')");
+                }
+                for (var k = 0; k < newRules.length; k++) {
+                  var newRule = newRules[k];
+                  if (rules.indexOf(newRule) !== -1) continue;
+                  splice.push(newRule);
+                }
+              }
+              rules.splice.apply(rules, splice);
+              j--;
+            }
+          }
+          var map = Object.create(null);
+          for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            map[key] = compileRules(ruleMap[key], true);
+          }
+          for (var i = 0; i < keys.length; i++) {
+            var name = keys[i];
+            var state = map[name];
+            var groups = state.groups;
+            for (var j = 0; j < groups.length; j++) {
+              checkStateGroup(groups[j], name, map);
+            }
+            var fastKeys = Object.getOwnPropertyNames(state.fast);
+            for (var j = 0; j < fastKeys.length; j++) {
+              checkStateGroup(state.fast[fastKeys[j]], name, map);
+            }
+          }
+          return new Lexer(map, start);
+        }
+        function keywordTransform(map) {
+          // Use a JavaScript Map to map keywords to their corresponding token type
+          // unless Map is unsupported, then fall back to using an Object:
+          var isMap = typeof Map !== 'undefined';
+          var reverseMap = isMap ? new Map() : Object.create(null);
+          var types = Object.getOwnPropertyNames(map);
+          for (var i = 0; i < types.length; i++) {
+            var tokenType = types[i];
+            var item = map[tokenType];
+            var keywordList = Array.isArray(item) ? item : [item];
+            keywordList.forEach(function (keyword) {
+              if (typeof keyword !== 'string') {
+                throw new Error("keyword must be string (in keyword '" + tokenType + "')");
+              }
+              if (isMap) {
+                reverseMap.set(keyword, tokenType);
+              } else {
+                reverseMap[keyword] = tokenType;
+              }
+            });
+          }
+          return function (k) {
+            return isMap ? reverseMap.get(k) : reverseMap[k];
+          };
+        }
+
+        /***************************************************************************/
+
+        var Lexer = function (states, state) {
+          this.startState = state;
+          this.states = states;
+          this.buffer = '';
+          this.stack = [];
+          this.reset();
+        };
+        Lexer.prototype.reset = function (data, info) {
+          this.buffer = data || '';
+          this.index = 0;
+          this.line = info ? info.line : 1;
+          this.col = info ? info.col : 1;
+          this.queuedToken = info ? info.queuedToken : null;
+          this.queuedText = info ? info.queuedText : "";
+          this.queuedThrow = info ? info.queuedThrow : null;
+          this.setState(info ? info.state : this.startState);
+          this.stack = info && info.stack ? info.stack.slice() : [];
+          return this;
+        };
+        Lexer.prototype.save = function () {
+          return {
+            line: this.line,
+            col: this.col,
+            state: this.state,
+            stack: this.stack.slice(),
+            queuedToken: this.queuedToken,
+            queuedText: this.queuedText,
+            queuedThrow: this.queuedThrow
+          };
+        };
+        Lexer.prototype.setState = function (state) {
+          if (!state || this.state === state) return;
+          this.state = state;
+          var info = this.states[state];
+          this.groups = info.groups;
+          this.error = info.error;
+          this.re = info.regexp;
+          this.fast = info.fast;
+        };
+        Lexer.prototype.popState = function () {
+          this.setState(this.stack.pop());
+        };
+        Lexer.prototype.pushState = function (state) {
+          this.stack.push(this.state);
+          this.setState(state);
+        };
+        var eat = hasSticky ? function (re, buffer) {
+          // assume re is /y
+          return re.exec(buffer);
+        } : function (re, buffer) {
+          // assume re is /g
+          var match = re.exec(buffer);
+          // will always match, since we used the |(?:) trick
+          if (match[0].length === 0) {
+            return null;
+          }
+          return match;
+        };
+        Lexer.prototype._getGroup = function (match) {
+          var groupCount = this.groups.length;
+          for (var i = 0; i < groupCount; i++) {
+            if (match[i + 1] !== undefined) {
+              return this.groups[i];
+            }
+          }
+          throw new Error('Cannot find token type for matched text');
+        };
+        function tokenToString() {
+          return this.value;
+        }
+        Lexer.prototype.next = function () {
+          var index = this.index;
+
+          // If a fallback token matched, we don't need to re-run the RegExp
+          if (this.queuedGroup) {
+            var token = this._token(this.queuedGroup, this.queuedText, index);
+            this.queuedGroup = null;
+            this.queuedText = "";
+            return token;
+          }
+          var buffer = this.buffer;
+          if (index === buffer.length) {
+            return; // EOF
+          }
+
+          // Fast matching for single characters
+          var group = this.fast[buffer.charCodeAt(index)];
+          if (group) {
+            return this._token(group, buffer.charAt(index), index);
+          }
+
+          // Execute RegExp
+          var re = this.re;
+          re.lastIndex = index;
+          var match = eat(re, buffer);
+
+          // Error tokens match the remaining buffer
+          var error = this.error;
+          if (match == null) {
+            return this._token(error, buffer.slice(index, buffer.length), index);
+          }
+          var group = this._getGroup(match);
+          var text = match[0];
+          if (error.fallback && match.index !== index) {
+            this.queuedGroup = group;
+            this.queuedText = text;
+
+            // Fallback tokens contain the unmatched portion of the buffer
+            return this._token(error, buffer.slice(index, match.index), index);
+          }
+          return this._token(group, text, index);
+        };
+        Lexer.prototype._token = function (group, text, offset) {
+          // count line breaks
+          var lineBreaks = 0;
+          if (group.lineBreaks) {
+            var matchNL = /\n/g;
+            var nl = 1;
+            if (text === '\n') {
+              lineBreaks = 1;
+            } else {
+              while (matchNL.exec(text)) {
+                lineBreaks++;
+                nl = matchNL.lastIndex;
+              }
+            }
+          }
+          var token = {
+            type: typeof group.type === 'function' && group.type(text) || group.defaultType,
+            value: typeof group.value === 'function' ? group.value(text) : text,
+            text: text,
+            toString: tokenToString,
+            offset: offset,
+            lineBreaks: lineBreaks,
+            line: this.line,
+            col: this.col
+          };
+          // nb. adding more props to token object will make V8 sad!
+
+          var size = text.length;
+          this.index += size;
+          this.line += lineBreaks;
+          if (lineBreaks !== 0) {
+            this.col = size - nl + 1;
+          } else {
+            this.col += size;
+          }
+
+          // throw, if no rule with {error: true}
+          if (group.shouldThrow) {
+            var err = new Error(this.formatError(token, "invalid syntax"));
+            throw err;
+          }
+          if (group.pop) this.popState();else if (group.push) this.pushState(group.push);else if (group.next) this.setState(group.next);
+          return token;
+        };
+        if (typeof Symbol !== 'undefined' && Symbol.iterator) {
+          var LexerIterator = function (lexer) {
+            this.lexer = lexer;
+          };
+          LexerIterator.prototype.next = function () {
+            var token = this.lexer.next();
+            return {
+              value: token,
+              done: !token
+            };
+          };
+          LexerIterator.prototype[Symbol.iterator] = function () {
+            return this;
+          };
+          Lexer.prototype[Symbol.iterator] = function () {
+            return new LexerIterator(this);
+          };
+        }
+        Lexer.prototype.formatError = function (token, message) {
+          if (token == null) {
+            // An undefined token indicates EOF
+            var text = this.buffer.slice(this.index);
+            var token = {
+              text: text,
+              offset: this.index,
+              lineBreaks: text.indexOf('\n') === -1 ? 0 : 1,
+              line: this.line,
+              col: this.col
+            };
+          }
+          var numLinesAround = 2;
+          var firstDisplayedLine = Math.max(token.line - numLinesAround, 1);
+          var lastDisplayedLine = token.line + numLinesAround;
+          var lastLineDigits = String(lastDisplayedLine).length;
+          var displayedLines = lastNLines(this.buffer, this.line - token.line + numLinesAround + 1).slice(0, 5);
+          var errorLines = [];
+          errorLines.push(message + " at line " + token.line + " col " + token.col + ":");
+          errorLines.push("");
+          for (var i = 0; i < displayedLines.length; i++) {
+            var line = displayedLines[i];
+            var lineNo = firstDisplayedLine + i;
+            errorLines.push(pad(String(lineNo), lastLineDigits) + "  " + line);
+            if (lineNo === token.line) {
+              errorLines.push(pad("", lastLineDigits + token.col + 1) + "^");
+            }
+          }
+          return errorLines.join("\n");
+        };
+        Lexer.prototype.clone = function () {
+          return new Lexer(this.states, this.state);
+        };
+        Lexer.prototype.has = function (tokenType) {
+          return true;
+        };
+        return {
+          compile: compile,
+          states: compileStates,
+          error: Object.freeze({
+            error: true
+          }),
+          fallback: Object.freeze({
+            fallback: true
+          }),
+          keywords: keywordTransform
+        };
+      });
+    })(moo);
+
+    (function (exports) {
+
+      var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function (mod) {
+        return mod && mod.__esModule ? mod : {
+          "default": mod
+        };
+      };
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.lexer = exports.states = void 0;
+      const moo_1 = __importDefault(mooExports);
+      exports.states = {
+        body: {
+          doubleapos: {
+            match: "''",
+            value: () => "'"
+          },
+          quoted: {
+            lineBreaks: true,
+            match: /'[{}#](?:[^]*?[^'])?'(?!')/u,
+            value: src => src.slice(1, -1).replace(/''/g, "'")
+          },
+          argument: {
+            lineBreaks: true,
+            match: /\{\s*[^\p{Pat_Syn}\p{Pat_WS}]+\s*/u,
+            push: 'arg',
+            value: src => src.substring(1).trim()
+          },
+          octothorpe: '#',
+          end: {
+            match: '}',
+            pop: 1
+          },
+          content: {
+            lineBreaks: true,
+            match: /[^][^{}#']*/u
+          }
+        },
+        arg: {
+          select: {
+            lineBreaks: true,
+            match: /,\s*(?:plural|select|selectordinal)\s*,\s*/u,
+            next: 'select',
+            value: src => src.split(',')[1].trim()
+          },
+          'func-args': {
+            lineBreaks: true,
+            match: /,\s*[^\p{Pat_Syn}\p{Pat_WS}]+\s*,/u,
+            next: 'body',
+            value: src => src.split(',')[1].trim()
+          },
+          'func-simple': {
+            lineBreaks: true,
+            match: /,\s*[^\p{Pat_Syn}\p{Pat_WS}]+\s*/u,
+            value: src => src.substring(1).trim()
+          },
+          end: {
+            match: '}',
+            pop: 1
+          }
+        },
+        select: {
+          offset: {
+            lineBreaks: true,
+            match: /\s*offset\s*:\s*\d+\s*/u,
+            value: src => src.split(':')[1].trim()
+          },
+          case: {
+            lineBreaks: true,
+            match: /\s*(?:=\d+|[^\p{Pat_Syn}\p{Pat_WS}]+)\s*\{/u,
+            push: 'body',
+            value: src => src.substring(0, src.indexOf('{')).trim()
+          },
+          end: {
+            match: /\s*\}/u,
+            pop: 1
+          }
+        }
+      };
+      exports.lexer = moo_1.default.states(exports.states);
+    })(lexer);
+
+    /**
+     * An AST parser for ICU MessageFormat strings
+     *
+     * @packageDocumentation
+     * @example
+     * ```
+     * import { parse } from '@messageformat/parser
+     *
+     * parse('So {wow}.')
+     * [ { type: 'content', value: 'So ' },
+     *   { type: 'argument', arg: 'wow' },
+     *   { type: 'content', value: '.' } ]
+     *
+     *
+     * parse('Such { thing }. { count, selectordinal, one {First} two {Second}' +
+     *       '                  few {Third} other {#th} } word.')
+     * [ { type: 'content', value: 'Such ' },
+     *   { type: 'argument', arg: 'thing' },
+     *   { type: 'content', value: '. ' },
+     *   { type: 'selectordinal',
+     *     arg: 'count',
+     *     cases: [
+     *       { key: 'one', tokens: [ { type: 'content', value: 'First' } ] },
+     *       { key: 'two', tokens: [ { type: 'content', value: 'Second' } ] },
+     *       { key: 'few', tokens: [ { type: 'content', value: 'Third' } ] },
+     *       { key: 'other',
+     *         tokens: [ { type: 'octothorpe' }, { type: 'content', value: 'th' } ] }
+     *     ] },
+     *   { type: 'content', value: ' word.' } ]
+     *
+     *
+     * parse('Many{type,select,plural{ numbers}selectordinal{ counting}' +
+     *                          'select{ choices}other{ some {type}}}.')
+     * [ { type: 'content', value: 'Many' },
+     *   { type: 'select',
+     *     arg: 'type',
+     *     cases: [
+     *       { key: 'plural', tokens: [ { type: 'content', value: 'numbers' } ] },
+     *       { key: 'selectordinal', tokens: [ { type: 'content', value: 'counting' } ] },
+     *       { key: 'select', tokens: [ { type: 'content', value: 'choices' } ] },
+     *       { key: 'other',
+     *         tokens: [ { type: 'content', value: 'some ' }, { type: 'argument', arg: 'type' } ] }
+     *     ] },
+     *   { type: 'content', value: '.' } ]
+     *
+     *
+     * parse('{Such compliance')
+     * // ParseError: invalid syntax at line 1 col 7:
+     * //
+     * //  {Such compliance
+     * //        ^
+     *
+     *
+     * const msg = '{words, plural, zero{No words} one{One word} other{# words}}'
+     * parse(msg)
+     * [ { type: 'plural',
+     *     arg: 'words',
+     *     cases: [
+     *       { key: 'zero', tokens: [ { type: 'content', value: 'No words' } ] },
+     *       { key: 'one', tokens: [ { type: 'content', value: 'One word' } ] },
+     *       { key: 'other',
+     *         tokens: [ { type: 'octothorpe' }, { type: 'content', value: ' words' } ] }
+     *     ] } ]
+     *
+     *
+     * parse(msg, { cardinal: [ 'one', 'other' ], ordinal: [ 'one', 'two', 'few', 'other' ] })
+     * // ParseError: The plural case zero is not valid in this locale at line 1 col 17:
+     * //
+     * //   {words, plural, zero{
+     * //                   ^
+     * ```
+     */
+    Object.defineProperty(parser, "__esModule", {
+      value: true
+    });
+    var parse_1 = parser.parse = parser.ParseError = void 0;
+    const lexer_js_1 = lexer;
+    const getContext = lt => ({
+      offset: lt.offset,
+      line: lt.line,
+      col: lt.col,
+      text: lt.text,
+      lineBreaks: lt.lineBreaks
+    });
+    const isSelectType = type => type === 'plural' || type === 'select' || type === 'selectordinal';
+    function strictArgStyleParam(lt, param) {
+      let value = '';
+      let text = '';
+      for (const p of param) {
+        const pText = p.ctx.text;
+        text += pText;
+        switch (p.type) {
+          case 'content':
+            value += p.value;
+            break;
+          case 'argument':
+          case 'function':
+          case 'octothorpe':
+            value += pText;
+            break;
+          default:
+            throw new ParseError(lt, `Unsupported part in strict mode function arg style: ${pText}`);
+        }
+      }
+      const c = {
+        type: 'content',
+        value: value.trim(),
+        ctx: Object.assign({}, param[0].ctx, {
+          text
+        })
+      };
+      return [c];
+    }
+    const strictArgTypes = ['number', 'date', 'time', 'spellout', 'ordinal', 'duration'];
+    const defaultPluralKeys = ['zero', 'one', 'two', 'few', 'many', 'other'];
+    /**
+     * Thrown by {@link parse} on error
+     *
+     * @public
+     */
+    class ParseError extends Error {
+      /** @internal */
+      constructor(lt, msg) {
+        super(lexer_js_1.lexer.formatError(lt, msg));
+      }
+    }
+    parser.ParseError = ParseError;
+    class Parser {
+      constructor(src, opt) {
+        var _a, _b, _c, _d;
+        this.lexer = lexer_js_1.lexer.reset(src);
+        this.cardinalKeys = (_a = opt === null || opt === void 0 ? void 0 : opt.cardinal) !== null && _a !== void 0 ? _a : defaultPluralKeys;
+        this.ordinalKeys = (_b = opt === null || opt === void 0 ? void 0 : opt.ordinal) !== null && _b !== void 0 ? _b : defaultPluralKeys;
+        this.strict = (_c = opt === null || opt === void 0 ? void 0 : opt.strict) !== null && _c !== void 0 ? _c : false;
+        this.strictPluralKeys = (_d = opt === null || opt === void 0 ? void 0 : opt.strictPluralKeys) !== null && _d !== void 0 ? _d : true;
+      }
+      parse() {
+        return this.parseBody(false, true);
+      }
+      checkSelectKey(lt, type, key) {
+        if (key[0] === '=') {
+          if (type === 'select') throw new ParseError(lt, `The case ${key} is not valid with select`);
+        } else if (type !== 'select') {
+          const keys = type === 'plural' ? this.cardinalKeys : this.ordinalKeys;
+          if (this.strictPluralKeys && keys.length > 0 && !keys.includes(key)) {
+            const msg = `The ${type} case ${key} is not valid in this locale`;
+            throw new ParseError(lt, msg);
+          }
+        }
+      }
+      parseSelect(_ref, inPlural, ctx, type) {
+        let {
+          value: arg
+        } = _ref;
+        const sel = {
+          type,
+          arg,
+          cases: [],
+          ctx
+        };
+        if (type === 'plural' || type === 'selectordinal') inPlural = true;else if (this.strict) inPlural = false;
+        for (const lt of this.lexer) {
+          switch (lt.type) {
+            case 'offset':
+              if (type === 'select') throw new ParseError(lt, 'Unexpected plural offset for select');
+              if (sel.cases.length > 0) throw new ParseError(lt, 'Plural offset must be set before cases');
+              sel.pluralOffset = Number(lt.value);
+              ctx.text += lt.text;
+              ctx.lineBreaks += lt.lineBreaks;
+              break;
+            case 'case':
+              {
+                this.checkSelectKey(lt, type, lt.value);
+                sel.cases.push({
+                  key: lt.value,
+                  tokens: this.parseBody(inPlural),
+                  ctx: getContext(lt)
+                });
+                break;
+              }
+            case 'end':
+              return sel;
+            /* istanbul ignore next: never happens */
+            default:
+              throw new ParseError(lt, `Unexpected lexer token: ${lt.type}`);
+          }
+        }
+        throw new ParseError(null, 'Unexpected message end');
+      }
+      parseArgToken(lt, inPlural) {
+        const ctx = getContext(lt);
+        const argType = this.lexer.next();
+        if (!argType) throw new ParseError(null, 'Unexpected message end');
+        ctx.text += argType.text;
+        ctx.lineBreaks += argType.lineBreaks;
+        if (this.strict && (argType.type === 'func-simple' || argType.type === 'func-args') && !strictArgTypes.includes(argType.value)) {
+          const msg = `Invalid strict mode function arg type: ${argType.value}`;
+          throw new ParseError(lt, msg);
+        }
+        switch (argType.type) {
+          case 'end':
+            return {
+              type: 'argument',
+              arg: lt.value,
+              ctx
+            };
+          case 'func-simple':
+            {
+              const end = this.lexer.next();
+              if (!end) throw new ParseError(null, 'Unexpected message end');
+              /* istanbul ignore if: never happens */
+              if (end.type !== 'end') throw new ParseError(end, `Unexpected lexer token: ${end.type}`);
+              ctx.text += end.text;
+              if (isSelectType(argType.value.toLowerCase())) throw new ParseError(argType, `Invalid type identifier: ${argType.value}`);
+              return {
+                type: 'function',
+                arg: lt.value,
+                key: argType.value,
+                ctx
+              };
+            }
+          case 'func-args':
+            {
+              if (isSelectType(argType.value.toLowerCase())) {
+                const msg = `Invalid type identifier: ${argType.value}`;
+                throw new ParseError(argType, msg);
+              }
+              let param = this.parseBody(this.strict ? false : inPlural);
+              if (this.strict && param.length > 0) param = strictArgStyleParam(lt, param);
+              return {
+                type: 'function',
+                arg: lt.value,
+                key: argType.value,
+                param,
+                ctx
+              };
+            }
+          case 'select':
+            /* istanbul ignore else: never happens */
+            if (isSelectType(argType.value)) return this.parseSelect(lt, inPlural, ctx, argType.value);else throw new ParseError(argType, `Unexpected select type ${argType.value}`);
+          /* istanbul ignore next: never happens */
+          default:
+            throw new ParseError(argType, `Unexpected lexer token: ${argType.type}`);
+        }
+      }
+      parseBody(inPlural, atRoot) {
+        const tokens = [];
+        let content = null;
+        for (const lt of this.lexer) {
+          if (lt.type === 'argument') {
+            if (content) content = null;
+            tokens.push(this.parseArgToken(lt, inPlural));
+          } else if (lt.type === 'octothorpe' && inPlural) {
+            if (content) content = null;
+            tokens.push({
+              type: 'octothorpe',
+              ctx: getContext(lt)
+            });
+          } else if (lt.type === 'end' && !atRoot) {
+            return tokens;
+          } else {
+            let value = lt.value;
+            if (!inPlural && lt.type === 'quoted' && value[0] === '#') {
+              if (value.includes('{')) {
+                const errMsg = `Unsupported escape pattern: ${value}`;
+                throw new ParseError(lt, errMsg);
+              }
+              value = lt.text;
+            }
+            if (content) {
+              content.value += value;
+              content.ctx.text += lt.text;
+              content.ctx.lineBreaks += lt.lineBreaks;
+            } else {
+              content = {
+                type: 'content',
+                value,
+                ctx: getContext(lt)
+              };
+              tokens.push(content);
+            }
+          }
+        }
+        if (atRoot) return tokens;
+        throw new ParseError(null, 'Unexpected message end');
+      }
+    }
+    /**
+     * Parse an input string into an array of tokens
+     *
+     * @public
+     * @remarks
+     * The parser only supports the default `DOUBLE_OPTIONAL`
+     * {@link http://www.icu-project.org/apiref/icu4c/messagepattern_8h.html#af6e0757e0eb81c980b01ee5d68a9978b | apostrophe mode}.
+     */
+    function parse(src) {
+      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      const parser = new Parser(src, options);
+      return parser.parse();
+    }
+    parse_1 = parser.parse = parse;
+
+    /**
+     * A set of utility functions that are called by the compiled Javascript
+     * functions, these are included locally in the output of {@link MessageFormat.compile compile()}.
+     */
+    /** @private */
+    function _nf$1(lc) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return _nf$1[lc] || (_nf$1[lc] = new Intl.NumberFormat(lc));
+    }
+    /**
+     * Utility function for `#` in plural rules
+     *
+     * @param lc The current locale
+     * @param value The value to operate on
+     * @param offset An offset, set by the surrounding context
+     * @returns The result of applying the offset to the input value
+     */
+    function number(lc, value, offset) {
+      return _nf$1(lc).format(value - offset);
+    }
+    /**
+     * Strict utility function for `#` in plural rules
+     *
+     * Will throw an Error if `value` or `offset` are non-numeric.
+     *
+     * @param lc The current locale
+     * @param value The value to operate on
+     * @param offset An offset, set by the surrounding context
+     * @param name The name of the argument, used for error reporting
+     * @returns The result of applying the offset to the input value
+     */
+    function strictNumber(lc, value, offset, name) {
+      var n = value - offset;
+      if (isNaN(n)) throw new Error('`' + name + '` or its offset is not a number');
+      return _nf$1(lc).format(n);
+    }
+    /**
+     * Utility function for `{N, plural|selectordinal, ...}`
+     *
+     * @param value The key to use to find a pluralization rule
+     * @param offset An offset to apply to `value`
+     * @param lcfunc A locale function from `pluralFuncs`
+     * @param data The object from which results are looked up
+     * @param isOrdinal If true, use ordinal rather than cardinal rules
+     * @returns The result of the pluralization
+     */
+    function plural(value, offset, lcfunc, data, isOrdinal) {
+      if ({}.hasOwnProperty.call(data, value)) return data[value];
+      if (offset) value -= offset;
+      var key = lcfunc(value, isOrdinal);
+      return key in data ? data[key] : data.other;
+    }
+    /**
+     * Utility function for `{N, select, ...}`
+     *
+     * @param value The key to use to find a selection
+     * @param data The object from which results are looked up
+     * @returns The result of the select statement
+     */
+    function select(value, data) {
+      return {}.hasOwnProperty.call(data, value) ? data[value] : data.other;
+    }
+    /**
+     * Checks that all required arguments are set to defined values
+     *
+     * Throws on failure; otherwise returns undefined
+     *
+     * @param keys The required keys
+     * @param data The data object being checked
+     */
+    function reqArgs(keys, data) {
+      for (var i = 0; i < keys.length; ++i) if (!data || data[keys[i]] === undefined) throw new Error("Message requires argument '".concat(keys[i], "'"));
+    }
+
+    var Runtime = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        _nf: _nf$1,
+        number: number,
+        plural: plural,
+        reqArgs: reqArgs,
+        select: select,
+        strictNumber: strictNumber
+    });
+
+    /**
+     * Represent a date as a short/default/long/full string
+     *
+     * @param value Either a Unix epoch time in milliseconds, or a string value
+     *   representing a date. Parsed with `new Date(value)`
+     *
+     * @example
+     * ```js
+     * var mf = new MessageFormat(['en', 'fi']);
+     *
+     * mf.compile('Today is {T, date}')({ T: Date.now() })
+     * // 'Today is Feb 21, 2016'
+     *
+     * mf.compile('Tänään on {T, date}', 'fi')({ T: Date.now() })
+     * // 'Tänään on 21. helmikuuta 2016'
+     *
+     * mf.compile('Unix time started on {T, date, full}')({ T: 0 })
+     * // 'Unix time started on Thursday, January 1, 1970'
+     *
+     * var cf = mf.compile('{sys} became operational on {d0, date, short}');
+     * cf({ sys: 'HAL 9000', d0: '12 January 1999' })
+     * // 'HAL 9000 became operational on 1/12/1999'
+     * ```
+     */
+    function date(value, lc, size) {
+      var o = {
+        day: 'numeric',
+        month: 'short',
+        year: 'numeric'
+      };
+      /* eslint-disable no-fallthrough */
+      switch (size) {
+        case 'full':
+          o.weekday = 'long';
+        case 'long':
+          o.month = 'long';
+          break;
+        case 'short':
+          o.month = 'numeric';
+      }
+      return new Date(value).toLocaleDateString(lc, o);
+    }
+
+    /**
+     * Represent a duration in seconds as a string
+     *
+     * @param value A finite number, or its string representation
+     * @return Includes one or two `:` separators, and matches the pattern
+     *   `hhhh:mm:ss`, possibly with a leading `-` for negative values and a
+     *   trailing `.sss` part for non-integer input
+     *
+     * @example
+     * ```js
+     * var mf = new MessageFormat();
+     *
+     * mf.compile('It has been {D, duration}')({ D: 123 })
+     * // 'It has been 2:03'
+     *
+     * mf.compile('Countdown: {D, duration}')({ D: -151200.42 })
+     * // 'Countdown: -42:00:00.420'
+     * ```
+     */
+    function duration(value) {
+      if (typeof value !== 'number') value = Number(value);
+      if (!isFinite(value)) return String(value);
+      var sign = '';
+      if (value < 0) {
+        sign = '-';
+        value = Math.abs(value);
+      } else {
+        value = Number(value);
+      }
+      var sec = value % 60;
+      var parts = [Math.round(sec) === sec ? sec : sec.toFixed(3)];
+      if (value < 60) {
+        parts.unshift(0); // at least one : is required
+      } else {
+        value = Math.round((value - Number(parts[0])) / 60);
+        parts.unshift(value % 60); // minutes
+        if (value >= 60) {
+          value = Math.round((value - Number(parts[0])) / 60);
+          parts.unshift(value); // hours
+        }
+      }
+
+      var first = parts.shift();
+      return sign + first + ':' + parts.map(function (n) {
+        return Number(n) < 10 ? '0' + String(n) : String(n);
+      }).join(':');
+    }
+
+    /**
+     * Represent a number as an integer, percent or currency value
+     *
+     * Available in MessageFormat strings as `{VAR, number, integer|percent|currency}`.
+     * Internally, calls Intl.NumberFormat with appropriate parameters. `currency` will
+     * default to USD; to change, set `MessageFormat#currency` to the appropriate
+     * three-letter currency code, or use the `currency:EUR` form of the argument.
+     *
+     * @example
+     * ```js
+     * var mf = new MessageFormat('en', { currency: 'EUR'});
+     *
+     * mf.compile('{N} is almost {N, number, integer}')({ N: 3.14 })
+     * // '3.14 is almost 3'
+     *
+     * mf.compile('{P, number, percent} complete')({ P: 0.99 })
+     * // '99% complete'
+     *
+     * mf.compile('The total is {V, number, currency}.')({ V: 5.5 })
+     * // 'The total is €5.50.'
+     *
+     * mf.compile('The total is {V, number, currency:GBP}.')({ V: 5.5 })
+     * // 'The total is £5.50.'
+     * ```
+     */
+    var _nf = {};
+    function nf(lc, opt) {
+      var key = String(lc) + JSON.stringify(opt);
+      if (!_nf[key]) _nf[key] = new Intl.NumberFormat(lc, opt);
+      return _nf[key];
+    }
+    function numberFmt(value, lc, arg, defaultCurrency) {
+      var _a = arg && arg.split(':') || [],
+        type = _a[0],
+        currency = _a[1];
+      var opt = {
+        integer: {
+          maximumFractionDigits: 0
+        },
+        percent: {
+          style: 'percent'
+        },
+        currency: {
+          style: 'currency',
+          currency: currency && currency.trim() || defaultCurrency,
+          minimumFractionDigits: 2,
+          maximumFractionDigits: 2
+        }
+      };
+      return nf(lc, opt[type] || {}).format(value);
+    }
+    var numberCurrency = function (value, lc, arg) {
+      return nf(lc, {
+        style: 'currency',
+        currency: arg,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2
+      }).format(value);
+    };
+    var numberInteger = function (value, lc) {
+      return nf(lc, {
+        maximumFractionDigits: 0
+      }).format(value);
+    };
+    var numberPercent = function (value, lc) {
+      return nf(lc, {
+        style: 'percent'
+      }).format(value);
+    };
+
+    /**
+     * Represent a time as a short/default/long string
+     *
+     * @param value Either a Unix epoch time in milliseconds, or a string value
+     *   representing a date. Parsed with `new Date(value)`
+     *
+     * @example
+     * ```js
+     * var mf = new MessageFormat(['en', 'fi']);
+     *
+     * mf.compile('The time is now {T, time}')({ T: Date.now() })
+     * // 'The time is now 11:26:35 PM'
+     *
+     * mf.compile('Kello on nyt {T, time}', 'fi')({ T: Date.now() })
+     * // 'Kello on nyt 23.26.35'
+     *
+     * var cf = mf.compile('The Eagle landed at {T, time, full} on {T, date, full}');
+     * cf({ T: '1969-07-20 20:17:40 UTC' })
+     * // 'The Eagle landed at 10:17:40 PM GMT+2 on Sunday, July 20, 1969'
+     * ```
+     */
+    function time(value, lc, size) {
+      var o = {
+        second: 'numeric',
+        minute: 'numeric',
+        hour: 'numeric'
+      };
+      /* eslint-disable no-fallthrough */
+      switch (size) {
+        case 'full':
+        case 'long':
+          o.timeZoneName = 'short';
+          break;
+        case 'short':
+          delete o.second;
+      }
+      return new Date(value).toLocaleTimeString(lc, o);
+    }
+
+    var Formatters = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        date: date,
+        duration: duration,
+        numberCurrency: numberCurrency,
+        numberFmt: numberFmt,
+        numberInteger: numberInteger,
+        numberPercent: numberPercent,
+        time: time
+    });
+
+    const ES3 = {
+      break: true,
+      continue: true,
+      delete: true,
+      else: true,
+      for: true,
+      function: true,
+      if: true,
+      in: true,
+      new: true,
+      return: true,
+      this: true,
+      typeof: true,
+      var: true,
+      void: true,
+      while: true,
+      with: true,
+      case: true,
+      catch: true,
+      default: true,
+      do: true,
+      finally: true,
+      instanceof: true,
+      switch: true,
+      throw: true,
+      try: true
+    };
+    const ESnext = {
+      // in addition to reservedES3
+      await: true,
+      debugger: true,
+      class: true,
+      enum: true,
+      extends: true,
+      super: true,
+      const: true,
+      export: true,
+      import: true,
+      null: true,
+      true: true,
+      false: true,
+      implements: true,
+      let: true,
+      private: true,
+      public: true,
+      yield: true,
+      interface: true,
+      package: true,
+      protected: true,
+      static: true
+    };
+    var reserved = {
+      ES3,
+      ESnext
+    };
+    var reserved$1 = reserved;
+
+    // from https://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
+    function hashCode(str) {
+      let hash = 0;
+      for (let i = 0; i < str.length; ++i) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash |= 0; // Convert to 32bit integer
+      }
+
+      return hash;
+    }
+    function identifier(key, unique) {
+      if (unique) key += ' ' + hashCode(key).toString(36);
+      const id = key.trim().replace(/\W+/g, '_');
+      return reserved$1.ES3[id] || reserved$1.ESnext[id] || /^\d/.test(id) ? '_' + id : id;
+    }
+    function property(obj, key) {
+      if (/^[A-Z_$][0-9A-Z_$]*$/i.test(key) && !reserved$1.ES3[key]) {
+        return obj ? obj + '.' + key : key;
+      } else {
+        const jkey = JSON.stringify(key);
+        return obj ? obj + '[' + jkey + ']' : jkey;
+      }
+    }
+
+    var rtlLanguages = [
+        'ar',
+        'ckb',
+        'fa',
+        'he',
+        'ks($|[^bfh])',
+        'lrc',
+        'mzn',
+        'pa-Arab',
+        'ps',
+        'ug',
+        'ur',
+        'uz-Arab',
+        'yi'
+    ];
+    var rtlRegExp = new RegExp('^' + rtlLanguages.join('|^'));
+    function biDiMarkText(text, locale) {
+        var isLocaleRTL = rtlRegExp.test(locale);
+        var mark = JSON.stringify(isLocaleRTL ? '\u200F' : '\u200E');
+        return "".concat(mark, " + ").concat(text, " + ").concat(mark);
+    }
+
+    var RUNTIME_MODULE = '@messageformat/runtime';
+    var CARDINAL_MODULE = '@messageformat/runtime/lib/cardinals';
+    var PLURAL_MODULE = '@messageformat/runtime/lib/plurals';
+    var FORMATTER_MODULE = '@messageformat/runtime/lib/formatters';
+    var Compiler = (function () {
+        function Compiler(options) {
+            this.arguments = [];
+            this.runtime = {};
+            this.options = options;
+        }
+        Compiler.prototype.compile = function (src, plural, plurals) {
+            var e_1, _a;
+            var _this = this;
+            var _b = this.options, localeCodeFromKey = _b.localeCodeFromKey, requireAllArguments = _b.requireAllArguments, strict = _b.strict, strictPluralKeys = _b.strictPluralKeys;
+            if (typeof src === 'object') {
+                var result = {};
+                try {
+                    for (var _c = __values(Object.keys(src)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var key = _d.value;
+                        var lc = localeCodeFromKey ? localeCodeFromKey(key) : key;
+                        var pl = (plurals && lc && plurals[lc]) || plural;
+                        result[key] = this.compile(src[key], pl, plurals);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                return result;
+            }
+            this.plural = plural;
+            var parserOptions = {
+                cardinal: plural.cardinals,
+                ordinal: plural.ordinals,
+                strict: strict,
+                strictPluralKeys: strictPluralKeys
+            };
+            this.arguments = [];
+            var r = parse_1(src, parserOptions).map(function (token) { return _this.token(token, null); });
+            var hasArgs = this.arguments.length > 0;
+            var res = this.concatenate(r, true);
+            if (requireAllArguments && hasArgs) {
+                this.setRuntimeFn('reqArgs');
+                var reqArgs = JSON.stringify(this.arguments);
+                return "(d) => { reqArgs(".concat(reqArgs, ", d); return ").concat(res, "; }");
+            }
+            return "(".concat(hasArgs ? 'd' : '', ") => ").concat(res);
+        };
+        Compiler.prototype.cases = function (token, pluralToken) {
+            var _this = this;
+            var needOther = true;
+            var r = token.cases.map(function (_a) {
+                var key = _a.key, tokens = _a.tokens;
+                if (key === 'other')
+                    needOther = false;
+                var s = tokens.map(function (tok) { return _this.token(tok, pluralToken); });
+                return "".concat(property(null, key.replace(/^=/, '')), ": ").concat(_this.concatenate(s, false));
+            });
+            if (needOther) {
+                var type = token.type;
+                var _a = this.plural, cardinals = _a.cardinals, ordinals = _a.ordinals;
+                if (type === 'select' ||
+                    (type === 'plural' && cardinals.includes('other')) ||
+                    (type === 'selectordinal' && ordinals.includes('other')))
+                    throw new Error("No 'other' form found in ".concat(JSON.stringify(token)));
+            }
+            return "{ ".concat(r.join(', '), " }");
+        };
+        Compiler.prototype.concatenate = function (tokens, root) {
+            var asValues = this.options.returnType === 'values';
+            return asValues && (root || tokens.length > 1)
+                ? '[' + tokens.join(', ') + ']'
+                : tokens.join(' + ') || '""';
+        };
+        Compiler.prototype.token = function (token, pluralToken) {
+            if (token.type === 'content')
+                return JSON.stringify(token.value);
+            var _a = this.plural, id = _a.id, lc = _a.lc;
+            var args, fn;
+            if ('arg' in token) {
+                this.arguments.push(token.arg);
+                args = [property('d', token.arg)];
+            }
+            else
+                args = [];
+            switch (token.type) {
+                case 'argument':
+                    return this.options.biDiSupport
+                        ? biDiMarkText(String(args[0]), lc)
+                        : String(args[0]);
+                case 'select':
+                    fn = 'select';
+                    if (pluralToken && this.options.strict)
+                        pluralToken = null;
+                    args.push(this.cases(token, pluralToken));
+                    this.setRuntimeFn('select');
+                    break;
+                case 'selectordinal':
+                    fn = 'plural';
+                    args.push(token.pluralOffset || 0, id, this.cases(token, token), 1);
+                    this.setLocale(id, true);
+                    this.setRuntimeFn('plural');
+                    break;
+                case 'plural':
+                    fn = 'plural';
+                    args.push(token.pluralOffset || 0, id, this.cases(token, token));
+                    this.setLocale(id, false);
+                    this.setRuntimeFn('plural');
+                    break;
+                case 'function':
+                    if (!this.options.customFormatters[token.key]) {
+                        if (token.key === 'date') {
+                            fn = this.setDateFormatter(token, args, pluralToken);
+                            break;
+                        }
+                        else if (token.key === 'number') {
+                            fn = this.setNumberFormatter(token, args, pluralToken);
+                            break;
+                        }
+                    }
+                    args.push(JSON.stringify(this.plural.locale));
+                    if (token.param) {
+                        if (pluralToken && this.options.strict)
+                            pluralToken = null;
+                        var arg = this.getFormatterArg(token, pluralToken);
+                        if (arg)
+                            args.push(arg);
+                    }
+                    fn = token.key;
+                    this.setFormatter(fn);
+                    break;
+                case 'octothorpe':
+                    if (!pluralToken)
+                        return '"#"';
+                    args = [
+                        JSON.stringify(this.plural.locale),
+                        property('d', pluralToken.arg),
+                        pluralToken.pluralOffset || 0
+                    ];
+                    if (this.options.strict) {
+                        fn = 'strictNumber';
+                        args.push(JSON.stringify(pluralToken.arg));
+                        this.setRuntimeFn('strictNumber');
+                    }
+                    else {
+                        fn = 'number';
+                        this.setRuntimeFn('number');
+                    }
+                    break;
+            }
+            if (!fn)
+                throw new Error('Parser error for token ' + JSON.stringify(token));
+            return "".concat(fn, "(").concat(args.join(', '), ")");
+        };
+        Compiler.prototype.runtimeIncludes = function (key, type) {
+            if (identifier(key) !== key)
+                throw new SyntaxError("Reserved word used as ".concat(type, " identifier: ").concat(key));
+            var prev = this.runtime[key];
+            if (!prev || prev.type === type)
+                return prev;
+            throw new TypeError("Cannot override ".concat(prev.type, " runtime function as ").concat(type, ": ").concat(key));
+        };
+        Compiler.prototype.setLocale = function (key, ord) {
+            var prev = this.runtimeIncludes(key, 'locale');
+            var _a = this.plural, getCardinal = _a.getCardinal, getPlural = _a.getPlural, isDefault = _a.isDefault;
+            var pf, module, toString;
+            if (!ord && isDefault && getCardinal) {
+                if (prev)
+                    return;
+                pf = function (n) { return getCardinal(n); };
+                module = CARDINAL_MODULE;
+                toString = function () { return String(getCardinal); };
+            }
+            else {
+                if (prev && (!isDefault || prev.module === PLURAL_MODULE))
+                    return;
+                pf = function (n, ord) { return getPlural(n, ord); };
+                module = isDefault ? PLURAL_MODULE : getPlural.module || null;
+                toString = function () { return String(getPlural); };
+            }
+            this.runtime[key] = Object.assign(pf, {
+                id: key,
+                module: module,
+                toString: toString,
+                type: 'locale'
+            });
+        };
+        Compiler.prototype.setRuntimeFn = function (key) {
+            if (this.runtimeIncludes(key, 'runtime'))
+                return;
+            this.runtime[key] = Object.assign(Runtime[key], {
+                id: key,
+                module: RUNTIME_MODULE,
+                type: 'runtime'
+            });
+        };
+        Compiler.prototype.getFormatterArg = function (_a, pluralToken) {
+            var e_2, _b, e_3, _c;
+            var _this = this;
+            var key = _a.key, param = _a.param;
+            var fmt = this.options.customFormatters[key] ||
+                (isFormatterKey(key) && Formatters[key]);
+            if (!fmt || !param)
+                return null;
+            var argShape = ('arg' in fmt && fmt.arg) || 'string';
+            if (argShape === 'options') {
+                var value = '';
+                try {
+                    for (var param_1 = __values(param), param_1_1 = param_1.next(); !param_1_1.done; param_1_1 = param_1.next()) {
+                        var tok = param_1_1.value;
+                        if (tok.type === 'content')
+                            value += tok.value;
+                        else
+                            throw new SyntaxError("Expected literal options for ".concat(key, " formatter"));
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (param_1_1 && !param_1_1.done && (_b = param_1.return)) _b.call(param_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                var options = {};
+                try {
+                    for (var _d = __values(value.split(',')), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var pair = _e.value;
+                        var keyEnd = pair.indexOf(':');
+                        if (keyEnd === -1)
+                            options[pair.trim()] = null;
+                        else {
+                            var k = pair.substring(0, keyEnd).trim();
+                            var v = pair.substring(keyEnd + 1).trim();
+                            if (v === 'true')
+                                options[k] = true;
+                            else if (v === 'false')
+                                options[k] = false;
+                            else if (v === 'null')
+                                options[k] = null;
+                            else {
+                                var n = Number(v);
+                                options[k] = Number.isFinite(n) ? n : v;
+                            }
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                return JSON.stringify(options);
+            }
+            else {
+                var parts = param.map(function (tok) { return _this.token(tok, pluralToken); });
+                if (argShape === 'raw')
+                    return "[".concat(parts.join(', '), "]");
+                var s = parts.join(' + ');
+                return s ? "(".concat(s, ").trim()") : '""';
+            }
+        };
+        Compiler.prototype.setFormatter = function (key) {
+            if (this.runtimeIncludes(key, 'formatter'))
+                return;
+            var cf = this.options.customFormatters[key];
+            if (cf) {
+                if (typeof cf === 'function')
+                    cf = { formatter: cf };
+                this.runtime[key] = Object.assign(cf.formatter, { type: 'formatter' }, 'module' in cf && cf.module && cf.id
+                    ? { id: identifier(cf.id), module: cf.module }
+                    : { id: null, module: null });
+            }
+            else if (isFormatterKey(key)) {
+                this.runtime[key] = Object.assign(Formatters[key], { type: 'formatter' }, { id: key, module: FORMATTER_MODULE });
+            }
+            else {
+                throw new Error("Formatting function not found: ".concat(key));
+            }
+        };
+        Compiler.prototype.setDateFormatter = function (_a, args, plural) {
+            var _this = this;
+            var param = _a.param;
+            var locale = this.plural.locale;
+            var argStyle = param && param.length === 1 && param[0];
+            if (argStyle &&
+                argStyle.type === 'content' &&
+                /^\s*::/.test(argStyle.value)) {
+                var argSkeletonText_1 = argStyle.value.trim().substr(2);
+                var key = identifier("date_".concat(locale, "_").concat(argSkeletonText_1), true);
+                if (!this.runtimeIncludes(key, 'formatter')) {
+                    var fmt = getDateFormatter(locale, argSkeletonText_1);
+                    this.runtime[key] = Object.assign(fmt, {
+                        id: key,
+                        module: null,
+                        toString: function () { return getDateFormatterSource(locale, argSkeletonText_1); },
+                        type: 'formatter'
+                    });
+                }
+                return key;
+            }
+            args.push(JSON.stringify(locale));
+            if (param && param.length > 0) {
+                if (plural && this.options.strict)
+                    plural = null;
+                var s = param.map(function (tok) { return _this.token(tok, plural); });
+                args.push('(' + (s.join(' + ') || '""') + ').trim()');
+            }
+            this.setFormatter('date');
+            return 'date';
+        };
+        Compiler.prototype.setNumberFormatter = function (_a, args, plural) {
+            var _this = this;
+            var param = _a.param;
+            var locale = this.plural.locale;
+            if (!param || param.length === 0) {
+                args.unshift(JSON.stringify(locale));
+                args.push('0');
+                this.setRuntimeFn('number');
+                return 'number';
+            }
+            args.push(JSON.stringify(locale));
+            if (param.length === 1 && param[0].type === 'content') {
+                var fmtArg_1 = param[0].value.trim();
+                switch (fmtArg_1) {
+                    case 'currency':
+                        args.push(JSON.stringify(this.options.currency));
+                        this.setFormatter('numberCurrency');
+                        return 'numberCurrency';
+                    case 'integer':
+                        this.setFormatter('numberInteger');
+                        return 'numberInteger';
+                    case 'percent':
+                        this.setFormatter('numberPercent');
+                        return 'numberPercent';
+                }
+                var cm = fmtArg_1.match(/^currency:([A-Z]+)$/);
+                if (cm) {
+                    args.push(JSON.stringify(cm[1]));
+                    this.setFormatter('numberCurrency');
+                    return 'numberCurrency';
+                }
+                var key = identifier("number_".concat(locale, "_").concat(fmtArg_1), true);
+                if (!this.runtimeIncludes(key, 'formatter')) {
+                    var currency_1 = this.options.currency;
+                    var fmt = getNumberFormatter(locale, fmtArg_1, currency_1);
+                    this.runtime[key] = Object.assign(fmt, {
+                        id: null,
+                        module: null,
+                        toString: function () { return getNumberFormatterSource(locale, fmtArg_1, currency_1); },
+                        type: 'formatter'
+                    });
+                }
+                return key;
+            }
+            if (plural && this.options.strict)
+                plural = null;
+            var s = param.map(function (tok) { return _this.token(tok, plural); });
+            args.push('(' + (s.join(' + ') || '""') + ').trim()');
+            args.push(JSON.stringify(this.options.currency));
+            this.setFormatter('numberFmt');
+            return 'numberFmt';
+        };
+        return Compiler;
+    }());
+    function isFormatterKey(key) {
+        return key in Formatters;
+    }
+
+    const a$2 = n => n == 1 ? 'one' : 'other';
+    const b$2 = n => n == 0 || n == 1 ? 'one' : 'other';
+    const c$2 = n => n >= 0 && n <= 1 ? 'one' : 'other';
+    const d$2 = n => {
+      const s = String(n).split('.'),
+        v0 = !s[1];
+      return n == 1 && v0 ? 'one' : 'other';
+    };
+    const e$1 = n => 'other';
+    const f$2 = n => n == 1 ? 'one' : n == 2 ? 'two' : 'other';
+    const af$2 = a$2;
+    const ak$2 = b$2;
+    const am$2 = c$2;
+    const an$2 = a$2;
+    const ar$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      return n == 0 ? 'zero' : n == 1 ? 'one' : n == 2 ? 'two' : n100 >= 3 && n100 <= 10 ? 'few' : n100 >= 11 && n100 <= 99 ? 'many' : 'other';
+    };
+    const ars$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      return n == 0 ? 'zero' : n == 1 ? 'one' : n == 2 ? 'two' : n100 >= 3 && n100 <= 10 ? 'few' : n100 >= 11 && n100 <= 99 ? 'many' : 'other';
+    };
+    const as$2 = c$2;
+    const asa$2 = a$2;
+    const ast$2 = d$2;
+    const az$2 = a$2;
+    const bal$2 = a$2;
+    const be$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2);
+      return n10 == 1 && n100 != 11 ? 'one' : n10 >= 2 && n10 <= 4 && (n100 < 12 || n100 > 14) ? 'few' : t0 && n10 == 0 || n10 >= 5 && n10 <= 9 || n100 >= 11 && n100 <= 14 ? 'many' : 'other';
+    };
+    const bem$2 = a$2;
+    const bez$2 = a$2;
+    const bg$2 = a$2;
+    const bho$2 = b$2;
+    const bm$2 = e$1;
+    const bn$2 = c$2;
+    const bo$2 = e$1;
+    const br$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2),
+        n1000000 = t0 && s[0].slice(-6);
+      return n10 == 1 && n100 != 11 && n100 != 71 && n100 != 91 ? 'one' : n10 == 2 && n100 != 12 && n100 != 72 && n100 != 92 ? 'two' : (n10 == 3 || n10 == 4 || n10 == 9) && (n100 < 10 || n100 > 19) && (n100 < 70 || n100 > 79) && (n100 < 90 || n100 > 99) ? 'few' : n != 0 && t0 && n1000000 == 0 ? 'many' : 'other';
+    };
+    const brx$2 = a$2;
+    const bs$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const ca$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const ce$2 = a$2;
+    const ceb$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        f10 = f.slice(-1);
+      return v0 && (i == 1 || i == 2 || i == 3) || v0 && i10 != 4 && i10 != 6 && i10 != 9 || !v0 && f10 != 4 && f10 != 6 && f10 != 9 ? 'one' : 'other';
+    };
+    const cgg$2 = a$2;
+    const chr$2 = a$2;
+    const ckb$2 = a$2;
+    const cs$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1];
+      return n == 1 && v0 ? 'one' : i >= 2 && i <= 4 && v0 ? 'few' : !v0 ? 'many' : 'other';
+    };
+    const cy$2 = n => n == 0 ? 'zero' : n == 1 ? 'one' : n == 2 ? 'two' : n == 3 ? 'few' : n == 6 ? 'many' : 'other';
+    const da$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        t0 = Number(s[0]) == n;
+      return n == 1 || !t0 && (i == 0 || i == 1) ? 'one' : 'other';
+    };
+    const de$2 = d$2;
+    const doi$2 = c$2;
+    const dsb$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i100 = i.slice(-2),
+        f100 = f.slice(-2);
+      return v0 && i100 == 1 || f100 == 1 ? 'one' : v0 && i100 == 2 || f100 == 2 ? 'two' : v0 && (i100 == 3 || i100 == 4) || f100 == 3 || f100 == 4 ? 'few' : 'other';
+    };
+    const dv$2 = a$2;
+    const dz$2 = e$1;
+    const ee$2 = a$2;
+    const el$2 = a$2;
+    const en$2 = d$2;
+    const eo$2 = a$2;
+    const es$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      return n == 1 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const et$2 = d$2;
+    const eu$2 = a$2;
+    const fa$2 = c$2;
+    const ff$2 = n => n >= 0 && n < 2 ? 'one' : 'other';
+    const fi$2 = d$2;
+    const fil$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        f10 = f.slice(-1);
+      return v0 && (i == 1 || i == 2 || i == 3) || v0 && i10 != 4 && i10 != 6 && i10 != 9 || !v0 && f10 != 4 && f10 != 6 && f10 != 9 ? 'one' : 'other';
+    };
+    const fo$2 = a$2;
+    const fr$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      return n >= 0 && n < 2 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const fur$2 = a$2;
+    const fy$2 = d$2;
+    const ga$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      return n == 1 ? 'one' : n == 2 ? 'two' : t0 && n >= 3 && n <= 6 ? 'few' : t0 && n >= 7 && n <= 10 ? 'many' : 'other';
+    };
+    const gd$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      return n == 1 || n == 11 ? 'one' : n == 2 || n == 12 ? 'two' : t0 && n >= 3 && n <= 10 || t0 && n >= 13 && n <= 19 ? 'few' : 'other';
+    };
+    const gl$2 = d$2;
+    const gsw$2 = a$2;
+    const gu$2 = c$2;
+    const guw$2 = b$2;
+    const gv$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      return v0 && i10 == 1 ? 'one' : v0 && i10 == 2 ? 'two' : v0 && (i100 == 0 || i100 == 20 || i100 == 40 || i100 == 60 || i100 == 80) ? 'few' : !v0 ? 'many' : 'other';
+    };
+    const ha$2 = a$2;
+    const haw$2 = a$2;
+    const he$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1];
+      return i == 1 && v0 || i == 0 && !v0 ? 'one' : i == 2 && v0 ? 'two' : 'other';
+    };
+    const hi$2 = c$2;
+    const hnj$2 = e$1;
+    const hr$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const hsb$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i100 = i.slice(-2),
+        f100 = f.slice(-2);
+      return v0 && i100 == 1 || f100 == 1 ? 'one' : v0 && i100 == 2 || f100 == 2 ? 'two' : v0 && (i100 == 3 || i100 == 4) || f100 == 3 || f100 == 4 ? 'few' : 'other';
+    };
+    const hu$2 = a$2;
+    const hy$2 = n => n >= 0 && n < 2 ? 'one' : 'other';
+    const ia$2 = d$2;
+    const id$2 = e$1;
+    const ig$2 = e$1;
+    const ii$2 = e$1;
+    const io$2 = d$2;
+    const is$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        t = (s[1] || '').replace(/0+$/, ''),
+        t0 = Number(s[0]) == n,
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      return t0 && i10 == 1 && i100 != 11 || t % 10 == 1 && t % 100 != 11 ? 'one' : 'other';
+    };
+    const it$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const iu$2 = f$2;
+    const ja$2 = e$1;
+    const jbo$2 = e$1;
+    const jgo$2 = a$2;
+    const jmc$2 = a$2;
+    const jv$2 = e$1;
+    const jw$2 = e$1;
+    const ka$2 = a$2;
+    const kab$2 = n => n >= 0 && n < 2 ? 'one' : 'other';
+    const kaj$2 = a$2;
+    const kcg$2 = a$2;
+    const kde$2 = e$1;
+    const kea$2 = e$1;
+    const kk$2 = a$2;
+    const kkj$2 = a$2;
+    const kl$2 = a$2;
+    const km$2 = e$1;
+    const kn$2 = c$2;
+    const ko$2 = e$1;
+    const ks$2 = a$2;
+    const ksb$2 = a$2;
+    const ksh$2 = n => n == 0 ? 'zero' : n == 1 ? 'one' : 'other';
+    const ku$2 = a$2;
+    const kw$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2),
+        n1000 = t0 && s[0].slice(-3),
+        n100000 = t0 && s[0].slice(-5),
+        n1000000 = t0 && s[0].slice(-6);
+      return n == 0 ? 'zero' : n == 1 ? 'one' : n100 == 2 || n100 == 22 || n100 == 42 || n100 == 62 || n100 == 82 || t0 && n1000 == 0 && (n100000 >= 1000 && n100000 <= 20000 || n100000 == 40000 || n100000 == 60000 || n100000 == 80000) || n != 0 && n1000000 == 100000 ? 'two' : n100 == 3 || n100 == 23 || n100 == 43 || n100 == 63 || n100 == 83 ? 'few' : n != 1 && (n100 == 1 || n100 == 21 || n100 == 41 || n100 == 61 || n100 == 81) ? 'many' : 'other';
+    };
+    const ky$2 = a$2;
+    const lag$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0];
+      return n == 0 ? 'zero' : (i == 0 || i == 1) && n != 0 ? 'one' : 'other';
+    };
+    const lb$2 = a$2;
+    const lg$2 = a$2;
+    const lij$2 = d$2;
+    const lkt$2 = e$1;
+    const ln$2 = b$2;
+    const lo$2 = e$1;
+    const lt$2 = n => {
+      const s = String(n).split('.'),
+        f = s[1] || '',
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2);
+      return n10 == 1 && (n100 < 11 || n100 > 19) ? 'one' : n10 >= 2 && n10 <= 9 && (n100 < 11 || n100 > 19) ? 'few' : f != 0 ? 'many' : 'other';
+    };
+    const lv$2 = n => {
+      const s = String(n).split('.'),
+        f = s[1] || '',
+        v = f.length,
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2),
+        f100 = f.slice(-2),
+        f10 = f.slice(-1);
+      return t0 && n10 == 0 || n100 >= 11 && n100 <= 19 || v == 2 && f100 >= 11 && f100 <= 19 ? 'zero' : n10 == 1 && n100 != 11 || v == 2 && f10 == 1 && f100 != 11 || v != 2 && f10 == 1 ? 'one' : 'other';
+    };
+    const mas$2 = a$2;
+    const mg$2 = b$2;
+    const mgo$2 = a$2;
+    const mk$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : 'other';
+    };
+    const ml$2 = a$2;
+    const mn$2 = a$2;
+    const mo$2 = n => {
+      const s = String(n).split('.'),
+        v0 = !s[1],
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      return n == 1 && v0 ? 'one' : !v0 || n == 0 || n != 1 && n100 >= 1 && n100 <= 19 ? 'few' : 'other';
+    };
+    const mr$2 = a$2;
+    const ms$2 = e$1;
+    const mt$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      return n == 1 ? 'one' : n == 2 ? 'two' : n == 0 || n100 >= 3 && n100 <= 10 ? 'few' : n100 >= 11 && n100 <= 19 ? 'many' : 'other';
+    };
+    const my$2 = e$1;
+    const nah$2 = a$2;
+    const naq$2 = f$2;
+    const nb$2 = a$2;
+    const nd$2 = a$2;
+    const ne$2 = a$2;
+    const nl$2 = d$2;
+    const nn$2 = a$2;
+    const nnh$2 = a$2;
+    const no$2 = a$2;
+    const nqo$2 = e$1;
+    const nr$2 = a$2;
+    const nso$2 = b$2;
+    const ny$2 = a$2;
+    const nyn$2 = a$2;
+    const om$2 = a$2;
+    const or$2 = a$2;
+    const os$2 = a$2;
+    const osa$2 = e$1;
+    const pa$2 = b$2;
+    const pap$2 = a$2;
+    const pcm$2 = c$2;
+    const pl$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      return n == 1 && v0 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? 'few' : v0 && i != 1 && (i10 == 0 || i10 == 1) || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 12 && i100 <= 14 ? 'many' : 'other';
+    };
+    const prg$2 = n => {
+      const s = String(n).split('.'),
+        f = s[1] || '',
+        v = f.length,
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2),
+        f100 = f.slice(-2),
+        f10 = f.slice(-1);
+      return t0 && n10 == 0 || n100 >= 11 && n100 <= 19 || v == 2 && f100 >= 11 && f100 <= 19 ? 'zero' : n10 == 1 && n100 != 11 || v == 2 && f10 == 1 && f100 != 11 || v != 2 && f10 == 1 ? 'one' : 'other';
+    };
+    const ps$2 = a$2;
+    const pt$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      return i == 0 || i == 1 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const pt_PT$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const rm$2 = a$2;
+    const ro$2 = n => {
+      const s = String(n).split('.'),
+        v0 = !s[1],
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      return n == 1 && v0 ? 'one' : !v0 || n == 0 || n != 1 && n100 >= 1 && n100 <= 19 ? 'few' : 'other';
+    };
+    const rof$2 = a$2;
+    const ru$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      return v0 && i10 == 1 && i100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? 'few' : v0 && i10 == 0 || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 11 && i100 <= 14 ? 'many' : 'other';
+    };
+    const rwk$2 = a$2;
+    const sah$2 = e$1;
+    const saq$2 = a$2;
+    const sat$2 = f$2;
+    const sc$2 = d$2;
+    const scn$2 = d$2;
+    const sd$2 = a$2;
+    const sdh$2 = a$2;
+    const se$2 = f$2;
+    const seh$2 = a$2;
+    const ses$2 = e$1;
+    const sg$2 = e$1;
+    const sh$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const shi$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      return n >= 0 && n <= 1 ? 'one' : t0 && n >= 2 && n <= 10 ? 'few' : 'other';
+    };
+    const si$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '';
+      return n == 0 || n == 1 || i == 0 && f == 1 ? 'one' : 'other';
+    };
+    const sk$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1];
+      return n == 1 && v0 ? 'one' : i >= 2 && i <= 4 && v0 ? 'few' : !v0 ? 'many' : 'other';
+    };
+    const sl$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i100 = i.slice(-2);
+      return v0 && i100 == 1 ? 'one' : v0 && i100 == 2 ? 'two' : v0 && (i100 == 3 || i100 == 4) || !v0 ? 'few' : 'other';
+    };
+    const sma$2 = f$2;
+    const smi$2 = f$2;
+    const smj$2 = f$2;
+    const smn$2 = f$2;
+    const sms$2 = f$2;
+    const sn$2 = a$2;
+    const so$2 = a$2;
+    const sq$2 = a$2;
+    const sr$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const ss$2 = a$2;
+    const ssy$2 = a$2;
+    const st$2 = a$2;
+    const su$2 = e$1;
+    const sv$2 = d$2;
+    const sw$2 = d$2;
+    const syr$2 = a$2;
+    const ta$2 = a$2;
+    const te$2 = a$2;
+    const teo$2 = a$2;
+    const th$2 = e$1;
+    const ti$2 = b$2;
+    const tig$2 = a$2;
+    const tk$2 = a$2;
+    const tl$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        f10 = f.slice(-1);
+      return v0 && (i == 1 || i == 2 || i == 3) || v0 && i10 != 4 && i10 != 6 && i10 != 9 || !v0 && f10 != 4 && f10 != 6 && f10 != 9 ? 'one' : 'other';
+    };
+    const tn$2 = a$2;
+    const to$2 = e$1;
+    const tpi$2 = e$1;
+    const tr$2 = a$2;
+    const ts$2 = a$2;
+    const tzm$2 = n => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      return n == 0 || n == 1 || t0 && n >= 11 && n <= 99 ? 'one' : 'other';
+    };
+    const ug$2 = a$2;
+    const uk$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      return v0 && i10 == 1 && i100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? 'few' : v0 && i10 == 0 || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 11 && i100 <= 14 ? 'many' : 'other';
+    };
+    const und$2 = e$1;
+    const ur$2 = d$2;
+    const uz$2 = a$2;
+    const ve$2 = a$2;
+    const vec$2 = n => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const vi$2 = e$1;
+    const vo$2 = a$2;
+    const vun$2 = a$2;
+    const wa$2 = b$2;
+    const wae$2 = a$2;
+    const wo$2 = e$1;
+    const xh$2 = a$2;
+    const xog$2 = a$2;
+    const yi$2 = d$2;
+    const yo$2 = e$1;
+    const yue$2 = e$1;
+    const zh$2 = e$1;
+    const zu$2 = c$2;
+
+    var Cardinals = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        af: af$2,
+        ak: ak$2,
+        am: am$2,
+        an: an$2,
+        ar: ar$2,
+        ars: ars$2,
+        as: as$2,
+        asa: asa$2,
+        ast: ast$2,
+        az: az$2,
+        bal: bal$2,
+        be: be$2,
+        bem: bem$2,
+        bez: bez$2,
+        bg: bg$2,
+        bho: bho$2,
+        bm: bm$2,
+        bn: bn$2,
+        bo: bo$2,
+        br: br$2,
+        brx: brx$2,
+        bs: bs$2,
+        ca: ca$2,
+        ce: ce$2,
+        ceb: ceb$2,
+        cgg: cgg$2,
+        chr: chr$2,
+        ckb: ckb$2,
+        cs: cs$2,
+        cy: cy$2,
+        da: da$2,
+        de: de$2,
+        doi: doi$2,
+        dsb: dsb$2,
+        dv: dv$2,
+        dz: dz$2,
+        ee: ee$2,
+        el: el$2,
+        en: en$2,
+        eo: eo$2,
+        es: es$2,
+        et: et$2,
+        eu: eu$2,
+        fa: fa$2,
+        ff: ff$2,
+        fi: fi$2,
+        fil: fil$2,
+        fo: fo$2,
+        fr: fr$2,
+        fur: fur$2,
+        fy: fy$2,
+        ga: ga$2,
+        gd: gd$2,
+        gl: gl$2,
+        gsw: gsw$2,
+        gu: gu$2,
+        guw: guw$2,
+        gv: gv$2,
+        ha: ha$2,
+        haw: haw$2,
+        he: he$2,
+        hi: hi$2,
+        hnj: hnj$2,
+        hr: hr$2,
+        hsb: hsb$2,
+        hu: hu$2,
+        hy: hy$2,
+        ia: ia$2,
+        id: id$2,
+        ig: ig$2,
+        ii: ii$2,
+        io: io$2,
+        is: is$2,
+        it: it$2,
+        iu: iu$2,
+        ja: ja$2,
+        jbo: jbo$2,
+        jgo: jgo$2,
+        jmc: jmc$2,
+        jv: jv$2,
+        jw: jw$2,
+        ka: ka$2,
+        kab: kab$2,
+        kaj: kaj$2,
+        kcg: kcg$2,
+        kde: kde$2,
+        kea: kea$2,
+        kk: kk$2,
+        kkj: kkj$2,
+        kl: kl$2,
+        km: km$2,
+        kn: kn$2,
+        ko: ko$2,
+        ks: ks$2,
+        ksb: ksb$2,
+        ksh: ksh$2,
+        ku: ku$2,
+        kw: kw$2,
+        ky: ky$2,
+        lag: lag$2,
+        lb: lb$2,
+        lg: lg$2,
+        lij: lij$2,
+        lkt: lkt$2,
+        ln: ln$2,
+        lo: lo$2,
+        lt: lt$2,
+        lv: lv$2,
+        mas: mas$2,
+        mg: mg$2,
+        mgo: mgo$2,
+        mk: mk$2,
+        ml: ml$2,
+        mn: mn$2,
+        mo: mo$2,
+        mr: mr$2,
+        ms: ms$2,
+        mt: mt$2,
+        my: my$2,
+        nah: nah$2,
+        naq: naq$2,
+        nb: nb$2,
+        nd: nd$2,
+        ne: ne$2,
+        nl: nl$2,
+        nn: nn$2,
+        nnh: nnh$2,
+        no: no$2,
+        nqo: nqo$2,
+        nr: nr$2,
+        nso: nso$2,
+        ny: ny$2,
+        nyn: nyn$2,
+        om: om$2,
+        or: or$2,
+        os: os$2,
+        osa: osa$2,
+        pa: pa$2,
+        pap: pap$2,
+        pcm: pcm$2,
+        pl: pl$2,
+        prg: prg$2,
+        ps: ps$2,
+        pt: pt$2,
+        pt_PT: pt_PT$2,
+        rm: rm$2,
+        ro: ro$2,
+        rof: rof$2,
+        ru: ru$2,
+        rwk: rwk$2,
+        sah: sah$2,
+        saq: saq$2,
+        sat: sat$2,
+        sc: sc$2,
+        scn: scn$2,
+        sd: sd$2,
+        sdh: sdh$2,
+        se: se$2,
+        seh: seh$2,
+        ses: ses$2,
+        sg: sg$2,
+        sh: sh$2,
+        shi: shi$2,
+        si: si$2,
+        sk: sk$2,
+        sl: sl$2,
+        sma: sma$2,
+        smi: smi$2,
+        smj: smj$2,
+        smn: smn$2,
+        sms: sms$2,
+        sn: sn$2,
+        so: so$2,
+        sq: sq$2,
+        sr: sr$2,
+        ss: ss$2,
+        ssy: ssy$2,
+        st: st$2,
+        su: su$2,
+        sv: sv$2,
+        sw: sw$2,
+        syr: syr$2,
+        ta: ta$2,
+        te: te$2,
+        teo: teo$2,
+        th: th$2,
+        ti: ti$2,
+        tig: tig$2,
+        tk: tk$2,
+        tl: tl$2,
+        tn: tn$2,
+        to: to$2,
+        tpi: tpi$2,
+        tr: tr$2,
+        ts: ts$2,
+        tzm: tzm$2,
+        ug: ug$2,
+        uk: uk$2,
+        und: und$2,
+        ur: ur$2,
+        uz: uz$2,
+        ve: ve$2,
+        vec: vec$2,
+        vi: vi$2,
+        vo: vo$2,
+        vun: vun$2,
+        wa: wa$2,
+        wae: wae$2,
+        wo: wo$2,
+        xh: xh$2,
+        xog: xog$2,
+        yi: yi$2,
+        yo: yo$2,
+        yue: yue$2,
+        zh: zh$2,
+        zu: zu$2
+    });
+
+    const z = "zero",
+      o = "one",
+      t = "two",
+      f$1 = "few",
+      m = "many",
+      x = "other";
+    const a$1 = {
+      cardinal: [o, x],
+      ordinal: [x]
+    };
+    const b$1 = {
+      cardinal: [o, x],
+      ordinal: [o, x]
+    };
+    const c$1 = {
+      cardinal: [x],
+      ordinal: [x]
+    };
+    const d$1 = {
+      cardinal: [o, t, x],
+      ordinal: [x]
+    };
+    const af$1 = a$1;
+    const ak$1 = a$1;
+    const am$1 = a$1;
+    const an$1 = a$1;
+    const ar$1 = {
+      cardinal: [z, o, t, f$1, m, x],
+      ordinal: [x]
+    };
+    const ars$1 = {
+      cardinal: [z, o, t, f$1, m, x],
+      ordinal: [x]
+    };
+    const as$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, f$1, m, x]
+    };
+    const asa$1 = a$1;
+    const ast$1 = a$1;
+    const az$1 = {
+      cardinal: [o, x],
+      ordinal: [o, f$1, m, x]
+    };
+    const bal$1 = b$1;
+    const be$1 = {
+      cardinal: [o, f$1, m, x],
+      ordinal: [f$1, x]
+    };
+    const bem$1 = a$1;
+    const bez$1 = a$1;
+    const bg$1 = a$1;
+    const bho$1 = a$1;
+    const bm$1 = c$1;
+    const bn$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, f$1, m, x]
+    };
+    const bo$1 = c$1;
+    const br$1 = {
+      cardinal: [o, t, f$1, m, x],
+      ordinal: [x]
+    };
+    const brx$1 = a$1;
+    const bs$1 = {
+      cardinal: [o, f$1, x],
+      ordinal: [x]
+    };
+    const ca$1 = {
+      cardinal: [o, m, x],
+      ordinal: [o, t, f$1, x]
+    };
+    const ce$1 = a$1;
+    const ceb$1 = a$1;
+    const cgg$1 = a$1;
+    const chr$1 = a$1;
+    const ckb$1 = a$1;
+    const cs$1 = {
+      cardinal: [o, f$1, m, x],
+      ordinal: [x]
+    };
+    const cy$1 = {
+      cardinal: [z, o, t, f$1, m, x],
+      ordinal: [z, o, t, f$1, m, x]
+    };
+    const da$1 = a$1;
+    const de$1 = a$1;
+    const doi$1 = a$1;
+    const dsb$1 = {
+      cardinal: [o, t, f$1, x],
+      ordinal: [x]
+    };
+    const dv$1 = a$1;
+    const dz$1 = c$1;
+    const ee$1 = a$1;
+    const el$1 = a$1;
+    const en$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, f$1, x]
+    };
+    const eo$1 = a$1;
+    const es$1 = {
+      cardinal: [o, m, x],
+      ordinal: [x]
+    };
+    const et$1 = a$1;
+    const eu$1 = a$1;
+    const fa$1 = a$1;
+    const ff$1 = a$1;
+    const fi$1 = a$1;
+    const fil$1 = b$1;
+    const fo$1 = a$1;
+    const fr$1 = {
+      cardinal: [o, m, x],
+      ordinal: [o, x]
+    };
+    const fur$1 = a$1;
+    const fy$1 = a$1;
+    const ga$1 = {
+      cardinal: [o, t, f$1, m, x],
+      ordinal: [o, x]
+    };
+    const gd$1 = {
+      cardinal: [o, t, f$1, x],
+      ordinal: [o, t, f$1, x]
+    };
+    const gl$1 = a$1;
+    const gsw$1 = a$1;
+    const gu$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, f$1, m, x]
+    };
+    const guw$1 = a$1;
+    const gv$1 = {
+      cardinal: [o, t, f$1, m, x],
+      ordinal: [x]
+    };
+    const ha$1 = a$1;
+    const haw$1 = a$1;
+    const he$1 = d$1;
+    const hi$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, f$1, m, x]
+    };
+    const hnj$1 = c$1;
+    const hr$1 = {
+      cardinal: [o, f$1, x],
+      ordinal: [x]
+    };
+    const hsb$1 = {
+      cardinal: [o, t, f$1, x],
+      ordinal: [x]
+    };
+    const hu$1 = b$1;
+    const hy$1 = b$1;
+    const ia$1 = a$1;
+    const id$1 = c$1;
+    const ig$1 = c$1;
+    const ii$1 = c$1;
+    const io$1 = a$1;
+    const is$1 = a$1;
+    const it$1 = {
+      cardinal: [o, m, x],
+      ordinal: [m, x]
+    };
+    const iu$1 = d$1;
+    const ja$1 = c$1;
+    const jbo$1 = c$1;
+    const jgo$1 = a$1;
+    const jmc$1 = a$1;
+    const jv$1 = c$1;
+    const jw$1 = c$1;
+    const ka$1 = {
+      cardinal: [o, x],
+      ordinal: [o, m, x]
+    };
+    const kab$1 = a$1;
+    const kaj$1 = a$1;
+    const kcg$1 = a$1;
+    const kde$1 = c$1;
+    const kea$1 = c$1;
+    const kk$1 = {
+      cardinal: [o, x],
+      ordinal: [m, x]
+    };
+    const kkj$1 = a$1;
+    const kl$1 = a$1;
+    const km$1 = c$1;
+    const kn$1 = a$1;
+    const ko$1 = c$1;
+    const ks$1 = a$1;
+    const ksb$1 = a$1;
+    const ksh$1 = {
+      cardinal: [z, o, x],
+      ordinal: [x]
+    };
+    const ku$1 = a$1;
+    const kw$1 = {
+      cardinal: [z, o, t, f$1, m, x],
+      ordinal: [o, m, x]
+    };
+    const ky$1 = a$1;
+    const lag$1 = {
+      cardinal: [z, o, x],
+      ordinal: [x]
+    };
+    const lb$1 = a$1;
+    const lg$1 = a$1;
+    const lij$1 = {
+      cardinal: [o, x],
+      ordinal: [m, x]
+    };
+    const lkt$1 = c$1;
+    const ln$1 = a$1;
+    const lo$1 = {
+      cardinal: [x],
+      ordinal: [o, x]
+    };
+    const lt$1 = {
+      cardinal: [o, f$1, m, x],
+      ordinal: [x]
+    };
+    const lv$1 = {
+      cardinal: [z, o, x],
+      ordinal: [x]
+    };
+    const mas$1 = a$1;
+    const mg$1 = a$1;
+    const mgo$1 = a$1;
+    const mk$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, m, x]
+    };
+    const ml$1 = a$1;
+    const mn$1 = a$1;
+    const mo$1 = {
+      cardinal: [o, f$1, x],
+      ordinal: [o, x]
+    };
+    const mr$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, f$1, x]
+    };
+    const ms$1 = {
+      cardinal: [x],
+      ordinal: [o, x]
+    };
+    const mt$1 = {
+      cardinal: [o, t, f$1, m, x],
+      ordinal: [x]
+    };
+    const my$1 = c$1;
+    const nah$1 = a$1;
+    const naq$1 = d$1;
+    const nb$1 = a$1;
+    const nd$1 = a$1;
+    const ne$1 = b$1;
+    const nl$1 = a$1;
+    const nn$1 = a$1;
+    const nnh$1 = a$1;
+    const no$1 = a$1;
+    const nqo$1 = c$1;
+    const nr$1 = a$1;
+    const nso$1 = a$1;
+    const ny$1 = a$1;
+    const nyn$1 = a$1;
+    const om$1 = a$1;
+    const or$1 = {
+      cardinal: [o, x],
+      ordinal: [o, t, f$1, m, x]
+    };
+    const os$1 = a$1;
+    const osa$1 = c$1;
+    const pa$1 = a$1;
+    const pap$1 = a$1;
+    const pcm$1 = a$1;
+    const pl$1 = {
+      cardinal: [o, f$1, m, x],
+      ordinal: [x]
+    };
+    const prg$1 = {
+      cardinal: [z, o, x],
+      ordinal: [x]
+    };
+    const ps$1 = a$1;
+    const pt$1 = {
+      cardinal: [o, m, x],
+      ordinal: [x]
+    };
+    const pt_PT$1 = {
+      cardinal: [o, m, x],
+      ordinal: [x]
+    };
+    const rm$1 = a$1;
+    const ro$1 = {
+      cardinal: [o, f$1, x],
+      ordinal: [o, x]
+    };
+    const rof$1 = a$1;
+    const ru$1 = {
+      cardinal: [o, f$1, m, x],
+      ordinal: [x]
+    };
+    const rwk$1 = a$1;
+    const sah$1 = c$1;
+    const saq$1 = a$1;
+    const sat$1 = d$1;
+    const sc$1 = {
+      cardinal: [o, x],
+      ordinal: [m, x]
+    };
+    const scn$1 = {
+      cardinal: [o, x],
+      ordinal: [m, x]
+    };
+    const sd$1 = a$1;
+    const sdh$1 = a$1;
+    const se$1 = d$1;
+    const seh$1 = a$1;
+    const ses$1 = c$1;
+    const sg$1 = c$1;
+    const sh$1 = {
+      cardinal: [o, f$1, x],
+      ordinal: [x]
+    };
+    const shi$1 = {
+      cardinal: [o, f$1, x],
+      ordinal: [x]
+    };
+    const si$1 = a$1;
+    const sk$1 = {
+      cardinal: [o, f$1, m, x],
+      ordinal: [x]
+    };
+    const sl$1 = {
+      cardinal: [o, t, f$1, x],
+      ordinal: [x]
+    };
+    const sma$1 = d$1;
+    const smi$1 = d$1;
+    const smj$1 = d$1;
+    const smn$1 = d$1;
+    const sms$1 = d$1;
+    const sn$1 = a$1;
+    const so$1 = a$1;
+    const sq$1 = {
+      cardinal: [o, x],
+      ordinal: [o, m, x]
+    };
+    const sr$1 = {
+      cardinal: [o, f$1, x],
+      ordinal: [x]
+    };
+    const ss$1 = a$1;
+    const ssy$1 = a$1;
+    const st$1 = a$1;
+    const su$1 = c$1;
+    const sv$1 = b$1;
+    const sw$1 = a$1;
+    const syr$1 = a$1;
+    const ta$1 = a$1;
+    const te$1 = a$1;
+    const teo$1 = a$1;
+    const th$1 = c$1;
+    const ti$1 = a$1;
+    const tig$1 = a$1;
+    const tk$1 = {
+      cardinal: [o, x],
+      ordinal: [f$1, x]
+    };
+    const tl$1 = b$1;
+    const tn$1 = a$1;
+    const to$1 = c$1;
+    const tpi$1 = c$1;
+    const tr$1 = a$1;
+    const ts$1 = a$1;
+    const tzm$1 = a$1;
+    const ug$1 = a$1;
+    const uk$1 = {
+      cardinal: [o, f$1, m, x],
+      ordinal: [f$1, x]
+    };
+    const und$1 = c$1;
+    const ur$1 = a$1;
+    const uz$1 = a$1;
+    const ve$1 = a$1;
+    const vec$1 = {
+      cardinal: [o, m, x],
+      ordinal: [m, x]
+    };
+    const vi$1 = {
+      cardinal: [x],
+      ordinal: [o, x]
+    };
+    const vo$1 = a$1;
+    const vun$1 = a$1;
+    const wa$1 = a$1;
+    const wae$1 = a$1;
+    const wo$1 = c$1;
+    const xh$1 = a$1;
+    const xog$1 = a$1;
+    const yi$1 = a$1;
+    const yo$1 = c$1;
+    const yue$1 = c$1;
+    const zh$1 = c$1;
+    const zu$1 = a$1;
+
+    var PluralCategories = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        af: af$1,
+        ak: ak$1,
+        am: am$1,
+        an: an$1,
+        ar: ar$1,
+        ars: ars$1,
+        as: as$1,
+        asa: asa$1,
+        ast: ast$1,
+        az: az$1,
+        bal: bal$1,
+        be: be$1,
+        bem: bem$1,
+        bez: bez$1,
+        bg: bg$1,
+        bho: bho$1,
+        bm: bm$1,
+        bn: bn$1,
+        bo: bo$1,
+        br: br$1,
+        brx: brx$1,
+        bs: bs$1,
+        ca: ca$1,
+        ce: ce$1,
+        ceb: ceb$1,
+        cgg: cgg$1,
+        chr: chr$1,
+        ckb: ckb$1,
+        cs: cs$1,
+        cy: cy$1,
+        da: da$1,
+        de: de$1,
+        doi: doi$1,
+        dsb: dsb$1,
+        dv: dv$1,
+        dz: dz$1,
+        ee: ee$1,
+        el: el$1,
+        en: en$1,
+        eo: eo$1,
+        es: es$1,
+        et: et$1,
+        eu: eu$1,
+        fa: fa$1,
+        ff: ff$1,
+        fi: fi$1,
+        fil: fil$1,
+        fo: fo$1,
+        fr: fr$1,
+        fur: fur$1,
+        fy: fy$1,
+        ga: ga$1,
+        gd: gd$1,
+        gl: gl$1,
+        gsw: gsw$1,
+        gu: gu$1,
+        guw: guw$1,
+        gv: gv$1,
+        ha: ha$1,
+        haw: haw$1,
+        he: he$1,
+        hi: hi$1,
+        hnj: hnj$1,
+        hr: hr$1,
+        hsb: hsb$1,
+        hu: hu$1,
+        hy: hy$1,
+        ia: ia$1,
+        id: id$1,
+        ig: ig$1,
+        ii: ii$1,
+        io: io$1,
+        is: is$1,
+        it: it$1,
+        iu: iu$1,
+        ja: ja$1,
+        jbo: jbo$1,
+        jgo: jgo$1,
+        jmc: jmc$1,
+        jv: jv$1,
+        jw: jw$1,
+        ka: ka$1,
+        kab: kab$1,
+        kaj: kaj$1,
+        kcg: kcg$1,
+        kde: kde$1,
+        kea: kea$1,
+        kk: kk$1,
+        kkj: kkj$1,
+        kl: kl$1,
+        km: km$1,
+        kn: kn$1,
+        ko: ko$1,
+        ks: ks$1,
+        ksb: ksb$1,
+        ksh: ksh$1,
+        ku: ku$1,
+        kw: kw$1,
+        ky: ky$1,
+        lag: lag$1,
+        lb: lb$1,
+        lg: lg$1,
+        lij: lij$1,
+        lkt: lkt$1,
+        ln: ln$1,
+        lo: lo$1,
+        lt: lt$1,
+        lv: lv$1,
+        mas: mas$1,
+        mg: mg$1,
+        mgo: mgo$1,
+        mk: mk$1,
+        ml: ml$1,
+        mn: mn$1,
+        mo: mo$1,
+        mr: mr$1,
+        ms: ms$1,
+        mt: mt$1,
+        my: my$1,
+        nah: nah$1,
+        naq: naq$1,
+        nb: nb$1,
+        nd: nd$1,
+        ne: ne$1,
+        nl: nl$1,
+        nn: nn$1,
+        nnh: nnh$1,
+        no: no$1,
+        nqo: nqo$1,
+        nr: nr$1,
+        nso: nso$1,
+        ny: ny$1,
+        nyn: nyn$1,
+        om: om$1,
+        or: or$1,
+        os: os$1,
+        osa: osa$1,
+        pa: pa$1,
+        pap: pap$1,
+        pcm: pcm$1,
+        pl: pl$1,
+        prg: prg$1,
+        ps: ps$1,
+        pt: pt$1,
+        pt_PT: pt_PT$1,
+        rm: rm$1,
+        ro: ro$1,
+        rof: rof$1,
+        ru: ru$1,
+        rwk: rwk$1,
+        sah: sah$1,
+        saq: saq$1,
+        sat: sat$1,
+        sc: sc$1,
+        scn: scn$1,
+        sd: sd$1,
+        sdh: sdh$1,
+        se: se$1,
+        seh: seh$1,
+        ses: ses$1,
+        sg: sg$1,
+        sh: sh$1,
+        shi: shi$1,
+        si: si$1,
+        sk: sk$1,
+        sl: sl$1,
+        sma: sma$1,
+        smi: smi$1,
+        smj: smj$1,
+        smn: smn$1,
+        sms: sms$1,
+        sn: sn$1,
+        so: so$1,
+        sq: sq$1,
+        sr: sr$1,
+        ss: ss$1,
+        ssy: ssy$1,
+        st: st$1,
+        su: su$1,
+        sv: sv$1,
+        sw: sw$1,
+        syr: syr$1,
+        ta: ta$1,
+        te: te$1,
+        teo: teo$1,
+        th: th$1,
+        ti: ti$1,
+        tig: tig$1,
+        tk: tk$1,
+        tl: tl$1,
+        tn: tn$1,
+        to: to$1,
+        tpi: tpi$1,
+        tr: tr$1,
+        ts: ts$1,
+        tzm: tzm$1,
+        ug: ug$1,
+        uk: uk$1,
+        und: und$1,
+        ur: ur$1,
+        uz: uz$1,
+        ve: ve$1,
+        vec: vec$1,
+        vi: vi$1,
+        vo: vo$1,
+        vun: vun$1,
+        wa: wa$1,
+        wae: wae$1,
+        wo: wo$1,
+        xh: xh$1,
+        xog: xog$1,
+        yi: yi$1,
+        yo: yo$1,
+        yue: yue$1,
+        zh: zh$1,
+        zu: zu$1
+    });
+
+    const a = (n, ord) => {
+      if (ord) return 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const b = (n, ord) => {
+      if (ord) return 'other';
+      return n == 0 || n == 1 ? 'one' : 'other';
+    };
+    const c = (n, ord) => {
+      if (ord) return 'other';
+      return n >= 0 && n <= 1 ? 'one' : 'other';
+    };
+    const d = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1];
+      if (ord) return 'other';
+      return n == 1 && v0 ? 'one' : 'other';
+    };
+    const e = (n, ord) => 'other';
+    const f = (n, ord) => {
+      if (ord) return 'other';
+      return n == 1 ? 'one' : n == 2 ? 'two' : 'other';
+    };
+    const af = a;
+    const ak = b;
+    const am = c;
+    const an = a;
+    const ar = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return 'other';
+      return n == 0 ? 'zero' : n == 1 ? 'one' : n == 2 ? 'two' : n100 >= 3 && n100 <= 10 ? 'few' : n100 >= 11 && n100 <= 99 ? 'many' : 'other';
+    };
+    const ars = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return 'other';
+      return n == 0 ? 'zero' : n == 1 ? 'one' : n == 2 ? 'two' : n100 >= 3 && n100 <= 10 ? 'few' : n100 >= 11 && n100 <= 99 ? 'many' : 'other';
+    };
+    const as = (n, ord) => {
+      if (ord) return n == 1 || n == 5 || n == 7 || n == 8 || n == 9 || n == 10 ? 'one' : n == 2 || n == 3 ? 'two' : n == 4 ? 'few' : n == 6 ? 'many' : 'other';
+      return n >= 0 && n <= 1 ? 'one' : 'other';
+    };
+    const asa = a;
+    const ast = d;
+    const az = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        i1000 = i.slice(-3);
+      if (ord) return i10 == 1 || i10 == 2 || i10 == 5 || i10 == 7 || i10 == 8 || i100 == 20 || i100 == 50 || i100 == 70 || i100 == 80 ? 'one' : i10 == 3 || i10 == 4 || i1000 == 100 || i1000 == 200 || i1000 == 300 || i1000 == 400 || i1000 == 500 || i1000 == 600 || i1000 == 700 || i1000 == 800 || i1000 == 900 ? 'few' : i == 0 || i10 == 6 || i100 == 40 || i100 == 60 || i100 == 90 ? 'many' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const bal = (n, ord) => n == 1 ? 'one' : 'other';
+    const be = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return (n10 == 2 || n10 == 3) && n100 != 12 && n100 != 13 ? 'few' : 'other';
+      return n10 == 1 && n100 != 11 ? 'one' : n10 >= 2 && n10 <= 4 && (n100 < 12 || n100 > 14) ? 'few' : t0 && n10 == 0 || n10 >= 5 && n10 <= 9 || n100 >= 11 && n100 <= 14 ? 'many' : 'other';
+    };
+    const bem = a;
+    const bez = a;
+    const bg = a;
+    const bho = b;
+    const bm = e;
+    const bn = (n, ord) => {
+      if (ord) return n == 1 || n == 5 || n == 7 || n == 8 || n == 9 || n == 10 ? 'one' : n == 2 || n == 3 ? 'two' : n == 4 ? 'few' : n == 6 ? 'many' : 'other';
+      return n >= 0 && n <= 1 ? 'one' : 'other';
+    };
+    const bo = e;
+    const br = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2),
+        n1000000 = t0 && s[0].slice(-6);
+      if (ord) return 'other';
+      return n10 == 1 && n100 != 11 && n100 != 71 && n100 != 91 ? 'one' : n10 == 2 && n100 != 12 && n100 != 72 && n100 != 92 ? 'two' : (n10 == 3 || n10 == 4 || n10 == 9) && (n100 < 10 || n100 > 19) && (n100 < 70 || n100 > 79) && (n100 < 90 || n100 > 99) ? 'few' : n != 0 && t0 && n1000000 == 0 ? 'many' : 'other';
+    };
+    const brx = a;
+    const bs = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      if (ord) return 'other';
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const ca = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      if (ord) return n == 1 || n == 3 ? 'one' : n == 2 ? 'two' : n == 4 ? 'few' : 'other';
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const ce = a;
+    const ceb = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        f10 = f.slice(-1);
+      if (ord) return 'other';
+      return v0 && (i == 1 || i == 2 || i == 3) || v0 && i10 != 4 && i10 != 6 && i10 != 9 || !v0 && f10 != 4 && f10 != 6 && f10 != 9 ? 'one' : 'other';
+    };
+    const cgg = a;
+    const chr = a;
+    const ckb = a;
+    const cs = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1];
+      if (ord) return 'other';
+      return n == 1 && v0 ? 'one' : i >= 2 && i <= 4 && v0 ? 'few' : !v0 ? 'many' : 'other';
+    };
+    const cy = (n, ord) => {
+      if (ord) return n == 0 || n == 7 || n == 8 || n == 9 ? 'zero' : n == 1 ? 'one' : n == 2 ? 'two' : n == 3 || n == 4 ? 'few' : n == 5 || n == 6 ? 'many' : 'other';
+      return n == 0 ? 'zero' : n == 1 ? 'one' : n == 2 ? 'two' : n == 3 ? 'few' : n == 6 ? 'many' : 'other';
+    };
+    const da = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        t0 = Number(s[0]) == n;
+      if (ord) return 'other';
+      return n == 1 || !t0 && (i == 0 || i == 1) ? 'one' : 'other';
+    };
+    const de = d;
+    const doi = c;
+    const dsb = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i100 = i.slice(-2),
+        f100 = f.slice(-2);
+      if (ord) return 'other';
+      return v0 && i100 == 1 || f100 == 1 ? 'one' : v0 && i100 == 2 || f100 == 2 ? 'two' : v0 && (i100 == 3 || i100 == 4) || f100 == 3 || f100 == 4 ? 'few' : 'other';
+    };
+    const dv = a;
+    const dz = e;
+    const ee = a;
+    const el = a;
+    const en = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1],
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return n10 == 1 && n100 != 11 ? 'one' : n10 == 2 && n100 != 12 ? 'two' : n10 == 3 && n100 != 13 ? 'few' : 'other';
+      return n == 1 && v0 ? 'one' : 'other';
+    };
+    const eo = a;
+    const es = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      if (ord) return 'other';
+      return n == 1 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const et = d;
+    const eu = a;
+    const fa = c;
+    const ff = (n, ord) => {
+      if (ord) return 'other';
+      return n >= 0 && n < 2 ? 'one' : 'other';
+    };
+    const fi = d;
+    const fil = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        f10 = f.slice(-1);
+      if (ord) return n == 1 ? 'one' : 'other';
+      return v0 && (i == 1 || i == 2 || i == 3) || v0 && i10 != 4 && i10 != 6 && i10 != 9 || !v0 && f10 != 4 && f10 != 6 && f10 != 9 ? 'one' : 'other';
+    };
+    const fo = a;
+    const fr = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      if (ord) return n == 1 ? 'one' : 'other';
+      return n >= 0 && n < 2 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const fur = a;
+    const fy = d;
+    const ga = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      if (ord) return n == 1 ? 'one' : 'other';
+      return n == 1 ? 'one' : n == 2 ? 'two' : t0 && n >= 3 && n <= 6 ? 'few' : t0 && n >= 7 && n <= 10 ? 'many' : 'other';
+    };
+    const gd = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      if (ord) return n == 1 || n == 11 ? 'one' : n == 2 || n == 12 ? 'two' : n == 3 || n == 13 ? 'few' : 'other';
+      return n == 1 || n == 11 ? 'one' : n == 2 || n == 12 ? 'two' : t0 && n >= 3 && n <= 10 || t0 && n >= 13 && n <= 19 ? 'few' : 'other';
+    };
+    const gl = d;
+    const gsw = a;
+    const gu = (n, ord) => {
+      if (ord) return n == 1 ? 'one' : n == 2 || n == 3 ? 'two' : n == 4 ? 'few' : n == 6 ? 'many' : 'other';
+      return n >= 0 && n <= 1 ? 'one' : 'other';
+    };
+    const guw = b;
+    const gv = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      if (ord) return 'other';
+      return v0 && i10 == 1 ? 'one' : v0 && i10 == 2 ? 'two' : v0 && (i100 == 0 || i100 == 20 || i100 == 40 || i100 == 60 || i100 == 80) ? 'few' : !v0 ? 'many' : 'other';
+    };
+    const ha = a;
+    const haw = a;
+    const he = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1];
+      if (ord) return 'other';
+      return i == 1 && v0 || i == 0 && !v0 ? 'one' : i == 2 && v0 ? 'two' : 'other';
+    };
+    const hi = (n, ord) => {
+      if (ord) return n == 1 ? 'one' : n == 2 || n == 3 ? 'two' : n == 4 ? 'few' : n == 6 ? 'many' : 'other';
+      return n >= 0 && n <= 1 ? 'one' : 'other';
+    };
+    const hnj = e;
+    const hr = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      if (ord) return 'other';
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const hsb = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i100 = i.slice(-2),
+        f100 = f.slice(-2);
+      if (ord) return 'other';
+      return v0 && i100 == 1 || f100 == 1 ? 'one' : v0 && i100 == 2 || f100 == 2 ? 'two' : v0 && (i100 == 3 || i100 == 4) || f100 == 3 || f100 == 4 ? 'few' : 'other';
+    };
+    const hu = (n, ord) => {
+      if (ord) return n == 1 || n == 5 ? 'one' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const hy = (n, ord) => {
+      if (ord) return n == 1 ? 'one' : 'other';
+      return n >= 0 && n < 2 ? 'one' : 'other';
+    };
+    const ia = d;
+    const id = e;
+    const ig = e;
+    const ii = e;
+    const io = d;
+    const is = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        t = (s[1] || '').replace(/0+$/, ''),
+        t0 = Number(s[0]) == n,
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      if (ord) return 'other';
+      return t0 && i10 == 1 && i100 != 11 || t % 10 == 1 && t % 100 != 11 ? 'one' : 'other';
+    };
+    const it = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      if (ord) return n == 11 || n == 8 || n == 80 || n == 800 ? 'many' : 'other';
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const iu = f;
+    const ja = e;
+    const jbo = e;
+    const jgo = a;
+    const jmc = a;
+    const jv = e;
+    const jw = e;
+    const ka = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        i100 = i.slice(-2);
+      if (ord) return i == 1 ? 'one' : i == 0 || i100 >= 2 && i100 <= 20 || i100 == 40 || i100 == 60 || i100 == 80 ? 'many' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const kab = (n, ord) => {
+      if (ord) return 'other';
+      return n >= 0 && n < 2 ? 'one' : 'other';
+    };
+    const kaj = a;
+    const kcg = a;
+    const kde = e;
+    const kea = e;
+    const kk = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1);
+      if (ord) return n10 == 6 || n10 == 9 || t0 && n10 == 0 && n != 0 ? 'many' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const kkj = a;
+    const kl = a;
+    const km = e;
+    const kn = c;
+    const ko = e;
+    const ks = a;
+    const ksb = a;
+    const ksh = (n, ord) => {
+      if (ord) return 'other';
+      return n == 0 ? 'zero' : n == 1 ? 'one' : 'other';
+    };
+    const ku = a;
+    const kw = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2),
+        n1000 = t0 && s[0].slice(-3),
+        n100000 = t0 && s[0].slice(-5),
+        n1000000 = t0 && s[0].slice(-6);
+      if (ord) return t0 && n >= 1 && n <= 4 || n100 >= 1 && n100 <= 4 || n100 >= 21 && n100 <= 24 || n100 >= 41 && n100 <= 44 || n100 >= 61 && n100 <= 64 || n100 >= 81 && n100 <= 84 ? 'one' : n == 5 || n100 == 5 ? 'many' : 'other';
+      return n == 0 ? 'zero' : n == 1 ? 'one' : n100 == 2 || n100 == 22 || n100 == 42 || n100 == 62 || n100 == 82 || t0 && n1000 == 0 && (n100000 >= 1000 && n100000 <= 20000 || n100000 == 40000 || n100000 == 60000 || n100000 == 80000) || n != 0 && n1000000 == 100000 ? 'two' : n100 == 3 || n100 == 23 || n100 == 43 || n100 == 63 || n100 == 83 ? 'few' : n != 1 && (n100 == 1 || n100 == 21 || n100 == 41 || n100 == 61 || n100 == 81) ? 'many' : 'other';
+    };
+    const ky = a;
+    const lag = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0];
+      if (ord) return 'other';
+      return n == 0 ? 'zero' : (i == 0 || i == 1) && n != 0 ? 'one' : 'other';
+    };
+    const lb = a;
+    const lg = a;
+    const lij = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1],
+        t0 = Number(s[0]) == n;
+      if (ord) return n == 11 || n == 8 || t0 && n >= 80 && n <= 89 || t0 && n >= 800 && n <= 899 ? 'many' : 'other';
+      return n == 1 && v0 ? 'one' : 'other';
+    };
+    const lkt = e;
+    const ln = b;
+    const lo = (n, ord) => {
+      if (ord) return n == 1 ? 'one' : 'other';
+      return 'other';
+    };
+    const lt = (n, ord) => {
+      const s = String(n).split('.'),
+        f = s[1] || '',
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return 'other';
+      return n10 == 1 && (n100 < 11 || n100 > 19) ? 'one' : n10 >= 2 && n10 <= 9 && (n100 < 11 || n100 > 19) ? 'few' : f != 0 ? 'many' : 'other';
+    };
+    const lv = (n, ord) => {
+      const s = String(n).split('.'),
+        f = s[1] || '',
+        v = f.length,
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2),
+        f100 = f.slice(-2),
+        f10 = f.slice(-1);
+      if (ord) return 'other';
+      return t0 && n10 == 0 || n100 >= 11 && n100 <= 19 || v == 2 && f100 >= 11 && f100 <= 19 ? 'zero' : n10 == 1 && n100 != 11 || v == 2 && f10 == 1 && f100 != 11 || v != 2 && f10 == 1 ? 'one' : 'other';
+    };
+    const mas = a;
+    const mg = b;
+    const mgo = a;
+    const mk = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      if (ord) return i10 == 1 && i100 != 11 ? 'one' : i10 == 2 && i100 != 12 ? 'two' : (i10 == 7 || i10 == 8) && i100 != 17 && i100 != 18 ? 'many' : 'other';
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : 'other';
+    };
+    const ml = a;
+    const mn = a;
+    const mo = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1],
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return n == 1 ? 'one' : 'other';
+      return n == 1 && v0 ? 'one' : !v0 || n == 0 || n != 1 && n100 >= 1 && n100 <= 19 ? 'few' : 'other';
+    };
+    const mr = (n, ord) => {
+      if (ord) return n == 1 ? 'one' : n == 2 || n == 3 ? 'two' : n == 4 ? 'few' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const ms = (n, ord) => {
+      if (ord) return n == 1 ? 'one' : 'other';
+      return 'other';
+    };
+    const mt = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return 'other';
+      return n == 1 ? 'one' : n == 2 ? 'two' : n == 0 || n100 >= 3 && n100 <= 10 ? 'few' : n100 >= 11 && n100 <= 19 ? 'many' : 'other';
+    };
+    const my = e;
+    const nah = a;
+    const naq = f;
+    const nb = a;
+    const nd = a;
+    const ne = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      if (ord) return t0 && n >= 1 && n <= 4 ? 'one' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const nl = d;
+    const nn = a;
+    const nnh = a;
+    const no = a;
+    const nqo = e;
+    const nr = a;
+    const nso = b;
+    const ny = a;
+    const nyn = a;
+    const om = a;
+    const or = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      if (ord) return n == 1 || n == 5 || t0 && n >= 7 && n <= 9 ? 'one' : n == 2 || n == 3 ? 'two' : n == 4 ? 'few' : n == 6 ? 'many' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const os = a;
+    const osa = e;
+    const pa = b;
+    const pap = a;
+    const pcm = c;
+    const pl = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      if (ord) return 'other';
+      return n == 1 && v0 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? 'few' : v0 && i != 1 && (i10 == 0 || i10 == 1) || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 12 && i100 <= 14 ? 'many' : 'other';
+    };
+    const prg = (n, ord) => {
+      const s = String(n).split('.'),
+        f = s[1] || '',
+        v = f.length,
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2),
+        f100 = f.slice(-2),
+        f10 = f.slice(-1);
+      if (ord) return 'other';
+      return t0 && n10 == 0 || n100 >= 11 && n100 <= 19 || v == 2 && f100 >= 11 && f100 <= 19 ? 'zero' : n10 == 1 && n100 != 11 || v == 2 && f10 == 1 && f100 != 11 || v != 2 && f10 == 1 ? 'one' : 'other';
+    };
+    const ps = a;
+    const pt = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      if (ord) return 'other';
+      return i == 0 || i == 1 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const pt_PT = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      if (ord) return 'other';
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const rm = a;
+    const ro = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1],
+        t0 = Number(s[0]) == n,
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return n == 1 ? 'one' : 'other';
+      return n == 1 && v0 ? 'one' : !v0 || n == 0 || n != 1 && n100 >= 1 && n100 <= 19 ? 'few' : 'other';
+    };
+    const rof = a;
+    const ru = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      if (ord) return 'other';
+      return v0 && i10 == 1 && i100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? 'few' : v0 && i10 == 0 || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 11 && i100 <= 14 ? 'many' : 'other';
+    };
+    const rwk = a;
+    const sah = e;
+    const saq = a;
+    const sat = f;
+    const sc = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1];
+      if (ord) return n == 11 || n == 8 || n == 80 || n == 800 ? 'many' : 'other';
+      return n == 1 && v0 ? 'one' : 'other';
+    };
+    const scn = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1];
+      if (ord) return n == 11 || n == 8 || n == 80 || n == 800 ? 'many' : 'other';
+      return n == 1 && v0 ? 'one' : 'other';
+    };
+    const sd = a;
+    const sdh = a;
+    const se = f;
+    const seh = a;
+    const ses = e;
+    const sg = e;
+    const sh = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      if (ord) return 'other';
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const shi = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      if (ord) return 'other';
+      return n >= 0 && n <= 1 ? 'one' : t0 && n >= 2 && n <= 10 ? 'few' : 'other';
+    };
+    const si = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '';
+      if (ord) return 'other';
+      return n == 0 || n == 1 || i == 0 && f == 1 ? 'one' : 'other';
+    };
+    const sk = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1];
+      if (ord) return 'other';
+      return n == 1 && v0 ? 'one' : i >= 2 && i <= 4 && v0 ? 'few' : !v0 ? 'many' : 'other';
+    };
+    const sl = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i100 = i.slice(-2);
+      if (ord) return 'other';
+      return v0 && i100 == 1 ? 'one' : v0 && i100 == 2 ? 'two' : v0 && (i100 == 3 || i100 == 4) || !v0 ? 'few' : 'other';
+    };
+    const sma = f;
+    const smi = f;
+    const smj = f;
+    const smn = f;
+    const sms = f;
+    const sn = a;
+    const so = a;
+    const sq = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return n == 1 ? 'one' : n10 == 4 && n100 != 14 ? 'many' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const sr = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        i100 = i.slice(-2),
+        f10 = f.slice(-1),
+        f100 = f.slice(-2);
+      if (ord) return 'other';
+      return v0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14) ? 'few' : 'other';
+    };
+    const ss = a;
+    const ssy = a;
+    const st = a;
+    const su = e;
+    const sv = (n, ord) => {
+      const s = String(n).split('.'),
+        v0 = !s[1],
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2);
+      if (ord) return (n10 == 1 || n10 == 2) && n100 != 11 && n100 != 12 ? 'one' : 'other';
+      return n == 1 && v0 ? 'one' : 'other';
+    };
+    const sw = d;
+    const syr = a;
+    const ta = a;
+    const te = a;
+    const teo = a;
+    const th = e;
+    const ti = b;
+    const tig = a;
+    const tk = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1);
+      if (ord) return n10 == 6 || n10 == 9 || n == 10 ? 'few' : 'other';
+      return n == 1 ? 'one' : 'other';
+    };
+    const tl = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        f = s[1] || '',
+        v0 = !s[1],
+        i10 = i.slice(-1),
+        f10 = f.slice(-1);
+      if (ord) return n == 1 ? 'one' : 'other';
+      return v0 && (i == 1 || i == 2 || i == 3) || v0 && i10 != 4 && i10 != 6 && i10 != 9 || !v0 && f10 != 4 && f10 != 6 && f10 != 9 ? 'one' : 'other';
+    };
+    const tn = a;
+    const to = e;
+    const tpi = e;
+    const tr = a;
+    const ts = a;
+    const tzm = (n, ord) => {
+      const s = String(n).split('.'),
+        t0 = Number(s[0]) == n;
+      if (ord) return 'other';
+      return n == 0 || n == 1 || t0 && n >= 11 && n <= 99 ? 'one' : 'other';
+    };
+    const ug = a;
+    const uk = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        t0 = Number(s[0]) == n,
+        n10 = t0 && s[0].slice(-1),
+        n100 = t0 && s[0].slice(-2),
+        i10 = i.slice(-1),
+        i100 = i.slice(-2);
+      if (ord) return n10 == 3 && n100 != 13 ? 'few' : 'other';
+      return v0 && i10 == 1 && i100 != 11 ? 'one' : v0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) ? 'few' : v0 && i10 == 0 || v0 && i10 >= 5 && i10 <= 9 || v0 && i100 >= 11 && i100 <= 14 ? 'many' : 'other';
+    };
+    const und = e;
+    const ur = d;
+    const uz = a;
+    const ve = a;
+    const vec = (n, ord) => {
+      const s = String(n).split('.'),
+        i = s[0],
+        v0 = !s[1],
+        i1000000 = i.slice(-6);
+      if (ord) return n == 11 || n == 8 || n == 80 || n == 800 ? 'many' : 'other';
+      return n == 1 && v0 ? 'one' : i != 0 && i1000000 == 0 && v0 ? 'many' : 'other';
+    };
+    const vi = (n, ord) => {
+      if (ord) return n == 1 ? 'one' : 'other';
+      return 'other';
+    };
+    const vo = a;
+    const vun = a;
+    const wa = b;
+    const wae = a;
+    const wo = e;
+    const xh = a;
+    const xog = a;
+    const yi = d;
+    const yo = e;
+    const yue = e;
+    const zh = e;
+    const zu = c;
+
+    var Plurals = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        af: af,
+        ak: ak,
+        am: am,
+        an: an,
+        ar: ar,
+        ars: ars,
+        as: as,
+        asa: asa,
+        ast: ast,
+        az: az,
+        bal: bal,
+        be: be,
+        bem: bem,
+        bez: bez,
+        bg: bg,
+        bho: bho,
+        bm: bm,
+        bn: bn,
+        bo: bo,
+        br: br,
+        brx: brx,
+        bs: bs,
+        ca: ca,
+        ce: ce,
+        ceb: ceb,
+        cgg: cgg,
+        chr: chr,
+        ckb: ckb,
+        cs: cs,
+        cy: cy,
+        da: da,
+        de: de,
+        doi: doi,
+        dsb: dsb,
+        dv: dv,
+        dz: dz,
+        ee: ee,
+        el: el,
+        en: en,
+        eo: eo,
+        es: es,
+        et: et,
+        eu: eu,
+        fa: fa,
+        ff: ff,
+        fi: fi,
+        fil: fil,
+        fo: fo,
+        fr: fr,
+        fur: fur,
+        fy: fy,
+        ga: ga,
+        gd: gd,
+        gl: gl,
+        gsw: gsw,
+        gu: gu,
+        guw: guw,
+        gv: gv,
+        ha: ha,
+        haw: haw,
+        he: he,
+        hi: hi,
+        hnj: hnj,
+        hr: hr,
+        hsb: hsb,
+        hu: hu,
+        hy: hy,
+        ia: ia,
+        id: id,
+        ig: ig,
+        ii: ii,
+        io: io,
+        is: is,
+        it: it,
+        iu: iu,
+        ja: ja,
+        jbo: jbo,
+        jgo: jgo,
+        jmc: jmc,
+        jv: jv,
+        jw: jw,
+        ka: ka,
+        kab: kab,
+        kaj: kaj,
+        kcg: kcg,
+        kde: kde,
+        kea: kea,
+        kk: kk,
+        kkj: kkj,
+        kl: kl,
+        km: km,
+        kn: kn,
+        ko: ko,
+        ks: ks,
+        ksb: ksb,
+        ksh: ksh,
+        ku: ku,
+        kw: kw,
+        ky: ky,
+        lag: lag,
+        lb: lb,
+        lg: lg,
+        lij: lij,
+        lkt: lkt,
+        ln: ln,
+        lo: lo,
+        lt: lt,
+        lv: lv,
+        mas: mas,
+        mg: mg,
+        mgo: mgo,
+        mk: mk,
+        ml: ml,
+        mn: mn,
+        mo: mo,
+        mr: mr,
+        ms: ms,
+        mt: mt,
+        my: my,
+        nah: nah,
+        naq: naq,
+        nb: nb,
+        nd: nd,
+        ne: ne,
+        nl: nl,
+        nn: nn,
+        nnh: nnh,
+        no: no,
+        nqo: nqo,
+        nr: nr,
+        nso: nso,
+        ny: ny,
+        nyn: nyn,
+        om: om,
+        or: or,
+        os: os,
+        osa: osa,
+        pa: pa,
+        pap: pap,
+        pcm: pcm,
+        pl: pl,
+        prg: prg,
+        ps: ps,
+        pt: pt,
+        pt_PT: pt_PT,
+        rm: rm,
+        ro: ro,
+        rof: rof,
+        ru: ru,
+        rwk: rwk,
+        sah: sah,
+        saq: saq,
+        sat: sat,
+        sc: sc,
+        scn: scn,
+        sd: sd,
+        sdh: sdh,
+        se: se,
+        seh: seh,
+        ses: ses,
+        sg: sg,
+        sh: sh,
+        shi: shi,
+        si: si,
+        sk: sk,
+        sl: sl,
+        sma: sma,
+        smi: smi,
+        smj: smj,
+        smn: smn,
+        sms: sms,
+        sn: sn,
+        so: so,
+        sq: sq,
+        sr: sr,
+        ss: ss,
+        ssy: ssy,
+        st: st,
+        su: su,
+        sv: sv,
+        sw: sw,
+        syr: syr,
+        ta: ta,
+        te: te,
+        teo: teo,
+        th: th,
+        ti: ti,
+        tig: tig,
+        tk: tk,
+        tl: tl,
+        tn: tn,
+        to: to,
+        tpi: tpi,
+        tr: tr,
+        ts: ts,
+        tzm: tzm,
+        ug: ug,
+        uk: uk,
+        und: und,
+        ur: ur,
+        uz: uz,
+        ve: ve,
+        vec: vec,
+        vi: vi,
+        vo: vo,
+        vun: vun,
+        wa: wa,
+        wae: wae,
+        wo: wo,
+        xh: xh,
+        xog: xog,
+        yi: yi,
+        yo: yo,
+        yue: yue,
+        zh: zh,
+        zu: zu
+    });
+
+    function normalize(locale) {
+        if (typeof locale !== 'string' || locale.length < 2)
+            throw new RangeError("Invalid language tag: ".concat(locale));
+        if (locale.startsWith('pt-PT'))
+            return 'pt-PT';
+        var m = locale.match(/.+?(?=[-_])/);
+        return m ? m[0] : locale;
+    }
+    function getPlural(locale) {
+        if (typeof locale === 'function') {
+            var lc_1 = normalize(locale.name);
+            return {
+                isDefault: false,
+                id: identifier(lc_1),
+                lc: lc_1,
+                locale: locale.name,
+                getPlural: locale,
+                cardinals: locale.cardinals || [],
+                ordinals: locale.ordinals || []
+            };
+        }
+        var lc = normalize(locale);
+        var id = identifier(lc);
+        if (isPluralId(id)) {
+            return {
+                isDefault: true,
+                id: id,
+                lc: lc,
+                locale: locale,
+                getCardinal: Cardinals[id],
+                getPlural: Plurals[id],
+                cardinals: PluralCategories[id].cardinal,
+                ordinals: PluralCategories[id].ordinal
+            };
+        }
+        return null;
+    }
+    function getAllPlurals(firstLocale) {
+        var keys = Object.keys(Plurals).filter(function (key) { return key !== firstLocale; });
+        keys.unshift(firstLocale);
+        return keys.map(getPlural);
+    }
+    function hasPlural(locale) {
+        var lc = normalize(locale);
+        return identifier(lc) in Plurals;
+    }
+    function isPluralId(id) {
+        return id in Plurals;
+    }
+
+    var MessageFormat = (function () {
+        function MessageFormat(locale, options) {
+            this.plurals = [];
+            this.options = Object.assign({
+                biDiSupport: false,
+                currency: 'USD',
+                customFormatters: {},
+                localeCodeFromKey: null,
+                requireAllArguments: false,
+                returnType: 'string',
+                strict: (options && options.strictNumberSign) || false,
+                strictPluralKeys: true
+            }, options);
+            if (locale === '*') {
+                this.plurals = getAllPlurals(MessageFormat.defaultLocale);
+            }
+            else if (Array.isArray(locale)) {
+                this.plurals = locale.map(getPlural).filter(Boolean);
+            }
+            else if (locale) {
+                var pl = getPlural(locale);
+                if (pl)
+                    this.plurals = [pl];
+            }
+            if (this.plurals.length === 0) {
+                var pl = getPlural(MessageFormat.defaultLocale);
+                this.plurals = [pl];
+            }
+        }
+        MessageFormat.escape = function (str, octothorpe) {
+            var esc = octothorpe ? /[#{}]/g : /[{}]/g;
+            return String(str).replace(esc, "'$&'");
+        };
+        MessageFormat.supportedLocalesOf = function (locales) {
+            var la = Array.isArray(locales) ? locales : [locales];
+            return la.filter(hasPlural);
+        };
+        MessageFormat.prototype.resolvedOptions = function () {
+            return __assign(__assign({}, this.options), { locale: this.plurals[0].locale, plurals: this.plurals });
+        };
+        MessageFormat.prototype.compile = function (message) {
+            var e_1, _a;
+            var compiler = new Compiler(this.options);
+            var fnBody = 'return ' + compiler.compile(message, this.plurals[0]);
+            var nfArgs = [];
+            var fnArgs = [];
+            try {
+                for (var _b = __values(Object.entries(compiler.runtime)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), key = _d[0], fmt = _d[1];
+                    nfArgs.push(key);
+                    fnArgs.push(fmt);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            var fn = new (Function.bind.apply(Function, __spreadArray(__spreadArray([void 0], __read(nfArgs), false), [fnBody], false)))();
+            return fn.apply(void 0, __spreadArray([], __read(fnArgs), false));
+        };
+        MessageFormat.defaultLocale = 'en';
+        return MessageFormat;
+    }());
+
+    return MessageFormat;
+
+}));

node_modules/@messageformat/core/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@messageformat/core",
+  "version": "3.2.0",
+  "description": "PluralFormat and SelectFormat Message and i18n Tool - A JavaScript Implemenation of the ICU standards.",
+  "keywords": [
+    "i18n",
+    "pluralformat",
+    "icu",
+    "gettext",
+    "selectformat",
+    "messageformat",
+    "internationalization"
+  ],
+  "contributors": [
+    "Alex Sexton <alexsexton@gmail.com>",
+    "Eemeli Aro <eemeli@gmail.com>"
+  ],
+  "license": "MIT",
+  "homepage": "http://messageformat.github.io/messageformat/api/core/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/messageformat/messageformat.git",
+    "directory": "packages/core"
+  },
+  "main": "lib/messageformat.js",
+  "browser": "./messageformat.js",
+  "files": [
+    "compile-module.js",
+    "lib/",
+    "messageformat.js"
+  ],
+  "dependencies": {
+    "@messageformat/date-skeleton": "^1.0.0",
+    "@messageformat/number-skeleton": "^1.0.0",
+    "@messageformat/parser": "^5.1.0",
+    "@messageformat/runtime": "^3.0.1",
+    "make-plural": "^7.0.0",
+    "safe-identifier": "^0.4.1"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "postbuild": "tsc -p tsconfig.declarations.json",
+    "extract-api": "api-extractor run --verbose"
+  }
+}

node_modules/@messageformat/date-skeleton/LICENSE

@@ -0,0 +1,20 @@
+Copyright OpenJS Foundation and contributors, https://openjsf.org/
+
+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.

node_modules/@messageformat/date-skeleton/README.md

@@ -0,0 +1,48 @@
+# @messageformat/date-skeleton
+
+Tools for working with [ICU DateFormat skeletons](http://userguide.icu-project.org/formatparse/datetime)<!-- -->.
+
+```js
+import {
+  DateFormatError,
+  DateToken, // TS only
+  getDateFormatter,
+  getDateFormatterSource,
+  parseDateTokens
+} from '@messageformat/date-skeleton';
+```
+
+The package is released as an ES module only. If using from a CommonJS context, you may need to `import()` it, or use a module loader like [esm](https://www.npmjs.com/package/esm)<!-- -->.
+
+Uses [Intl.DateTimeFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat) internally. Position-dependent ICU DateFormat [patterns](https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns) are not supported, as they cannot be represented with Intl.DateTimeFormat options.
+
+## Classes
+
+| Class                                                                                                                         | Description              |
+| ----------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
+| [DateFormatError](https://github.com/messageformat/skeletons/blob/master/docs/messageformat-date-skeleton.dateformaterror.md) | Parent class for errors. |
+
+## Functions
+
+| Function                                                                                                                                                              | Description                                                                                                                                                                                                                                                                                                                           |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [getDateFormatter(locales, tokens, onError)](https://github.com/messageformat/skeletons/blob/master/docs/messageformat-date-skeleton.getdateformatter.md)             | Returns a date formatter function for the given locales and date skeleton                                                                                                                                                                                                                                                             |
+| [getDateFormatterSource(locales, tokens, onError)](https://github.com/messageformat/skeletons/blob/master/docs/messageformat-date-skeleton.getdateformattersource.md) | Returns a string of JavaScript source that evaluates to a date formatter function with the same <code>(date: Date &#124; number) =&gt; string</code> signature as the function returned by [getDateFormatter()](https://github.com/messageformat/skeletons/blob/master/docs/messageformat-date-skeleton.getdateformatter.md)<!-- -->. |
+| [parseDateTokens(src)](https://github.com/messageformat/skeletons/blob/master/docs/messageformat-date-skeleton.parsedatetokens.md)                                    | Parse an [ICU DateFormat skeleton](http://userguide.icu-project.org/formatparse/datetime) string into a [DateToken](https://github.com/messageformat/skeletons/blob/master/docs/messageformat-date-skeleton.datetoken.md) array.                                                                                                      |
+
+## Type Aliases
+
+| Type Alias                                                                                                        | Description                                              |
+| ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| [DateToken](https://github.com/messageformat/skeletons/blob/master/docs/messageformat-date-skeleton.datetoken.md) | An object representation of a parsed date skeleton token |
+
+---
+
+[Messageformat] is an OpenJS Foundation project, and we follow its [Code of Conduct].
+
+[messageformat]: https://messageformat.github.io/
+[code of conduct]: https://github.com/openjs-foundation/cross-project-council/blob/master/CODE_OF_CONDUCT.md
+
+<a href="https://openjsf.org">
+<img width=200 alt="OpenJS Foundation" src="https://messageformat.github.io/messageformat/logo/openjsf.svg" />
+</a>

node_modules/@messageformat/date-skeleton/lib/get-date-formatter.d.ts

@@ -0,0 +1,69 @@
+import { DateFormatError } from './options.js';
+import { DateToken } from './tokens.js';
+/**
+ * Returns a date formatter function for the given locales and date skeleton
+ *
+ * @remarks
+ * Uses `Intl.DateTimeFormat` internally.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+ *   `DateToken` tokens
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getDateFormatter } from '@messageformat/date-skeleton'
+ *
+ * // 2006 Jan 2, 15:04:05.789 in local time
+ * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+ *
+ * let fmt = getDateFormatter('en-CA', 'GrMMMdd', console.error)
+ * fmt(date) // 'Jan. 02, 2006 AD'
+ *
+ * fmt = getDateFormatter('en-CA', 'hamszzzz', console.error)
+ * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+ * ```
+ */
+export declare function getDateFormatter(locales: string | string[], tokens: string | DateToken[], onError?: (error: DateFormatError) => void): (date: Date | number) => string;
+/**
+ * Returns a string of JavaScript source that evaluates to a date formatter
+ * function with the same `(date: Date | number) => string` signature as the
+ * function returned by {@link getDateFormatter}.
+ *
+ * @remarks
+ * The returned function will memoize an `Intl.DateTimeFormat` instance.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+ *   `DateToken` tokens
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getDateFormatterSource } from '@messageformat/date-skeleton'
+ *
+ * getDateFormatterSource('en-CA', 'GrMMMdd', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"era":"short","calendar":"gregory","year":"numeric",' +
+ * //      '"month":"short","day":"2-digit"};\n' +
+ * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+ * // '  return function(value) { return dtf.format(value); }\n' +
+ * // '})()'
+ *
+ * const src = getDateFormatterSource('en-CA', 'hamszzzz', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"hour":"numeric","hourCycle":"h12","minute":"numeric",' +
+ * //      '"second":"numeric","timeZoneName":"long"};\n' +
+ * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+ * // '  return function(value) { return dtf.format(value); }\n' +
+ * // '})()'
+ *
+ * const fmt = new Function(`return ${src}`)()
+ * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+ * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+ * ```
+ */
+export declare function getDateFormatterSource(locales: string | string[], tokens: string | DateToken[], onError?: (err: DateFormatError) => void): string;

node_modules/@messageformat/date-skeleton/lib/get-date-formatter.js

@@ -0,0 +1,86 @@
+import { getDateFormatOptions } from './options.js';
+import { parseDateTokens } from './tokens.js';
+/**
+ * Returns a date formatter function for the given locales and date skeleton
+ *
+ * @remarks
+ * Uses `Intl.DateTimeFormat` internally.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+ *   `DateToken` tokens
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getDateFormatter } from '@messageformat/date-skeleton'
+ *
+ * // 2006 Jan 2, 15:04:05.789 in local time
+ * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+ *
+ * let fmt = getDateFormatter('en-CA', 'GrMMMdd', console.error)
+ * fmt(date) // 'Jan. 02, 2006 AD'
+ *
+ * fmt = getDateFormatter('en-CA', 'hamszzzz', console.error)
+ * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+ * ```
+ */
+export function getDateFormatter(locales, tokens, onError) {
+    if (typeof tokens === 'string')
+        tokens = parseDateTokens(tokens);
+    const opt = getDateFormatOptions(tokens, onError);
+    const dtf = new Intl.DateTimeFormat(locales, opt);
+    return (date) => dtf.format(date);
+}
+/**
+ * Returns a string of JavaScript source that evaluates to a date formatter
+ * function with the same `(date: Date | number) => string` signature as the
+ * function returned by {@link getDateFormatter}.
+ *
+ * @remarks
+ * The returned function will memoize an `Intl.DateTimeFormat` instance.
+ *
+ * @public
+ * @param locales - One or more valid BCP 47 language tags, e.g. `fr` or `en-CA`
+ * @param tokens - An ICU DateFormat skeleton string, or an array or parsed
+ *   `DateToken` tokens
+ * @param onError - If defined, will be called separately for each encountered
+ *   parsing error and unsupported feature.
+ * @example
+ * ```js
+ * import { getDateFormatterSource } from '@messageformat/date-skeleton'
+ *
+ * getDateFormatterSource('en-CA', 'GrMMMdd', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"era":"short","calendar":"gregory","year":"numeric",' +
+ * //      '"month":"short","day":"2-digit"};\n' +
+ * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+ * // '  return function(value) { return dtf.format(value); }\n' +
+ * // '})()'
+ *
+ * const src = getDateFormatterSource('en-CA', 'hamszzzz', console.error)
+ * // '(function() {\n' +
+ * // '  var opt = {"hour":"numeric","hourCycle":"h12","minute":"numeric",' +
+ * //      '"second":"numeric","timeZoneName":"long"};\n' +
+ * // '  var dtf = new Intl.DateTimeFormat("en-CA", opt);\n' +
+ * // '  return function(value) { return dtf.format(value); }\n' +
+ * // '})()'
+ *
+ * const fmt = new Function(`return ${src}`)()
+ * const date = new Date(2006, 0, 2, 15, 4, 5, 789)
+ * fmt(date) // '3:04:05 p.m. Newfoundland Daylight Time'
+ * ```
+ */
+export function getDateFormatterSource(locales, tokens, onError) {
+    if (typeof tokens === 'string')
+        tokens = parseDateTokens(tokens);
+    const opt = getDateFormatOptions(tokens, onError);
+    const lines = [
+        `(function() {`,
+        `var opt = ${JSON.stringify(opt)};`,
+        `var dtf = new Intl.DateTimeFormat(${JSON.stringify(locales)}, opt);`,
+        `return function(value) { return dtf.format(value); }`
+    ];
+    return lines.join('\n  ') + '\n})()';
+}

node_modules/@messageformat/date-skeleton/lib/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Tools for working with
+ * {@link http://userguide.icu-project.org/formatparse/datetime | ICU DateFormat skeletons}.
+ *
+ * @remarks
+ * ```js
+ * import {
+ *   DateFormatError,
+ *   DateToken, // TS only
+ *   getDateFormatter,
+ *   getDateFormatterSource,
+ *   parseDateTokens
+ * } from '@messageformat/date-skeleton'
+ * ```
+ *
+ * The package is released as an ES module only. If using from a CommonJS
+ * context, you may need to `import()` it, or use a module loader like
+ * {@link https://www.npmjs.com/package/esm | esm}.
+ *
+ * Uses
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat | Intl.DateTimeFormat}
+ * internally. Position-dependent ICU DateFormat
+ * {@link https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns | patterns}
+ * are not supported, as they cannot be represented with Intl.DateTimeFormat options.
+ *
+ * @packageDocumentation
+ */
+export { getDateFormatter, getDateFormatterSource } from './get-date-formatter.js';
+export { DateFormatError } from './options.js';
+export { DateToken, parseDateTokens } from './tokens.js';

node_modules/@messageformat/date-skeleton/lib/index.js

@@ -0,0 +1,30 @@
+/**
+ * Tools for working with
+ * {@link http://userguide.icu-project.org/formatparse/datetime | ICU DateFormat skeletons}.
+ *
+ * @remarks
+ * ```js
+ * import {
+ *   DateFormatError,
+ *   DateToken, // TS only
+ *   getDateFormatter,
+ *   getDateFormatterSource,
+ *   parseDateTokens
+ * } from '@messageformat/date-skeleton'
+ * ```
+ *
+ * The package is released as an ES module only. If using from a CommonJS
+ * context, you may need to `import()` it, or use a module loader like
+ * {@link https://www.npmjs.com/package/esm | esm}.
+ *
+ * Uses
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat | Intl.DateTimeFormat}
+ * internally. Position-dependent ICU DateFormat
+ * {@link https://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns | patterns}
+ * are not supported, as they cannot be represented with Intl.DateTimeFormat options.
+ *
+ * @packageDocumentation
+ */
+export { getDateFormatter, getDateFormatterSource } from './get-date-formatter.js';
+export { DateFormatError } from './options.js';
+export { parseDateTokens } from './tokens.js';

node_modules/@messageformat/date-skeleton/lib/options.d.ts

@@ -0,0 +1,20 @@
+import { DateToken } from './tokens.js';
+/**
+ * Parent class for errors.
+ *
+ * @remarks
+ * Errors with `type: "warning"` do not necessarily indicate that the parser
+ * encountered an error. In addition to a human-friendly `message`, may also
+ * includes the `token` at which the error was encountered.
+ *
+ * @public
+ */
+export declare class DateFormatError extends Error {
+    static ERROR: 'error';
+    static WARNING: 'warning';
+    token: DateToken;
+    type: 'error' | 'warning';
+    /** @internal */
+    constructor(msg: string, token: DateToken, type?: 'error' | 'warning');
+}
+export declare function getDateFormatOptions(tokens: DateToken[], onError?: (error: DateFormatError) => void): Intl.DateTimeFormatOptions;

node_modules/@messageformat/date-skeleton/lib/options.js

@@ -0,0 +1,165 @@
+/**
+ * Parent class for errors.
+ *
+ * @remarks
+ * Errors with `type: "warning"` do not necessarily indicate that the parser
+ * encountered an error. In addition to a human-friendly `message`, may also
+ * includes the `token` at which the error was encountered.
+ *
+ * @public
+ */
+export class DateFormatError extends Error {
+    /** @internal */
+    constructor(msg, token, type) {
+        super(msg);
+        this.token = token;
+        this.type = type || 'error';
+    }
+}
+const alpha = (width) => width < 4 ? 'short' : width === 4 ? 'long' : 'narrow';
+const numeric = (width) => (width % 2 === 0 ? '2-digit' : 'numeric');
+function yearOptions(token, onError) {
+    switch (token.char) {
+        case 'y':
+            return { year: numeric(token.width) };
+        case 'r':
+            return { calendar: 'gregory', year: 'numeric' };
+        case 'u':
+        case 'U':
+        case 'Y':
+        default:
+            onError(`${token.desc} is not supported; falling back to year:numeric`, DateFormatError.WARNING);
+            return { year: 'numeric' };
+    }
+}
+function monthStyle(token, onError) {
+    switch (token.width) {
+        case 1:
+            return 'numeric';
+        case 2:
+            return '2-digit';
+        case 3:
+            return 'short';
+        case 4:
+            return 'long';
+        case 5:
+            return 'narrow';
+        default:
+            onError(`${token.desc} is not supported with width ${token.width}`);
+            return undefined;
+    }
+}
+function dayStyle(token, onError) {
+    const { char, desc, width } = token;
+    if (char === 'd')
+        return numeric(width);
+    else {
+        onError(`${desc} is not supported`);
+        return undefined;
+    }
+}
+function weekdayStyle(token, onError) {
+    const { char, desc, width } = token;
+    if ((char === 'c' || char === 'e') && width < 3) {
+        // ignoring stand-alone-ness
+        const msg = `Numeric value is not supported for ${desc}; falling back to weekday:short`;
+        onError(msg, DateFormatError.WARNING);
+    }
+    // merging narrow styles
+    return alpha(width);
+}
+function hourOptions(token) {
+    const hour = numeric(token.width);
+    let hourCycle;
+    switch (token.char) {
+        case 'h':
+            hourCycle = 'h12';
+            break;
+        case 'H':
+            hourCycle = 'h23';
+            break;
+        case 'k':
+            hourCycle = 'h24';
+            break;
+        case 'K':
+            hourCycle = 'h11';
+            break;
+    }
+    return hourCycle ? { hour, hourCycle } : { hour };
+}
+function timeZoneNameStyle(token, onError) {
+    // so much fallback behaviour here
+    const { char, desc, width } = token;
+    switch (char) {
+        case 'v':
+        case 'z':
+            return width === 4 ? 'long' : 'short';
+        case 'V':
+            if (width === 4)
+                return 'long';
+            onError(`${desc} is not supported with width ${width}`);
+            return undefined;
+        case 'X':
+            onError(`${desc} is not supported`);
+            return undefined;
+    }
+    return 'short';
+}
+function compileOptions(token, onError) {
+    switch (token.field) {
+        case 'era':
+            return { era: alpha(token.width) };
+        case 'year':
+            return yearOptions(token, onError);
+        case 'month':
+            return { month: monthStyle(token, onError) };
+        case 'day':
+            return { day: dayStyle(token, onError) };
+        case 'weekday':
+            return { weekday: weekdayStyle(token, onError) };
+        case 'period':
+            return undefined;
+        case 'hour':
+            return hourOptions(token);
+        case 'min':
+            return { minute: numeric(token.width) };
+        case 'sec':
+            return { second: numeric(token.width) };
+        case 'tz':
+            return { timeZoneName: timeZoneNameStyle(token, onError) };
+        case 'quarter':
+        case 'week':
+        case 'sec-frac':
+        case 'ms':
+            onError(`${token.desc} is not supported`);
+    }
+    return undefined;
+}
+export function getDateFormatOptions(tokens, onError = error => {
+    throw error;
+}) {
+    const options = {};
+    const fields = [];
+    for (const token of tokens) {
+        const { error, field, str } = token;
+        if (error) {
+            const dte = new DateFormatError(error.message, token);
+            dte.stack = error.stack;
+            onError(dte);
+        }
+        if (str) {
+            const msg = `Ignoring string part: ${str}`;
+            onError(new DateFormatError(msg, token, DateFormatError.WARNING));
+        }
+        if (field) {
+            if (fields.indexOf(field) === -1)
+                fields.push(field);
+            else
+                onError(new DateFormatError(`Duplicate ${field} token`, token));
+        }
+        const opt = compileOptions(token, (msg, isWarning) => onError(new DateFormatError(msg, token, isWarning)));
+        if (opt)
+            Object.assign(options, opt);
+    }
+    return options;
+}

node_modules/@messageformat/date-skeleton/lib/tokens.d.ts

@@ -0,0 +1,45 @@
+export declare type DateField = 'era' | 'year' | 'quarter' | 'month' | 'week' | 'day' | 'weekday' | 'period' | 'hour' | 'min' | 'sec' | 'sec-frac' | 'ms' | 'tz';
+export declare const fields: {
+    [symbol: string]: {
+        field: DateField;
+        desc: string;
+    };
+};
+/**
+ * An object representation of a parsed date skeleton token
+ *
+ * @public
+ */
+export declare type DateToken = {
+    char: string;
+    error?: Error;
+    field?: DateField;
+    desc?: string;
+    str?: string;
+    width: number;
+};
+/**
+ * Parse an {@link http://userguide.icu-project.org/formatparse/datetime | ICU
+ * DateFormat skeleton} string into a {@link DateToken} array.
+ *
+ * @remarks
+ * Errors will not be thrown, but if encountered are included as the relevant
+ * token's `error` value.
+ *
+ * @public
+ * @param src - The skeleton string
+ *
+ * @example
+ * ```js
+ * import { parseDateTokens } from '@messageformat/date-skeleton'
+ *
+ * parseDateTokens('GrMMMdd', console.error)
+ * // [
+ * //   { char: 'G', field: 'era', desc: 'Era', width: 1 },
+ * //   { char: 'r', field: 'year', desc: 'Related Gregorian year', width: 1 },
+ * //   { char: 'M', field: 'month', desc: 'Month in year', width: 3 },
+ * //   { char: 'd', field: 'day', desc: 'Day in month', width: 2 }
+ * // ]
+ * ```
+ */
+export declare function parseDateTokens(src: string): DateToken[];

node_modules/@messageformat/date-skeleton/lib/tokens.js

@@ -0,0 +1,129 @@
+export const fields = {
+    G: { field: 'era', desc: 'Era' },
+    y: { field: 'year', desc: 'Year' },
+    Y: { field: 'year', desc: 'Year of "Week of Year"' },
+    u: { field: 'year', desc: 'Extended year' },
+    U: { field: 'year', desc: 'Cyclic year name' },
+    r: { field: 'year', desc: 'Related Gregorian year' },
+    Q: { field: 'quarter', desc: 'Quarter' },
+    q: { field: 'quarter', desc: 'Stand-alone quarter' },
+    M: { field: 'month', desc: 'Month in year' },
+    L: { field: 'month', desc: 'Stand-alone month in year' },
+    w: { field: 'week', desc: 'Week of year' },
+    W: { field: 'week', desc: 'Week of month' },
+    d: { field: 'day', desc: 'Day in month' },
+    D: { field: 'day', desc: 'Day of year' },
+    F: { field: 'day', desc: 'Day of week in month' },
+    g: { field: 'day', desc: 'Modified julian day' },
+    E: { field: 'weekday', desc: 'Day of week' },
+    e: { field: 'weekday', desc: 'Local day of week' },
+    c: { field: 'weekday', desc: 'Stand-alone local day of week' },
+    a: { field: 'period', desc: 'AM/PM marker' },
+    b: { field: 'period', desc: 'AM/PM/noon/midnight marker' },
+    B: { field: 'period', desc: 'Flexible day period' },
+    h: { field: 'hour', desc: 'Hour in AM/PM (1~12)' },
+    H: { field: 'hour', desc: 'Hour in day (0~23)' },
+    k: { field: 'hour', desc: 'Hour in day (1~24)' },
+    K: { field: 'hour', desc: 'Hour in AM/PM (0~11)' },
+    j: { field: 'hour', desc: 'Hour in preferred cycle' },
+    J: { field: 'hour', desc: 'Hour in preferred cycle without marker' },
+    C: { field: 'hour', desc: 'Hour in preferred cycle with flexible marker' },
+    m: { field: 'min', desc: 'Minute in hour' },
+    s: { field: 'sec', desc: 'Second in minute' },
+    S: { field: 'sec-frac', desc: 'Fractional second' },
+    A: { field: 'ms', desc: 'Milliseconds in day' },
+    z: { field: 'tz', desc: 'Time Zone: specific non-location' },
+    Z: { field: 'tz', desc: 'Time Zone' },
+    O: { field: 'tz', desc: 'Time Zone: localized' },
+    v: { field: 'tz', desc: 'Time Zone: generic non-location' },
+    V: { field: 'tz', desc: 'Time Zone: ID' },
+    X: { field: 'tz', desc: 'Time Zone: ISO8601 with Z' },
+    x: { field: 'tz', desc: 'Time Zone: ISO8601' }
+};
+const isLetter = (char) => (char >= 'A' && char <= 'Z') || (char >= 'a' && char <= 'z');
+function readFieldToken(src, pos) {
+    const char = src[pos];
+    let width = 1;
+    while (src[++pos] === char)
+        ++width;
+    const field = fields[char];
+    if (!field) {
+        const msg = `The letter ${char} is not a valid field identifier`;
+        return { char, error: new Error(msg), width };
+    }
+    return { char, field: field.field, desc: field.desc, width };
+}
+function readQuotedToken(src, pos) {
+    let str = src[++pos];
+    let width = 2;
+    if (str === "'")
+        return { char: "'", str, width };
+    while (true) {
+        const next = src[++pos];
+        ++width;
+        if (next === undefined) {
+            const msg = `Unterminated quoted literal in pattern: ${str || src}`;
+            return { char: "'", error: new Error(msg), str, width };
+        }
+        else if (next === "'") {
+            if (src[++pos] !== "'")
+                return { char: "'", str, width };
+            else
+                ++width;
+        }
+        str += next;
+    }
+}
+function readToken(src, pos) {
+    const char = src[pos];
+    if (!char)
+        return null;
+    if (isLetter(char))
+        return readFieldToken(src, pos);
+    if (char === "'")
+        return readQuotedToken(src, pos);
+    let str = char;
+    let width = 1;
+    while (true) {
+        const next = src[++pos];
+        if (!next || isLetter(next) || next === "'")
+            return { char, str, width };
+        str += next;
+        width += 1;
+    }
+}
+/**
+ * Parse an {@link http://userguide.icu-project.org/formatparse/datetime | ICU
+ * DateFormat skeleton} string into a {@link DateToken} array.
+ *
+ * @remarks
+ * Errors will not be thrown, but if encountered are included as the relevant
+ * token's `error` value.
+ *
+ * @public
+ * @param src - The skeleton string
+ *
+ * @example
+ * ```js
+ * import { parseDateTokens } from '@messageformat/date-skeleton'
+ *
+ * parseDateTokens('GrMMMdd', console.error)
+ * // [
+ * //   { char: 'G', field: 'era', desc: 'Era', width: 1 },
+ * //   { char: 'r', field: 'year', desc: 'Related Gregorian year', width: 1 },
+ * //   { char: 'M', field: 'month', desc: 'Month in year', width: 3 },
+ * //   { char: 'd', field: 'day', desc: 'Day in month', width: 2 }
+ * // ]
+ * ```
+ */
+export function parseDateTokens(src) {
+    const tokens = [];
+    let pos = 0;
+    while (true) {
+        const token = readToken(src, pos);
+        if (!token)
+            return tokens;
+        tokens.push(token);
+        pos += token.width;
+    }
+}

node_modules/@messageformat/date-skeleton/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@messageformat/date-skeleton",
+  "version": "1.0.1",
+  "description": "A parser & formatter for ICU DateFormat skeleton strings",
+  "keywords": [
+    "icu",
+    "messageformat",
+    "dateformat",
+    "skeleton",
+    "parser",
+    "formatter"
+  ],
+  "contributors": [
+    "Eemeli Aro <eemeli@gmail.com>"
+  ],
+  "license": "MIT",
+  "homepage": "http://messageformat.github.io/messageformat/api/date-skeleton/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/messageformat/messageformat.git",
+    "directory": "packages/date-skeleton"
+  },
+  "files": [
+    "lib/"
+  ],
+  "type": "module",
+  "main": "lib/index.js",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "extract-api": "api-extractor run --verbose"
+  }
+}

node_modules/@messageformat/number-skeleton/LICENSE

@@ -0,0 +1,20 @@
+Copyright OpenJS Foundation and contributors, https://openjsf.org/
+
+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.