Initial Commit - NG UI
[osm/NG-UI.git] / src / assets / js / tar.js
diff --git a/src/assets/js/tar.js b/src/assets/js/tar.js
new file mode 100644 (file)
index 0000000..058d1ee
--- /dev/null
@@ -0,0 +1,432 @@
+/*
+ Copyright 2020 TATA ELXSI
+
+ Licensed under the Apache License, Version 2.0 (the 'License');
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ Author: KUMARAN M (kumaran.m@tataelxsi.co.in), RAJESH S (rajesh.s@tataelxsi.co.in), BARATH KUMAR R (barath.r@tataelxsi.co.in)
+ */
+var Tar =
+/******/ (function(modules) { // webpackBootstrap
+/******/       // The module cache
+/******/       var installedModules = {};
+/******/
+/******/       // The require function
+/******/       function __webpack_require__(moduleId) {
+/******/
+/******/               // Check if module is in cache
+/******/               if(installedModules[moduleId]) {
+/******/                       return installedModules[moduleId].exports;
+/******/               }
+/******/               // Create a new module (and put it into the cache)
+/******/               var module = installedModules[moduleId] = {
+/******/                       i: moduleId,
+/******/                       l: false,
+/******/                       exports: {}
+/******/               };
+/******/
+/******/               // Execute the module function
+/******/               modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/               // Flag the module as loaded
+/******/               module.l = true;
+/******/
+/******/               // Return the exports of the module
+/******/               return module.exports;
+/******/       }
+/******/
+/******/
+/******/       // expose the modules object (__webpack_modules__)
+/******/       __webpack_require__.m = modules;
+/******/
+/******/       // expose the module cache
+/******/       __webpack_require__.c = installedModules;
+/******/
+/******/       // identity function for calling harmony imports with the correct context
+/******/       __webpack_require__.i = function(value) { return value; };
+/******/
+/******/       // define getter function for harmony exports
+/******/       __webpack_require__.d = function(exports, name, getter) {
+/******/               if(!__webpack_require__.o(exports, name)) {
+/******/                       Object.defineProperty(exports, name, {
+/******/                               configurable: false,
+/******/                               enumerable: true,
+/******/                               get: getter
+/******/                       });
+/******/               }
+/******/       };
+/******/
+/******/       // getDefaultExport function for compatibility with non-harmony modules
+/******/       __webpack_require__.n = function(module) {
+/******/               var getter = module && module.__esModule ?
+/******/                       function getDefault() { return module['default']; } :
+/******/                       function getModuleExports() { return module; };
+/******/               __webpack_require__.d(getter, 'a', getter);
+/******/               return getter;
+/******/       };
+/******/
+/******/       // Object.prototype.hasOwnProperty.call
+/******/       __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/       // __webpack_public_path__
+/******/       __webpack_require__.p = "";
+/******/
+/******/       // Load entry module and return exports
+/******/       return __webpack_require__(__webpack_require__.s = 2);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+/*
+ * tar-js
+ * MIT (c) 2011 T. Jameson Little
+ */
+
+(function () {
+       "use strict";
+
+       var lookup = [
+                       'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+                       'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+                       'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+                       'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+                       'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+                       'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+                       'w', 'x', 'y', 'z', '0', '1', '2', '3',
+                       '4', '5', '6', '7', '8', '9', '+', '/'
+               ];
+       function clean(length) {
+               var i, buffer = new Uint8Array(length);
+               for (i = 0; i < length; i += 1) {
+                       buffer[i] = 0;
+               }
+               return buffer;
+       }
+
+       function extend(orig, length, addLength, multipleOf) {
+               var newSize = length + addLength,
+                       buffer = clean((parseInt(newSize / multipleOf) + 1) * multipleOf);
+
+               buffer.set(orig);
+
+               return buffer;
+       }
+
+       function pad(num, bytes, base) {
+               num = num.toString(base || 8);
+               return "000000000000".substr(num.length + 12 - bytes) + num;
+       }       
+       
+       function stringToUint8 (input, out, offset) {
+               var i, length;
+
+               out = out || clean(input.length);
+
+               offset = offset || 0;
+               for (i = 0, length = input.length; i < length; i += 1) {
+                       out[offset] = input.charCodeAt(i);
+                       offset += 1;
+               }
+
+               return out;
+       }
+
+       function uint8ToBase64(uint8) {
+               var i,
+                       extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+                       output = "",
+                       temp, length;
+
+               function tripletToBase64 (num) {
+                       return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
+               };
+
+               // go through the array every three bytes, we'll deal with trailing stuff later
+               for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+                       temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
+                       output += tripletToBase64(temp);
+               }
+
+               // this prevents an ERR_INVALID_URL in Chrome (Firefox okay)
+               switch (output.length % 4) {
+                       case 1:
+                               output += '=';
+                               break;
+                       case 2:
+                               output += '==';
+                               break;
+                       default:
+                               break;
+               }
+
+               return output;
+       }
+
+       module.exports.clean = clean;
+       module.exports.pad = pad;
+       module.exports.extend = extend;
+       module.exports.stringToUint8 = stringToUint8;
+       module.exports.uint8ToBase64 = uint8ToBase64;
+}());
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/*
+ * tar-js
+ * MIT (c) 2011 T. Jameson Little
+ */
+
+(function () {
+       "use strict";
+       
+/*
+struct posix_header {             // byte offset
+       char name[100];               //   0
+       char mode[8];                 // 100
+       char uid[8];                  // 108
+       char gid[8];                  // 116
+       char size[12];                // 124
+       char mtime[12];               // 136
+       char chksum[8];               // 148
+       char typeflag;                // 156
+       char linkname[100];           // 157
+       char magic[6];                // 257
+       char version[2];              // 263
+       char uname[32];               // 265
+       char gname[32];               // 297
+       char devmajor[8];             // 329
+       char devminor[8];             // 337
+       char prefix[155];             // 345
+                                  // 500
+};
+*/
+
+       var utils = __webpack_require__(0),
+               headerFormat;
+       
+       headerFormat = [
+               {
+                       'field': 'fileName',
+                       'length': 100
+               },
+               {
+                       'field': 'fileMode',
+                       'length': 8
+               },
+               {
+                       'field': 'uid',
+                       'length': 8
+               },
+               {
+                       'field': 'gid',
+                       'length': 8
+               },
+               {
+                       'field': 'fileSize',
+                       'length': 12
+               },
+               {
+                       'field': 'mtime',
+                       'length': 12
+               },
+               {
+                       'field': 'checksum',
+                       'length': 8
+               },
+               {
+                       'field': 'type',
+                       'length': 1
+               },
+               {
+                       'field': 'linkName',
+                       'length': 100
+               },
+               {
+                       'field': 'ustar',
+                       'length': 8
+               },
+               {
+                       'field': 'owner',
+                       'length': 32
+               },
+               {
+                       'field': 'group',
+                       'length': 32
+               },
+               {
+                       'field': 'majorNumber',
+                       'length': 8
+               },
+               {
+                       'field': 'minorNumber',
+                       'length': 8
+               },
+               {
+                       'field': 'filenamePrefix',
+                       'length': 155
+               },
+               {
+                       'field': 'padding',
+                       'length': 12
+               }
+       ];
+
+       function formatHeader(data, cb) {
+               var buffer = utils.clean(512),
+                       offset = 0;
+
+               headerFormat.forEach(function (value) {
+                       var str = data[value.field] || "",
+                               i, length;
+
+                       for (i = 0, length = str.length; i < length; i += 1) {
+                               buffer[offset] = str.charCodeAt(i);
+                               offset += 1;
+                       }
+
+                       offset += value.length - i; // space it out with nulls
+               });
+
+               if (typeof cb === 'function') {
+                       return cb(buffer, offset);
+               }
+               return buffer;
+       }
+       
+       module.exports.structure = headerFormat;
+       module.exports.format = formatHeader;
+}());
+
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/*
+ * tar-js
+ * MIT (c) 2011 T. Jameson Little
+ */
+
+(function () {
+       "use strict";
+
+       var header = __webpack_require__(1),
+               utils = __webpack_require__(0),
+               recordSize = 512,
+               blockSize;
+       
+       function Tar(recordsPerBlock) {
+               this.written = 0;
+               blockSize = (recordsPerBlock || 20) * recordSize;
+               this.out = utils.clean(blockSize);
+       }
+
+       Tar.prototype.append = function (filepath, input, opts, callback) {
+               var data,
+                       checksum,
+                       mode,
+                       mtime,
+                       uid,
+                       gid,
+                       headerArr;
+
+               if (typeof input === 'string') {
+                       input = utils.stringToUint8(input);
+               } else if (input.constructor !== Uint8Array.prototype.constructor) {
+                       throw 'Invalid input type. You gave me: ' + input.constructor.toString().match(/function\s*([$A-Za-z_][0-9A-Za-z_]*)\s*\(/)[1];
+               }
+
+               if (typeof opts === 'function') {
+                       callback = opts;
+                       opts = {};
+               }
+
+               opts = opts || {};
+
+               mode = opts.mode || parseInt('777', 8) & 0xfff;
+               mtime = opts.mtime || Math.floor(+new Date() / 1000);
+               uid = opts.uid || 0;
+               gid = opts.gid || 0;
+
+               data = {
+                       fileName: filepath,
+                       fileMode: utils.pad(mode, 7),
+                       uid: utils.pad(uid, 7),
+                       gid: utils.pad(gid, 7),
+                       fileSize: utils.pad(input.length, 11),
+                       mtime: utils.pad(mtime, 11),
+                       checksum: '        ',
+                       type: opts.type || '0',
+                       ustar: 'ustar  ',
+                       owner: opts.owner || '',
+                       group: opts.group || ''
+               };
+
+               // calculate the checksum
+               checksum = 0;
+               Object.keys(data).forEach(function (key) {
+                       var i, value = data[key], length;
+
+                       for (i = 0, length = value.length; i < length; i += 1) {
+                               checksum += value.charCodeAt(i);
+                       }
+               });
+
+               data.checksum = utils.pad(checksum, 6) + "\u0000 ";
+
+               headerArr = header.format(data);
+
+               var i, offset, length;
+
+               this.out.set(headerArr, this.written);
+
+               this.written += headerArr.length;
+
+               // If there is not enough space in this.out, we need to expand it to
+               // fit the new input.
+               if (this.written + input.length > this.out.length) {
+                       this.out = utils.extend(this.out, this.written, input.length, blockSize);
+               }
+
+               this.out.set(input, this.written);
+
+               // to the nearest multiple of recordSize
+               this.written += input.length + (recordSize - (input.length % recordSize || recordSize));
+
+               // make sure there's at least 2 empty records worth of extra space
+               if (this.out.length - this.written < recordSize * 2) {
+                       this.out = utils.extend(this.out, this.written, recordSize * 2, blockSize);
+               }
+
+               if (typeof callback === 'function') {
+                       callback(this.out);
+               }
+
+               return this.out;
+       };
+
+       Tar.prototype.clear = function () {
+               this.written = 0;
+               this.out = utils.clean(blockSize);
+       };
+       
+       module.exports = Tar;
+}());
+
+
+/***/ })
+/******/ ]);
\ No newline at end of file