https://learnercommunity.com/Scripts/akamai/resources/js/dash.all.debug.js

1(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
2/* $Date: 2007-06-12 18:02:31 $ */
3
4// from: http://bannister.us/weblog/2007/06/09/simple-base64-encodedecode-javascript/
5// Handles encode/decode of ASCII and Unicode strings.
6
7'use strict';
8
9var UTF8 = {};
10UTF8.encode = function (s) {
11    var u = [];
12    for (var i = 0; i < s.length; ++i) {
13        var c = s.charCodeAt(i);
14        if (c < 0x80) {
15            u.push(c);
16        } else if (c < 0x800) {
17            u.push(0xC0 | c >> 6);
18            u.push(0x80 | 63 & c);
19        } else if (c < 0x10000) {
20            u.push(0xE0 | c >> 12);
21            u.push(0x80 | 63 & c >> 6);
22            u.push(0x80 | 63 & c);
23        } else {
24            u.push(0xF0 | c >> 18);
25            u.push(0x80 | 63 & c >> 12);
26            u.push(0x80 | 63 & c >> 6);
27            u.push(0x80 | 63 & c);
28        }
29    }
30    return u;
31};
32UTF8.decode = function (u) {
33    var a = [];
34    var i = 0;
35    while (i < u.length) {
36        var v = u[i++];
37        if (v < 0x80) {
38            // no need to mask byte
39        } else if (v < 0xE0) {
40                v = (31 & v) << 6;
41                v |= 63 & u[i++];
42            } else if (v < 0xF0) {
43                v = (15 & v) << 12;
44                v |= (63 & u[i++]) << 6;
45                v |= 63 & u[i++];
46            } else {
47                v = (7 & v) << 18;
48                v |= (63 & u[i++]) << 12;
49                v |= (63 & u[i++]) << 6;
50                v |= 63 & u[i++];
51            }
52        a.push(String.fromCharCode(v));
53    }
54    return a.join('');
55};
56
57var BASE64 = {};
58(function (T) {
59    var encodeArray = function encodeArray(u) {
60        var i = 0;
61        var a = [];
62        var n = 0 | u.length / 3;
63        while (0 < n--) {
64            var v = (u[i] << 16) + (u[i + 1] << 8) + u[i + 2];
65            i += 3;
66            a.push(T.charAt(63 & v >> 18));
67            a.push(T.charAt(63 & v >> 12));
68            a.push(T.charAt(63 & v >> 6));
69            a.push(T.charAt(63 & v));
70        }
71        if (2 == u.length - i) {
72            var v = (u[i] << 16) + (u[i + 1] << 8);
73            a.push(T.charAt(63 & v >> 18));
74            a.push(T.charAt(63 & v >> 12));
75            a.push(T.charAt(63 & v >> 6));
76            a.push('=');
77        } else if (1 == u.length - i) {
78            var v = u[i] << 16;
79            a.push(T.charAt(63 & v >> 18));
80            a.push(T.charAt(63 & v >> 12));
81            a.push('==');
82        }
83        return a.join('');
84    };
85    var R = (function () {
86        var a = [];
87        for (var i = 0; i < T.length; ++i) {
88            a[T.charCodeAt(i)] = i;
89        }
90        a['='.charCodeAt(0)] = 0;
91        return a;
92    })();
93    var decodeArray = function decodeArray(s) {
94        var i = 0;
95        var u = [];
96        var n = 0 | s.length / 4;
97        while (0 < n--) {
98            var v = (R[s.charCodeAt(i)] << 18) + (R[s.charCodeAt(i + 1)] << 12) + (R[s.charCodeAt(i + 2)] << 6) + R[s.charCodeAt(i + 3)];
99            u.push(255 & v >> 16);
100            u.push(255 & v >> 8);
101            u.push(255 & v);
102            i += 4;
103        }
104        if (u) {
105            if ('=' == s.charAt(i - 2)) {
106                u.pop();
107                u.pop();
108            } else if ('=' == s.charAt(i - 1)) {
109                u.pop();
110            }
111        }
112        return u;
113    };
114    var ASCII = {};
115    ASCII.encode = function (s) {
116        var u = [];
117        for (var i = 0; i < s.length; ++i) {
118            u.push(s.charCodeAt(i));
119        }
120        return u;
121    };
122    ASCII.decode = function (u) {
123        for (var i = 0; i < s.length; ++i) {
124            a[i] = String.fromCharCode(a[i]);
125        }
126        return a.join('');
127    };
128    BASE64.decodeArray = function (s) {
129        var u = decodeArray(s);

321: 13, 0x14: 15 };
322    var rowsLowCh2 = { 0x19: 1, 0x1A: 3, 0x1D: 5, 0x1E: 7, 0x1F: 9, 0x18: 11, 0x1B: 12, 0x1C: 14 };
323    var rowsHighCh2 = { 0x19: 2, 0x1A: 4, 0x1D: 6, 0x1E: 8, 0x1F: 10, 0x1B: 13, 0x1C: 15 };
324
325    var backgroundColors = ['white', 'green', 'blue', 'cyan', 'red', 'yellow', 'magenta', 'black', 'transparent'];
326
327    /**
328     * Simple logger class to be able to write with time-stamps and filter on level.
329     */
330    var logger = {
331        verboseFilter: { 'DATA': 3, 'DEBUG': 3, 'INFO': 2, 'WARNING': 2, 'TEXT': 1, 'ERROR': 0 },
332        time: null,
333        verboseLevel: 0, // Only write errors
334        setTime: function setTime(newTime) {
335            this.time = newTime;
336        },
337        log: function log(severity, msg) {
338            var minLevel = this.verboseFilter[severity];
339            if (this.verboseLevel >= minLevel) {
340                console.log(this.time + " [" + severity + "] " + msg);
341            }
342        }
343    };
344
345    var numArrayToHexArray = function numArrayToHexArray(numArray) {
346        var hexArray = [];
347        for (var j = 0; j < numArray.length; j++) {
348            hexArray.push(numArray[j].toString(16));
349        }
350        return hexArray;
351    };
352
353    /**
354     * State of CEA-608 pen or character
355     * @constructor
356     */
357    var PenState = function PenState(foreground, underline, italics, background, flash) {
358        this.foreground = foreground || "white";
359        this.underline = underline || false;
360        this.italics = italics || false;
361        this.background = background || "black";
362        this.flash = flash || false;
363    };
364
365    PenState.prototype = {
366
367        reset: function reset() {
368            this.foreground = "white";
369            this.underline = false;
370            this.italics = false;
371            this.background = "black";
372            this.flash = false;
373        },
374
375        setStyles: function setStyles(styles) {
376            var attribs = ["foreground", "underline", "italics", "background", "flash"];
377            for (var i = 0; i < attribs.length; i++) {
378                var style = attribs[i];
379                if (styles.hasOwnProperty(style)) {
380                    this[style] = styles[style];
381                }
382            }
383        },
384
385        isDefault: function isDefault() {
386            return this.foreground === "white" && !this.underline && !this.italics && this.background === "black" && !this.flash;
387        },
388
389        equals: function equals(other) {
390            return this.foreground === other.foreground && this.underline === other.underline && this.italics === other.italics && this.background === other.background && this.flash === other.flash;
391        },
392
393        copy: function copy(newPenState) {
394            this.foreground = newPenState.foreground;
395            this.underline = newPenState.underline;
396            this.italics = newPenState.italics;
397            this.background = newPenState.background;
398            this.flash = newPenState.flash;
399        },
400
401        toString: function toString() {
402            return "color=" + this.foreground + ", underline=" + this.underline + ", italics=" + this.italics + ", background=" + this.background + ", flash=" + this.flash;
403        }
404    };
405
406    /**
407     * Unicode character with styling and background.
408     * @constructor
409     */
410    var StyledUnicodeChar = function StyledUnicodeChar(uchar, foreground, underline, italics, background, flash) {
411        this.uchar = uchar || ' '; // unicode character
412        this.penState = new PenState(foreground, underline, italics, background, flash);
413    };
414
415    StyledUnicodeChar.prototype = {
416
417        reset: function reset() {
418            this.uchar = ' ';
419            this.penState.reset();
420        },
421
422        setChar: function setChar(uchar, newPenState) {
423            this.uchar = uchar;
424            this.penState.copy(newPenState);
425        },
426
427        setPenState: function setPenState(newPenState) {
428            this.penState.copy(newPenState);
429        },
430
431        equals: function equals(other) {
432            return this.uchar === other.uchar && this.penState.equals(other.penState);
433        },
434
435        copy: function copy(newChar) {
436            this.uchar = newChar.uchar;
437            this.penState.copy(newChar.penState);
438        },
439
440        isEmpty: function isEmpty() {
441            return this.uchar === ' ' && this.penState.isDefault();
442        }
443    };
444
445    /**
446     * CEA-608 row consisting of NR_COLS instances of StyledUnicodeChar.
447     * @constructor
448     */
449    var Row = function Row() {
450        this.chars = [];
451        for (var i = 0; i < NR_COLS; i++) {
452            this.chars.push(new StyledUnicodeChar());
453        }
454        this.pos = 0;
455        this.currPenState = new PenState();
456    };
457
458    Row.prototype = {
459
460        equals: function equals(other) {
461            var equal = true;
462            for (var i = 0; i < NR_COLS; i++) {
463                if (!this.chars[i].equals(other.chars[i])) {
464                    equal = false;
465                    break;
466                }
467            }
468            return equal;
469        },
470
471        copy: function copy(other) {
472            for (var i = 0; i < NR_COLS; i++) {
473                this.chars[i].copy(other.chars[i]);
474            }
475        },
476
477        isEmpty: function isEmpty() {
478            var empty = true;
479            for (var i = 0; i < NR_COLS; i++) {
480                if (!this.chars[i].isEmpty()) {
481                    empty = false;
482                    break;
483                }
484            }
485            return empty;
486        },
487
488        /**
489         *  Set the cursor to a valid column.
490         */
491        setCursor: function setCursor(absPos) {
492            if (this.pos !== absPos) {
493                this.pos = absPos;
494            }
495            if (this.pos < 0) {
496                logger.log("ERROR", "Negative cursor position " + this.pos);
497                this.pos = 0;
498            } else if (this.pos > NR_COLS) {
499                logger.log("ERROR", "Too large cursor position " + this.pos);
500                this.pos = NR_COLS;
501            }
502        },
503
504        /** 
505         * Move the cursor relative to current position.
506         */
507        moveCursor: function moveCursor(relPos) {
508            var newPos = this.pos + relPos;
509            if (relPos > 1) {
510                for (var i = this.pos + 1; i < newPos + 1; i++) {
511                    this.chars[i].setPenState(this.currPenState);
512                }
513            }
514            this.setCursor(newPos);
515        },
516
517        /**
518         * Backspace, move one step back and clear character.
519         */
520        backSpace: function backSpace() {
521            this.moveCursor(-1);
522            this.chars[this.pos].setChar(' ', this.currPenState);
523        },
524
525        insertChar: function insertChar(byte) {
526            if (byte >= 0x90) {
527                //Extended char
528                this.backSpace();
529            }
530            var char = getCharForByte(byte);
531            if (this.pos >= NR_COLS) {
532                logger.log("ERROR", "Cannot insert " + byte.toString(16) + " (" + char + ") at position " + this.pos + ". Skipping it!");
533                return;
534            }
535            this.chars[this.pos].setChar(char, this.currPenState);
536            this.moveCursor(1);
537        },
538
539        clearFromPos: function clearFromPos(startPos) {
540            var i;
541            for (i = startPos; i < NR_COLS; i++) {
542                this.chars[i].reset();
543            }
544        },
545
546        clear: function clear() {
547            this.clearFromPos(0);
548            this.pos = 0;
549            this.currPenState.reset();
550        },
551
552        clearToEndOfRow: function clearToEndOfRow() {
553            this.clearFromPos(this.pos);
554        },
555
556        getTextString: function getTextString() {
557            var chars = [];
558            var empty = true;
559            for (var i = 0; i < NR_COLS; i++) {
560                var char = this.chars[i].uchar;
561                if (char !== " ") {
562                    empty = false;
563                }
564                chars.push(char);
565            }
566            if (empty) {
567                return "";
568            } else {
569                return chars.join("");
570            }
571        },
572
573        setPenStyles: function setPenStyles(styles) {
574            this.currPenState.setStyles(styles);
575            var currChar = this.chars[this.pos];
576            currChar.setPenState(this.currPenState);
577        }
578    };
579
580    /**
581     * Keep a CEA-608 screen of 32x15 styled characters
582     * @constructor
583    */
584    var CaptionScreen = function CaptionScreen() {
585
586        this.rows = [];
587        for (var i = 0; i < NR_ROWS; i++) {
588            this.rows.push(new Row()); // Note that we use zero-based numbering (0-14)
589        }
590        this.currRow = NR_ROWS - 1;
591        this.nrRollUpRows = null;
592        this.reset();
593    };
594
595    CaptionScreen.prototype = {
596
597        reset: function reset() {
598            for (var i = 0; i < NR_ROWS; i++) {
599                this.rows[i].clear();
600            }
601            this.currRow = NR_ROWS - 1;
602        },
603
604        equals: function equals(other) {
605            var equal = true;
606            for (var i = 0; i < NR_ROWS; i++) {
607                if (!this.rows[i].equals(other.rows[i])) {
608                    equal = false;
609                    break;
610                }
611            }
612            return equal;
613        },
614
615        copy: function copy(other) {
616            for (var i = 0; i < NR_ROWS; i++) {
617                this.rows[i].copy(other.rows[i]);
618            }
619        },
620
621        isEmpty: function isEmpty() {
622            var empty = true;
623            for (var i = 0; i < NR_ROWS; i++) {
624                if (!this.rows[i].isEmpty()) {
625                    empty = false;
626                    break;
627                }
628            }
629            return empty;
630        },
631
632        backSpace: function backSpace() {
633            var row = this.rows[this.currRow];
634            row.backSpace();
635        },
636
637        clearToEndOfRow: function clearToEndOfRow() {
638            var row = this.rows[this.currRow];
639            row.clearToEndOfRow();
640        },
641
642        /**
643         * Insert a character (without styling) in the current row.
644         */
645        insertChar: function insertChar(char) {
646            var row = this.rows[this.currRow];
647            row.insertChar(char);
648        },
649
650        setPen: function setPen(styles) {
651            var row = this.rows[this.currRow];
652            row.setPenStyles(styles);
653        },
654
655        moveCursor: function moveCursor(relPos) {
656            var row = this.rows[this.currRow];
657            row.moveCursor(relPos);
658        },
659
660        setCursor: function setCursor(absPos) {
661            logger.log("INFO", "setCursor: " + absPos);
662            var row = this.rows[this.currRow];
663            row.setCursor(absPos);
664        },
665
666        setPAC: function setPAC(pacData) {
667            logger.log("INFO", "pacData = " + JSON.stringify(pacData));
668            var newRow = pacData.row - 1;
669            if (this.nrRollUpRows && newRow < this.nrRollUpRows - 1) {
670                newRow = this.nrRollUpRows - 1;
671            }
672            this.currRow = newRow;
673            var row = this.rows[this.currRow];
674            if (pacData.indent !== null) {
675                var indent = pacData.indent;
676                var prevPos = Math.max(indent - 1, 0);
677                row.setCursor(pacData.indent);
678                pacData.color = row.chars[prevPos].penState.foreground;
679            }
680            var styles = { foreground: pacData.color, underline: pacData.underline, italics: pacData.italics, background: 'black', flash: false };
681            this.setPen(styles);
682        },
683
684        /**
685         * Set background/extra foreground, but first do back_space, and then insert space (backwards compatibility).
686         */
687        setBkgData: function setBkgData(bkgData) {
688
689            logger.log("INFO", "bkgData = " + JSON.stringify(bkgData));
690            this.backSpace();
691            this.setPen(bkgData);
692            this.insertChar(0x20); //Space
693        },
694
695        setRollUpRows: function setRollUpRows(nrRows) {
696            this.nrRollUpRows = nrRows;
697        },
698
699        rollUp: function rollUp() {
700            if (this.nrRollUpRows === null) {
701                logger.log("DEBUG", "roll_up but nrRollUpRows not set yet");
702                return; //Not properly setup
703            }
704            logger.log("TEXT", this.getDisplayText());
705            var topRowIndex = this.currRow + 1 - this.nrRollUpRows;
706            var topRow = this.rows.splice(topRowIndex, 1)[0];
707            topRow.clear();
708            this.rows.splice(this.currRow, 0, topRow);
709            logger.log("INFO", "Rolling up");
710            //logger.log("TEXT", this.get_display_text())
711        },
712
713        /**
714         * Get all non-empty rows with as unicode text. 
715         */
716        getDisplayText: function getDisplayText(asOneRow) {
717            asOneRow = asOneRow || false;
718            var displayText = [];
719            var text = "";
720            var rowNr = -1;
721            for (var i = 0; i < NR_ROWS; i++) {
722                var rowText = this.rows[i].getTextString();
723                if (rowText) {
724                    rowNr = i + 1;
725                    if (asOneRow) {
726                        displayText.push("Row " + rowNr + ': "' + rowText + '"');
727                    } else {
728                        displayText.push(rowText.trim());
729                    }
730                }
731            }
732            if (displayText.length > 0) {
733                if (asOneRow) {
734                    text = "[" + displayText.join(" | ") + "]";
735                } else {
736                    text = displayText.join("\n");
737                }
738            }
739            return text;
740        },
741
742        getTextAndFormat: function getTextAndFormat() {
743            return this.rows;
744        }
745    };
746
747    /**
748     * Handle a CEA-608 channel and send decoded data to outputFilter
749     * @constructor
750     * @param {Number} channelNumber (1 or 2)
751     * @param {CueHandler} outputFilter Output from channel1 newCue(startTime, endTime, captionScreen)
752    */
753    var Cea608Channel = function Cea608Channel(channelNumber, outputFilter) {
754
755        this.chNr = channelNumber;
756        this.outputFilter = outputFilter;
757        this.mode = null;
758        this.verbose = 0;
759        this.displayedMemory = new CaptionScreen();
760        this.nonDisplayedMemory = new CaptionScreen();
761        this.lastOutputScreen = new CaptionScreen();
762        this.currRollUpRow = this.displayedMemory.rows[NR_ROWS - 1];
763        this.writeScreen = this.displayedMemory;
764        this.mode = null;
765        this.cueStartTime = null; // Keeps track of where a cue started.
766    };
767
768    Cea608Channel.prototype = {
769
770        modes: ["MODE_ROLL-UP", "MODE_POP-ON", "MODE_PAINT-ON", "MODE_TEXT"],
771
772        reset: function reset() {
773            this.mode = null;
774            this.displayedMemory.reset();
775            this.nonDisplayedMemory.reset();
776            this.lastOutputScreen.reset();
777            this.currRollUpRow = this.displayedMemory.rows[NR_ROWS - 1];
778            this.writeScreen = this.displayedMemory;
779            this.mode = null;
780            this.cueStartTime = null;
781            this.lastCueEndTime = null;
782        },
783
784        getHandler: function getHandler() {
785            return this.outputFilter;
786        },
787
788        setHandler: function setHandler(newHandler) {
789            this.outputFilter = newHandler;
790        },
791
792        setPAC: function setPAC(pacData) {
793            this.writeScreen.setPAC(pacData);
794        },
795
796        setBkgData: function setBkgData(bkgData) {
797            this.writeScreen.setBkgData(bkgData);
798        },
799
800        setMode: function setMode(newMode) {
801            if (newMode === this.mode) {
802                return;
803            }
804            this.mode = newMode;
805            logger.log("INFO", "MODE=" + newMode);
806            if (this.mode == "MODE_POP-ON") {
807                this.writeScreen = this.nonDisplayedMemory;
808            } else {
809                this.writeScreen = this.displayedMemory;
810                this.writeScreen.reset();
811            }
812            if (this.mode !== "MODE_ROLL-UP") {
813                this.displayedMemory.nrRollUpRows = null;
814                this.nonDisplayedMemory.nrRollUpRows = null;
815            }
816            this.mode = newMode;
817        },
818
819        insertChars: function insertChars(chars) {
820            for (var i = 0; i < chars.length; i++) {
821                this.writeScreen.insertChar(chars[i]);
822            }
823            var screen = this.writeScreen === this.displayedMemory ? "DISP" : "NON_DISP";
824            logger.log("INFO", screen + ": " + this.writeScreen.getDisplayText(true));
825            if (this.mode === "MODE_PAINT-ON" || this.mode === "MODE_ROLL-UP") {
826                logger.log("TEXT", "DISPLAYED: " + this.displayedMemory.getDisplayText(true));
827                this.outputDataUpdate();
828            }
829        },
830
831        cc_RCL: function cc_RCL() {
832            // Resume Caption Loading (switch mode to Pop On)
833            logger.log("INFO", "RCL - Resume Caption Loading");
834            this.setMode("MODE_POP-ON");
835        },
836        cc_BS: function cc_BS() {
837            // BackSpace
838            logger.log("INFO", "BS - BackSpace");
839            if (this.mode === "MODE_TEXT") {
840                return;
841            }
842            this.writeScreen.backSpace();
843            if (this.writeScreen === this.displayedMemory) {
844                this.outputDataUpdate();
845            }
846        },
847        cc_AOF: function cc_AOF() {
848            // Reserved (formerly Alarm Off)
849            return;
850        },
851        cc_AON: function cc_AON() {
852            // Reserved (formerly Alarm On)
853            return;
854        },
855        cc_DER: function cc_DER() {
856            // Delete to End of Row
857            logger.log("INFO", "DER- Delete to End of Row");
858            this.writeScreen.clearToEndOfRow();
859            this.outputDataUpdate();
860        },
861        cc_RU: function cc_RU(nrRows) {
862            //Roll-Up Captions-2,3,or 4 Rows
863            logger.log("INFO", "RU(" + nrRows + ") - Roll Up");
864            this.writeScreen = this.displayedMemory;
865            this.setMode("MODE_ROLL-UP");
866            this.writeScreen.setRollUpRows(nrRows);
867        },
868        cc_FON: function cc_FON() {
869            //Flash On
870            logger.log("INFO", "FON - Flash On");
871            this.writeScreen.setPen({ flash: true });
872        },
873        cc_RDC: function cc_RDC() {
874            // Resume Direct Captioning (switch mode to PaintOn)
875            logger.log("INFO", "RDC - Resume Direct Captioning");
876            this.setMode("MODE_PAINT-ON");
877        },
878        cc_TR: function cc_TR() {
879            // Text Restart in text mode (not supported, however)
880            logger.log("INFO", "TR");
881            this.setMode("MODE_TEXT");
882        },
883        cc_RTD: function cc_RTD() {
884            // Resume Text Display in Text mode (not supported, however)
885            logger.log("INFO", "RTD");
886            this.setMode("MODE_TEXT");
887        },
888        cc_EDM: function cc_EDM() {
889            // Erase Displayed Memory
890            logger.log("INFO", "EDM - Erase Displayed Memory");
891            this.displayedMemory.reset();
892            this.outputDataUpdate();
893        },
894        cc_CR: function cc_CR() {
895            // Carriage Return
896            logger.log("CR - Carriage Return");
897            this.writeScreen.rollUp();
898            this.outputDataUpdate();
899        },
900        cc_ENM: function cc_ENM() {
901            //Erase Non-Displayed Memory
902            logger.log("INFO", "ENM - Erase Non-displayed Memory");
903            this.nonDisplayedMemory.reset();
904        },
905        cc_EOC: function cc_EOC() {
906            //End of Caption (Flip Memories)
907            logger.log("INFO", "EOC - End Of Caption");
908            if (this.mode === "MODE_POP-ON") {
909                var tmp = this.displayedMemory;
910                this.displayedMemory = this.nonDisplayedMemory;
911                this.nonDisplayedMemory = tmp;
912                this.writeScreen = this.nonDisplayedMemory;
913                logger.log("TEXT", "DISP: " + this.displayedMemory.getDisplayText());
914            }
915            this.outputDataUpdate();
916        },
917        cc_TO: function cc_TO(nrCols) {
918            // Tab Offset 1,2, or 3 columns
919            logger.log("INFO", "TO(" + nrCols + ") - Tab Offset");
920            this.writeScreen.moveCursor(nrCols);
921        },
922        cc_MIDROW: function cc_MIDROW(secondByte) {
923            // Parse MIDROW command
924            var styles = { flash: false };
925            styles.underline = secondByte % 2 === 1;
926            styles.italics = secondByte >= 0x2e;
927            if (!styles.italics) {
928                var colorIndex = Math.floor(secondByte / 2) - 0x10;
929                var colors = ["white", "green", "blue", "cyan", "red", "yellow", "magenta"];
930                styles.foreground = colors[colorIndex];
931            } else {
932                styles.foreground = "white";
933            }
934            logger.log("INFO", "MIDROW: " + JSON.stringify(styles));
935            this.writeScreen.setPen(styles);
936        },
937
938        outputDataUpdate: function outputDataUpdate() {
939            var t = logger.time;
940            if (t === null) {
941                return;
942            }
943            if (this.outputFilter) {
944                if (this.outputFilter.updateData) {
945                    this.outputFilter.updateData(t, this.displayedMemory);
946                }
947                if (this.cueStartTime === null && !this.displayedMemory.isEmpty()) {
948                    // Start of a new cue
949                    this.cueStartTime = t;
950                } else {
951                    if (!this.displayedMemory.equals(this.lastOutputScreen)

951) {
952                        if (this.outputFilter.newCue) {
953                            this.outputFilter.newCue(this.cueStartTime, t, this.lastOutputScreen);
954                        }
955                        this.cueStartTime = this.displayedMemory.isEmpty() ? null : t;
956                    }
957                }
958                this.lastOutputScreen.copy(this.displayedMemory);
959            }
960        },
961
962        cueSplitAtTime: function cueSplitAtTime(t) {
963            if (this.outputFilter) {
964                if (!this.displayedMemory.isEmpty()) {
965                    if (this.outputFilter.newCue) {
966                        this.outputFilter.newCue(this.cueStartTime, t, this.displayedMemory);
967                    }
968                    this.cueStartTime = t;
969                }
970            }
971        }
972    };
973
974    /**
975     * Parse CEA-608 data and send decoded data to out1 and out2.
976     * @constructor
977     * @param {Number} field  CEA-608 field (1 or 2)
978     * @param {CueHandler} out1 Output from channel1 newCue(startTime, endTime, captionScreen)
979     * @param {CueHandler} out2 Output from channel2 newCue(startTime, endTime, captionScreen)
980     */
981    var Cea608Parser = function Cea608Parser(field, out1, out2) {
982        this.field = field || 1;
983        this.outputs = [out1, out2];
984        this.channels = [new Cea608Channel(1, out1), new Cea608Channel(2, out2)];
985        this.currChNr = -1; // Will be 1 or 2
986        this.lastCmdA = null; // First byte of last command
987        this.lastCmdB = null; // Second byte of last command
988        this.bufferedData = [];
989        this.startTime = null;
990        this.lastTime = null;
991        this.dataCounters = { 'padding': 0, 'char': 0, 'cmd': 0, 'other': 0 };
992    };
993
994    Cea608Parser.prototype = {
995
996        getHandler: function getHandler(index) {
997            return this.channels[index].getHandler();
998        },
999
1000        setHandler: function setHandler(index, newHandler) {
1001            this.channels[index].setHandler(newHandler);
1002        },
1003
1004        /**
1005         * Add data for time t in forms of list of bytes (unsigned ints). The bytes are treated as pairs.
1006         */
1007        addData: function addData(t, byteList) {
1008            var cmdFound,
1009                a,
1010                b,
1011                charsFound = false;
1012
1013            this.lastTime = t;
1014            logger.setTime(t);
1015
1016            for (var i = 0; i < byteList.length; i += 2) {
1017                a = byteList[i] & 0x7f;
1018                b = byteList[i + 1] & 0x7f;
1019
1020                if (a >= 0x10 && a <= 0x1f && a === this.lastCmdA && b === this.lastCmdB) {
1021                    this.lastCmdA = null;
1022                    this.lastCmdB = null;
1023                    logger.log("DEBUG", "Repeated command (" + numArrayToHexArray([a, b]) + ") is dropped");
1024                    continue; // Repeated commands are dropped (once)
1025                }
1026
1027                if (a === 0 && b === 0) {
1028                    this.dataCounters.padding += 2;
1029                    continue;
1030                } else {
1031                    logger.log("DATA", "[" + numArrayToHexArray([byteList[i], byteList[i + 1]]) + "] -> (" + numArrayToHexArray([a, b]) + ")");
1032                }
1033                cmdFound = this.parseCmd(a, b);
1034                if (!cmdFound) {
1035                    cmdFound = this.parseMidrow(a, b);
1036                }
1037                if (!cmdFound) {
1038                    cmdFound = this.parsePAC(a, b);
1039                }
1040                if (!cmdFound) {
1041                    cmdFound = this.parseBackgroundAttributes(a, b);
1042                }
1043                if (!cmdFound) {
1044                    charsFound = this.parseChars(a, b);
1045                    if (charsFound) {
1046                        if (this.currChNr && this.currChNr >= 0) {
1047                            var channel = this.channels[this.currChNr - 1];
1048                            channel.insertChars(charsFound);
1049                        } else {
1050                            logger.log("WARNING", "No channel found yet. TEXT-MODE?");
1051                        }
1052                    }
1053                }
1054                if (cmdFound) {
1055                    this.dataCounters.cmd += 2;
1056                } else if (charsFound) {
1057                    this.dataCounters.char += 2;
1058                } else {
1059                    this.dataCounters.other += 2;
1060                    logger.log("WARNING", "Couldn't parse cleaned data " + numArrayToHexArray([a, b]) + " orig: " + numArrayToHexArray([byteList[i], byteList[i + 1]]));
1061                }
1062            }
1063        },
1064
1065        /**
1066         * Parse Command.
1067         * @returns {Boolean} Tells if a command was found
1068         */
1069        parseCmd: function parseCmd(a, b) {
1070            var chNr = null;
1071
1072            var cond1 = (a === 0x14 || a === 0x15 || a === 0x1C || a === 0x1D) && 0x20 <= b && b <= 0x2F;
1073            var cond2 = (a === 0x17 || a === 0x1F) && 0x21 <= b && b <= 0x23;
1074            if (!(cond1 || cond2)) {
1075                return false;
1076            }
1077
1078            if (a === 0x14 || a === 0x15 || a === 0x17) {
1079                chNr = 1;
1080            } else {
1081                chNr = 2; // (a === 0x1C || a === 0x1D || a=== 0x1f)
1082            }
1083
1084            var channel = this.channels[chNr - 1];
1085
1086            if (a === 0x14 || a === 0x15 || a === 0x1C || a === 0x1D) {
1087                if (b === 0x20) {
1088                    channel.cc_RCL();
1089                } else if (b === 0x21) {
1090                    channel.cc_BS();
1091                } else if (b === 0x22) {
1092                    channel.cc_AOF();
1093                } else if (b === 0x23) {
1094                    channel.cc_AON();
1095                } else if (b === 0x24) {
1096                    channel.cc_DER();
1097                } else if (b === 0x25) {
1098                    channel.cc_RU(2);
1099                } else if (b === 0x26) {
1100                    channel.cc_RU(3);
1101                } else if (b === 0x27) {
1102                    channel.cc_RU(4);
1103                } else if (b === 0x28) {
1104                    channel.cc_FON();

1105                } else if (b === 0x29) {
1106                    channel.cc_RDC();
1107                } else if (b === 0x2A) {
1108                    channel.cc_TR();
1109                } else if (b === 0x2B) {
1110                    channel.cc_RTD();
1111                } else if (b === 0x2C) {
1112                    channel.cc_EDM();
1113                } else if (b === 0x2D) {
1114                    channel.cc_CR();
1115                } else if (b === 0x2E) {
1116                    channel.cc_ENM();
1117                } else if (b === 0x2F) {
1118                    channel.cc_EOC();
1119                }
1120            } else {
1121                //a == 0x17 || a == 0x1F
1122                channel.cc_TO(b - 0x20);
1123            }
1124            this.lastCmdA = a;
1125            this.lastCmdB = b;
1126            this.currChNr = chNr;
1127            return true;
1128        },
1129
1130        /**
1131         * Parse midrow styling command
1132         * @returns {Boolean}
1133         */
1134        parseMidrow: function parseMidrow(a, b) {
1135            var chNr = null;
1136
1137            if ((a === 0x11 || a === 0x19) && 0x20 <= b && b <= 0x2f) {
1138                if (a === 0x11) {
1139                    chNr = 1;
1140                } else {
1141                    chNr = 2;
1142                }
1143                if (chNr !== this.currChNr) {
1144                    logger.log("ERROR", "Mismatch channel in midrow parsing");
1145                    return false;
1146                }
1147                var channel = this.channels[chNr - 1];
1148                // cea608 spec says midrow codes should inject a space
1149                channel.insertChars([0x20]);
1150                channel.cc_MIDROW(b);
1151                logger.log("DEBUG", "MIDROW (" + numArrayToHexArray([a, b]) + ")");
1152                this.lastCmdA = a;
1153                this.lastCmdB = b;
1154                return true;
1155            }
1156            return false;
1157        },
1158        /**
1159         * Parse Preable Access Codes (Table 53).
1160         * @returns {Boolean} Tells if PAC found
1161         */
1162        parsePAC: function parsePAC(a, b) {
1163
1164            var chNr = null;
1165            var row = null;
1166
1167            var case1 = (0x11 <= a && a <= 0x17 || 0x19 <= a && a <= 0x1F) && 0x40 <= b && b <= 0x7F;
1168            var case2 = (a === 0x10 || a === 0x18) && 0x40 <= b && b <= 0x5F;
1169            if (!(case1 || case2)) {
1170                return false;
1171            }
1172
1173            chNr = a <= 0x17 ? 1 : 2;
1174
1175            if (0x40 <= b && b <= 0x5F) {
1176                row = chNr === 1 ? rowsLowCh1[a] : rowsLowCh2[a];
1177            } else {
1178                // 0x60 <= b <= 0x7F
1179                row = chNr === 1 ? rowsHighCh1[a] : rowsHighCh2[a];
1180            }
1181            var pacData = this.interpretPAC(row, b);
1182            var channel = this.channels[chNr - 1];
1183            channel.setPAC(pacData);
1184            this.lastCmdA = a;
1185            this.lastCmdB = b;
1186            this.currChNr = chNr;
1187            return true;
1188        },
1189
1190        /**
1191         * Interpret the second byte of the pac, and return the information.
1192         * @returns {Object} pacData with style parameters.
1193         */
1194        interpretPAC: function interpretPAC(row, byte) {
1195            var pacIndex = byte;
1196            var pacData = { color: null, italics: false, indent: null, underline: false, row: row };
1197
1198            if (byte > 0x5F) {
1199                pacIndex = byte - 0x60;
1200            } else {
1201                pacIndex = byte - 0x40;
1202            }
1203            pacData.underline = (pacIndex & 1) === 1;
1204            if (pacIndex <= 0xd) {
1205                pacData.color = ['white', 'green', 'blue', 'cyan', 'red', 'yellow', 'magenta', 'white'][Math.floor(pacIndex / 2)];
1206            } else if (pacIndex <= 0xf) {
1207                pacData.italics = true;
1208                pacData.color = 'white';
1209            } else {
1210                pacData.indent = Math.floor((pacIndex - 0x10) / 2) * 4;
1211            }
1212            return pacData; // Note that row has zero offset. The spec uses 1.
1213        },
1214
1215        /**
1216         * Parse characters.
1217         * @returns An array with 1 to 2 codes corresponding to chars, if found. null otherwise.
1218         */
1219        parseChars: function parseChars(a, b) {
1220
1221            var channelNr = null,
1222                charCodes = null,
1223                charCode1 = null,
1224                charCode2 = null;
1225
1226            if (a >= 0x19) {
1227                channelNr = 2;
1228                charCode1 = a - 8;
1229            } else {
1230                channelNr = 1;
1231                charCode1 = a;
1232            }
1233            if (0x11 <= charCode1 && charCode1 <= 0x13) {
1234                // Special character
1235                var oneCode = b;
1236                if (charCode1 === 0x11) {
1237                    oneCode = b + 0x50;
1238                } else if (charCode1 === 0x12) {
1239                    oneCode = b + 0x70;
1240                } else {
1241                    oneCode = b + 0x90;
1242                }
1243                logger.log("INFO", "Special char '" + getCharForByte(oneCode) + "' in channel " + channelNr);
1244                charCodes = [oneCode];
1245                this.lastCmdA = a;
1246                this.lastCmdB = b;
1247            } else if (0x20 <= a && a <= 0x7f) {
1248                charCodes = b === 0 ? [a] : [a, b];
1249                this.lastCmdA = null;
1250                this.lastCmdB = null;
1251            }
1252            if (charCodes) {
1253                var hexCodes = numArrayToHexArray(charCodes);
1254                logger.log("DEBUG", "Char codes =  " + hexCodes.join(","));
1255            }
1256            return charCodes;
1257        },
1258
1259        /**
1260        * Parse extended background attributes as well as new foreground color black.
1261        * @returns{Boolean} Tells if background attributes are found
1262        */
1263        parseBackgroundAttributes: function parseBackgroundAttributes(a, b) {
1264            var bkgData, index, chNr, channel;
1265
1266            var case1 = (a === 0x10 || a === 0x18) && 0x20 <= b && b <= 0x2f;
1267            var case2 = (a === 0x17 || a === 0x1f) && 0x2d <= b && b <= 0x2f;
1268            if (!(case1 || case2)) {
1269                return false;
1270            }
1271            bkgData = {};
1272            if (a === 0x10 || a === 0x18) {
1273                index = Math.floor((b - 0x20) / 2);
1274                bkgData.background = backgroundColors[index];
1275                if (b % 2 === 1) {
1276                    bkgData.background = bkgData.background + "_semi";
1277                }
1278            } else if (b === 0x2d) {
1279                bkgData.background = "transparent";
1280            } else {
1281                bkgData.foreground = "black";
1282                if (b === 0x2f) {
1283                    bkgData.underline = true;
1284                }
1285            }
1286            chNr = a < 0x18 ? 1 : 2;
1287            channel = this.channels[chNr - 1];
1288            channel.setBkgData(bkgData);
1289            this.lastCmdA = a;
1290            this.lastCmdB = b;
1291            return true;
1292        },
1293
1294        /**
1295         * Reset state of parser and its channels.
1296         */
1297        reset: function reset() {
1298            for (var i = 0; i < this.channels.length; i++) {
1299                if (this.channels[i]) {
1300                    this.channels[i].reset();
1301                }
1302            }
1303            this.lastCmdA = null;
1304            this.lastCmdB = null;
1305        },
1306
1307        /**
1308         * Trigger the generation of a cue, and the start of a new one if displayScreens are not empty.
1309         */
1310        cueSplitAtTime: function cueSplitAtTime(t) {
1311            for (var i = 0; i < this.channels.length; i++) {
1312                if (this.channels[i]) {
1313                    this.channels[i].cueSplitAtTime(t);
1314                }
1315            }
1316        }
1317    };
1318
1319    /**
1320     * Find ranges corresponding to SEA CEA-608 NALUS in sizeprepended NALU array.
1321     * @param {raw} dataView of binary data
1322     * @param {startPos} start position in raw
1323     * @param {size} total size of data in raw to consider
1324     * @returns 
1325     */
1326    var findCea608Nalus = function findCea608Nalus(raw, startPos, size) {
1327        var nalSize = 0,
1328            cursor = startPos,
1329            nalType = 0,
1330            cea608NaluRanges = [],
1331
1332        // Check SEI data according to ANSI-SCTE 128
1333        isCEA608SEI = function isCEA608SEI(payloadType, payloadSize, raw, pos) {
1334            if (payloadType !== 4 || payloadSize < 8) {
1335                return null;
1336            }
1337            var countryCode = raw.getUint8(pos);
1338            var providerCode = raw.getUint16(pos + 1);
1339            var userIdentifier = raw.getUint32(pos + 3);
1340            var userDataTypeCode = raw.getUint8(pos + 7);
1341            return countryCode == 0xB5 && providerCode == 0x31 && userIdentifier == 0x47413934 && userDataTypeCode == 0x3;
1342        };
1343        while (cursor < startPos + size) {
1344            nalSize = raw.getUint32(cursor);
1345            nalType = raw.getUint8(cursor + 4) & 0x1F;

1346            //console.log(time + "  NAL " + nalType);
1347            if (nalType === 6) {
1348                // SEI NAL Unit. The NAL header is the first byte
1349                //console.log("SEI NALU of size " + nalSize + " at time " + time);
1350                var pos = cursor + 5;
1351                var payloadType = -1;
1352                while (pos < cursor + 4 + nalSize - 1) {
1353                    // The last byte should be rbsp_trailing_bits
1354                    payloadType = 0;
1355                    var b = 0xFF;
1356                    while (b === 0xFF) {
1357                        b = raw.getUint8(pos);
1358                        payloadType += b;
1359                        pos++;
1360                    }
1361                    var payloadSize = 0;
1362                    b = 0xFF;
1363                    while (b === 0xFF) {
1364                        b = raw.getUint8(pos);
1365                        payloadSize += b;
1366                        pos++;
1367                    }
1368                    if (isCEA608SEI(payloadType, payloadSize, raw, pos)) {
1369                        //console.log("CEA608 SEI " + time + " " + payloadSize);
1370                        cea608NaluRanges.push([pos, payloadSize]);
1371                    }
1372                    pos += payloadSize;
1373                }
1374            }
1375            cursor += nalSize + 4;
1376        }
1377        return cea608NaluRanges;
1378    };
1379
1380    var extractCea608DataFromRange = function extractCea608DataFromRange(raw, cea608Range) {
1381        var pos = cea608Range[0];
1382        var fieldData = [[], []];
1383
1384        pos += 8; // Skip the identifier up to userDataTypeCode
1385        var ccCount = raw.getUint8(pos) & 0x1f;
1386        pos += 2; // Advance 1 and skip reserved byte
1387
1388        for (var i = 0; i < ccCount; i++) {
1389            var byte = raw.getUint8(pos);
1390            var ccValid = byte & 0x4;
1391            var ccType = byte & 0x3;
1392            pos++;
1393            var ccData1 = raw.getUint8(pos); // Keep parity bit
1394            pos++;
1395            var ccData2 = raw.getUint8(pos); // Keep parity bit
1396            pos++;
1397            if (ccValid && (ccData1 & 0x7f) + (ccData2 & 0x7f) !== 0) {
1398                //Check validity and non-empty data
1399                if (ccType === 0) {
1400                    fieldData[0].push(ccData1);
1401                    fieldData[0].push(ccData2);
1402                } else if (ccType === 1) {
1403                    fieldData[1].push(ccData1);
1404                    fieldData[1].push(ccData2);
1405                }
1406            }
1407        }
1408        return fieldData;
1409    };
1410
1411    exports.logger = logger;
1412    exports.PenState = PenState;
1413    exports.CaptionScreen = CaptionScreen;
1414    exports.Cea608Parser = Cea608Parser;
1415    exports.findCea608Nalus = findCea608Nalus;
1416    exports.extractCea608DataFromRange = extractCea608DataFromRange;
1417})(typeof exports === 'undefined' ? undefined.cea608parser = {} : exports);
1418
1419},{}],3:[function(_dereq_,module,exports){
1420/*
1421 *
1422 * Licensed under the Apache License, Version 2.0 (the "License");
1423 * you may not use this file except in compliance with the License.
1424 * You may obtain a copy of the License at
1425 *
1426 *     http://www.apache.org/licenses/LICENSE-2.0
1427 *
1428 * Unless required by applicable law or agreed to in writing, software
1429 * distributed under the License is distributed on an "AS IS" BASIS,
1430 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1431 * See the License for the specific language governing permissions and
1432 * limitations under the License.
1433 *
1434 * author Digital Primates
1435 * copyright dash-if 2012
1436 */
1437
1438/*
1439 * var parent,
1440 *     child,
1441 *     properties = [
1442                    {
1443                        name: 'profiles',
1444                        merge: false
1445                    }
1446                ];
1447 *
1448 * parent = {};
1449 * parent.name = "ParentNode";
1450 * parent.isRoor = false;
1451 * parent.isArray = false;
1452 * parent.children = [];
1453 * parent.properties = properties;
1454 *
1455 * child = {};
1456 * child.name = "ChildNode";
1457 * child.isRoor = false;
1458 * child.isArray = true;
1459 * child.children = null;
1460 * child.properties = properties;
1461 * parent.children.push(child);
1462 *
1463 */
1464
1465'use strict';
1466
1467Object.defineProperty(exports, '__esModule', {
1468    value: true
1469});
1470function ObjectIron(map) {
1471
1472    var lookup, len, i;
1473
1474    // create a list of top level items to search for
1475    lookup = [];
1476    for (i = 0, len = map.length; i < len; i += 1) {

1630 you may not use this file except in compliance with the License.
1631 You may obtain a copy of the License at
1632
1633 http://www.apache.org/licenses/LICENSE-2.0
1634
1635 Unless required by applicable law or agreed to in writing, software
1636 distributed under the License is distributed on an "AS IS" BASIS,
1637 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1638 See the License for the specific language governing permissions and
1639 limitations under the License.
1640 */
1641
1642/*
1643  Further modified for dashjs to:
1644  - keep track of children nodes in order in attribute __children.
1645  - add type conversion matchers
1646  - re-add ignoreRoot
1647  - allow zero-length attributePrefix
1648  - don't add white-space text nodes
1649  - remove explicit RequireJS support
1650*/
1651
1652"use strict";
1653
1654Object.defineProperty(exports, "__esModule", {
1655    value: true
1656});
1657function X2JS(config) {
1658    'use strict';
1659
1660    var VERSION = "1.2.0";
1661
1662    config = config || {};
1663    initConfigDefaults();
1664    initRequiredPolyfills();
1665
1666    function initConfigDefaults() {
1667        if (config.escapeMode === undefined) {
1668            config.escapeMode = true;
1669        }
1670
1671        if (config.attributePrefix === undefined) {
1672            config.attributePrefix = "_";
1673        }
1674
1675        config.arrayAccessForm = config.arrayAccessForm || "none";
1676        config.emptyNodeForm = config.emptyNodeForm || "text";
1677
1678        if (config.enableToStringFunc === undefined) {
1679            config.enableToStringFunc = true;
1680        }
1681        config.arrayAccessFormPaths = config.arrayAccessFormPaths || [];
1682        if (config.skipEmptyTextNodesForObj === undefined) {
1683            config.skipEmptyTextNodesForObj = true;
1684        }
1685        if (config.stripWhitespaces === undefined) {
1686            config.stripWhitespaces = true;
1687        }
1688        config.datetimeAccessFormPaths = config.datetimeAccessFormPaths || [];
1689
1690        if (config.useDoubleQuotes === undefined) {
1691            config.useDoubleQuotes = false;
1692        }
1693
1694        config.xmlElementsFilter = config.xmlElementsFilter || [];
1695        config.jsonPropertiesFilter = config.jsonPropertiesFilter || [];
1696
1697        if (config.keepCData === undefined) {
1698            config.keepCData = false;
1699        }
1700
1701        if (config.ignoreRoot === undefined) {
1702            config.ignoreRoot = false;
1703        }
1704    }
1705
1706    var DOMNodeTypes = {
1707        ELEMENT_NODE: 1,
1708        TEXT_NODE: 3,
1709        CDATA_SECTION_NODE: 4,
1710        COMMENT_NODE: 8,
1711        DOCUMENT_NODE: 9
1712    };
1713
1714    function initRequiredPolyfills() {}
1715
1716    function getNodeLocalName(node) {
1717        var nodeLocalName = node.localName;
1718        if (nodeLocalName == null) // Yeah, this is IE!!
1719            nodeLocalName = node.baseName;
1720        if (nodeLocalName == null || nodeLocalName == "") // =="" is IE too
1721            nodeLocalName = node.nodeName;
1722        return nodeLocalName;
1723    }
1724
1725    function getNodePrefix(node) {
1726        return node.prefix;
1727    }
1728
1729    function escapeXmlChars(str) {
1730        if (typeof str == "string") return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');else return str;
1731    }
1732
1733    function unescapeXmlChars(str) {
1734        return str.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, '&');
1735    }
1736
1737    function checkInStdFiltersArrayForm(stdFiltersArrayForm, obj, name, path) {
1738        var idx = 0;
1739        for (; idx < stdFiltersArrayForm.length; idx++) {
1740            var filterPath = stdFiltersArrayForm[idx];
1741            if (typeof filterPath === "string") {
1742                if (filterPath == path) break;
1743            } else if (filterPath instanceof RegExp) {
1744                if (filterPath.test(path)) break;
1745            } else if (typeof filterPath === "function") {
1746                if (filterPath(obj, name, path)) break;
1747            }
1748        }
1749        return idx != stdFiltersArrayForm.length;
1750    }
1751
1752    function toArrayAccessForm(obj, childName, path) {
1753        switch (config.arrayAccessForm) {
1754            case "property":
1755                if (!(obj[childName] instanceof Array)) obj[childName + "_asArray"] = [obj[childName]];else obj[childName + "_asArray"] = obj[childName];
1756                break;
1757            /*case "none":
1758                break;*/
1759        }
1760
1761        if (!(obj[childName] instanceof Array) && config.arrayAccessFormPaths.length > 0) {
1762            if (checkInStdFiltersArrayForm(config.arrayAccessFormPaths, obj, childName, path)) {
1763                obj[childName] = [obj[childName]];
1764            }
1765        }
1766    }
1767
1768    function fromXmlDateTime(prop) {
1769        // Implementation based up on http://stackoverflow.com/questions/8178598/xml-datetime-to-javascript-date-object
1770        // Improved to support full spec and optional parts
1771        var bits = prop.split(/[-T:+Z]/g);
1772
1773        var d = new Date(bits[0], bits[1] - 1, bits[2]);
1774        var secondBits = bits[5].split("\.");
1775        d.setHours(bits[3], bits[4], secondBits[0]);
1776        if (secondBits.length > 1) d.setMilliseconds(secondBits[1]);
1777
1778        // Get supplied time zone offset in minutes
1779        if (bits[6] && bits[7]) {
1780            var offsetMinutes = bits[6] * 60 + Number(bits[7]);
1781            var sign = /\d\d-\d\d:\d\d$/.test(prop) ? '-' : '+';
1782
1783            // Apply the sign
1784            offsetMinutes = 0 + (sign == '-' ? -1 * offsetMinutes : offsetMinutes);
1785
1786            // Apply offset and local timezone
1787            d.setMinutes(d.getMinutes() - offsetMinutes - d.getTimezoneOffset());
1788        } else if (prop.indexOf("Z", prop.length - 1) !== -1) {
1789            d = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()));
1790        }
1791
1792        // d is now a local time equivalent to the supplied time
1793        return d;
1794    }
1795
1796    function checkFromXmlDateTimePaths(value, childName, fullPath) {
1797        if (config.datetimeAccessFormPaths.length > 0) {
1798            var path = fullPath.split("\.#")[0];
1799            if (checkInStdFiltersArrayForm(config.datetimeAccessFormPaths, value, childName, path)) {
1800                return fromXmlDateTime(value);
1801            } else return value;
1802        } else return value;
1803    }
1804
1805    function checkXmlElementsFilter(obj, childType, childName, childPath) {
1806        if (childType == DOMNodeTypes.ELEMENT_NODE && config.xmlElementsFilter.length > 0) {
1807            return checkInStdFiltersArrayForm(config.xmlElementsFilter, obj, childName, childPath);
1808        } else return true;
1809    }
1810
1811    function parseDOMChildren(node, path) {
1812        if (node.nodeType == DOMNodeTypes.DOCUMENT_NODE) {
1813            var result = new Object();
1814            var nodeChildren = node.childNodes;
1815            // Alternative for firstElementChild which is not supported in some environments
1816            for (var cidx = 0; cidx < nodeChildren.length; cidx++) {
1817                var child = nodeChildren[cidx];
1818                if (child.nodeType == DOMNodeTypes.ELEMENT_NODE) {
1819                    if (config.ignoreRoot) {
1820                        result = parseDOMChildren(child);
1821                    } else {
1822                        result = {};
1823                        var childName = getNodeLocalName(child);
1824                        result[childName] = parseDOMChildren(child);
1825                    }
1826                }
1827            }
1828            return result;
1829        } else if (node.nodeType == DOMNodeTypes.ELEMENT_NODE) {
1830            var result = new Object();
1831            result.__cnt = 0;
1832
1833            var children = [];
1834            var nodeChildren = node.childNodes;
1835
1836            // Children nodes
1837            for (var cidx = 0; cidx < nodeChildren.length; cidx++) {
1838                var child = nodeChildren[cidx];
1839                var childName = getNodeLocalName(child);
1840
1841                if (child.nodeType != DOMNodeTypes.COMMENT_NODE) {
1842                    var childPath = path + "." + childName;
1843                    if (checkXmlElementsFilter(result, child.nodeType, childName, childPath)) {
1844                        result.__cnt++;
1845                        if (result[childName] == null) {
1846                            var c = parseDOMChildren(child, childPath);
1847                            if (childName != "#text" || /[^\s]/.test(c)) {
1848                                var o = {};
1849                                o[childName] = c;
1850                                children.push(o);
1851                            }
1852                            result[childName] = c;
1853                            toArrayAccessForm(result, childName, childPath);
1854                        } else {
1855                            if (result[childName] != null) {
1856                                if (!(result[childName] instanceof Array)) {
1857                                    result[childName] = [result[childName]];
1858                                    toArrayAccessForm(result, childName, childPath);
1859                                }
1860                            }
1861
1862                            var c = parseDOMChildren(child, childPath);
1863                            if (childName != "#text" || /[^\s]/.test(c)) {
1864                                // Don't add white-space text nodes
1865                                var o = {};
1866                                o[childName] = c;
1867                                children.push(o);
1868                            }
1869                            result[childName][result[childName].length] = c;
1870                        }
1871                    }
1872                }
1873            }
1874
1875            result.__children = children;
1876
1877            // Attributes
1878            var nodeLocalName = getNodeLocalName(node);
1879            for (var aidx = 0; aidx < node.attributes.length; aidx++) {
1880                var attr = node.attributes[aidx];
1881                result.__cnt++;
1882
1883                var value2 = attr.value;
1884                for (var m = 0, ml = config.matchers.length; m < ml; m++) {
1885                    var matchobj = config.matchers[m];
1886                    if (matchobj.test(attr, nodeLocalName)) value2 = matchobj.converter(attr.value);
1887                }
1888
1889                result[config.attributePrefix + attr.name] = value2;
1890            }
1891
1892            // Node namespace prefix
1893            var nodePrefix = getNodePrefix(node);
1894            if (nodePrefix != null && nodePrefix != "") {
1895                result.__cnt++;
1896                result.__prefix = nodePrefix;
1897            }
1898
1899            if (result["#text"] != null) {
1900                result.__text = result["#text"];
1901                if (result.__text instanceof Array) {
1902                    result.__text = result.__text.join("\n");
1903                }
1904                //if(config.escapeMode)
1905                //	result.__text = unescapeXmlChars(result.__text);

1906                if (config.stripWhitespaces) result.__text = result.__text.trim();
1907                delete result["#text"];
1908                if (config.arrayAccessForm == "property") delete result["#text_asArray"];
1909                result.__text = checkFromXmlDateTimePaths(result.__text, childName, path + "." + childName);
1910            }
1911            if (result["#cdata-section"] != null) {
1912                result.__cdata = result["#cdata-section"];
1913                delete result["#cdata-section"];
1914                if (config.arrayAccessForm == "property") delete result["#cdata-section_asArray"];
1915            }
1916
1917            if (result.__cnt == 0 && config.emptyNodeForm == "text") {
1918                result = '';
1919            } else if (result.__cnt == 1 && result.__text != null) {
1920                result = result.__text;
1921            } else if (result.__cnt == 1 && result.__cdata != null && !config.keepCData) {
1922                result = result.__cdata;
1923            } else if (result.__cnt > 1 && result.__text != null && config.skipEmptyTextNodesForObj) {
1924                if (config.stripWhitespaces && result.__text == "" || result.__text.trim() == "") {
1925                    delete result.__text;
1926                }
1927            }
1928            delete result.__cnt;
1929
1930            if (config.enableToStringFunc && (result.__text != null || result.__cdata != null)) {
1931                result.toString = function () {
1932                    return (this.__text != null ? this.__text : '') + (this.__cdata != null ? this.__cdata : '');
1933                };
1934            }
1935
1936            return result;
1937        } else if (node.nodeType == DOMNodeTypes.TEXT_NODE || node.nodeType == DOMNodeTypes.CDATA_SECTION_NODE) {
1938            return node.nodeValue;
1939        }
1940    }
1941
1942    function startTag(jsonObj, element, attrList, closed) {
1943        var resultStr = "<" + (jsonObj != null && jsonObj.__prefix != null ? jsonObj.__prefix + ":" : "") + element;
1944        if (attrList != null) {
1945            for (var aidx = 0; aidx < attrList.length; aidx++) {
1946                var attrName = attrList[aidx];
1947                var attrVal = jsonObj[attrName];
1948                if (config.escapeMode) attrVal = escapeXmlChars(attrVal);
1949                resultStr += " " + attrName.substr(config.attributePrefix.length) + "=";
1950                if (config.useDoubleQuotes) resultStr += '"' + attrVal + '"';else resultStr += "'" + attrVal + "'";
1951            }
1952        }
1953        if (!closed) resultStr += ">";else resultStr += "/>";
1954        return resultStr;
1955    }
1956
1957    function endTag(jsonObj, elementName) {
1958        return "</" + (jsonObj.__prefix != null ? jsonObj.__prefix + ":" : "") + elementName + ">";
1959    }
1960
1961    function endsWith(str, suffix) {
1962        return str.indexOf(suffix, str.length - suffix.length) !== -1;
1963    }
1964
1965    function jsonXmlSpecialElem(jsonObj, jsonObjField) {
1966        if (config.arrayAccessForm == "property" && endsWith(jsonObjField.toString(), "_asArray") || jsonObjField.toString().indexOf(config.attributePrefix) == 0 || jsonObjField.toString().indexOf("__") == 0 || jsonObj[jsonObjField] instanceof Function) return true;else return false;
1967    }
1968
1969    function jsonXmlElemCount(jsonObj) {
1970        var elementsCnt = 0;
1971        if (jsonObj instanceof Object) {
1972            for (var it in jsonObj) {
1973                if (jsonXmlSpecialElem(jsonObj, it)) continue;
1974                elementsCnt++;
1975            }
1976        }
1977        return elementsCnt;
1978    }
1979
1980    function checkJsonObjPropertiesFilter(jsonObj, propertyName, jsonObjPath) {
1981        return config.jsonPropertiesFilter.length == 0 || jsonObjPath == "" || checkInStdFiltersArrayForm(config.jsonPropertiesFilter, jsonObj, propertyName, jsonObjPath);
1982    }
1983
1984    function parseJSONAttributes(jsonObj) {
1985        var attrList = [];
1986        if (jsonObj instanceof Object) {
1987            for (var ait in jsonObj) {
1988                if (ait.toString().indexOf("__") == -1 && ait.toString().indexOf(config.attributePrefix) == 0) {
1989                    attrList.push(ait);
1990                }
1991            }
1992        }
1993        return attrList;
1994    }
1995
1996    function parseJSONTextAttrs(jsonTxtObj) {
1997        var result = "";
1998
1999        if (jsonTxtObj.__cdata != null) {
2000            result += "<![CDATA[" + jsonTxtObj.__cdata + "]]>";
2001        }
2002
2003        if (jsonTxtObj.__text != null) {
2004            if (config.escapeMode) result += escapeXmlChars(jsonTxtObj.__text);else result += jsonTxtObj.__text;
2005        }
2006        return result;
2007    }
2008
2009    function parseJSONTextObject(jsonTxtObj) {
2010        var result = "";
2011
2012        if (jsonTxtObj instanceof Object) {
2013            result += parseJSONTextAttrs(jsonTxtObj);
2014        } else if (jsonTxtObj != null) {
2015            if (config.escapeMode) result += escapeXmlChars(jsonTxtObj);else result += jsonTxtObj;
2016        }
2017
2018        return result;
2019    }
2020
2021    function getJsonPropertyPath(jsonObjPath, jsonPropName) {
2022        if (jsonObjPath === "") {
2023            return jsonPropName;
2024        } else return jsonObjPath + "." + jsonPropName;
2025    }
2026
2027    function parseJSONArray(jsonArrRoot, jsonArrObj, attrList, jsonObjPath) {
2028        var result = "";
2029        if (jsonArrRoot.length == 0) {
2030            result += startTag(jsonArrRoot, jsonArrObj, attrList, true);
2031        } else {
2032            for (var arIdx = 0; arIdx < jsonArrRoot.length; arIdx++) {
2033                result += startTag(jsonArrRoot[arIdx], jsonArrObj, parseJSONAttributes(jsonArrRoot[arIdx]), false);
2034                result += parseJSONObject(jsonArrRoot[arIdx], getJsonPropertyPath(jsonObjPath, jsonArrObj));
2035                result += endTag(jsonArrRoot[arIdx], jsonArrObj);
2036            }
2037        }
2038        return result;
2039    }
2040
2041    function parseJSONObject(jsonObj, jsonObjPath) {
2042        var result = "";
2043
2044        var elementsCnt = jsonXmlElemCount(jsonObj);
2045
2046        if (elementsCnt > 0) {
2047            for (var it in jsonObj) {
2048
2049                if (jsonXmlSpecialElem(jsonObj, it) || jsonObjPath != "" && !checkJsonObjPropertiesFilter(jsonObj, it, getJsonPropertyPath(jsonObjPath, it))) continue;
2050
2051                var subObj = jsonObj[it];
2052
2053                var attrList = parseJSONAttributes(subObj);
2054
2055                if (subObj == null || subObj == undefined) {
2056                    result += startTag(subObj, it, attrList, true);
2057                } else if (subObj instanceof Object) {
2058
2059                    if (subObj instanceof Array) {
2060                        result += parseJSONArray(subObj, it, attrList, jsonObjPath);
2061                    } else if (subObj instanceof Date) {
2062                        result += startTag(subObj, it, attrList, false);
2063                        result += subObj.toISOString();
2064                        result += endTag(subObj, it);
2065                    } else {
2066                        var subObjElementsCnt = jsonXmlElemCount(subObj);
2067                        if (subObjElementsCnt > 0 || subObj.__text != null || subObj.__cdata != null) {
2068                            result += startTag(subObj, it, attrList, false);
2069                            result += parseJSONObject(subObj, getJsonPropertyPath(jsonObjPath, it));
2070                            result += endTag(subObj, it);
2071                        } else {
2072                            result += startTag(subObj, it, attrList, true);
2073                        }
2074                    }
2075                } else {
2076                    result += startTag(subObj, it, attrList, false);
2077                    result += parseJSONTextObject(subObj);
2078                    result += endTag(subObj, it);
2079                }
2080            }
2081        }
2082        result += parseJSONTextObject(jsonObj);
2083
2084        return result;
2085    }
2086
2087    this.parseXmlString = function (xmlDocStr) {
2088        var isIEParser = window.ActiveXObject || "ActiveXObject" in window;
2089        if (xmlDocStr === undefined) {
2090            return null;
2091        }
2092        var xmlDoc;
2093        if (window.DOMParser) {
2094            var parser = new window.DOMParser();
2095            var parsererrorNS = null;
2096            // IE9+ now is here
2097            if (!isIEParser) {
2098                try {
2099                    parsererrorNS = parser.parseFromString("INVALID", "text/xml").getElementsByTagName("parsererror")[0].namespaceURI;
2100                } catch (err) {
2101                    parsererrorNS = null;
2102                }
2103            }
2104            try {
2105                xmlDoc = parser.parseFromString(xmlDocStr, "text/xml");
2106                if (parsererrorNS != null && xmlDoc.getElementsByTagNameNS(parsererrorNS, "parsererror").length > 0) {
2107                    //throw new Error('Error parsing XML: '+xmlDocStr);
2108                    xmlDoc = null;
2109                }
2110            } catch (err) {
2111                xmlDoc = null;
2112            }
2113        } else {
2114            // IE :(
2115            if (xmlDocStr.indexOf("<?") == 0) {
2116                xmlDocStr = xmlDocStr.substr(xmlDocStr.indexOf("?>") + 2);
2117            }
2118            xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
2119            xmlDoc.async = "false";
2120            xmlDoc.loadXML(xmlDocStr);
2121        }
2122        return xmlDoc;
2123    };
2124
2125    this.asArray = function (prop) {
2126        if (prop === undefined || prop == null) return [];else if (prop instanceof Array) return prop;else return [prop];
2127    };
2128
2129    this.toXmlDateTime = function (dt) {
2130        if (dt instanceof Date) return dt.toISOString();else if (typeof dt === 'number') return new Date(dt).toISOString();else return null;
2131    };
2132
2133    this.asDateTime = function (prop) {
2134        if (typeof prop == "string") {
2135            return fromXmlDateTime(prop);
2136        } else return prop;
2137    };
2138
2139    this.xml2json = function (xmlDoc) {
2140        return parseDOMChildren(xmlDoc);
2141    };
2142
2143    this.xml_str2json = function (xmlDocStr) {
2144        var xmlDoc = this.parseXmlString(xmlDocStr);
2145        if (xmlDoc != null) return this.xml2json(xmlDoc);else return null;
2146    };
2147
2148    this.json2xml_str = function (jsonObj) {
2149        return parseJSONObject(jsonObj, "");
2150    };
2151
2152    this.json2xml = function (jsonObj) {
2153        var xmlDocStr = this.json2xml_str(jsonObj);
2154        return this.parseXmlString(xmlDocStr);
2155    };
2156
2157    this.getVersion = function () {
2158        return VERSION;
2159    };
2160}
2161
2162exports["default"] = X2JS;
2163module.exports = exports["default"];
2164
2165},{}],5:[function(_dereq_,module,exports){
2166/**
2167 * The copyright in this software is being made available under the BSD License,
2168 * included below. This software may be subject to other third party and contributor
2169 * rights, including patent rights, and no such rights are granted under this license.
2170 *
2171 * Copyright (c) 2013, Dash Industry Forum.
2172 * All rights reserved.
2173 *
2174 * Redistribution and use in source and binary forms, with or without modification,
2175 * are permitted provided that the following conditions are met:
2176 *  * Redistributions of source code must retain the above copyright notice, this
2177 *  list of conditions and the following disclaimer.
2178 *  * Redistributions in binary form must reproduce the above copyright notice,
2179 *  this list of conditions and the following disclaimer in the documentation and/or
2180 *  other materials provided with the distribution.
2181 *  * Neither the name of Dash Industry Forum nor the names of its
2182 *  contributors may be used to endorse or promote products derived from this software
2183 *  without specific prior written permission.
2184 *
2185 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
2186 *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
2187 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
2188 *  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
2189 *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (

2508// character found at the end of the buffer is buffered up, and will be
2509// returned when calling write again with the remaining bytes.
2510//
2511// Note: Converting a Buffer containing an orphan surrogate to a String
2512// currently works, but converting a String to a Buffer (via `new Buffer`, or
2513// Buffer#write) will replace incomplete surrogates with the unicode
2514// replacement character. See https://codereview.chromium.org/121173009/ .
2515StringDecoder.prototype.write = function(buffer) {
2516  var charStr = '';
2517  // if our last write ended with an incomplete multibyte character
2518  while (this.charLength) {
2519    // determine how many remaining bytes this buffer has to offer for this char
2520    var available = (buffer.length >= this.charLength - this.charReceived) ?
2521        this.charLength - this.charReceived :
2522        buffer.length;
2523
2524    // add the new bytes to the char buffer
2525    buffer.copy(this.charBuffer, this.charReceived, 0, available);
2526    this.charReceived += available;
2527
2528    if (this.charReceived < this.charLength) {
2529      // still not enough chars in this buffer? wait for more ...
2530      return '';
2531    }
2532
2533    // remove bytes belonging to the current character from the buffer
2534    buffer = buffer.slice(available, buffer.length);
2535
2536    // get the character that was split
2537    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
2538
2539    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
2540    var charCode = charStr.charCodeAt(charStr.length - 1);
2541    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
2542      this.charLength += this.surrogateSize;
2543      charStr = '';
2544      continue;
2545    }
2546    this.charReceived = this.charLength = 0;
2547
2548    // if there are no more bytes in this buffer, just emit our char
2549    if (buffer.length === 0) {
2550      return charStr;
2551    }
2552    break;
2553  }
2554
2555  // determine and set charLength / charReceived
2556  this.detectIncompleteChar(buffer);
2557
2558  var end = buffer.length;
2559  if (this.charLength) {
2560    // buffer the incomplete character bytes we got
2561    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
2562    end -= this.charReceived;
2563  }
2564
2565  charStr += buffer.toString(this.encoding, 0, end);
2566
2567  var end = charStr.length - 1;
2568  var charCode = charStr.charCodeAt(end);
2569  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
2570  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
2571    var size = this.surrogateSize;
2572    this.charLength += size;
2573    this.charReceived += size;
2574    this.charBuffer.copy(this.charBuffer, size, 0, size);
2575    buffer.copy(this.charBuffer, 0, 0, size);
2576    return charStr.substring(0, end);
2577  }
2578
2579  // or just emit the charStr
2580  return charStr;
2581};
2582
2583// detectIncompleteChar determines if there is an incomplete UTF-8 character at
2584// the end of the given buffer. If so, it sets this.charLength to the byte
2585// length that character, and sets this.charReceived to the number of bytes
2586// that are available for this character.
2587StringDecoder.prototype.detectIncompleteChar = function(buffer) {
2588  // determine how many bytes we have to check at the end of this buffer
2589  var i = (buffer.length >= 3) ? 3 : buffer.length;
2590
2591  // Figure out if one of the last i bytes of our buffer announces an
2592  // incomplete char.
2593  for (; i > 0; i--) {
2594    var c = buffer[buffer.length - i];
2595
2596    // See http://en.wikipedia.org/wiki/UTF-8#Description
2597
2598    // 110XXXXX
2599    if (i == 1 && c >> 5 == 0x06) {
2600      this.charLength = 2;
2601      break;
2602    }
2603
2604    // 1110XXXX
2605    if (i <= 2 && c >> 4 == 0x0E) {
2606      this.charLength = 3;
2607      break;
2608    }
2609
2610    // 11110XXX
2611    if (i <= 3 && c >> 3 == 0x1E) {
2612      this.charLength = 4;
2613      break;
2614    }
2615  }
2616  this.charReceived = i;
2617};
2618
2619StringDecoder.prototype.end = function(buffer) {
2620  var res = '';
2621  if (buffer && buffer.length)
2622    res = this.write(buffer);
2623
2624  if (this.charReceived) {
2625    var cr = this.charReceived;
2626    var buf = this.charBuffer;
2627    var enc = this.encoding;
2628    res += buf.slice(0, cr).toString(enc);
2629  }
2630
2631  return res;
2632};
2633
2634function passThroughWrite(buffer) {
2635  return buffer.toString(this.encoding);
2636}
2637
2638function utf16DetectIncompleteChar(buffer) {
2639  this.charReceived = buffer.length % 2;
2640  this.charLength = this.charReceived ? 2 : 0;
2641}
2642
2643function base64DetectIncompleteChar(buffer) {
2644  this.charReceived = buffer.length % 3;
2645  this.charLength = this.charReceived ? 3 : 0;
2646}
2647
2648},{"10":10}],10:[function(_dereq_,module,exports){
2649(function (global){
2650/*!
2651 * The buffer module from node.js, for the browser.
2652 *
2653 * @author   Feross Aboukhadijeh <[email protected]> <http://feross.org>
2654 * @license  MIT
2655 */
2656/* eslint-disable no-proto */
2657
2658'use strict'
2659
2660var base64 = _dereq_(7)
2661var ieee754 = _dereq_(17)
2662var isArray = _dereq_(27)
2663
2664exports.Buffer = Buffer
2665exports.SlowBuffer = SlowBuffer
2666exports.INSPECT_MAX_BYTES = 50
2667Buffer.poolSize = 8192 // not used by this implementation
2668
2669var rootParent = {}
2670
2671/**
2672 * If `Buffer.TYPED_ARRAY_SUPPORT`:
2673 *   === true    Use Uint8Array implementation (fastest)
2674 *   === false   Use Object implementation (most compatible, even IE6)
2675 *
2676 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
2677 * Opera 11.6+, iOS 4.2+.
2678 *
2679 * Due to various browser bugs, sometimes the Object implementation will be used even
2680 * when the browser supports typed arrays.
2681 *
2682 * Note:
2683 *