Context Navigation

← Previous Change
Next Change →

Changeset c6b84df for public/vendors/dataTable/pdfmake-0.1.36/pdfmake.js

Timestamp:

10/21/21 23:45:59 (3 years ago)

Author:

beratkjufliju <kufliju@…>

Branches:

develop, master

Children:

Parents:

Message:

added fileTypes controller, notifications, excel export, edited views

File:

: 1 edited

public/vendors/dataTable/pdfmake-0.1.36/pdfmake.js (modified) (98 diffs)

Legend:

: Unmodified
: Added
: Removed

public/vendors/dataTable/pdfmake-0.1.36/pdfmake.js

-              r6b95845
+              rc6b84df
     var res = encoder.write(str);
     var trail = encoder.end();
     return (trail && trail.length > 0) ? Buffer.concat([res, trail]) : res;
+}
 …
     if (!iconv.encodings)
         iconv.encodings = __webpack_require__(171); // Lazy load all encoding definitions.
     // Canonicalize encoding name: strip all non-alphanumeric chars and appended year.
     var enc = (''+encoding).toLowerCase().replace(/[^0-9a-z]|:\d{4}$/g, "");
 …
                 if (!codecOptions.encodingName)
                     codecOptions.encodingName = enc;
                 enc = codecDef.type;
                 break;
 …
   UnicodeTrie = __webpack_require__(43);
   base64 = __webpack_require__(131);
 …
   this.tag = 0;
   this.bitcount = 0;
   this.dest = dest;
   this.destLen = 0;
   this.ltree = new Tree();  /* dynamic length/symbol tree */
   this.dtree = new Tree();  /* dynamic distance tree */
 …
     d.bitcount += 8;
+  }
   var sum = 0, cur = 0, len = 0;
   var tag = d.tag;
 …
     cur -= t.table[len];
   } while (cur >= 0);
   d.tag = tag;
   d.bitcount -= len;
 …
   var length, invlength;
   var i;
   /* unread from bitbuffer */
   while (d.bitcount > 8) {
 …
       return d.dest.subarray(0, d.destLen);
+  }
   return d.dest;
+}
 …
     return 16;
+  }
   n = br.readBits(3);
   if (n > 0) {
     return 17 + n;
+  }
   n = br.readBits(3);
   if (n > 0) {
     return 8 + n;
+  }
   return 17;
+}
 …
 function DecodeMetaBlockLength(br) {
   var out = new MetaBlockLength;
+  var out = new MetaBlockLength;
   var size_nibbles;
   var size_bytes;
   var i;
   out.input_end = br.readBits(1);
   if (out.input_end && br.readBits(1)) {
     return out;
+  }
   size_nibbles = br.readBits(2) + 4;
   if (size_nibbles === 7) {
     out.is_metadata = true;
     if (br.readBits(1) !== 0)
       throw new Error('Invalid reserved bit');
     size_bytes = br.readBits(2);
     if (size_bytes === 0)
       return out;
     for (i = 0; i < size_bytes; i++) {
       var next_byte = br.readBits(8);
       if (i + 1 === size_bytes && size_bytes > 1 && next_byte === 0)
         throw new Error('Invalid size byte');
       out.meta_block_length |= next_byte << (i * 8);
+    }
 …
       if (i + 1 === size_nibbles && size_nibbles > 4 && next_nibble === 0)
         throw new Error('Invalid size nibble');
       out.meta_block_length |= next_nibble << (i * 4);
+    }
+  }
   ++out.meta_block_length;
   if (!out.input_end && !out.is_metadata) {
     out.is_uncompressed = br.readBits(1);
+  }
   return out;
+}
 …
 function ReadSymbol(table, index, br) {
   var start_index = index;
   var nbits;
   br.fillBitWindow();
 …
   var repeat_code_len = 0;
   var space = 32768;
   var table = [];
   for (var i = 0; i < 32; i++)
     table.push(new HuffmanCode(0, 0));
   BrotliBuildHuffmanTable(table, 0, 5, code_length_code_lengths, CODE_LENGTH_CODES);
 …
     var p = 0;
     var code_len;
     br.readMoreInput();
     br.fillBitWindow();
 …
         throw new Error('[ReadHuffmanCodeLengths] symbol + repeat_delta > num_symbols');
+      }
       for (var x = 0; x < repeat_delta; x++)
         code_lengths[symbol + x] = repeat_code_len;
       symbol += repeat_delta;
       if (repeat_code_len !== 0) {
         space -= repeat_delta << (15 - repeat_code_len);
 …
     throw new Error("[ReadHuffmanCodeLengths] space = " + space);
+  }
   for (; symbol < num_symbols; symbol++)
     code_lengths[symbol] = 0;
 …
   var simple_code_or_skip;
   var code_lengths = new Uint8Array(alphabet_size);
   br.readMoreInput();
   /* simple_code_or_skip is used as follows:
 for simple code;
 …
           throw new Error('[ReadHuffmanCode] invalid symbols');
+        }
         code_lengths[symbols[1]] = 1;
         break;
 …
           throw new Error('[ReadHuffmanCode] invalid symbols');
+        }
         if (br.readBits(1)) {
           code_lengths[symbols[2]] = 3;
 …
     /* Static Huffman code for the code length code lengths */
     var huff = [
       new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2),
+      new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2),
       new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(4, 1),
       new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2),
+      new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2),
       new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(4, 5)
     ];
 …
+      }
+    }
     if (!(num_codes === 1 || space === 0))
       throw new Error('[ReadHuffmanCode] invalid num_codes or space');
     ReadHuffmanCodeLengths(code_length_code_lengths, alphabet_size, code_lengths, br);
+  }
   table_size = BrotliBuildHuffmanTable(tables, table, HUFFMAN_TABLE_BITS, code_lengths, alphabet_size);
   if (table_size === 0) {
     throw new Error("[ReadHuffmanCode] BuildHuffmanTable failed: ");
+  }
   return table_size;
+}
 …
   this.alphabet_size = alphabet_size;
   this.num_htrees = num_htrees;
   this.codes = new Array(num_htrees + num_htrees * kMaxHuffmanTableSize[(alphabet_size + 31) >>> 5]);
+  this.codes = new Array(num_htrees + num_htrees * kMaxHuffmanTableSize[(alphabet_size + 31) >>> 5]);
   this.htrees = new Uint32Array(num_htrees);
+}
 …
   var table;
   var i;
   br.readMoreInput();
   var num_htrees = out.num_htrees = DecodeVarLenUint8(br) + 1;
 …
     max_run_length_prefix = br.readBits(4) + 1;
+  }
   table = [];
   for (i = 0; i < HUFFMAN_MAX_TABLE_SIZE; i++) {
     table[i] = new HuffmanCode(0, 0);
+  }
   ReadHuffmanCode(num_htrees + max_run_length_prefix, table, 0, br);
   for (i = 0; i < context_map_size;) {
     var code;
 …
     InverseMoveToFrontTransform(context_map, context_map_size);
+  }
   return out;
+}
 …
     for (var x = 0; x < tail; x++)
       ringbuffer[rb_pos + x] = br.buf_[br_pos + x];
     nbytes -= tail;
     rb_pos += tail;
 …
   for (var x = 0; x < nbytes; x++)
     ringbuffer[rb_pos + x] = br.buf_[br_pos + x];
   rb_pos += nbytes;
   len -= nbytes;
 …
   if (rb_pos >= rb_size) {
     output.write(ringbuffer, rb_size);
     rb_pos -= rb_size;
+    rb_pos -= rb_size;
     for (var x = 0; x < rb_pos; x++)
       ringbuffer[x] = ringbuffer[rb_size + x];
 …
 function BrotliDecompressBuffer(buffer, output_size) {
   var input = new BrotliInput(buffer);
   if (output_size == null) {
     output_size = BrotliDecompressedSize(buffer);
+  }
   var output_buffer = new Uint8Array(output_size);
   var output = new BrotliOutput(output_buffer);
   BrotliDecompress(input, output);
   if (output.pos < output.buffer.length) {
     output.buffer = output.buffer.subarray(0, output.pos);
+  }
   return output.buffer;
+}
 …
     br.readMoreInput();
     var _out = DecodeMetaBlockLength(br);
     meta_block_remaining_len = _out.meta_block_length;
 …
       tmp.set( output.buffer );
       output.buffer = tmp;
+    }
+    }
     input_end = _out.input_end;
     is_uncompressed = _out.is_uncompressed;
     if (_out.is_metadata) {
       JumpToByteBoundary(br);
       for (; meta_block_remaining_len > 0; --meta_block_remaining_len) {
         br.readMoreInput();
 …
         br.readBits(8);
+      }
       continue;
+    }
     if (meta_block_remaining_len === 0) {
       continue;
+    }
     if (is_uncompressed) {
       br.bit_pos_ = (br.bit_pos_ + 7) & ~7;
 …
       continue;
+    }
     for (i = 0; i < 3; ++i) {
       num_block_types[i] = DecodeVarLenUint8(br) + 1;
 …
+      }
+    }
     br.readMoreInput();
     distance_postfix_bits = br.readBits(2);
     num_direct_distance_codes = NUM_DISTANCE_SHORT_CODES + (br.readBits(4) << distance_postfix_bits);
 …
        context_modes[i] = (br.readBits(2) << 1);
+    }
     var _o1 = DecodeContextMap(num_block_types[0] << kLiteralContextBits, br);
     num_literal_htrees = _o1.num_htrees;
     context_map = _o1.context_map;
     var _o2 = DecodeContextMap(num_block_types[2] << kDistanceContextBits, br);
     num_dist_htrees = _o2.num_htrees;
     dist_context_map = _o2.context_map;
     hgroup[0] = new HuffmanTreeGroup(kNumLiteralCodes, num_literal_htrees);
     hgroup[1] = new HuffmanTreeGroup(kNumInsertAndCopyCodes, num_block_types[1]);
 …
       br.readMoreInput();
       if (block_length[1] === 0) {
         DecodeBlockType(num_block_types[1],
 …
       if (distance_code < 0) {
         var context;
         br.readMoreInput();
         if (block_length[2] === 0) {
 …
             if (copy_dst >= ringbuffer_end) {
               output.write(ringbuffer, ringbuffer_size);
               for (var _x = 0; _x < (copy_dst - ringbuffer_end); _x++)
                 ringbuffer[_x] = ringbuffer[ringbuffer_end + _x];
 …
     count = this.buffer.length - this.pos;
+  }
   for (var p = 0; p < count; p++)
     buf[i + p] = this.buffer[this.pos + p];
   this.pos += count;
   return count;
 …
   if (this.pos + count > this.buffer.length)
     throw new Error('Output buffer is not large enough');
   this.buffer.set(buf.subarray(0, count), this.pos);
   this.pos += count;
 …
+    }
+  }
   table_bits = root_bits;
   table_size = 1 << table_bits;
 …
       root_table[table + key] = new HuffmanCode(0, sorted[0] & 0xffff);
+    }
     return total_size;
+  }
 …
+    }
+  }
   return total_size;
+}
 …
 /*
 PDFImage - embeds images in PDF documents
+PDFImage - embeds images in PDF folders
 By Devon Govett
  */
 …
  * var docDefinition = {
  *      info: {
  *              title: 'awesome Document',
+ *              title: 'awesome Folder',
  *              author: 'john doe',
  *              subject: 'subject of document',
 …
       this._font = null;
       this._registeredFonts = {};
     },
     font: function(src, family, size) {
 …
 // ISO (deprecated)
 [], { // windows
+[], { // windows
 x0436: 'af', 0x4009: 'en-IN', 0x0487: 'rw', 0x0432: 'tn',
 x041C: 'sq', 0x1809: 'en-IE', 0x0441: 'sw', 0x045B: 'si',
 …
  *   - apply ljmo, vjmo, and tjmo OpenType features to decomposed Jamo sequences.
+ *
  * This logic is based on the following documents:
+ * This logic is based on the following folders:
  *   - http://www.microsoft.com/typography/OpenTypeDev/hangul/intro.htm
  *   - http://ktug.org/~nomos/harfbuzz-hangul/hangulshaper.pdf
 …
 ];
 // Put all encoding/alias/codec definitions to single object and export it.
+// Put all encoding/alias/codec definitions to single object and export it.
 for (var i = 0; i < modules.length; i++) {
     var module = modules[i];
 …
 InternalDecoderCesu8.prototype.write = function(buf) {
     var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes,
+    var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes,
         res = '';
     for (var i = 0; i < buf.length; i++) {
 …
         this.initialBytes.push(buf);
         this.initialBytesLen += buf.length;
         if (this.initialBytesLen < 16) // We need more bytes to use space heuristic (see below)
             return '';
 …
     // Non-direct chars are encoded as "+<base64>-"; single "+" char is encoded as "+-".
     return new Buffer(str.replace(nonDirectChars, function(chunk) {
         return "+" + (chunk === '+' ? '' :
             this.iconv.encode(chunk, 'utf16-be').toString('base64').replace(/=+$/, ''))
+        return "+" + (chunk === '+' ? '' :
+            this.iconv.encode(chunk, 'utf16-be').toString('base64').replace(/=+$/, ''))
             + "-";
     }.bind(this)));
 …
     base64Chars[i] = base64Regex.test(String.fromCharCode(i));
 var plusChar = '+'.charCodeAt(0),
+var plusChar = '+'.charCodeAt(0),
     minusChar = '-'.charCodeAt(0),
     andChar = '&'.charCodeAt(0);
 …
 // Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that
 // correspond to encoded bytes (if 128 - then lower half is ASCII).
+// correspond to encoded bytes (if 128 - then lower half is ASCII).
 exports._sbcs = SBCSCodec;
 …
     if (!codecOptions)
         throw new Error("SBCS codec is called without the data.")
     // Prepare char buffer for decoding.
     if (!codecOptions.chars || (codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256))
         throw new Error("Encoding '"+codecOptions.type+"' has incorrect 'chars' (must be of len 128 or 256)");
     if (codecOptions.chars.length === 128) {
         var asciiString = "";
 …
     this.decodeBuf = new Buffer(codecOptions.chars, 'ucs2');
     // Encoding buffer.
     var encodeBuf = new Buffer(65536);
 …
     for (var i = 0; i < str.length; i++)
         buf[i] = this.encodeBuf[str.charCodeAt(i)];
     return buf;
+}
 …
     this.decodeTables[0] = UNASSIGNED_NODE.slice(0); // Create root node.
     // Sometimes a MBCS char corresponds to a sequence of unicode chars. We store them as arrays of integers here.
+    // Sometimes a MBCS char corresponds to a sequence of unicode chars. We store them as arrays of integers here.
     this.decodeTableSeq = [];
 …
     this.defaultCharUnicode = iconv.defaultCharUnicode;
     // Encode tables: Unicode -> DBCS.
 …
     //         <= SEQ_START  -> it's an index in encodeTableSeq, see below. The character starts a sequence.
     this.encodeTable = [];
     // `encodeTableSeq` is used when a sequence of unicode characters is encoded as a single code. We use a tree of
     // objects where keys correspond to characters in sequence and leafs are the encoded dbcs values. A special DEF_CHAR key
 …
                     skipEncodeChars[j] = true;
+        }
     // Use decode trie to recursively fill out encode tables.
     this._fillEncodeTable(0, 0, skipEncodeChars);
 …
         for (var i = 0x30; i <= 0x39; i++)
             fourthByteNode[i] = GB18030_CODE
+    }
+    }
+}
 …
                     writeTable[curAddr++] = code; // Basic char
+            }
+        }
+        }
         else if (typeof part === "number") { // Integer, meaning increasing sequence starting with prev character.
             var charCode = writeTable[curAddr - 1] + 1;
 …
 DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {
     // Get the root of character tree according to first character of the sequence.
     var uCode = seq[0];
 …
     this.leadSurrogate = -1;
     this.seqObj = undefined;
     // Static data
     this.encodeTable = codec.encodeTable;
 …
 DBCSEncoder.prototype.write = function(str) {
     var newBuf = new Buffer(str.length * (this.gb18030 ? 4 : 3)),
+    var newBuf = new Buffer(str.length * (this.gb18030 ? 4 : 3)),
         leadSurrogate = this.leadSurrogate,
         seqObj = this.seqObj, nextChar = -1,
 …
         else {
             var uCode = nextChar;
             nextChar = -1;
+            nextChar = -1;
+        }
 …
                     uCode = UNASSIGNED;
+                }
+            }
+        }
 …
             if (subtable !== undefined)
                 dbcsCode = subtable[uCode & 0xFF];
             if (dbcsCode <= SEQ_START) { // Sequence start
                 seqObj = this.encodeTableSeq[SEQ_START-dbcsCode];
 …
         if (dbcsCode === UNASSIGNED)
             dbcsCode = this.defaultCharSingleByte;
         if (dbcsCode < 0x100) {
             newBuf[j++] = dbcsCode;
 …
         this.leadSurrogate = -1;
+    }
     return newBuf.slice(0, j);
+}
 …
 DBCSDecoder.prototype.write = function(buf) {
     var newBuf = new Buffer(buf.length*2),
         nodeIdx = this.nodeIdx,
+        nodeIdx = this.nodeIdx,
         prevBuf = this.prevBuf, prevBufOffset = this.prevBuf.length,
         seqStart = -this.prevBuf.length, // idx of the start of current parsed sequence.
 …
     if (prevBufOffset > 0) // Make prev buf overlap a little to make it easier to slice later.
         prevBuf = Buffer.concat([prevBuf, buf.slice(0, 10)]);
     for (var i = 0, j = 0; i < buf.length; i++) {
         var curByte = (i >= 0) ? buf[i] : prevBuf[i + prevBufOffset];
 …
         var uCode = this.decodeTables[nodeIdx][curByte];
         if (uCode >= 0) {
+        if (uCode >= 0) {
             // Normal character, just use it.
+        }
 …
         // Write the character to buffer, handling higher planes using surrogate pair.
         if (uCode > 0xFFFF) {
+        if (uCode > 0xFFFF) {
             uCode -= 0x10000;
             var uCodeLead = 0xD800 + Math.floor(uCode / 0x400);
 …
 module.exports = {
     // == Japanese/ShiftJIS ====================================================
     // All japanese encodings are based on JIS X set of standards:
     // JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF.
     // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes.
+    // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes.
     //              Has several variations in 1978, 1983, 1990 and 1997.
     // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.
 …
     //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.
     //               Used as-is in ISO2022 family.
     //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII,
+    //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII,
     //                0201-1976 Roman, 0208-1978, 0208-1983.
     //  * ISO2022-JP-1: Adds esc seq for 0212-1990.
 …
     //  * Big5-2003 (Taiwan standard) almost superset of cp950.
     //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.
     //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard.
+    //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard.
     //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.
     //    Plus, it has 4 combining sequences.
 …
     //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt
     //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt
     //
+    //
     // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder
     // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.
 …
 // == Exports ==================================================================
 module.exports = function(iconv) {
     // Additional Public API.
     iconv.encodeStream = function encodeStream(encoding, options) {
 …
     try {
         var res = this.conv.end();
         if (res && res.length) this.push(res, this.encoding);
+        if (res && res.length) this.push(res, this.encoding);
         done();
+    }
 …
         var nodeNativeEncodings = {
             'hex': true, 'utf8': true, 'utf-8': true, 'ascii': true, 'binary': true,
+            'hex': true, 'utf8': true, 'utf-8': true, 'ascii': true, 'binary': true,
             'base64': true, 'ucs2': true, 'ucs-2': true, 'utf16le': true, 'utf-16le': true,
         };
 …
   this.buf_ = new Uint8Array(BROTLI_IBUF_SIZE);
   this.input_ = input;    /* input callback */
   this.reset();
+}
 …
   this.bit_end_pos_ = 0;  /* bit-reading end position from LSB of val_ */
   this.eos_ = 0;          /* input stream is finished */
   this.readMoreInput();
   for (var i = 0; i < 4; i++) {
 …
     ++this.pos_;
+  }
   return this.bit_end_pos_ > 0;
 };
 …
       throw new Error('Unexpected end of input');
+    }
     if (bytes_read < BROTLI_READ_SIZE) {
       this.eos_ = 1;
 …
         this.buf_[dst + bytes_read + p] = 0;
+    }
     if (dst === 0) {
       /* Copy the head of the ringbuffer to the slack region. */
 …
       this.buf_ptr_ = 0;
+    }
     this.bit_end_pos_ += bytes_read << 3;
+  }
 …
 /* Guarantees that there are at least 24 bits in the buffer. */
 BrotliBitReader.prototype.fillBitWindow = function() {
+BrotliBitReader.prototype.fillBitWindow = function() {
   while (this.bit_pos_ >= 8) {
     this.val_ >>>= 8;
 …
     this.fillBitWindow();
+  }
   var val = ((this.val_ >>> this.bit_pos_) & kBitMask[n_bits]);
   this.bit_pos_ += n_bits;
 …
 /**
  * The normal dictionary-data.js is quite large, which makes it
  * unsuitable for browser usage. In order to make it smaller,
+ * The normal dictionary-data.js is quite large, which makes it
+ * unsuitable for browser usage. In order to make it smaller,
  * we read dictionary.bin, which is a compressed version of
  * the dictionary, and on initial load, Brotli decompresses
+ * the dictionary, and on initial load, Brotli decompresses
  * it's own dictionary. 😜
  */
 …
   this.transform = transform;
   this.suffix = new Uint8Array(suffix.length);
   for (var i = 0; i < prefix.length; i++)
     this.prefix[i] = prefix.charCodeAt(i);
   for (var i = 0; i < suffix.length; i++)
     this.suffix[i] = suffix.charCodeAt(i);
 …
     return 1;
+  }
   /* An overly simplified uppercasing model for utf-8. */
   if (p[i] < 0xe0) {
 …
     return 2;
+  }
   /* An arbitrary transform for three byte characters. */
   p[i + 2] ^= 5;
 …
   var start_idx = idx;
   var uppercase;
   if (skip > len) {
     skip = len;
+  }
   var prefix_pos = 0;
   while (prefix_pos < prefix.length) {
     dst[idx++] = prefix[prefix_pos++];
+  }
   word += skip;
   len -= skip;
   if (t <= kOmitLast9) {
     len -= t;
+  }
   for (i = 0; i < len; i++) {
     dst[idx++] = BrotliDictionary.dictionary[word + i];
+  }
   uppercase = idx - len;
   if (t === kUppercaseFirst) {
     ToUpperCase(dst, uppercase);
 …
+    }
+  }
   var suffix_pos = 0;
   while (suffix_pos < suffix.length) {
     dst[idx++] = suffix[suffix_pos++];
+  }
   return idx - start_idx;
+}
 …
 # MIT LICENSE
 # Copyright (c) 2011 Devon Govett
+#
 # Permission is hereby granted, free of charge, to any person obtaining a copy of this
 # software and associated documentation files (the "Software"), to deal in the Software
 # without restriction, including without limitation the rights to use, copy, modify, merge,
 # publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this
+# software and associated documentation files (the "Software"), to deal in the Software
+# without restriction, including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
 # to whom the Software is furnished to do so, subject to the following conditions:
+#
 # The above copyright notice and this permission notice shall be included in all copies or
+#
+# The above copyright notice and this permission notice shall be included in all copies or
 # substantial portions of the Software.
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 # BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 # DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

Note: See TracChangeset for help on using the changeset viewer.

Download in other formats: