reduce-precision 1.0.6 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reduce-precision",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "",
   "main": "./ts/lib/index.js",
   "files": [
@@ -60,4 +60,4 @@
       "main"
     ]
   }
-}
+}

package/ts/lib/bundle.min.js

@@ -1 +1 @@
-!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.ReducePrecision=t():e.ReducePrecision=t()}(self,(()=>(()=>{"use strict";var e={900:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.default=class{constructor(e={}){this.languageBaseConfig={prefixMarker:"i",postfixMarker:"i",prefix:"",postfix:""},this.defaultLanguageConfig={en:Object.assign(Object.assign({},this.languageBaseConfig),{thousandSeparator:",",decimalSeparator:"."}),fa:Object.assign(Object.assign({},this.languageBaseConfig),{thousandSeparator:"٫",decimalSeparator:"٬"})},this.options=Object.assign({language:"en",template:"number",precision:"high",outputFormat:"plain"},this.defaultLanguageConfig.en),this.options=Object.assign(Object.assign({},this.options),e)}setLanguage(e,t={}){return this.options.language=e,this.options.prefixMarker=t.prefixMarker||this.defaultLanguageConfig[e].prefixMarker,this.options.postfixMarker=t.postfixMarker||this.defaultLanguageConfig[e].postfixMarker,this.options.prefix=t.prefix||this.defaultLanguageConfig[e].prefix,this.options.postfix=t.postfix||this.defaultLanguageConfig[e].postfix,this.options.thousandSeparator=t.thousandSeparator||this.defaultLanguageConfig[e].thousandSeparator,this.options.decimalSeparator=t.decimalSeparator||this.defaultLanguageConfig[e].decimalSeparator,this}setTemplate(e,t){return this.options.template=e,this.options.precision=t,this}toJson(e){const t=this.format(e);return delete t.value,t}toString(e){return this.format(e).value||""}toPlainString(e){return this.options.outputFormat="plain",this.format(e).value||""}toHtmlString(e){return this.options.outputFormat="html",this.format(e).value||""}toMdString(e){return this.options.outputFormat="markdown",this.format(e).value||""}isENotation(e){return/^[-+]?[0-9]*\.?[0-9]+([eE][-+][0-9]+)$/.test(e)}format(e){let{precision:t,template:r}=this.options;const{language:i,outputFormat:o,prefixMarker:n,postfixMarker:a,prefix:s,postfix:u,thousandSeparator:l,decimalSeparator:p}=this.options;if(null==e||""===e)return{};(null==r?void 0:r.match(/^(number|usd|irt|irr|percent)$/g))||(r="number"),this.isENotation(e.toString())&&(e=this.convertENotationToRegularNumber(Number(e)));let g=e.toString().replace(/[\u0660-\u0669\u06F0-\u06F9]/g,(function(e){return String(15&e.charCodeAt(0))})).replace(/[^\d.-]/g,"");g=g.replace(/^0+(?=\d)/g,"").replace(/\.\d*0+$|(\.\d)0+\b/g,"$1");const f=Math.abs(Number(g));let c,d,h,m,x=0;if("auto"===t&&(r.match(/^(usd|irt|irr|number)$/g)?t=f>=1e-4&&f<1e11?"high":"medium":"percent"===r&&(t="low")),"medium"===t)if(f>=0&&f<1e-4)c=33,d=4,h=!1,m=!0;else if(f>=1e-4&&f<.001)c=7,d=4,h=!1,m=!1;else if(f>=.001&&f<.01)c=5,d=3,h=!1,m=!1;else if(f>=.001&&f<.1)c=3,d=2,h=!1,m=!1;else if(f>=.1&&f<1)c=1,d=1,h=!1,m=!1;else if(f>=1&&f<10)c=3,d=3,h=!1,m=!1;else if(f>=10&&f<100)c=2,d=2,h=!1,m=!1;else if(f>=100&&f<1e3)c=1,d=1,h=!1,m=!1;else if(f>=1e3){const e=Math.floor(Math.log10(f))%3;c=2-e,d=2-e,h=!0,m=!0}else c=0,d=0,h=!0,m=!0;else if("low"===t)if(f>=0&&f<.01)c=2,d=0,h=!0,m=!1,x=2;else if(f>=.01&&f<.1)c=2,d=1,h=!0,m=!1;else if(f>=.1&&f<1)c=2,d=2,h=!0,m=!1;else if(f>=1&&f<10)c=2,d=2,h=!0,m=!1,x=2;else if(f>=10&&f<100)c=1,d=1,h=!0,m=!1,x=1;else if(f>=100&&f<1e3)c=0,d=0,h=!0,m=!1;else if(f>=1e3){const e=Math.floor(Math.log10(f))%3;c=1-e,d=1-e,h=!0,m=!0}else c=0,d=0,h=!0,m=!0,x=2;else f>=0&&f<1?(c=33,d=4,h=!1,m=!1):f>=1&&f<10?(c=3,d=3,h=!0,m=!1):f>=10&&f<100||f>=100&&f<1e3?(c=2,d=2,h=!0,m=!1):f>=1e3&&f<1e4?(c=1,d=1,h=!0,m=!1):(c=0,d=0,h=!0,m=!1);return this.reducePrecision(g,c,d,h,m,x,r,i,o,n,a,s,u,l,p)}convertENotationToRegularNumber(e){const[t,r]=e.toString().split("e"),i=t.replace(".","").replace("-","").length,o=parseFloat(r),n=Math.max(i-o,1);return e.toFixed(n)}reducePrecision(e,t=30,r=4,i=!1,o=!1,n=0,a="number",s="en",u="plain",l="span",p="span",g="",f="",c=",",d="."){var h,m;if(null==e||""===e.trim())return{};e=e.toString();const x=a.match(/^(number|percent)$/g)?{"":"",K:" هزار",M:" میلیون",B:" میلیارد",T:" تریلیون",Qd:" کادریلیون",Qt:" کنتیلیون"}:{"":"",K:" هزار ت",M:" میلیون ت",B:" میلیارد ت",T:" همت",Qd:" هزار همت",Qt:" میلیون همت"},b=a.match(/^(number|percent)$/g)?{"":"",K:" هزار",M:" میلیون",B:" میلیارد",T:" تریلیون",Qd:" کادریلیون",Qt:" کنتیلیون"}:{"":"",K:" هزار تومان",M:" میلیون تومان",B:" میلیارد تومان",T:" هزار میلیارد تومان",Qd:" کادریلیون تومان",Qt:" کنتیلیون تومان"};let $=/^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(e);if(!$)return{};const S=$[1]||"";let M=$[2],v=$[3],C=$[4],Q="",N="";if(v.length>=30?(v="0".padEnd(29,"0"),C="1"):v.length+r>t?(r=t-v.length)<1&&(r=1):M.length>21&&(M="0",v="",C=""),o&&M.length>=4){const e=Object.keys(x);let t=M,r=0;for(;+t>999&&r<e.length-1;)t=(+t/1e3).toFixed(2),r++;if(N=e[r],$=/^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(t.toString()),!$)return{};M=$[2],v=$[3],C=$[4]}C.length>r&&(i?parseInt(C[r])<5?C=C.substring(0,r):(C=(parseInt(C.substring(0,r))+1).toString(),C.length>r&&(v.length>0?v=v.substring(0,v.length-1):(M=(Number(M)+1).toString(),C=C.substring(1)))):C=C.substring(0,r)),o&&""!==v&&""===N&&(v="0"+v.length.toString().replace(/\d/g,(function(e){return["₀","₁","₂","₃","₄","₅","₆","₇","₈","₉"][parseInt(e,10)]})));let j=`${v}${C}`;j=j.substring(0,t),j=j.replace(/^(\d*[1-9])0+$/g,"$1"),"usd"===a?(Q="en"===s?"$":"",N||(N="fa"===s?" دلار":"")):"irr"===a?N||(N="fa"===s?" ر":" R"):"irt"===a?N||(N="fa"===s?" ت":" T"):"percent"===a&&(N+="en"===s?"%":N?" درصد":"٪"),Q=g+Q,N+=f,"html"===u?(Q&&(Q=`<${l}>${Q}</${l}>`),N&&(N=`<${p}>${N}</${p}>`)):"markdown"===u&&(Q&&(Q=`${l}${Q}${l}`),N&&(N=`${p}${N}${p}`));const k=/\B(?=(\d{3})+(?!\d))/g,B=n?".".padEnd(n+1,"0"):"";let F,T="";F=t<=0||r<=0||!C?`${M.replace(k,",")}${B}`:`${M.replace(k,",")}.${j}`,T=`${S}${Q}${F}${N}`;const O={value:T,prefix:Q,postfix:N,sign:S,wholeNumber:F};return O.value=(null!==(h=null==O?void 0:O.value)&&void 0!==h?h:"").replace(/,/g,c).replace(/\./g,d),"fa"===s&&(O.value=(null!==(m=null==O?void 0:O.value)&&void 0!==m?m:"").replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(x[e])})),O.fullPostfix=N.replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(b[e])})),O.postfix=O.postfix.replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(x[e])})),O.wholeNumber=O.wholeNumber.replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(x[e])}))),O}}},986:function(e,t,r){var i=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0}),t.NumberFormatter=void 0;const o=i(r(900));t.NumberFormatter=o.default}},t={};return function r(i){var o=t[i];if(void 0!==o)return o.exports;var n=t[i]={exports:{}};return e[i].call(n.exports,n,n.exports,r),n.exports}(986)})()));
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.ReducePrecision=t():e.ReducePrecision=t()}(self,(()=>(()=>{"use strict";var e={900:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.default=class{constructor(e={}){this.languageBaseConfig={prefixMarker:"i",postfixMarker:"i",prefix:"",postfix:""},this.defaultLanguageConfig={en:Object.assign(Object.assign({},this.languageBaseConfig),{thousandSeparator:",",decimalSeparator:"."}),fa:Object.assign(Object.assign({},this.languageBaseConfig),{thousandSeparator:"٬",decimalSeparator:"٫"})},this.options=Object.assign({language:"en",template:"number",precision:"high",outputFormat:"plain"},this.defaultLanguageConfig.en),this.options=Object.assign(Object.assign({},this.options),e)}setLanguage(e,t={}){return this.options.language=e,this.options.prefixMarker=t.prefixMarker||this.defaultLanguageConfig[e].prefixMarker,this.options.postfixMarker=t.postfixMarker||this.defaultLanguageConfig[e].postfixMarker,this.options.prefix=t.prefix||this.defaultLanguageConfig[e].prefix,this.options.postfix=t.postfix||this.defaultLanguageConfig[e].postfix,this.options.thousandSeparator=t.thousandSeparator||this.defaultLanguageConfig[e].thousandSeparator,this.options.decimalSeparator=t.decimalSeparator||this.defaultLanguageConfig[e].decimalSeparator,this}setTemplate(e,t){return this.options.template=e,this.options.precision=t,this}toJson(e){const t=this.format(e);return delete t.value,t}toString(e){return this.format(e).value||""}toPlainString(e){return this.options.outputFormat="plain",this.format(e).value||""}toHtmlString(e){return this.options.outputFormat="html",this.format(e).value||""}toMdString(e){return this.options.outputFormat="markdown",this.format(e).value||""}isENotation(e){return/^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)$/.test(e)}convertENotationToRegularNumber(e,t){let r=String(e);if(0===e&&t){const e=t.toLowerCase().split("e");if(2===e.length&&e[0].match(/^0\.0*$/))return e[0]}if(-1===r.toLowerCase().indexOf("e"))return r;if(Math.abs(e)<1&&0!==e){const t=r.toLowerCase().split("e");if(2===t.length){const r=parseInt(t[1],10);if(r<0){let i=Math.abs(r);return t[0].includes(".")&&(i+=t[0].split(".")[1].length),e.toFixed(Math.min(i,100))}}}const i=r.toLowerCase().split("e");if(2===i.length){const t=i[0],r=parseInt(i[1],10);let[n,o]=t.split(".");if(o=o||"",r>0){const e=n.startsWith("-")?"-":"";return e&&(n=n.substring(1)),o.length<=r?e+n+o.padEnd(r,"0"):e+n+o.substring(0,r)+"."+o.substring(r)}if(r<0){let i=Math.abs(r);return t.includes(".")&&(i+=t.split(".")[1].length),e.toFixed(Math.min(i,100))}return t}return r}format(e){var t;let{precision:r,template:i}=this.options;const{language:n,outputFormat:o,prefixMarker:s,postfixMarker:a,prefix:l,postfix:u,thousandSeparator:g,decimalSeparator:f}=this.options;if(null==e||""===e)return{};const p=e.toString();if("liveformat"===i){let e=this._sanitizeLiveInput(p);const r=g||",",i=f||".";let n=p.replace(/[٠-٩۰-۹]/g,(function(e){return String(15&e.charCodeAt(0))}));if("fa"===(null!==(t=this.options.language)&&void 0!==t?t:"en")){const e=this.defaultLanguageConfig.fa.decimalSeparator||"٫";n=n.replace(new RegExp(e,"g"),".")}if(this.isENotation(n)&&0===Number(n)){const t=p.toLowerCase().indexOf("e");if(t>-1){const r=p.substring(0,t).replace(/[٠-٩۰-۹]/g,(function(e){return String(15&e.charCodeAt(0))}));let n=r;r.includes(".")&&"."!==i?n=r.replace(".",i):r.includes("٫")&&"٫"!==i&&(n=r.replace("٫",i));const o=new RegExp(`^0\\${i}0*$`);n.match(o)&&(e=n)}}let o="";if(e.startsWith("-")&&(o="-",e=e.substring(1)),""===e)return{value:"",prefix:"",postfix:"",sign:"",wholeNumber:""};if("0"===e){let e="0";return"fa"===this.options.language&&(e=String.fromCharCode("0".charCodeAt(0)+1728)),{value:e,prefix:"",postfix:"",sign:"",wholeNumber:e}}e===i&&(e="0"+i);let s="",a="",l=!1;if(e.includes(i)){l=!0;const t=e.split(i);s=t[0],a=t.length>1?t[1]:""}else if("."!==i&&e.includes(".")){l=!0;const t=e.split(".");s=t[0],a=t.length>1?t[1]:""}else s=e;if(""===s)s="0";else if("0"!==s){const e=s.replace(/^0+/,"");s=""===e?"0":e}let u=s.replace(/\B(?=(\d{3})+(?!\d))/g,r);l&&(u+=i+a);const c=u;let h="",d=c;"-"===o&&(0!==parseFloat(c)||c.includes(".")?(h="-",d=o+c):h="");const m=this._convertToFarsiDigits(u);let b="";return"-"===o&&(b="0"===u?"":"-"),{value:b+m,prefix:"",postfix:"",sign:b,wholeNumber:m}}(null==i?void 0:i.match(/^(number|usd|irt|irr|percent|liveformat)$/g))||(i="number"),this.isENotation(p)&&(e=this.convertENotationToRegularNumber(Number(e)));let c=e.toString().replace(/[\u0660-\u0669\u06F0-\u06F9]/g,(function(e){return String(15&e.charCodeAt(0))})).replace(/[^\d.-]/g,"");c=c.replace(/^0+(?=\d)/g,"");const h=Math.abs(Number(c));let d,m,b,x,v=0;if("auto"===r&&(i.match(/^(usd|irt|irr|number)$/g)?r=h>=1e-4&&h<1e11?"high":"medium":"percent"===i&&(r="low")),"medium"===r)if(h>=0&&h<1e-4)d=33,m=4,b=!1,x=!0;else if(h>=1e-4&&h<.001)d=7,m=4,b=!1,x=!1;else if(h>=.001&&h<.01)d=5,m=3,b=!1,x=!1;else if(h>=.001&&h<.1)d=3,m=2,b=!1,x=!1;else if(h>=.1&&h<1)d=1,m=1,b=!1,x=!1;else if(h>=1&&h<10)d=3,m=3,b=!1,x=!1;else if(h>=10&&h<100)d=2,m=2,b=!1,x=!1;else if(h>=100&&h<1e3)d=1,m=1,b=!1,x=!1;else if(h>=1e3){const e=Math.floor(Math.log10(h))%3;d=2-e,m=2-e,b=!0,x=!0}else d=0,m=0,b=!0,x=!0;else if("low"===r)if(h>=0&&h<.01)d=2,m=0,b=!0,x=!1,v=2;else if(h>=.01&&h<.1)d=2,m=1,b=!0,x=!1;else if(h>=.1&&h<1)d=2,m=2,b=!0,x=!1;else if(h>=1&&h<10)d=2,m=2,b=!0,x=!1,v=2;else if(h>=10&&h<100)d=1,m=1,b=!0,x=!1,v=1;else if(h>=100&&h<1e3)d=0,m=0,b=!0,x=!1;else if(h>=1e3){const e=Math.floor(Math.log10(h))%3;d=1-e,m=1-e,b=!0,x=!0}else d=0,m=0,b=!0,x=!0,v=2;else h>=0&&h<1?(d=33,m=4,b=!1,x=!1):h>=1&&h<10?(d=3,m=3,b=!0,x=!1):h>=10&&h<100||h>=100&&h<1e3?(d=2,m=2,b=!0,x=!1):h>=1e3&&h<1e4?(d=1,m=1,b=!0,x=!1):(d=0,m=0,b=!0,x=!1);return this.isENotation(p)&&(d=Math.max(d,20),b=!1),this.reducePrecision(c,d,m,b,x,v,i,n,o,s,a,l,u,g,f,p)}reducePrecision(e,t=30,r=4,i=!1,n=!1,o=0,s="number",a="en",l="plain",u="span",g="span",f="",p="",c=",",h=".",d=""){var m,b;if(null==e||""===e.trim())return{};"-0"!==e&&"-0.0"!==e||(e=e.substring(1)),e=e.toString();const x=s.match(/^(number|percent)$/g)?{"":"",K:" هزار",M:" میلیون",B:" میلیارد",T:" تریلیون",Qd:" کادریلیون",Qt:" کنتیلیون"}:{"":"",K:" هزار ت",M:" میلیون ت",B:" میلیارد ت",T:" همت",Qd:" هزار همت",Qt:" میلیون همت"},v=s.match(/^(number|percent)$/g)?{"":"",K:" هزار",M:" میلیون",B:" میلیارد",T:" تریلیون",Qd:" کادریلیون",Qt:" کنتیلیون"}:{"":"",K:" هزار تومان",M:" میلیون تومان",B:" میلیارد تومان",T:" هزار میلیارد تومان",Qd:" کادریلیون تومان",Qt:" کنتیلیون تومان"};let C=/^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(e);if(!C)return{};const S=C[1]||"";let M=C[2],$=C[3],N=C[4],w="",L="";if($.length>=30?($="0".padEnd(29,"0"),N="1"):$.length+r>t?(r=t-$.length)<1&&(r=1):M.length>21&&(M="0",$="",N=""),n&&M.length>=4){const e=Object.keys(x);let t=M,r=0;for(;+t>999&&r<e.length-1;)t=(+t/1e3).toFixed(2),r++;if(L=e[r],C=/^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(t.toString()),!C)return{};M=C[2],$=C[3],N=C[4]}N.length>r&&(i?parseInt(N[r])<5?N=N.substring(0,r):(N=(parseInt(N.substring(0,r))+1).toString(),N.length>r&&($.length>0?$=$.substring(0,$.length-1):(M=(Number(M)+1).toString(),N=N.substring(1)))):N=N.substring(0,r)),n&&""!==$&&""===L&&($="0"+$.length.toString().replace(/\d/g,(function(e){return["₀","₁","₂","₃","₄","₅","₆","₇","₈","₉"][parseInt(e,10)]})));let E=`${$}${N}`;if(E.length>t&&!d.includes("e")&&(E=E.substring(0,t)),d.includes("e")||d.includes("E"));else if(d.includes(".")){const e=d.split(".");if(2===e.length){const t=e[1];if(t.length>E.length&&t.endsWith("0")){let e=0;for(let r=t.length-1;r>=0&&"0"===t[r];r--)e++;e>0&&(E=E.padEnd(E.length+e,"0"))}}}"usd"===s?(w="en"===a?"$":"",L||(L="fa"===a?" دلار":"")):"irr"===s?L||(L="fa"===a?" ر":" R"):"irt"===s?L||(L="fa"===a?" ت":" T"):"percent"===s&&(L+="en"===a?"%":L?" درصد":"٪"),w=f+w,L+=p,"html"===l?(w&&(w=`<${u}>${w}</${u}>`),L&&(L=`<${g}>${L}</${g}>`)):"markdown"===l&&(w&&(w=`${u}${w}${u}`),L&&(L=`${g}${L}${g}`));const Q=/\B(?=(\d{3})+(?!\d))/g,F=o?".".padEnd(o+1,"0"):"";let T,j="";T=t<=0||r<=0||""===N&&""===$?`${M.replace(Q,",")}${F}`:`${M.replace(Q,",")}.${E}`,j=`${S}${w}${T}${L}`;const k={value:j,prefix:w,postfix:L,sign:S,wholeNumber:T};return k.value=(null!==(m=null==k?void 0:k.value)&&void 0!==m?m:"").replace(/,/g,c).replace(/\./g,h),"fa"===a&&(k.value=(null!==(b=null==k?void 0:k.value)&&void 0!==b?b:"").replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(x[e])})),k.fullPostfix=L.replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(v[e])})),k.postfix=k.postfix.replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(x[e])})),k.wholeNumber=k.wholeNumber.replace(/[0-9]/g,(e=>String.fromCharCode(e.charCodeAt(0)+1728))).replace(/(K|M|B|T|Qt|Qd)/g,(function(e){return String(x[e])}))),k}_sanitizeLiveInput(e){var t;let r=e;r=r.replace(/[٠-٩۰-۹]/g,(function(e){return String(15&e.charCodeAt(0))}));let i=r,n=null;if("fa"===(null!==(t=this.options.language)&&void 0!==t?t:"en")){const e=this.defaultLanguageConfig.fa.decimalSeparator||"٫";r.includes(e)&&(n=e,i=r.replace(new RegExp(e,"g"),"."))}if(this.isENotation(i)){const e=this.convertENotationToRegularNumber(Number(i),i);r=n&&e.includes(".")?e.replace(/\./g,n):e}return r}_convertToFarsiDigits(e){if("fa"!==this.options.language||null==e)return e;let t="";for(let r=0;r<e.length;r++){const i=e[r];t+=i>="0"&&i<="9"?String.fromCharCode(i.charCodeAt(0)+1728):i}return t}}},986:function(e,t,r){var i=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(t,"__esModule",{value:!0}),t.NumberFormatter=void 0;const n=i(r(900));t.NumberFormatter=n.default}},t={};return function r(i){var n=t[i];if(void 0!==n)return n.exports;var o=t[i]={exports:{}};return e[i].call(o.exports,o,o.exports,r),o.exports}(986)})()));

package/ts/lib/format/index.js

@@ -64,7 +64,7 @@ class NumberFormatter {
     }
     // Private methods...
     isENotation(input) {
-        return /^[-+]?[0-9]*\.?[0-9]+([eE][-+][0-9]+)$/.test(input);
+        return /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)$/.test(input);
     }
     format(input) {
         let { precision, template } = this.options;
@@ -74,7 +74,9 @@ class NumberFormatter {
         }
         if (!(template === null || template === void 0 ? void 0 : template.match(/^(number|usd|irt|irr|percent)$/g)))
             template = 'number';
-        if (this.isENotation(input.toString())) {
+        // Store original input string to preserve format for trailing zeros
+        const originalInput = input.toString();
+        if (this.isENotation(originalInput)) {
             input = this.convertENotationToRegularNumber(Number(input));
         }
         // Replace each Persian/Arabic numeral in the string with its English counterpart and strip all non-numeric chars
@@ -84,10 +86,9 @@ class NumberFormatter {
             return String(match.charCodeAt(0) & 0xf);
         })
             .replace(/[^\d.-]/g, '');
-        // Stripping leading zeros and trailing zeros after a decimal point
+        // Stripping leading zeros only, preserve trailing zeros
         numberString = numberString
-            .replace(/^0+(?=\d)/g, '')
-            .replace(/\.\d*0+$|(\.\d)0+\b/g, '$1');
+            .replace(/^0+(?=\d)/g, '');
         const number = Math.abs(Number(numberString));
         let p, d, r, c;
         let f = 0;
@@ -262,22 +263,43 @@ class NumberFormatter {
                 c = false;
             }
         }
-        return this.reducePrecision(numberString, p, d, r, c, f, template, language, outputFormat, prefixMarker, postfixMarker, prefix, postfix, thousandSeparator, decimalSeparator);
+        // For scientific notation, increase precision to ensure correct representation
+        if (this.isENotation(originalInput)) {
+            p = Math.max(p, 20);
+            r = false;
+        }
+        return this.reducePrecision(numberString, p, d, r, c, f, template, language, outputFormat, prefixMarker, postfixMarker, prefix, postfix, thousandSeparator, decimalSeparator, originalInput);
     }
     convertENotationToRegularNumber(eNotation) {
-        const [coefficientStr, exponentStr] = eNotation.toString().split('e');
-        const coefficientLength = coefficientStr
-            .replace('.', '')
-            .replace('-', '').length;
-        const exponent = parseFloat(exponentStr);
-        const precision = Math.max(coefficientLength - exponent, 1);
-        return eNotation.toFixed(precision);
+        // For simple cases like 1e3, directly use Number constructor
+        if (Number.isInteger(eNotation) && eNotation >= 1000) {
+            return eNotation.toString();
+        }
+        const parts = eNotation.toString().toLowerCase().split('e');
+        if (parts.length !== 2)
+            return eNotation.toString();
+        const coefficient = parseFloat(parts[0]);
+        const exponent = parseInt(parts[1], 10);
+        // Handle negative exponents (very small numbers)
+        if (exponent < 0) {
+            const absExponent = Math.abs(exponent);
+            // Determine precision needed to show all digits
+            const precision = absExponent +
+                (parts[0].includes('.') ? parts[0].split('.')[1].length : 0);
+            return eNotation.toFixed(precision);
+        }
+        // For positive exponents, let JavaScript do the conversion
+        return eNotation.toString();
     }
-    reducePrecision(numberString, precision = 30, nonZeroDigits = 4, round = false, compress = false, fixedDecimalZeros = 0, template = 'number', language = 'en', outputFormat = 'plain', prefixMarker = 'span', postfixMarker = 'span', prefix = '', postfix = '', thousandSeparator = ',', decimalSeparator = '.') {
+    reducePrecision(numberString, precision = 30, nonZeroDigits = 4, round = false, compress = false, fixedDecimalZeros = 0, template = 'number', language = 'en', outputFormat = 'plain', prefixMarker = 'span', postfixMarker = 'span', prefix = '', postfix = '', thousandSeparator = ',', decimalSeparator = '.', originalInput = '') {
         var _a, _b;
         if (numberString === undefined || numberString === null || numberString.trim() === '') {
             return {};
         }
+        // Handle negative zero
+        if (numberString === '-0' || numberString === '-0.0') {
+            numberString = numberString.substring(1); // Remove negative sign for zero
+        }
         numberString = numberString.toString();
         const maxPrecision = 30;
         const maxIntegerDigits = 21;
@@ -408,9 +430,40 @@ class NumberFormatter {
                         ][parseInt(match, 10)];
                     });
         }
+        // Check if the original input had trailing zeros
         let fractionalPartStr = `${fractionalZeroStr}${fractionalNonZeroStr}`;
-        fractionalPartStr = fractionalPartStr.substring(0, precision);
-        fractionalPartStr = fractionalPartStr.replace(/^(\d*[1-9])0+$/g, '$1');
+        // Don't truncate trailing zeros when they're in the original string
+        if (fractionalPartStr.length > precision && !originalInput.includes('e')) {
+            fractionalPartStr = fractionalPartStr.substring(0, precision);
+        }
+        // For scientific notation and numbers with trailing zeros, preserve the format
+        if (originalInput.includes('e') || originalInput.includes('E')) {
+            // For scientific notation, use the converted string
+        }
+        else if (originalInput.includes('.')) {
+            // For regular numbers with decimal point, check for trailing zeros
+            const originalParts = originalInput.split('.');
+            if (originalParts.length === 2) {
+                const originalDecimal = originalParts[1];
+                // If original has more digits than what we have now, preserve those trailing zeros
+                if (originalDecimal.length > fractionalPartStr.length && originalDecimal.endsWith('0')) {
+                    // Count trailing zeros in original
+                    let trailingZeros = 0;
+                    for (let i = originalDecimal.length - 1; i >= 0; i--) {
+                        if (originalDecimal[i] === '0') {
+                            trailingZeros++;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    // Add back trailing zeros if they were in the original
+                    if (trailingZeros > 0) {
+                        fractionalPartStr = fractionalPartStr.padEnd(fractionalPartStr.length + trailingZeros, '0');
+                    }
+                }
+            }
+        }
         // Output Formating, Prefix, Postfix
         if (template === 'usd') {
             unitPrefix = language === 'en' ? '$' : '';
@@ -453,7 +506,10 @@ class NumberFormatter {
             : '';
         let out = '';
         let wholeNumberStr;
-        if (precision <= 0 || nonZeroDigits <= 0 || !fractionalNonZeroStr) {
+        // FIXED: Changed condition to correctly handle numbers with trailing zeros
+        // Old condition: if (precision <= 0 || nonZeroDigits <= 0 || !fractionalNonZeroStr) {
+        // New condition checks if both fractional parts are empty
+        if (precision <= 0 || nonZeroDigits <= 0 || (fractionalNonZeroStr === '' && fractionalZeroStr === '')) {
             wholeNumberStr = `${nonFractionalStr.replace(thousandSeparatorRegex, ',')}${fixedDecimalZeroStr}`;
         }
         else {

package/ts/lib/src/format/index.d.ts

@@ -0,0 +1,46 @@
+type Template = 'number' | 'usd' | 'irt' | 'irr' | 'percent' | 'liveformat';
+type Precision = 'auto' | 'high' | 'medium' | 'low';
+type Language = 'en' | 'fa';
+type OutputFormat = 'plain' | 'html' | 'markdown';
+interface FormattedObject {
+    value?: string;
+    prefix: string;
+    postfix: string;
+    fullPostfix?: string;
+    sign: string;
+    wholeNumber: string;
+}
+interface LanguageConfig {
+    prefixMarker?: string;
+    postfixMarker?: string;
+    prefix?: string;
+    postfix?: string;
+    thousandSeparator?: string;
+    decimalSeparator?: string;
+}
+interface Options extends LanguageConfig {
+    precision?: Precision;
+    template?: Template;
+    language?: Language;
+    outputFormat?: OutputFormat;
+}
+declare class NumberFormatter {
+    private readonly languageBaseConfig;
+    private defaultLanguageConfig;
+    private options;
+    constructor(options?: Options);
+    setLanguage(lang: Language, config?: LanguageConfig): NumberFormatter;
+    setTemplate(template: Template, precision: Precision): NumberFormatter;
+    toJson(input: string | number): FormattedObject;
+    toString(input: string | number): string;
+    toPlainString(input: string | number): string;
+    toHtmlString(input: string | number): string;
+    toMdString(input: string | number): string;
+    private isENotation;
+    private convertENotationToRegularNumber;
+    private format;
+    private reducePrecision;
+    private _sanitizeLiveInput;
+    private _convertToFarsiDigits;
+}
+export default NumberFormatter;

package/ts/lib/src/format/index.js

@@ -0,0 +1,807 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NumberFormatter {
+    constructor(options = {}) {
+        this.languageBaseConfig = {
+            prefixMarker: 'i',
+            postfixMarker: 'i',
+            prefix: '',
+            postfix: '',
+        };
+        this.defaultLanguageConfig = {
+            en: Object.assign(Object.assign({}, this.languageBaseConfig), { thousandSeparator: ',', decimalSeparator: '.' }),
+            fa: Object.assign(Object.assign({}, this.languageBaseConfig), { thousandSeparator: '٬', decimalSeparator: '٫' }),
+        };
+        this.options = Object.assign({ language: 'en', template: 'number', precision: 'high', outputFormat: 'plain' }, this.defaultLanguageConfig['en']);
+        this.options = Object.assign(Object.assign({}, this.options), options);
+    }
+    setLanguage(lang, config = {}) {
+        this.options.language = lang;
+        this.options.prefixMarker =
+            config.prefixMarker || this.defaultLanguageConfig[lang].prefixMarker;
+        this.options.postfixMarker =
+            config.postfixMarker || this.defaultLanguageConfig[lang].postfixMarker;
+        this.options.prefix =
+            config.prefix || this.defaultLanguageConfig[lang].prefix;
+        this.options.postfix =
+            config.postfix || this.defaultLanguageConfig[lang].postfix;
+        this.options.thousandSeparator =
+            config.thousandSeparator ||
+                this.defaultLanguageConfig[lang].thousandSeparator;
+        this.options.decimalSeparator =
+            config.decimalSeparator ||
+                this.defaultLanguageConfig[lang].decimalSeparator;
+        return this;
+    }
+    setTemplate(template, precision) {
+        this.options.template = template;
+        this.options.precision = precision;
+        return this;
+    }
+    toJson(input) {
+        const formattedObject = this.format(input);
+        delete formattedObject.value;
+        return formattedObject;
+    }
+    toString(input) {
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    toPlainString(input) {
+        this.options.outputFormat = 'plain';
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    toHtmlString(input) {
+        this.options.outputFormat = 'html';
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    toMdString(input) {
+        this.options.outputFormat = 'markdown';
+        const formattedObject = this.format(input);
+        return formattedObject.value || '';
+    }
+    // Private methods...
+    isENotation(input) {
+        return /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)$/.test(input);
+    }
+    // Modify to accept originalEString to handle cases like "0.0e0" -> "0.0"
+    convertENotationToRegularNumber(num, originalEString) {
+        let numStr = String(num);
+        // If an originalEString is provided and represents 0 but has a specific format like "0.0", prefer that.
+        if (num === 0 && originalEString) {
+            const ePartsOriginal = originalEString.toLowerCase().split('e');
+            if (ePartsOriginal.length === 2) {
+                // Check if coefficient was like "0.0", "0.00" etc.
+                if (ePartsOriginal[0].match(/^0\.0*$/)) {
+                    return ePartsOriginal[0]; // Return "0.0" or "0.00" etc.
+                }
+            }
+        }
+        // If not E-notation according to JS default toString for the number, or if it's simple "0", return it.
+        if (numStr.toLowerCase().indexOf('e') === -1) {
+            return numStr;
+        }
+        // If it IS E-notation, attempt to convert to plain decimal string.
+        // Handle very small numbers (negative exponent) using toFixed.
+        // Check num !== 0 because String(0) is "0", which doesn't contain 'e'.
+        if (Math.abs(num) < 1.0 && num !== 0) {
+            const eParts = numStr.toLowerCase().split('e'); // Use numStr here, not originalEString unless passed carefully
+            // Ensure it's a valid E-notation string with a negative exponent
+            if (eParts.length === 2) {
+                const exponent = parseInt(eParts[1], 10);
+                if (exponent < 0) {
+                    let precision = Math.abs(exponent);
+                    // Use coefficient from numStr for precision calculation
+                    if (eParts[0].includes('.')) {
+                        precision += eParts[0].split('.')[1].length;
+                    }
+                    // Cap precision to prevent overly long strings or errors with toFixed.
+                    return num.toFixed(Math.min(precision, 100));
+                }
+            }
+        }
+        // Handle large numbers or numbers with positive E-notation if not caught above.
+        // This part manually reconstructs the string from numStr.
+        const parts = numStr.toLowerCase().split('e');
+        if (parts.length === 2) {
+            const coefficientStr = parts[0];
+            const exponent = parseInt(parts[1], 10);
+            let [integer, fraction] = coefficientStr.split('.');
+            fraction = fraction || '';
+            if (exponent > 0) { // Positive exponent
+                const sign = integer.startsWith('-') ? "-" : "";
+                if (sign)
+                    integer = integer.substring(1);
+                if (fraction.length <= exponent) {
+                    return sign + integer + fraction.padEnd(exponent, '0');
+                }
+                else {
+                    return sign + integer + fraction.substring(0, exponent) + '.' + fraction.substring(exponent);
+                }
+            }
+            else if (exponent < 0) { // Should have been caught by toFixed if num was < 1.0
+                let precision = Math.abs(exponent);
+                if (coefficientStr.includes('.')) {
+                    precision += coefficientStr.split('.')[1].length;
+                }
+                return num.toFixed(Math.min(precision, 100));
+            }
+            else { // exponent === 0
+                return coefficientStr;
+            }
+        }
+        return numStr;
+    }
+    format(input) {
+        var _a;
+        let { precision, template } = this.options;
+        const { language, outputFormat, prefixMarker, postfixMarker, prefix, postfix, thousandSeparator, decimalSeparator, } = this.options;
+        if (input === undefined || input === null || input === '') {
+            return {};
+        }
+        // Store original input string to preserve format for trailing zeros
+        const originalInput = input.toString();
+        if (template === 'liveformat') {
+            let currentInput = this._sanitizeLiveInput(originalInput);
+            // Define locale-specific separators early
+            const currentThousandSeparator = thousandSeparator || ',';
+            const currentDecimalSeparator = decimalSeparator || '.';
+            // Special override for inputs like "0.0e0" or "۰٫۰e0" which _sanitizeLiveInput might turn into "0".
+            // This override aims to restore the "0.0" or "0٫0" representation if originalInput implies it.
+            // First, create a version of originalInput with Western digits and '.' as decimal for reliable parsing.
+            let westernizedOriginalInput = originalInput.replace(/[٠-٩۰-۹]/g, function (match) {
+                return String(match.charCodeAt(0) & 0xf);
+            });
+            if (((_a = this.options.language) !== null && _a !== void 0 ? _a : 'en') === 'fa') {
+                const farsiDecimal = this.defaultLanguageConfig.fa.decimalSeparator || '٫';
+                westernizedOriginalInput = westernizedOriginalInput.replace(new RegExp(farsiDecimal, 'g'), '.');
+            }
+            if (this.isENotation(westernizedOriginalInput)) {
+                const numValOriginal = Number(westernizedOriginalInput);
+                if (numValOriginal === 0) {
+                    const eIndex = originalInput.toLowerCase().indexOf('e');
+                    if (eIndex > -1) {
+                        const partBeforeEOriginal = originalInput.substring(0, eIndex);
+                        const partBeforeEWesternDigits = partBeforeEOriginal.replace(/[٠-٩۰-۹]/g, function (match) {
+                            return String(match.charCodeAt(0) & 0xf);
+                        });
+                        // Check if this part (e.g., "0.0" or "0٫0") matches the "zero with explicit decimals" pattern
+                        // Normalize its decimal separator to currentDecimalSeparator for consistency before assigning to currentInput
+                        let partToTest = partBeforeEWesternDigits;
+                        if (partBeforeEWesternDigits.includes('.') && currentDecimalSeparator !== '.') {
+                            partToTest = partBeforeEWesternDigits.replace('.', currentDecimalSeparator);
+                        }
+                        else if (partBeforeEWesternDigits.includes('٫') && currentDecimalSeparator !== '٫') {
+                            // This case should ideally not happen if Farsi decimal is '٫' and currentDecimalSeparator is also '٫'
+                            partToTest = partBeforeEWesternDigits.replace('٫', currentDecimalSeparator);
+                        }
+                        const zeroWithDecimalsPattern = new RegExp(`^0\\${currentDecimalSeparator}0*$`);
+                        if (partToTest.match(zeroWithDecimalsPattern)) {
+                            currentInput = partToTest; // currentInput is now "0[currentSeparator]0..." e.g. "0.0" or "0٫0"
+                        }
+                    }
+                }
+            }
+            let sign = '';
+            if (currentInput.startsWith('-')) {
+                sign = '-';
+                currentInput = currentInput.substring(1); // currentInput is now the absolute numeric string
+            }
+            // const currentThousandSeparator = thousandSeparator || ','; // Moved up
+            // const currentDecimalSeparator = decimalSeparator || '.'; // Moved up
+            if (currentInput === '') {
+                return {
+                    value: '',
+                    prefix: '',
+                    postfix: '',
+                    sign: '',
+                    wholeNumber: ''
+                };
+            }
+            // Handles "0" (from input "0" or "-0")
+            if (currentInput === '0') {
+                let outputZero = '0';
+                if (this.options.language === 'fa') {
+                    outputZero = String.fromCharCode('0'.charCodeAt(0) + 1728); // Converts '0' to '۰'
+                }
+                return {
+                    value: outputZero,
+                    prefix: '',
+                    postfix: '',
+                    sign: '',
+                    wholeNumber: outputZero,
+                };
+            }
+            // Handle cases like "." or "0." or ".0"
+            // If input is just the decimal separator, treat as "0" + separator
+            if (currentInput === currentDecimalSeparator) {
+                currentInput = '0' + currentDecimalSeparator;
+            }
+            let integerPart = '';
+            let decimalPart = '';
+            let hasDecimalPoint = false;
+            // Try splitting with current locale's decimal separator first
+            if (currentInput.includes(currentDecimalSeparator)) {
+                hasDecimalPoint = true;
+                const parts = currentInput.split(currentDecimalSeparator);
+                integerPart = parts[0];
+                decimalPart = parts.length > 1 ? parts[1] : '';
+            }
+            // If not found, and current locale is not using '.', check for '.' as a fallback
+            else if (currentDecimalSeparator !== '.' && currentInput.includes('.')) {
+                hasDecimalPoint = true;
+                const parts = currentInput.split('.');
+                integerPart = parts[0];
+                decimalPart = parts.length > 1 ? parts[1] : '';
+            }
+            else {
+                // No decimal point found (neither locale specific nor '.')
+                integerPart = currentInput;
+            }
+            // Now integerPart is the true integer part (still needs leading zero trim).
+            if (integerPart === '') {
+                integerPart = '0';
+            }
+            else if (integerPart !== '0') {
+                const tempInt = integerPart.replace(/^0+/, '');
+                integerPart = (tempInt === '') ? '0' : tempInt;
+            }
+            // No change if integerPart is already "0"
+            const formattedIntegerPart = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, currentThousandSeparator);
+            let finalValue = formattedIntegerPart;
+            if (hasDecimalPoint) {
+                finalValue += currentDecimalSeparator + decimalPart;
+            }
+            const finalNumericValue = finalValue; // finalValue at this point is the formatted absolute number
+            let resultSign = '';
+            let resultValue = finalNumericValue;
+            if (sign === '-') {
+                // Only add sign if the number isn't representing plain zero.
+                // parseFloat "0.00" is 0. "0" is 0.
+                // We want "-0.123", but "0" for "-0".
+                // We want "-0.00" for input "-0.00" (if that's a required display for zero value with decimals)
+                // The tests for "-0.000000123" expect "-0.000000123".
+                // The tests for 0.000000123 expect "0.000000123".
+                // Test for -0 will clarify if it should be "0" or "-0". Assume "0".
+                if (parseFloat(finalNumericValue) === 0 && !finalNumericValue.includes('.')) { // handles "0"
+                    resultSign = ''; // Make "-0" become "0"
+                    // resultValue is already "0"
+                }
+                else {
+                    resultSign = '-';
+                    resultValue = sign + finalNumericValue;
+                }
+            }
+            // At this point, finalValue is the formatted absolute number string (Western digits, Farsi/default separators).
+            // sign is the extracted input sign ('-' or '').
+            // Convert finalValue to Farsi digits if necessary for the absolute part.
+            const outputFormattedAbsoluteValue = this._convertToFarsiDigits(finalValue);
+            let outputSign = '';
+            // Determine the final sign string.
+            // `finalValue` is absolute, western digits, locale separator e.g. "0", "0٫0", "0٫12", "123٫45"
+            // `sign` is the original sign from input, like "-"
+            if (sign === '-') {
+                if (finalValue === '0') { // Check if the absolute formatted value is literally "0"
+                    outputSign = ''; // Only for "-0" input that results in "0" absolute
+                }
+                else {
+                    outputSign = '-'; // For all other cases like "-0.0", "-0.12", "-123"
+                }
+            }
+            return {
+                value: outputSign + outputFormattedAbsoluteValue,
+                prefix: '',
+                postfix: '',
+                sign: outputSign,
+                wholeNumber: outputFormattedAbsoluteValue, // Store Farsi/Western formatted absolute value (unsigned)
+            };
+        }
+        if (!(template === null || template === void 0 ? void 0 : template.match(/^(number|usd|irt|irr|percent|liveformat)$/g)))
+            template = 'number';
+        if (this.isENotation(originalInput)) {
+            input = this.convertENotationToRegularNumber(Number(input));
+        }
+        // Replace each Persian/Arabic numeral in the string with its English counterpart and strip all non-numeric chars
+        let numberString = input
+            .toString()
+            .replace(/[\u0660-\u0669\u06F0-\u06F9]/g, function (match) {
+            return String(match.charCodeAt(0) & 0xf);
+        })
+            .replace(/[^\d.-]/g, '');
+        // Stripping leading zeros only, preserve trailing zeros
+        numberString = numberString
+            .replace(/^0+(?=\d)/g, '');
+        const number = Math.abs(Number(numberString));
+        let p, d, r, c;
+        let f = 0;
+        // Auto precision selection
+        if (precision === 'auto') {
+            if (template.match(/^(usd|irt|irr|number)$/g)) {
+                if (number >= 0.0001 && number < 100000000000) {
+                    precision = 'high';
+                }
+                else {
+                    precision = 'medium';
+                }
+            }
+            else if (template === 'percent') {
+                precision = 'low';
+            }
+        }
+        if (precision === 'medium') {
+            if (number >= 0 && number < 0.0001) {
+                p = 33;
+                d = 4;
+                r = false;
+                c = true;
+            }
+            else if (number >= 0.0001 && number < 0.001) {
+                p = 7;
+                d = 4;
+                r = false;
+                c = false;
+            }
+            else if (number >= 0.001 && number < 0.01) {
+                p = 5;
+                d = 3;
+                r = false;
+                c = false;
+            }
+            else if (number >= 0.001 && number < 0.1) {
+                p = 3;
+                d = 2;
+                r = false;
+                c = false;
+            }
+            else if (number >= 0.1 && number < 1) {
+                p = 1;
+                d = 1;
+                r = false;
+                c = false;
+            }
+            else if (number >= 1 && number < 10) {
+                p = 3;
+                d = 3;
+                r = false;
+                c = false;
+            }
+            else if (number >= 10 && number < 100) {
+                p = 2;
+                d = 2;
+                r = false;
+                c = false;
+            }
+            else if (number >= 100 && number < 1000) {
+                p = 1;
+                d = 1;
+                r = false;
+                c = false;
+            }
+            else if (number >= 1000) {
+                const x = Math.floor(Math.log10(number)) % 3;
+                p = 2 - x;
+                d = 2 - x;
+                r = true;
+                c = true;
+            }
+            else {
+                p = 0;
+                d = 0;
+                r = true;
+                c = true;
+            }
+        }
+        else if (precision === 'low') {
+            if (number >= 0 && number < 0.01) {
+                p = 2;
+                d = 0;
+                r = true;
+                c = false;
+                f = 2;
+            }
+            else if (number >= 0.01 && number < 0.1) {
+                p = 2;
+                d = 1;
+                r = true;
+                c = false;
+            }
+            else if (number >= 0.1 && number < 1) {
+                p = 2;
+                d = 2;
+                r = true;
+                c = false;
+            }
+            else if (number >= 1 && number < 10) {
+                p = 2;
+                d = 2;
+                r = true;
+                c = false;
+                f = 2;
+            }
+            else if (number >= 10 && number < 100) {
+                p = 1;
+                d = 1;
+                r = true;
+                c = false;
+                f = 1;
+            }
+            else if (number >= 100 && number < 1000) {
+                p = 0;
+                d = 0;
+                r = true;
+                c = false;
+            }
+            else if (number >= 1000) {
+                const x = Math.floor(Math.log10(number)) % 3;
+                p = 1 - x;
+                d = 1 - x;
+                r = true;
+                c = true;
+            }
+            else {
+                p = 0;
+                d = 0;
+                r = true;
+                c = true;
+                f = 2;
+            }
+        }
+        else {
+            // precision === "high"
+            if (number >= 0 && number < 1) {
+                p = 33;
+                d = 4;
+                r = false;
+                c = false;
+            }
+            else if (number >= 1 && number < 10) {
+                p = 3;
+                d = 3;
+                r = true;
+                c = false;
+            }
+            else if (number >= 10 && number < 100) {
+                p = 2;
+                d = 2;
+                r = true;
+                c = false;
+            }
+            else if (number >= 100 && number < 1000) {
+                p = 2;
+                d = 2;
+                r = true;
+                c = false;
+            }
+            else if (number >= 1000 && number < 10000) {
+                p = 1;
+                d = 1;
+                r = true;
+                c = false;
+            }
+            else {
+                p = 0;
+                d = 0;
+                r = true;
+                c = false;
+            }
+        }
+        // For scientific notation, increase precision to ensure correct representation
+        if (this.isENotation(originalInput)) {
+            p = Math.max(p, 20);
+            r = false;
+        }
+        return this.reducePrecision(numberString, p, d, r, c, f, template, language, outputFormat, prefixMarker, postfixMarker, prefix, postfix, thousandSeparator, decimalSeparator, originalInput);
+    }
+    reducePrecision(numberString, precision = 30, nonZeroDigits = 4, round = false, compress = false, fixedDecimalZeros = 0, template = 'number', language = 'en', outputFormat = 'plain', prefixMarker = 'span', postfixMarker = 'span', prefix = '', postfix = '', thousandSeparator = ',', decimalSeparator = '.', originalInput = '') {
+        var _a, _b;
+        if (numberString === undefined || numberString === null || numberString.trim() === '') {
+            return {};
+        }
+        // Handle negative zero
+        if (numberString === '-0' || numberString === '-0.0') {
+            numberString = numberString.substring(1); // Remove negative sign for zero
+        }
+        numberString = numberString.toString();
+        const maxPrecision = 30;
+        const maxIntegerDigits = 21;
+        const scaleUnits = template.match(/^(number|percent)$/g)
+            ? {
+                '': '',
+                K: ' هزار',
+                M: ' میلیون',
+                B: ' میلیارد',
+                T: ' تریلیون',
+                Qd: ' کادریلیون',
+                Qt: ' کنتیلیون',
+            }
+            : {
+                '': '',
+                K: ' هزار ت',
+                M: ' میلیون ت',
+                B: ' میلیارد ت',
+                T: ' همت',
+                Qd: ' هزار همت',
+                Qt: ' میلیون همت',
+            };
+        const fullScaleUnits = template.match(/^(number|percent)$/g)
+            ? {
+                '': '',
+                K: ' هزار',
+                M: ' میلیون',
+                B: ' میلیارد',
+                T: ' تریلیون',
+                Qd: ' کادریلیون',
+                Qt: ' کنتیلیون',
+            }
+            : {
+                '': '',
+                K: ' هزار تومان',
+                M: ' میلیون تومان',
+                B: ' میلیارد تومان',
+                T: ' هزار میلیارد تومان',
+                Qd: ' کادریلیون تومان',
+                Qt: ' کنتیلیون تومان',
+            };
+        let parts = /^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(numberString);
+        if (!parts) {
+            return {};
+        }
+        const sign = parts[1] || '';
+        let nonFractionalStr = parts[2];
+        let fractionalZeroStr = parts[3];
+        let fractionalNonZeroStr = parts[4];
+        let unitPrefix = '';
+        let unitPostfix = '';
+        if (fractionalZeroStr.length >= maxPrecision) {
+            // Number is smaller than maximum precision
+            fractionalZeroStr = '0'.padEnd(maxPrecision - 1, '0');
+            fractionalNonZeroStr = '1';
+        }
+        else if (fractionalZeroStr.length + nonZeroDigits > precision) {
+            // decrease non-zero digits
+            nonZeroDigits = precision - fractionalZeroStr.length;
+            if (nonZeroDigits < 1)
+                nonZeroDigits = 1;
+        }
+        else if (nonFractionalStr.length > maxIntegerDigits) {
+            nonFractionalStr = '0';
+            fractionalZeroStr = '';
+            fractionalNonZeroStr = '';
+        }
+        // compress large numbers
+        if (compress && nonFractionalStr.length >= 4) {
+            const scaleUnitKeys = Object.keys(scaleUnits);
+            let scaledWholeNumber = nonFractionalStr;
+            let unitIndex = 0;
+            while (+scaledWholeNumber > 999 && unitIndex < scaleUnitKeys.length - 1) {
+                scaledWholeNumber = (+scaledWholeNumber / 1000).toFixed(2);
+                unitIndex++;
+            }
+            unitPostfix = scaleUnitKeys[unitIndex];
+            parts = /^(-)?(\d+)\.?([0]*)(\d*)$/g.exec(scaledWholeNumber.toString());
+            if (!parts) {
+                return {};
+            }
+            // sign = parts[1] || "";
+            nonFractionalStr = parts[2];
+            fractionalZeroStr = parts[3];
+            fractionalNonZeroStr = parts[4];
+        }
+        // Truncate the fractional part or round it
+        // if (precision > 0 && nonZeroDigits > 0 && fractionalNonZeroStr.length > nonZeroDigits) {
+        if (fractionalNonZeroStr.length > nonZeroDigits) {
+            if (!round) {
+                fractionalNonZeroStr = fractionalNonZeroStr.substring(0, nonZeroDigits);
+            }
+            else {
+                if (parseInt(fractionalNonZeroStr[nonZeroDigits]) < 5) {
+                    fractionalNonZeroStr = fractionalNonZeroStr.substring(0, nonZeroDigits);
+                }
+                else {
+                    fractionalNonZeroStr = (parseInt(fractionalNonZeroStr.substring(0, nonZeroDigits)) + 1).toString();
+                    // If overflow occurs (e.g., 999 + 1 = 1000), adjust the substring length
+                    if (fractionalNonZeroStr.length > nonZeroDigits) {
+                        if (fractionalZeroStr.length > 0) {
+                            fractionalZeroStr = fractionalZeroStr.substring(0, fractionalZeroStr.length - 1);
+                        }
+                        else {
+                            nonFractionalStr = (Number(nonFractionalStr) + 1).toString();
+                            fractionalNonZeroStr = fractionalNonZeroStr.substring(1);
+                        }
+                    }
+                }
+            }
+        }
+        // Using dex style
+        if (compress && fractionalZeroStr !== '' && unitPostfix === '') {
+            fractionalZeroStr =
+                '0' +
+                    fractionalZeroStr.length.toString().replace(/\d/g, function (match) {
+                        return [
+                            '₀',
+                            '₁',
+                            '₂',
+                            '₃',
+                            '₄',
+                            '₅',
+                            '₆',
+                            '₇',
+                            '₈',
+                            '₉',
+                        ][parseInt(match, 10)];
+                    });
+        }
+        // Check if the original input had trailing zeros
+        let fractionalPartStr = `${fractionalZeroStr}${fractionalNonZeroStr}`;
+        // Don't truncate trailing zeros when they're in the original string
+        if (fractionalPartStr.length > precision && !originalInput.includes('e')) {
+            fractionalPartStr = fractionalPartStr.substring(0, precision);
+        }
+        // For scientific notation and numbers with trailing zeros, preserve the format
+        if (originalInput.includes('e') || originalInput.includes('E')) {
+            // For scientific notation, use the converted string
+        }
+        else if (originalInput.includes('.')) {
+            // For regular numbers with decimal point, check for trailing zeros
+            const originalParts = originalInput.split('.');
+            if (originalParts.length === 2) {
+                const originalDecimal = originalParts[1];
+                // If original has more digits than what we have now, preserve those trailing zeros
+                if (originalDecimal.length > fractionalPartStr.length && originalDecimal.endsWith('0')) {
+                    // Count trailing zeros in original
+                    let trailingZeros = 0;
+                    for (let i = originalDecimal.length - 1; i >= 0; i--) {
+                        if (originalDecimal[i] === '0') {
+                            trailingZeros++;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    // Add back trailing zeros if they were in the original
+                    if (trailingZeros > 0) {
+                        fractionalPartStr = fractionalPartStr.padEnd(fractionalPartStr.length + trailingZeros, '0');
+                    }
+                }
+            }
+        }
+        // Output Formating, Prefix, Postfix
+        if (template === 'usd') {
+            unitPrefix = language === 'en' ? '$' : '';
+            if (!unitPostfix)
+                unitPostfix = language === 'fa' ? ' دلار' : '';
+        }
+        else if (template === 'irr') {
+            if (!unitPostfix)
+                unitPostfix = language === 'fa' ? ' ر' : ' R';
+        }
+        else if (template === 'irt') {
+            if (!unitPostfix)
+                unitPostfix = language === 'fa' ? ' ت' : ' T';
+        }
+        else if (template === 'percent') {
+            if (language === 'en') {
+                unitPostfix += '%';
+            }
+            else {
+                unitPostfix += !unitPostfix ? '٪' : ' درصد';
+            }
+        }
+        unitPrefix = prefix + unitPrefix;
+        unitPostfix += postfix;
+        if (outputFormat === 'html') {
+            if (unitPrefix)
+                unitPrefix = `<${prefixMarker}>${unitPrefix}</${prefixMarker}>`;
+            if (unitPostfix)
+                unitPostfix = `<${postfixMarker}>${unitPostfix}</${postfixMarker}>`;
+        }
+        else if (outputFormat === 'markdown') {
+            if (unitPrefix)
+                unitPrefix = `${prefixMarker}${unitPrefix}${prefixMarker}`;
+            if (unitPostfix)
+                unitPostfix = `${postfixMarker}${unitPostfix}${postfixMarker}`;
+        }
+        const thousandSeparatorRegex = /\B(?=(\d{3})+(?!\d))/g;
+        const fixedDecimalZeroStr = fixedDecimalZeros
+            ? '.'.padEnd(fixedDecimalZeros + 1, '0')
+            : '';
+        let out = '';
+        let wholeNumberStr;
+        // FIXED: Changed condition to correctly handle numbers with trailing zeros
+        // Old condition: if (precision <= 0 || nonZeroDigits <= 0 || !fractionalNonZeroStr) {
+        // New condition checks if both fractional parts are empty
+        if (precision <= 0 || nonZeroDigits <= 0 || (fractionalNonZeroStr === '' && fractionalZeroStr === '')) {
+            wholeNumberStr = `${nonFractionalStr.replace(thousandSeparatorRegex, ',')}${fixedDecimalZeroStr}`;
+        }
+        else {
+            wholeNumberStr = `${nonFractionalStr.replace(thousandSeparatorRegex, ',')}.${fractionalPartStr}`;
+        }
+        out = `${sign}${unitPrefix}${wholeNumberStr}${unitPostfix}`;
+        const formattedObject = {
+            value: out,
+            prefix: unitPrefix,
+            postfix: unitPostfix,
+            sign: sign,
+            wholeNumber: wholeNumberStr,
+        };
+        // replace custom config
+        formattedObject.value = ((_a = formattedObject === null || formattedObject === void 0 ? void 0 : formattedObject.value) !== null && _a !== void 0 ? _a : '')
+            .replace(/,/g, thousandSeparator)
+            .replace(/\./g, decimalSeparator);
+        // Convert output to Persian numerals if language is "fa"
+        if (language === 'fa') {
+            formattedObject.value = ((_b = formattedObject === null || formattedObject === void 0 ? void 0 : formattedObject.value) !== null && _b !== void 0 ? _b : '')
+                .replace(/[0-9]/g, c => String.fromCharCode(c.charCodeAt(0) + 1728))
+                .replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
+                return String(scaleUnits[c]);
+            });
+            formattedObject.fullPostfix = unitPostfix
+                .replace(/[0-9]/g, c => String.fromCharCode(c.charCodeAt(0) + 1728))
+                .replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
+                return String(fullScaleUnits[c]);
+            });
+            formattedObject.postfix = formattedObject.postfix
+                .replace(/[0-9]/g, c => String.fromCharCode(c.charCodeAt(0) + 1728))
+                .replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
+                return String(scaleUnits[c]);
+            });
+            formattedObject.wholeNumber = formattedObject.wholeNumber
+                .replace(/[0-9]/g, c => String.fromCharCode(c.charCodeAt(0) + 1728))
+                .replace(/(K|M|B|T|Qt|Qd)/g, function (c) {
+                return String(scaleUnits[c]);
+            });
+        }
+        return formattedObject;
+    }
+    _sanitizeLiveInput(input) {
+        var _a;
+        let sanitizedInput = input;
+        // Convert Farsi/Arabic numerals to Western numerals
+        sanitizedInput = sanitizedInput.replace(/[٠-٩۰-۹]/g, function (match) {
+            return String(match.charCodeAt(0) & 0xf);
+        });
+        // Handle potential E-notation
+        let stringForENotationProcessing = sanitizedInput;
+        let originalFarsiSeparator = null;
+        if (((_a = this.options.language) !== null && _a !== void 0 ? _a : 'en') === 'fa') {
+            const farsiDecimal = this.defaultLanguageConfig.fa.decimalSeparator || '٫'; // Default to '٫'
+            if (sanitizedInput.includes(farsiDecimal)) {
+                originalFarsiSeparator = farsiDecimal;
+                stringForENotationProcessing = sanitizedInput.replace(new RegExp(farsiDecimal, 'g'), '.');
+            }
+        }
+        if (this.isENotation(stringForENotationProcessing)) {
+            // Pass stringForENotationProcessing as the originalEString argument
+            const convertedValue = this.convertENotationToRegularNumber(Number(stringForENotationProcessing), stringForENotationProcessing);
+            // If we replaced a Farsi separator and the result has a '.', convert it back.
+            // Otherwise, use the converted value directly.
+            if (originalFarsiSeparator && convertedValue.includes('.')) {
+                sanitizedInput = convertedValue.replace(/\./g, originalFarsiSeparator);
+            }
+            else {
+                sanitizedInput = convertedValue;
+            }
+        }
+        // If not E-notation, sanitizedInput (with original separators after Farsi digit conversion) is returned.
+        return sanitizedInput;
+    }
+    _convertToFarsiDigits(value) {
+        if (this.options.language !== 'fa' || value === null || value === undefined) {
+            return value;
+        }
+        let farsiConvertedValue = "";
+        for (let i = 0; i < value.length; i++) {
+            const char = value[i];
+            if (char >= '0' && char <= '9') {
+                farsiConvertedValue += String.fromCharCode(char.charCodeAt(0) + 1728);
+            }
+            else {
+                farsiConvertedValue += char;
+            }
+        }
+        return farsiConvertedValue;
+    }
+}
+exports.default = NumberFormatter;

package/ts/lib/src/index.d.ts

@@ -0,0 +1,2 @@
+import NumberFormatter from './format';
+export { NumberFormatter };

package/ts/lib/src/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberFormatter = void 0;
+const format_1 = __importDefault(require("./format"));
+exports.NumberFormatter = format_1.default;

package/ts/lib/test/format/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/ts/lib/test/format/index.spec.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_1 = __importDefault(require("../../src/format")); // Adjust path if necessary based on actual structure
+describe('NumberFormatter - Liveformat Template', () => {
+    const options = { template: 'liveformat' }; // Cast to any to allow new template type if TS is strict before build
+    const testCases = [
+        { input: '0', expected: '0' },
+        { input: '02', expected: '2' },
+        { input: '29', expected: '29' },
+        { input: '292', expected: '292' },
+        { input: '2923', expected: '2,923' },
+        { input: '29231', expected: '29,231' },
+        { input: '292312', expected: '292,312' },
+        { input: '2923123', expected: '2,923,123' },
+        { input: '2923123.', expected: '2,923,123.' },
+        { input: '2923123.0', expected: '2,923,123.0' },
+        { input: '2923123.00', expected: '2,923,123.00' },
+        { input: '2923123.003', expected: '2,923,123.003' },
+        { input: '2923123.0030', expected: '2,923,123.0030' },
+        { input: '2923123.00301', expected: '2,923,123.00301' },
+        { input: '2923123.003012', expected: '2,923,123.003012' },
+        // Edge cases
+        { input: '', expected: '' },
+        { input: '.', expected: '0.' },
+        { input: '0.0', expected: '0.0' },
+        { input: '0.12', expected: '0.12' },
+        { input: '.5', expected: '0.5' },
+        { input: '007', expected: '7' },
+        { input: '00.25', expected: '0.25' },
+        { input: '12345.6700', expected: '12,345.6700' },
+        { input: '000', expected: '0' },
+        { input: '000.000', expected: '0.000' },
+        // Test cases for E-notation handling by incremental template
+        { input: '1.23e-7', expected: '0.000000123' },
+        { input: '1.23E-7', expected: '0.000000123' },
+        { input: 0.000000123, expected: '0.000000123' },
+        { input: '12345e-2', expected: '123.45' },
+        { input: '0.00012345e+2', expected: '0.012345' },
+        { input: '1.23e+8', expected: '123,000,000' },
+        { input: '1.23E+8', expected: '123,000,000' },
+        { input: 123000000, expected: '123,000,000' },
+        { input: '1234567.89e+3', expected: '1,234,567,890' },
+        { input: '123456789012345', expected: '123,456,789,012,345' },
+        { input: 123456789012345, expected: '123,456,789,012,345' },
+        { input: '1e-3', expected: '0.001' },
+        { input: 0.001, expected: '0.001' },
+        { input: '1e+3', expected: '1,000' },
+        { input: 1000, expected: '1,000' },
+        { input: '0e0', expected: '0' },
+        { input: 0e0, expected: '0' },
+        { input: '0.0e0', expected: '0.0' },
+        // Cases that might stress the convertENotationToRegularNumber
+        { input: '123456789123456789123', expected: '123,456,789,123,456,789,123' },
+        { input: 123456789123456789123, expected: '123,456,789,123,456,800,000' },
+        { input: '1.0e-20', expected: '0.00000000000000000001' },
+        { input: 1.0e-20, expected: '0.00000000000000000001' },
+        { input: '1.0e+20', expected: '100,000,000,000,000,000,000' },
+        { input: 1.0e+20, expected: '100,000,000,000,000,000,000' },
+        // Check inputs that convertENotationToRegularNumber might have previously struggled with
+        { input: '1e21', expected: '1,000,000,000,000,000,000,000' },
+        { input: 1e21, expected: '1,000,000,000,000,000,000,000' },
+        // Test with negative numbers in E-notation
+        { input: '-1.23e-7', expected: '-0.000000123' },
+        { input: -0.000000123, expected: '-0.000000123' },
+        { input: '-1.23e+8', expected: '-123,000,000' },
+        { input: -123000000, expected: '-123,000,000' },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        it(`should format '${input}' to '${expected}'`, () => {
+            const formatter = new format_1.default(options);
+            expect(formatter.toPlainString(input)).toBe(expected);
+        });
+    });
+    // Test with different separators if possible, though the problem implies fixed separators for this template
+    // For now, assuming default separators (',' and '.') as per examples
+    describe('NumberFormatter - Liveformat Template with Fa Language (different separators)', () => {
+        const faOptions = {
+            template: 'liveformat',
+            language: 'fa' // 'fa' uses '٫' and '٬'
+        };
+        const formatter = new format_1.default(); // Create once
+        formatter.setLanguage('fa'); // Set language
+        formatter.setTemplate('liveformat', 'auto'); // Set template
+        // Confirmed Farsi Separators: Thousands: ٬ (U+066C), Decimal: ٫ (U+066B)
+        // Output Digits: Persian Numerals ۰۱۲... (U+06F0 range) as per TS implementation
+        it('should format Farsi input "۱۲۳۴" to "۱٬۲۳۴"', () => {
+            expect(formatter.toPlainString('۱۲۳۴')).toBe('۱٬۲۳۴');
+        });
+        it('should format Farsi input "۱۲۳۴۵٫۶۷" (Farsi decimal) to "۱۲٬۳۴۵٫۶۷"', () => {
+            expect(formatter.toPlainString('۱۲۳۴۵٫۶۷')).toBe('۱۲٬۳۴۵٫۶۷');
+        });
+        it('should format Farsi input "-۷۸۹٫۰۱" (Farsi decimal) to "-۷۸۹٫۰۱"', () => {
+            expect(formatter.toPlainString('-۷۸۹٫۰۱')).toBe('-۷۸۹٫۰۱');
+        });
+        it('should format Farsi input "۰" to "۰"', () => {
+            expect(formatter.toPlainString('۰')).toBe('۰');
+        });
+        it('should format Farsi input "-۰" to "۰"', () => {
+            expect(formatter.toPlainString('-۰')).toBe('۰');
+        });
+        it('should format Farsi input "۰٫۱۲" (Farsi decimal) to "۰٫۱۲"', () => {
+            expect(formatter.toPlainString('۰٫۱۲')).toBe('۰٫۱۲');
+        });
+        it('should format Farsi input "-۰٫۱۲" (Farsi decimal) to "-۰٫۱۲"', () => {
+            expect(formatter.toPlainString('-۰٫۱۲')).toBe('-۰٫۱۲');
+        });
+        it('should format Farsi input "۱۲۳۴۵۶۷۸۹٫۱۲۳" (Farsi decimal) to "۱۲۳٬۴۵۶٬۷۸۹٫۱۲۳"', () => {
+            expect(formatter.toPlainString('۱۲۳۴۵۶۷۸۹٫۱۲۳')).toBe('۱۲۳٬۴۵۶٬۷۸۹٫۱۲۳');
+        });
+        it('should format mixed Farsi/Western digit input "1۲۳۴٫۵۶" (Farsi decimal) to "۱٬۲۳۴٫۵۶"', () => {
+            expect(formatter.toPlainString('1۲۳۴٫۵۶')).toBe('۱٬۲۳۴٫۵۶');
+        });
+        it('should format Farsi input with only Farsi decimal separator "٫" to "۰٫"', () => {
+            expect(formatter.toPlainString('٫')).toBe('۰٫');
+        });
+        // User's critical case 1 (Farsi input, Farsi decimal '٫')
+        it('should format Farsi input "۹۳۱۲۸۳٫۰۰۰۹۱۲۳" to "۹۳۱٬۲۸۳٫۰۰۰۹۱۲۳"', () => {
+            expect(formatter.toPlainString('۹۳۱۲۸۳٫۰۰۰۹۱۲۳')).toBe('۹۳۱٬۲۸۳٫۰۰۰۹۱۲۳');
+        });
+        // User's critical case 2 (Western input "39312312.123123", lang 'fa')
+        // TS liveformat needs input to use '٫' if lang=fa for correct parsing.
+        it('should format Western digit input "39312312٫123123" (Farsi decimal) to "۳۹٬۳۱۲٬۳۱۲٫۱۲۳۱۲۳" when lang=fa', () => {
+            expect(formatter.toPlainString('39312312٫123123')).toBe('۳۹٬۳۱۲٬۳۱۲٫۱۲۳۱۲۳');
+        });
+        it('should format Farsi input "۱۲۳۴۵۶۷" to "۱٬۲۳۴٬۵۶۷"', () => {
+            expect(formatter.toPlainString('۱۲۳۴۵۶۷')).toBe('۱٬۲۳۴٬۵۶۷');
+        });
+        it('should format Farsi input "۱۲۳٫۴۵" (Farsi decimal) to "۱۲۳٫۴۵"', () => {
+            expect(formatter.toPlainString('۱۲۳٫۴۵')).toBe('۱۲۳٫۴۵');
+        });
+        // Test "0.0" like inputs
+        it('should format Farsi "۰٫۰" to "۰٫۰"', () => {
+            expect(formatter.toPlainString('۰٫۰')).toBe('۰٫۰');
+        });
+        it('should format Farsi "-۰٫۰" to "-۰٫۰"', () => {
+            expect(formatter.toPlainString('-۰٫۰')).toBe('-۰٫۰');
+        });
+        // Expectations for 0.0e0 related inputs, assuming they should result in "۰٫۰" after fixes
+        it('should format "0.0e0" to "۰٫۰" when lang=fa', () => {
+            expect(formatter.toPlainString('0.0e0')).toBe('۰٫۰');
+        });
+        it('should format "۰٫۰e0" (Farsi input) to "۰٫۰" when lang=fa', () => {
+            expect(formatter.toPlainString('۰٫۰e0')).toBe('۰٫۰');
+        });
+    });
+});