@mjhls/mjh-framework 1.0.972-masterdeck-pagination-v1 → 1.0.972-reference-serializer-v1

package/dist/esm/{index-264bbd3c.js → index-e3e16b8b.js}

@@ -10362,6 +10362,504 @@ var BlockTable = function BlockTable(props) {
   );
 };
 
+var bibtexParse = createCommonjsModule(function (module, exports) {
+/* start bibtexParse 0.0.24 */
+
+//Original work by Henrik Muehe (c) 2010
+//
+//CommonJS port by Mikola Lysenko 2013
+//
+//Port to Browser lib by ORCID / RCPETERS
+//
+//Issues:
+//no comment handling within strings
+//no string concatenation
+//no variable values yet
+//Grammar implemented here:
+//bibtex -> (string | preamble | comment | entry)*;
+//string -> '@STRING' '{' key_equals_value '}';
+//preamble -> '@PREAMBLE' '{' value '}';
+//comment -> '@COMMENT' '{' value '}';
+//entry -> '@' key '{' key ',' key_value_list '}';
+//key_value_list -> key_equals_value (',' key_equals_value)*;
+//key_equals_value -> key '=' value;
+//value -> value_quotes | value_braces | key;
+//value_quotes -> '"' .*? '"'; // not quite
+//value_braces -> '{' .*? '"'; // not quite
+(function(exports) {
+
+    function BibtexParser() {
+
+        this.months = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+        this.notKey = [',','{','}',' ','='];
+        this.pos = 0;
+        this.input = "";
+        this.entries = new Array();
+
+        this.currentEntry = "";
+
+        this.setInput = function(t) {
+            this.input = t;
+        };
+
+        this.getEntries = function() {
+            return this.entries;
+        };
+
+        this.isWhitespace = function(s) {
+            return (s == ' ' || s == '\r' || s == '\t' || s == '\n');
+        };
+
+        this.match = function(s, canCommentOut) {
+            if (canCommentOut == undefined || canCommentOut == null)
+                canCommentOut = true;
+            this.skipWhitespace(canCommentOut);
+            if (this.input.substring(this.pos, this.pos + s.length) == s) {
+                this.pos += s.length;
+            } else {
+                throw "Token mismatch, expected " + s + ", found "
+                        + this.input.substring(this.pos);
+            }            this.skipWhitespace(canCommentOut);
+        };
+
+        this.tryMatch = function(s, canCommentOut) {
+            if (canCommentOut == undefined || canCommentOut == null)
+                canCommentOut = true;
+            this.skipWhitespace(canCommentOut);
+            if (this.input.substring(this.pos, this.pos + s.length) == s) {
+                return true;
+            } else {
+                return false;
+            }        };
+
+        /* when search for a match all text can be ignored, not just white space */
+        this.matchAt = function() {
+            while (this.input.length > this.pos && this.input[this.pos] != '@') {
+                this.pos++;
+            }
+            if (this.input[this.pos] == '@') {
+                return true;
+            }            return false;
+        };
+
+        this.skipWhitespace = function(canCommentOut) {
+            while (this.isWhitespace(this.input[this.pos])) {
+                this.pos++;
+            }            if (this.input[this.pos] == "%" && canCommentOut == true) {
+                while (this.input[this.pos] != "\n") {
+                    this.pos++;
+                }                this.skipWhitespace(canCommentOut);
+            }        };
+
+        this.value_braces = function() {
+            var bracecount = 0;
+            this.match("{", false);
+            var start = this.pos;
+            var escaped = false;
+            while (true) {
+                if (!escaped) {
+                    if (this.input[this.pos] == '}') {
+                        if (bracecount > 0) {
+                            bracecount--;
+                        } else {
+                            var end = this.pos;
+                            this.match("}", false);
+                            return this.input.substring(start, end);
+                        }                    } else if (this.input[this.pos] == '{') {
+                        bracecount++;
+                    } else if (this.pos >= this.input.length - 1) {
+                        throw "Unterminated value";
+                    }                }                if (this.input[this.pos] == '\\' && escaped == false)
+                    escaped = true;
+                else
+                    escaped = false;
+                this.pos++;
+            }        };
+
+        this.value_comment = function() {
+            var str = '';
+            var brcktCnt = 0;
+            while (!(this.tryMatch("}", false) && brcktCnt == 0)) {
+                str = str + this.input[this.pos];
+                if (this.input[this.pos] == '{')
+                    brcktCnt++;
+                if (this.input[this.pos] == '}')
+                    brcktCnt--;
+                if (this.pos >= this.input.length - 1) {
+                    throw "Unterminated value:" + this.input.substring(start);
+                }                this.pos++;
+            }            return str;
+        };
+
+        this.value_quotes = function() {
+            this.match('"', false);
+            var start = this.pos;
+            var escaped = false;
+            while (true) {
+                if (!escaped) {
+                    if (this.input[this.pos] == '"') {
+                        var end = this.pos;
+                        this.match('"', false);
+                        return this.input.substring(start, end);
+                    } else if (this.pos >= this.input.length - 1) {
+                        throw "Unterminated value:" + this.input.substring(start);
+                    }                }
+                if (this.input[this.pos] == '\\' && escaped == false)
+                    escaped = true;
+                else
+                    escaped = false;
+                this.pos++;
+            }        };
+
+        this.single_value = function() {
+            var start = this.pos;
+            if (this.tryMatch("{")) {
+                return this.value_braces();
+            } else if (this.tryMatch('"')) {
+                return this.value_quotes();
+            } else {
+                var k = this.key();
+                if (k.match("^[0-9]+$"))
+                    return k;
+                else if (this.months.indexOf(k.toLowerCase()) >= 0)
+                    return k.toLowerCase();
+                else
+                    throw "Value expected:" + this.input.substring(start) + ' for key: ' + k;
+
+            }        };
+
+        this.value = function() {
+            var values = [];
+            values.push(this.single_value());
+            while (this.tryMatch("#")) {
+                this.match("#");
+                values.push(this.single_value());
+            }            return values.join("");
+        };
+
+        this.key = function(optional) {
+            var start = this.pos;
+            while (true) {
+                if (this.pos >= this.input.length) {
+                    throw "Runaway key";
+                }                                // а-яА-Я is Cyrillic
+                //console.log(this.input[this.pos]);
+                if (this.notKey.indexOf(this.input[this.pos]) >= 0) {
+                    if (optional && this.input[this.pos] != ',') {
+                        this.pos = start;
+                        return null;
+                    }                    return this.input.substring(start, this.pos);
+                } else {
+                    this.pos++;
+
+                }            }        };
+
+        this.key_equals_value = function() {
+            var key = this.key();
+            if (this.tryMatch("=")) {
+                this.match("=");
+                var val = this.value();
+                key = key.trim();
+                return [ key, val ];
+            } else {
+                throw "... = value expected, equals sign missing:"
+                        + this.input.substring(this.pos);
+            }        };
+
+        this.key_value_list = function() {
+            var kv = this.key_equals_value();
+            this.currentEntry['entryTags'] = {};
+            this.currentEntry['entryTags'][kv[0]] = kv[1];
+            while (this.tryMatch(",")) {
+                this.match(",");
+                // fixes problems with commas at the end of a list
+                if (this.tryMatch("}")) {
+                    break;
+                }
+                kv = this.key_equals_value();
+                this.currentEntry['entryTags'][kv[0]] = kv[1];
+            }        };
+
+        this.entry_body = function(d) {
+            this.currentEntry = {};
+            this.currentEntry['citationKey'] = this.key(true);
+            this.currentEntry['entryType'] = d.substring(1);
+            if (this.currentEntry['citationKey'] != null) {
+                this.match(",");
+            }
+            this.key_value_list();
+            this.entries.push(this.currentEntry);
+        };
+
+        this.directive = function() {
+            this.match("@");
+            return "@" + this.key();
+        };
+
+        this.preamble = function() {
+            this.currentEntry = {};
+            this.currentEntry['entryType'] = 'PREAMBLE';
+            this.currentEntry['entry'] = this.value_comment();
+            this.entries.push(this.currentEntry);
+        };
+
+        this.comment = function() {
+            this.currentEntry = {};
+            this.currentEntry['entryType'] = 'COMMENT';
+            this.currentEntry['entry'] = this.value_comment();
+            this.entries.push(this.currentEntry);
+        };
+
+        this.entry = function(d) {
+            this.entry_body(d);
+        };
+
+        this.alernativeCitationKey = function () {
+            this.entries.forEach(function (entry) {
+                if (!entry.citationKey && entry.entryTags) {
+                    entry.citationKey = '';
+                    if (entry.entryTags.author) {
+                        entry.citationKey += entry.entryTags.author.split(',')[0] += ', ';
+                    }
+                    entry.citationKey += entry.entryTags.year;
+                }
+            });
+        };
+
+        this.bibtex = function() {
+            while (this.matchAt()) {
+                var d = this.directive();
+                this.match("{");
+                if (d.toUpperCase() == "@STRING") {
+                    this.string();
+                } else if (d.toUpperCase() == "@PREAMBLE") {
+                    this.preamble();
+                } else if (d.toUpperCase() == "@COMMENT") {
+                    this.comment();
+                } else {
+                    this.entry(d);
+                }
+                this.match("}");
+            }
+            this.alernativeCitationKey();
+        };
+    }
+    exports.toJSON = function(bibtex) {
+        var b = new BibtexParser();
+        b.setInput(bibtex);
+        b.bibtex();
+        return b.entries;
+    };
+
+    /* added during hackathon don't hate on me */
+    exports.toBibtex = function(json) {
+        var out = '';
+        for ( var i in json) {
+            out += "@" + json[i].entryType;
+            out += '{';
+            if (json[i].citationKey)
+                out += json[i].citationKey + ', ';
+            if (json[i].entry)
+                out += json[i].entry ;
+            if (json[i].entryTags) {
+                var tags = '';
+                for (var jdx in json[i].entryTags) {
+                    if (tags.length != 0)
+                        tags += ', ';
+                    tags += jdx + '= {' + json[i].entryTags[jdx] + '}';
+                }
+                out += tags;
+            }
+            out += '}\n\n';
+        }
+        return out;
+
+    };
+
+})(exports);
+
+/* end bibtexParse */
+});
+
+var References = function References(_ref) {
+  var node = _ref.node,
+      getSerializers = _ref.getSerializers;
+  var referenceslist = node.referenceslist;
+
+  var getGoogleScholarUrl = function getGoogleScholarUrl(citationText, citationReferenceFormat) {
+    if (citationReferenceFormat == 'Bibtex' && citationText.length > 0 && citationText[0].children && citationText[0].children.length > 0 && citationText[0].children[0].text) {
+      var url = 'https://scholar.google.com/scholar_lookup?';
+      var bibtexJson = bibtexParse.toJSON(citationText[0].children[0].text)[0];
+      if (bibtexJson.entryTags) {
+        if (bibtexJson.entryTags.title) url += 'title=' + bibtexJson.entryTags.title;
+        if (bibtexJson.entryTags.author) {
+          bibtexJson.entryTags.author.split(',').map(function (authorName) {
+            return url += '&author=' + authorName;
+          });
+        }
+        if (bibtexJson.entryTags.year) {
+          url += '&publication_year=' + bibtexJson.entryTags.year;
+        }
+        if (bibtexJson.entryTags.journal) {
+          url += '&journal=' + bibtexJson.entryTags.journal;
+        }
+        if (bibtexJson.entryTags.volume) {
+          url += '&volume=' + bibtexJson.entryTags.volume;
+        }
+        if (bibtexJson.entryTags.pages) {
+          url += '&pages=' + bibtexJson.entryTags.pages.replace('--', '-');
+        }
+      }
+      return url;
+    }
+  };
+  var getPubmedUrl = function getPubmedUrl(citationText, citationReferenceFormat) {
+    if (citationReferenceFormat == 'URL' && citationText.length > 0 && citationText[0].children && citationText[0].children.length > 0 && citationText[0].children[0].text) {
+      return citationText[0].children[0].text;
+    }
+  };
+  var getCrossrefUrl = function getCrossrefUrl(citationText, citationReferenceFormat) {
+    if (citationReferenceFormat == 'URL' && citationText.length > 0 && citationText[0].children && citationText[0].children.length > 0 && citationText[0].children[0].text) {
+      if (citationText[0].children[0].text.includes('dx.doi.org')) {
+        return citationText[0].children[0].text;
+      } else {
+        return 'http://dx.doi.org/' + citationText[0].children[0].text;
+      }
+    }
+  };
+  return React__default.createElement(
+    'div',
+    { className: 'references-list' },
+    React__default.createElement(
+      Head,
+      null,
+      React__default.createElement('script', { src: 'https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js' }),
+      React__default.createElement('script', { src: 'https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js' })
+    ),
+    React__default.createElement(
+      'p',
+      { className: 'reference-title' },
+      React__default.createElement(
+        'strong',
+        null,
+        'REFERENCES'
+      )
+    ),
+    referenceslist && referenceslist.map(function (reference, ref_index) {
+      return React__default.createElement(
+        'div',
+        { key: reference._key, id: reference.referenceID.replace('#', '') + '__container', className: 'reference-container' },
+        React__default.createElement(
+          'div',
+          { className: 'reference-details', style: { display: 'flex', flexDirection: 'row' } },
+          React__default.createElement(
+            'span',
+            null,
+            ref_index + 1,
+            '.\xA0'
+          ),
+          React__default.createElement(BlockContent, { blocks: reference.referenceTitle, serializers: getSerializers })
+        ),
+        reference.citations && reference.citations.length > 0 && React__default.createElement(
+          'div',
+          { className: 'row citations-container ml-3 mr-3 mb-2' },
+          reference.citations.map(function (citation, cit_index) {
+            return React__default.createElement(
+              'div',
+              { key: 'citation_' + cit_index, className: 'mr-3 citation-link' },
+              citation.citationName === 'googleScholar' ? React__default.createElement(
+                'a',
+                { target: '_blank', href: getGoogleScholarUrl(citation.citationText, citation.citationReferenceFormat) },
+                'Google Scholar'
+              ) : citation.citationName === 'pubMed' ? React__default.createElement(
+                'a',
+                { target: '_blank', href: getPubmedUrl(citation.citationText, citation.citationReferenceFormat) },
+                'PubMed'
+              ) : React__default.createElement(
+                'a',
+                { target: '_blank', href: getCrossrefUrl(citation.citationText, citation.citationReferenceFormat) },
+                'Crossref'
+              )
+            );
+          })
+        ),
+        React__default.createElement(
+          'div',
+          {
+            className: 'modal fade',
+            id: '' + reference.referenceID.replace('#', ''),
+            tabindex: '-1',
+            role: 'dialog',
+            'aria-labelledby': 'reference-modal-' + reference.referenceID.replace('#', ''),
+            'aria-hidden': 'true' },
+          React__default.createElement(
+            'div',
+            { className: 'modal-dialog modal-dialog-centered', role: 'document' },
+            React__default.createElement(
+              'div',
+              { className: 'modal-content' },
+              React__default.createElement(
+                'div',
+                { className: 'modal-body' },
+                React__default.createElement(
+                  'button',
+                  { type: 'button', className: 'close', 'data-dismiss': 'modal', 'aria-label': 'Close' },
+                  React__default.createElement(
+                    'span',
+                    { 'aria-hidden': 'true' },
+                    '\xD7'
+                  )
+                ),
+                React__default.createElement(
+                  'div',
+                  { className: 'reference-details', style: { display: 'flex', flexDirection: 'row' } },
+                  React__default.createElement(
+                    'span',
+                    null,
+                    ref_index + 1,
+                    '.\xA0'
+                  ),
+                  React__default.createElement(BlockContent, { blocks: reference.referenceTitle, serializers: getSerializers })
+                ),
+                reference.citations && reference.citations.length > 0 && React__default.createElement(
+                  'div',
+                  { className: 'row citations-container ml-3 mr-3 mb-2' },
+                  reference.citations.map(function (citation, cit_index) {
+                    return React__default.createElement(
+                      'div',
+                      { key: 'citation_' + cit_index, className: 'mr-3 citation-link' },
+                      citation.citationName === 'googleScholar' ? React__default.createElement(
+                        'a',
+                        { target: '_blank', href: getGoogleScholarUrl(citation.citationText, citation.citationReferenceFormat) },
+                        'Google Scholar'
+                      ) : citation.citationName === 'pubMed' ? React__default.createElement(
+                        'a',
+                        { target: '_blank', href: getPubmedUrl(citation.citationText, citation.citationReferenceFormat) },
+                        'PubMed'
+                      ) : React__default.createElement(
+                        'a',
+                        { target: '_blank', href: getCrossrefUrl(citation.citationText, citation.citationReferenceFormat) },
+                        'Crossref'
+                      )
+                    );
+                  })
+                )
+              )
+            )
+          )
+        )
+      );
+    }),
+    React__default.createElement(
+      'style',
+      { jsx: 'true' },
+      '\n        .reference-details p {\n          margin-bottom: 0.5rem;\n        }\n        .citation-link a {\n          text-decoration: none;\n          color: var(--primary);\n          padding: 0.25rem 0.5rem;\n        }\n        .citation-link a:hover {\n          color: #ffffff;\n          background-color: var(--primary);\n          border-radius: 15px;\n        }\n      '
+    )
+  );
+};
+
+var References$1 = React__default.memo(References);
+
 var DigiohSmartTag = function DigiohSmartTag(props) {
   var _props$node = props.node,
       FormID = _props$node.FormID;
@@ -10489,52 +10987,57 @@ var getSerializers = function getSerializers() {
 
         return React__default.createElement(MultiFigure, { node: node, client: client, getSerializers: getSerializers.apply(undefined, props) });
       },
-      slideshow: function slideshow(_ref6) {
+      referencesList: function referencesList(_ref6) {
         var node = _ref6.node;
+
+        return React__default.createElement(References$1, { node: node, client: client, getSerializers: getSerializers.apply(undefined, props) });
+      },
+      slideshow: function slideshow(_ref7) {
+        var node = _ref7.node;
         var slides = node.slides;
 
         return React__default.createElement(Slideshow$1, { slides: slides, client: client, pageview: pageview });
       },
-      sidebar: function sidebar(_ref7) {
-        var node = _ref7.node;
+      sidebar: function sidebar(_ref8) {
+        var node = _ref8.node;
         var caption = node.caption,
             content = node.content;
 
         return React__default.createElement(Sidebar, { caption: caption, content: content, getSerializers: getSerializers.apply(undefined, props) });
       },
-      datatable: function datatable(_ref8) {
-        var node = _ref8.node;
+      datatable: function datatable(_ref9) {
+        var node = _ref9.node;
         var table = node.table;
 
         return React__default.createElement(TableShow, { rows: table.rows });
       },
-      media: function media(_ref9) {
-        var node = _ref9.node;
+      media: function media(_ref10) {
+        var node = _ref10.node;
 
         return React__default.createElement(Media, { node: node, client: client });
       },
-      iframe: function iframe(_ref10) {
-        var node = _ref10.node;
+      iframe: function iframe(_ref11) {
+        var node = _ref11.node;
 
         return React__default.createElement(IFrame, { url: node.url, needSegmentSupport: node.needSegmentSupport });
       },
-      video: function video(_ref11) {
-        var node = _ref11.node;
+      video: function video(_ref12) {
+        var node = _ref12.node;
 
         return React__default.createElement(Video, { node: node, autoplay: autoplay, accountIDs: videoAccountIDs || {}, targeting: targeting, nextVideo: nextVideo });
       },
-      audio: function audio(_ref12) {
-        var node = _ref12.node;
+      audio: function audio(_ref13) {
+        var node = _ref13.node;
 
         return React__default.createElement(Audio, { node: node, audioAutoplay: audioAutoplay });
       },
-      poll: function poll(_ref13) {
-        var node = _ref13.node;
+      poll: function poll(_ref14) {
+        var node = _ref14.node;
 
         return React__default.createElement(Poll$1, { node: node, client: client, pageview: pageview, videoAccountIDs: videoAccountIDs, showVotes: showVotes, onVote: onVote, getSerializers: getSerializers.apply(undefined, props) });
       },
-      pollMultiChoice: function pollMultiChoice(_ref14) {
-        var node = _ref14.node;
+      pollMultiChoice: function pollMultiChoice(_ref15) {
+        var node = _ref15.node;
 
         return React__default.createElement(Poll, {
           node: node,
@@ -10546,31 +11049,31 @@ var getSerializers = function getSerializers() {
           getSerializers: getSerializers.apply(undefined, props)
         });
       },
-      quiz: function quiz(_ref15) {
-        var node = _ref15.node;
+      quiz: function quiz(_ref16) {
+        var node = _ref16.node;
         var quizzes = node.quizzes;
 
         return React__default.createElement(Quiz, { quizzes: quizzes, getSerializers: getSerializers.apply(undefined, props), pageview: pageview, currentPage: currentPage });
       },
-      leads: function leads(_ref16) {
-        var node = _ref16.node;
+      leads: function leads(_ref17) {
+        var node = _ref17.node;
         var leadID = node.leadID;
 
         var url = '' + drupalLeadSettings.baseUrl + leadID;
         return React__default.createElement(Leads, { url: url });
       },
-      slideshows: function slideshows(_ref17) {
-        var node = _ref17.node;
+      slideshows: function slideshows(_ref18) {
+        var node = _ref18.node;
 
         return React__default.createElement(Slideshow, { node: node, client: client, pageview: pageview, getSerializers: getSerializers.apply(undefined, props) });
       },
-      nativeAd: function nativeAd(_ref18) {
-        var node = _ref18.node;
+      nativeAd: function nativeAd(_ref19) {
+        var node = _ref19.node;
 
         return React__default.createElement(NativeAd, { node: node });
       },
-      html_anchor_links: function html_anchor_links(_ref19) {
-        var node = _ref19.node;
+      html_anchor_links: function html_anchor_links(_ref20) {
+        var node = _ref20.node;
 
         return React__default.createElement(AnchorLinkElement, { node: node, getSerializers: getSerializers.apply(undefined, props), articleId: articleId });
       },
@@ -10580,8 +11083,8 @@ var getSerializers = function getSerializers() {
       brtag: function brtag() {
         return React__default.createElement('br', { className: 'line-break' });
       },
-      formstack: function formstack(_ref20) {
-        var node = _ref20.node;
+      formstack: function formstack(_ref21) {
+        var node = _ref21.node;
         var FormID = node.FormID,
             Caption = node.Caption,
             needSegmentSupport = node.needSegmentSupport;
@@ -10590,13 +11093,13 @@ var getSerializers = function getSerializers() {
       },
       formassembly: FormAssembly,
       digiohSmartTag: DigiohSmartTag,
-      multimedia: function multimedia(_ref21) {
-        var node = _ref21.node;
+      multimedia: function multimedia(_ref22) {
+        var node = _ref22.node;
 
         return React__default.createElement(MultiMedia, { node: node, client: client });
       },
-      blockTable: function blockTable(_ref22) {
-        var node = _ref22.node;
+      blockTable: function blockTable(_ref23) {
+        var node = _ref23.node;
         return React__default.createElement(BlockTable, { node: node, client: client, getSerializers: getSerializers.apply(undefined, props) });
       }
     },
@@ -10622,7 +11125,13 @@ var getSerializers = function getSerializers() {
             blank = _props$mark.blank,
             color = _props$mark.color;
 
-
+        if (href && href.charAt(0) === '#' && href.includes('#reference__')) {
+          return React__default.createElement(
+            'a',
+            { 'data-toggle': 'modal', 'data-target': href },
+            children
+          );
+        }
         if (href && href.charAt(0) === '#') {
           var elementId = href.slice(1);
           if (articleId) elementId = elementId + '-' + articleId;
@@ -10642,32 +11151,32 @@ var getSerializers = function getSerializers() {
           children
         ) : children;
       },
-      alignleft: function alignleft(_ref23) {
-        var children = _ref23.children;
+      alignleft: function alignleft(_ref24) {
+        var children = _ref24.children;
         return React__default.createElement(
           'div',
           { style: { textAlign: 'left' } },
           children
         );
       },
-      alignright: function alignright(_ref24) {
-        var children = _ref24.children;
+      alignright: function alignright(_ref25) {
+        var children = _ref25.children;
         return React__default.createElement(
           'div',
           { style: { textAlign: 'right' } },
           children
         );
       },
-      aligncenter: function aligncenter(_ref25) {
-        var children = _ref25.children;
+      aligncenter: function aligncenter(_ref26) {
+        var children = _ref26.children;
         return React__default.createElement(
           'div',
           { style: { textAlign: 'center' } },
           children
         );
       },
-      alignjustify: function alignjustify(_ref26) {
-        var children = _ref26.children;
+      alignjustify: function alignjustify(_ref27) {
+        var children = _ref27.children;
         return React__default.createElement(
           'div',
           { style: { textAlign: 'justify' } },