@trebco/treb 23.6.2 → 25.0.0-rc1

package/treb-embed/style/treb-spreadsheet-element.scss

@@ -0,0 +1,20 @@
+
+@import 'layout.scss';
+
+/**
+ * default styles for custom element. we basically want 
+ * it to act like a div.
+ */
+treb-spreadsheet {
+  display: block;
+  position: relative;
+}
+
+/**
+ * if we don't find a height/width on the element when it's 
+ * created, we will add this class to set a default size.
+ */
+.treb-default-size {
+  width: 800px;
+  height: 550px;
+}

package/treb-embed/style/z-index.scss

@@ -0,0 +1,43 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+/* z-index stacking */
+
+$z-index-contents:                    8;
+$z-index-grid-selection:             10;
+$z-index-frozen-selection:           12;
+$z-index-tile-cover:                 14;
+$z-index-annotations:                16;
+$z-index-headers:                    18;
+$z-index-corner:                     20;
+$z-index-header-tile-cover:          22;
+$z-index-cell-editor:                24;
+$z-index-scroller:                   26; /* legacy only */
+$z-index-autocomplete:               39;
+$z-index-tooltip:                    39;
+$z-index-dropdown-caret:             39;
+$z-index-note:                       39;
+$z-index-sort-button:                39;
+$z-index-scale-popup:                40;
+$z-index-error-highlight:            40;
+$z-index-mask:                     9999;
+
+

package/treb-export/docs/charts.md

@@ -0,0 +1,68 @@
+
+
+doughnut chart
+--------------
+
+(1) add files: 
+
+```
+charts/chartX.xml
+charts/colorsX.xml
+charts/styleX.xml
+charts/_rels/chartX.xml.rels [number matches chartX.xml]
+
+drawings/drawingX.xml
+drawings/_rels/drawingX.xml.rels [number matches drawingX.xml]
+```
+
+(2) add types to [Content_Types].xml
+
+```
+<Override PartName="/xl/drawings/drawing1.xml" ContentType="application/vnd.openxmlformats-officedocument.drawing+xml"/>
+<Override PartName="/xl/charts/chart1.xml" ContentType="application/vnd.openxmlformats-officedocument.drawingml.chart+xml"/>
+<Override PartName="/xl/charts/style1.xml" ContentType="application/vnd.ms-office.chartstyle+xml"/>
+<Override PartName="/xl/charts/colors1.xml" ContentType="application/vnd.ms-office.chartcolorstyle+xml"/>
+```
+
+(3) worksheet xml has reference to drawing
+
+```
+<drawing r:id="rId1"/>
+```
+
+(4) worksheet rels points to drawing file
+
+```
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing" Target="../drawings/drawing1.xml"/>
+```
+
+(5) drawing file has reference to chart
+
+```
+<c:chart
+	xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart"
+	xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" r:id="rId1"/>
+```
+
+(6) drawing rels points to chart
+
+```
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart" Target="../charts/chart1.xml"/>
+```
+
+(7) chart has no reference to colors, style? (...)
+
+(8) chart rels has rels to colors, style
+
+```
+<Relationship Id="rId2" Type="http://schemas.microsoft.com/office/2011/relationships/chartColorStyle" Target="colors1.xml"/>
+<Relationship Id="rId1" Type="http://schemas.microsoft.com/office/2011/relationships/chartStyle" Target="style1.xml"/>
+```
+
+given that there's no reference in chart, not clear that we need these (although knowing Excel...)
+
+
+
+
+
+

package/treb-export/modern.tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../tsproject.json",
+  "include": [
+    "../package.json",
+    "src/**/*.ts",
+    "../treb-utils/**/*.ts",
+    "../treb-grid/**/*.ts",
+    "../treb-embed/**/*.ts",
+    "../treb-charts/**/*.ts",
+    "../treb-format/**/*.ts",
+    "../treb-parser/**/*.ts",
+    "../treb-calculator/**/*.ts",
+    "../treb-base-types/**/*.ts"
+  ],
+  "exclude": [
+    "src/export-worker/index-legacy.ts"
+  ]
+}
+

package/treb-export/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "treb-export",
+  "main": "src/index.ts"
+}

package/treb-export/src/address-type.ts

@@ -0,0 +1,77 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+/** represents address in a sheet */
+export interface AddressType {
+  row: number;
+  col: number;
+  sheet?: string;
+}
+
+/** typeguard for address */
+export const is_address = (candidate: any): candidate is AddressType => {
+  return 'row' in candidate &&
+    'col' in candidate;
+};
+
+/** represents range in a sheet (e.g. A1:B2) */
+export interface RangeType {
+  from: AddressType;
+  to: AddressType;
+  sheet?: string;
+}
+
+export interface HyperlinkType {
+  address: AddressType;
+  reference: string;
+  text: string;
+}
+
+/** typeguard for range */
+export const is_range = (candidate: any): candidate is RangeType => {
+  return 'from' in candidate &&
+    'to' in candidate &&
+    is_address(candidate.from) &&
+    is_address(candidate.to);
+};
+
+export const InRange = (range: RangeType, address: AddressType) => {
+  return address.sheet === range.sheet &&
+    address.row >= range.from.row &&
+    address.row <= range.to.row &&
+    address.col >= range.from.col &&
+    address.col <= range.to.col;
+};
+
+export const ShiftRange = (range: RangeType, rows = 0, columns = 0) => {
+  return {
+    from: {
+      row: range.from.row + rows,
+      col: range.from.col + columns,
+      sheet: range.from.sheet,
+    }, to: {
+      row: range.to.row + rows,
+      col: range.to.col + columns,
+      sheet: range.to.sheet,
+    },
+  };
+};
+

package/treb-export/src/base-template.ts

@@ -0,0 +1,22 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+export const template = 'PK     ! bîh^     [Content_Types].xml ¢(                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ¬ËNÃ0E÷HüCä-JÜ²@5íÇ*Q>ÀÄÆªc[iiÿûB¡j7±ÏÜ{2ñÍh²nm¶Æ»RÈÀU^7/ÅÇì%¿rZYï @1__f q·ÃR4DáAJ¬h>ãÚÇVßÆ¹ªZ¨9ÈÛÁàNVÞ8Ê©ÓãÑÔji){^óã-I"{Üv^¥P!XS)bR¹rúK¾s(¸3Õ`cÞ0½ÝÎß»¾7M4²©ôªZÆk+¿|\|z¿(ôPúº6h_-[@!ÒØ Pk´­2nÏ}Ä?£LËðÂ Ýû%áÄßdºdN"m,à¥ÇDO97*~§ÈÉ¸8ÀOíc|n¦ÑäEøÿöéºóÀBÉÀ!$}íàÈé;{ìÐå[îñé2þ  ÿÿ PK     ! µU0#ô   L   _rels/.rels ¢(                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ¬MOÃ0ïHüÈ÷ÕÝBKwAH»!T~IÜµ£$Ý¿'TG½~üÊÛÝ<êÈ!öâ4¬;#¶w­úqu*&rFq¬áÄvÕõÕöGJy(v½*«¸¨¡KÉß#FÓñD±Ï.W	¥=ZÆMYÞbø®ÕBSí­°·7 êÏ×¦é?9LìÒÈsbgÙ®|Èl!õùUSh9i°br:"y_dlÀóD¿ý|-NÈR"4ø2ÏGÇ% õZ´4ñËyÄ7	Ã«ÈðÉ¨Þ  ÿÿ PK     ! ºpfô  Ê     xl/workbook.xml¬UÛn£0}_iÿñNÁ»Jª$5RwUµÙö%ÒÊ'XÌÓPUý÷CH/yé¶ßÆ9Î/Ú"W¯)+CªBÊ¥´Üê¯å\óT¥¸LqÎJª¤V/Æß¿ïß­Û) PÖ¡	Qº^')p}Æ*ReÃxLùV¯+NpZg"×MÃpôÓRíþ¶ÙÐD,i
R _g´ª´"ù\ù®©´@¬iNÅcª*E,¶%ãxÛ-²ÃãÀÐÃI`:9ª 	g5Û3Ö{Ò'þ#CGèMÚÓ|ÉÒ9y 2GVÜù$+çå¼!ãËh¤Õi%à}Í>r3Õñùæä®®«ê'.d¦rUÉq-â
ªS¶'oxSMÕDÈtT}|ó5WR²ÁM. änãø¦-w0&¹ ¼ÄÌX)@¿¾ª¹{1P¸rCþ4¸X /ðZx]_c)ÏCõ2X-oâéJp²ÖH[1.VÜ²z¥N|zþA8NëàuÏ¬¿ äÁ ÁkÁ/¢+ÈÃ-~¬@îÓÃ¥]@Ø½ßOg{sîjFä5-ÍX0òÙtdûSÇÁî	ÃÈ¡jI1½7ýÀí`AFÐÐôåü'ãðÓdÿ®lÏÒSYÓî(Ù×/S¥½§eÊö+¯Æûnù¦"9Y¶ÌúµKB·pE:º¦äªOQlÅn4²5Ë7#Í2"WóA\åXîÜöÜEqÇEE¦«@ªë²Óú­¬¥
´ìe\aÌy_¤¨ËÛðZó´-»n£Ó;H+®jÑõ +
ôeL\Ã·4#=HgLmfEfl»qOmY÷ÿQý:uÃE²Ì0K|nÈfkÐPïð	¬õá­ñ_   ÿÿ PK     ! >ó   º   xl/_rels/workbook.xml.rels ¢(                                                                                                                                                                                                                                                                  ¬RMKÄ0½þ0wvÙt/"ìUëÉ´)Û&!3~ôß*º]XÖK/oyïÍÇv÷5âõÁ+¨zlï;oÍóÍbí­Gìêë«ís¹>È,8æø(%£¦"Dô¹Ò4jÎ0u2jsÐÊMYÞË´äúSì­´·· )fåÿ¹CÛöyÑó	I<y ÑèÔ!+øÁEöò¼üfMyÎkÁ£úå«Kª5=|t ÈG)så¢»UïátBûÊ)¿Ûò,ËôïfäÉÇÕß   ÿÿ PK     ! ­DsÁ  ¤     xl/worksheets/sheet1.xmlMkã0ïûî¶lÇn§´qÃö°°ì×]Ç¶%Iiýï;v»K(H 4Ï¼£­ª'o`4º qQZZê¶ ¿~nJçºæ½ÑPÐ8ú¸þüiu0vç: O ]A;ï1':PÜf '±{4mËÜ`×êYEwLq©éÛ[¦i¤Ò½íÏ=÷¨ßurp·à·»ý£DT²þ4A)Q"mµ±¼ê1ïcrAGsq	3í_ERRXãLãC$³³æëôlÉ¸I×ùßSfáM|G%g3+y->»aãsÙ|/ëþÊlóÙfù¤eú,ÓMlÙ&Jãíbù\þ¥ëU-±ÂcVÄBSÐ§²õjjßî¿5ñ¼ú= ¦dìÍÊÝxñ·¢Ñ]ùn§ÞüfIß÷þ»9|Ùv!*K×§À^CLd³{Ô·ðÛVjGzh¦[÷Ø3&
qíÍ0úÞ#²2Þu±:üUB|Æ1FµóÿZÿ  ÿÿ PK     ! Á¾N  Æ      xl/theme/theme1.xmlìYÍ7¿ú?swü5ã%ÞàÏlÝ$dµ¶ìQV32¼%9õR(¤¥Bo=Ò@½ô	$´éÑ'ÍØ#­å$lJZvGþ½§§÷~zótñÒ½zGÂ_¾Pò=Ø$Ók8(4|OHe	nù,üKÛ~rmÉÇØùDl¡I9Û*Å¸Àf8ß&ÇHÂ#ÇÞ+¥R­#ø^bP{}2!#ìJ{©¼Oá1B(ßWª±%¡±ãÃ²BèRî!Úòa1;â{Ò÷(~hù%ýç·/ÑV&DåYCn ÿ2¹L`|XÑsòéÁjÒ Z{¥_¨\ÇõëýZ¿¶Ò§h4¦¶Ø:ënaPúÕ¡»WïUËÞÐ_]³¹ª× T°ºàE¯A)>\Ãf§gë× _[Ã×Kí^P·ôkPDIr¸.µjw¹ÚdÂèÞA½)ÏQ«ìRSLX"7åZî2> R$IâÉÅOÐ²¸(9àÄÛ%Óo&`¸T)JUø¯>þ¦#¶02¤]`XRöxbÄÉL¶ü+ Õ7 /={þðéó¿=ôèùÃ_²¹µ*Kn%SSîÕ_ÿýýÞ_¿þðêñ7éÔ'ñÂÄ¿üùË¿ÿñ:õ°âÜ/¾}òòéß}õçOÚÛð!±ð®ácï&aûñ?Ä0BÄ@èv¨îËÈ^[ êÂu°íÂÛXÆ¼<¿kÙºñ¹$¯F±Ücvw:àªËððpLÝó¹»Ðkî.J¬ ÷ç3 WâRÙ°eæ¦8ÁÒS¿±C«»Cå×=2âL°ôî¯Ó%Cr`%R.´CbËÂe ÚòÍÞm¯Ã¨kÕ=|d#a[ ê0~©åÆËh.QìR9D15¾dä2rÁG&®/$Dz)óúc,Kæ:õA¿
ãû]Ä6KrèÒ¹3=vØP<sÚLÈÄ~&!EwI|Ù;D=CP²1Ü·	¶Âýf"¸äj'úeÎ±¼½t°eÚ<¶ØµÍ3;:ó©Ú»StÆ{·>sXÐa3Ëç¹ÑW"`ìJ¬+ÈÎUõ`eªkÖ)r+e÷ñm°goqx(ß¤ùDÝJ]8åTzMà5åäÓ)×è0»¿IëYgzî|]p+~o³Ç`_Þ=í¾|j ö·öÍQk<a
Ýþ\D«ZlîØ6FV½äÅÏ²'üwÊws[ñû:(eçD³	÷,kzhÜÀp¬sÖyUs^ÕøÿûªfÓ^>¯eÎkóZÆõöõAj¼|Ê&ïòèO¼±å3!îËÅ»Bw}¼Ñ0¨ÛQº'¹jÎ"ø5,Ü#-ãq&?'2ÚÐZCeÝÀLõTx3& c¤u+Ð­ûNóxÓNg¹¬º©ùx)\CJ¦èZ=ïÞ­Ôë~èTwY(ÙÓaLfQuQ_B^g^ÙXÑtXÑPê¡ZFqå
0mxåöàE½åAÚAfçc§´¼®
ÎFz3©Pb/3 tSÙºqyjuiª½E¤-#t³0Ò0á,;ÍûYÆºÔ2O¹b¹r3êkE"'¸&&SÐÄ;nùµj·*#4kùèÃ×x¹#Ô[¢S¸vInøwa²D:\NÊ1{Ä-_-4Ñ¢m+W>Zã@+qt;Èx2Á#iÝQNáS®pþªÅß¬$ÙÂ½½:ç7¤XX/+rêÍ1°åùwâ`Êh×¼Ò9#:Pv¢dÂ5®ÌÑO+OÙÁ¡ë.<ªö½OÝ7ÕÊsiæg¦Å*êÔté;ä«òCÔ²*¥nýN-r®k.¹ÕyJ¼áÔ}Á0-Ì2MY¼NÃ³³QÛ´3,OÔ6ømuF8=ñ®'?ÈÌZu@,ëJøúÊÜ¼Õfw<zp8§RèPBo#(úÒÈ6`ÜYß¼9'-ÿ~)lÝJØ-a¿TR¡¶«vVËý°\êu*à`Q\Óëú\aÐEvi¯Ç×.îãå-ÍL_Ìµáúâ¾\Ù|qï ûµÊ Ymvjfµ=(½N£ÐìÖ:^­[ïzÝ°Ñ<ð½#ÚÕnPë7
µr·[j%e~£Y¨J;¨·ý ý +c`å)}d¾ ÷j»¶ÿ  ÿÿ PK     ! y¡l¤  R     xl/styles.xml¤UmkÛ0þ>ØúîÊvã,	¶ËÒÔPèÆ ì«bË¨^$gÎÆþûNv^:¶Ñ~NçÓsÏÝsRÒN
´cÆr­2]1Uê«M¿>Á#ë¨ª¨ÐexÏ,¾Éß¿K­Ûö¸eÌ!P6Ã[ç!¶Ü2Iín/µ6:Ø±a´²þ$Ã)+< ,dù? ç¶	J-êøîö=F²\Üo6t-jMhºhjbÔcÞû"ä¥ÑV×î
p®k^²tçdNhyFä×!E		ãÚ;óJ¤	1lÇ½|8Ok­E¥n1¨oÁâYéïªð¼sÊSûí¨ OIZhHë=J6DÜRÁ×û°J.ö;ö^íCäÐ{ï$Ça±pqb{àÈSÏ1£
Ø ý´o ½I`ú¸DoÝGq2:@úyºÖ¦É>÷ãèÊSÁjDßlýêt¿kí¨§§­¨ð¥ 'Ê)~ú¿ÕØ]T+éî«Ã=òM8PÈÁðÇ£ØoE]}#Ú¤Oé×;Ãýu09´n¹p\ý0`VÝ¹¡WÀù«×7ç:Q±¶Â=>følboe|úÂwÚõ>Û^©hês°Î=X/XQkxÞ-?ÌWwEÌÂå,\³$'ËULn«U1ãðö×èxÃõïß«<µ°	s(öPâãÙáÑf ßÏ(ÐsÇÓðcAqFÁdJgÁlzEÅ«édyÉ{òÊg"$Q4<8|²p\2ÁÕQ«£Bc/Û¿AJóAþ  ÿÿ PK     ! Ð°|         xl/sharedStrings.xmlËA
Â0@Ñ½àÂìm¢iÚ'ÐÍØIÈ¢·7ËÏãÏë·dó¡.©²óäÀo5$Þ=¼Ó(rÀ\<üH`]YDÍxY<DÕv·V¶HeªxÈ»ö:²ïVZ'´d{qîj&»ü  ÿÿ PK     ! Ü7=  ]   docProps/core.xml ¢(                                                                                                                                                                                                                                                                  _KÃ0Åß¿CÉ{f1CÛÊNßBr·?$Ý¾½i;ke¾ø{ÎýÝs/)GÕ$à¼4ºB$ËQ!õ®B/Uº@LÖ:GËúúªärãàÉ.HðI$iO¹­Ð>K1ö|ù,:t·Æ)âÓí°eüí Ïò|&X`¸¦v$¢3Rði®éch@ào §ü½2q*N6ît;e>£ûèåhlÛ6k>FÌOðÛúñ¹_5º»TSîãjqÐéOJÝùæÃ:^z+AÜF×¥Y}ô"aèý[y-î6+TÏrræ$-ÈÌéÍæÅ{7øWn(¨óøÿg	ñPøâCÔ_   ÿÿ PK     ! aI	     docProps/app.xml ¢(                                                                                                                                                                                                                                                                  AoÛ0ïúÝ9ÝP¬bHWô°a¶gM¦c¡²$¬ì×¶ÑÔÙzêä{xúDIÝ:_ôÑÅPå¢köxØÝ]~	µñ1@%âF_|RdrG¬DKVR¢m¡3¸`9°ÒÄÜâ6ïelgá6ÚÉ«²¼p 5Ôé(¦ÄUO­£øðqwL¬Õ·¼³øú§³9bl¨ø~°àé¶`_²££.·jk5ëÆx%ßêÌ°´qµêiÕ¥txmW¢ømJô&;±ÛÔµOHY?Åü- ¡lc9÷Îk÷E/GçÆ!`aáqçÈþj6&Ó;ÄË9ñÈ0ñN8Ûo:sÎ7^Oú'{»dÂSõÃg|H»xk^×y>TÛÖd¨ùNë>Ô=o2û!dÝ°úÕó¿0<þãôÃõòzQ~.ù]g3%ßþ²þ  ÿÿ PK-      ! bîh^                     [Content_Types].xmlPK-      ! µU0#ô   L                 _rels/.relsPK-      ! ºpfô  Ê               ¼  xl/workbook.xmlPK-      ! >ó   º               Ý	  xl/_rels/workbook.xml.relsPK-      ! ­DsÁ  ¤                 xl/worksheets/sheet1.xmlPK-      ! Á¾N  Æ                  xl/theme/theme1.xmlPK-      ! y¡l¤  R                 xl/styles.xmlPK-      ! Ð°|                   U  xl/sharedStrings.xmlPK-      ! Ü7=  ]                 docProps/core.xmlPK-      ! aI	                 w  docProps/app.xmlPK    
 
   6    ';

package/treb-export/src/column-width.ts

@@ -0,0 +1,85 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+/**
+ * So here is how Excel column widths work:
+ * 
+ * Column width, as used in the <col/> elements, is
+ * 
+ * "
+ * ...measured as the number of characters of the maximum digit width of the 
+ * numbers 0, 1, 2, ..., 9 as rendered in the normal style's font. There are 
+ * 4 pixels of margin padding (two on each side), plus 1 pixel padding for the 
+ * gridlines.
+ * "
+ * 
+ * https://c-rex.net/projects/samples/ooxml/e1/Part4/OOXML_P4_DOCX_col_topic_ID0ELFQ4.html
+ * 
+ * (good resource, btw)
+ * 
+ * 
+ * ==== THIS IS COMPLETELY FUCKING INSANE ======================================
+ * 
+ * Using the Calibri font as an example, the maximum digit width of 11 point 
+ * font size is 7 pixels (at 96 dpi). In fact, each digit is the same width for 
+ * this font. Therefore if the cell width is 8 characters wide, the value of 
+ * this attribute shall be Truncate([8*7+5]/7*256)/256 = 8.7109375.
+ *
+ * To translate the value of width in the file into the column width value at 
+ * runtime (expressed in terms of pixels), use this calculation:
+ *
+ * =Truncate(((256 * {width} + Truncate(128/{Maximum Digit Width}))/256)*{Maximum Digit Width})
+ * 
+ * Using the same example as above, the calculation would be 
+ * Truncate(((256*8.7109375+Truncate(128/7))/256)*7) = 61 pixels
+ *
+ * To translate from pixels to character width, use this calculation:
+ *
+ * =Truncate(({pixels}-5)/{Maximum Digit Width} * 100+0.5)/100
+ * 
+ * Using the example above, the calculation would be 
+ * Truncate((61-5)/7*100+0.5)/100 = 8 characters.
+ * 
+ * =============================================================================
+ * 
+ * Reading the above, if you want the cell to be *8 characters wide* the value
+ * of the attribute shall be *8.7109375*. 
+ * 
+ * Step 3: Profit!
+ * 
+ */
+
+const MaximumDigitWidth = 7; // @ calibri 11
+
+export const PixelsToColumnWidth = (pixels: number): number => {
+  const characters = Math.floor((pixels - 5) / MaximumDigitWidth * 100 + 0.5) / 100;
+  const column_width = Math.floor((characters * MaximumDigitWidth + 5) / MaximumDigitWidth * 256) / 256;
+
+  // console.info('pixels', pixels, 'characters', characters, 'width', column_width);
+
+  return column_width;
+};
+
+export const ColumnWidthToPixels = (width: number): number => {
+  const pixels = Math.floor(((256 * width + Math.floor(128 / MaximumDigitWidth)) / 256) * MaximumDigitWidth);
+  // console.info('width', width, 'pixels', pixels);
+  return pixels;
+};