diff --git a/docs/Action Rog/.obsidian/community-plugins.json b/docs/Action Rog/.obsidian/community-plugins.json index 7e0c513..78daa6d 100644 --- a/docs/Action Rog/.obsidian/community-plugins.json +++ b/docs/Action Rog/.obsidian/community-plugins.json @@ -1,3 +1,4 @@ [ - "table-editor-obsidian" + "table-editor-obsidian", + "obsidian-plantuml" ] \ No newline at end of file diff --git a/docs/Action Rog/.obsidian/graph.json b/docs/Action Rog/.obsidian/graph.json index 1118fe7..016ddf4 100644 --- a/docs/Action Rog/.obsidian/graph.json +++ b/docs/Action Rog/.obsidian/graph.json @@ -5,8 +5,23 @@ "showAttachments": true, "hideUnresolved": false, "showOrphans": true, - "collapse-color-groups": false, - "colorGroups": [], + "collapse-color-groups": true, + "colorGroups": [ + { + "query": "path:Спелы/Начинания/Первичные ", + "color": { + "a": 1, + "rgb": 14441727 + } + }, + { + "query": "path:Спелы/Начинания/Вторичные ", + "color": { + "a": 1, + "rgb": 14441727 + } + } + ], "collapse-display": false, "showArrow": false, "textFadeMultiplier": 0, @@ -17,6 +32,6 @@ "repelStrength": 10, "linkStrength": 1, "linkDistance": 250, - "scale": 0.9999999999999969, + "scale": 0.7132754626224395, "close": true } \ No newline at end of file diff --git a/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/main.js b/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/main.js new file mode 100644 index 0000000..57f43c7 --- /dev/null +++ b/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/main.js @@ -0,0 +1,7732 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +if you want to view the source, please visit the github repository of this plugin +https://github.com/joethei/obsidian-plantuml +*/ + +var __create = Object.create; +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }); +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + __markAsModule(target); + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __reExport = (target, module2, desc) => { + if (module2 && typeof module2 === "object" || typeof module2 === "function") { + for (let key of __getOwnPropNames(module2)) + if (!__hasOwnProp.call(target, key) && key !== "default") + __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable }); + } + return target; +}; +var __toModule = (module2) => { + return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2); +}; +var __async = (__this, __arguments, generator) => { + return new Promise((resolve, reject) => { + var fulfilled = (value) => { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + }; + var rejected = (value) => { + try { + step(generator.throw(value)); + } catch (e) { + reject(e); + } + }; + var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected); + step((generator = generator.apply(__this, __arguments)).next()); + }); +}; + +// node_modules/plantuml-encoder/dist/plantuml-encoder.js +var require_plantuml_encoder = __commonJS({ + "node_modules/plantuml-encoder/dist/plantuml-encoder.js"(exports, module2) { + (function(f) { + if (typeof exports === "object" && typeof module2 !== "undefined") { + module2.exports = f(); + } else if (typeof define === "function" && define.amd) { + define([], f); + } else { + var g; + if (typeof window !== "undefined") { + g = window; + } else if (typeof global !== "undefined") { + g = global; + } else if (typeof self !== "undefined") { + g = self; + } else { + g = this; + } + g.plantumlEncoder = f(); + } + })(function() { + var define2, module3, exports2; + return function() { + function r(e, n, t) { + function o(i2, f) { + if (!n[i2]) { + if (!e[i2]) { + var c = typeof require == "function" && require; + if (!f && c) + return c(i2, true); + if (u) + return u(i2, true); + var a = new Error("Cannot find module '" + i2 + "'"); + throw a.code = "MODULE_NOT_FOUND", a; + } + var p = n[i2] = { exports: {} }; + e[i2][0].call(p.exports, function(r2) { + var n2 = e[i2][1][r2]; + return o(n2 || r2); + }, p, p.exports, r, e, n, t); + } + return n[i2].exports; + } + for (var u = typeof require == "function" && require, i = 0; i < t.length; i++) + o(t[i]); + return o; + } + return r; + }()({ 1: [function(require2, module4, exports3) { + "use strict"; + var pako = require2("pako/lib/deflate.js"); + module4.exports = function(data) { + return pako.deflateRaw(data, { level: 9, to: "string" }); + }; + }, { "pako/lib/deflate.js": 4 }], 2: [function(require2, module4, exports3) { + "use strict"; + function encode6bit(b) { + if (b < 10) { + return String.fromCharCode(48 + b); + } + b -= 10; + if (b < 26) { + return String.fromCharCode(65 + b); + } + b -= 26; + if (b < 26) { + return String.fromCharCode(97 + b); + } + b -= 26; + if (b === 0) { + return "-"; + } + if (b === 1) { + return "_"; + } + return "?"; + } + function append3bytes(b1, b2, b3) { + var c1 = b1 >> 2; + var c2 = (b1 & 3) << 4 | b2 >> 4; + var c3 = (b2 & 15) << 2 | b3 >> 6; + var c4 = b3 & 63; + var r = ""; + r += encode6bit(c1 & 63); + r += encode6bit(c2 & 63); + r += encode6bit(c3 & 63); + r += encode6bit(c4 & 63); + return r; + } + module4.exports = function(data) { + var r = ""; + for (var i = 0; i < data.length; i += 3) { + if (i + 2 === data.length) { + r += append3bytes(data.charCodeAt(i), data.charCodeAt(i + 1), 0); + } else if (i + 1 === data.length) { + r += append3bytes(data.charCodeAt(i), 0, 0); + } else { + r += append3bytes(data.charCodeAt(i), data.charCodeAt(i + 1), data.charCodeAt(i + 2)); + } + } + return r; + }; + }, {}], 3: [function(require2, module4, exports3) { + "use strict"; + var deflate = require2("./deflate"); + var encode64 = require2("./encode64"); + module4.exports.encode = function(puml) { + var deflated = deflate(puml); + return encode64(deflated); + }; + }, { "./deflate": 1, "./encode64": 2 }], 4: [function(require2, module4, exports3) { + "use strict"; + var zlib_deflate = require2("./zlib/deflate"); + var utils = require2("./utils/common"); + var strings = require2("./utils/strings"); + var msg = require2("./zlib/messages"); + var ZStream = require2("./zlib/zstream"); + var toString = Object.prototype.toString; + var Z_NO_FLUSH = 0; + var Z_FINISH = 4; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_SYNC_FLUSH = 2; + var Z_DEFAULT_COMPRESSION = -1; + var Z_DEFAULT_STRATEGY = 0; + var Z_DEFLATED = 8; + function Deflate(options) { + if (!(this instanceof Deflate)) + return new Deflate(options); + this.options = utils.assign({ + level: Z_DEFAULT_COMPRESSION, + method: Z_DEFLATED, + chunkSize: 16384, + windowBits: 15, + memLevel: 8, + strategy: Z_DEFAULT_STRATEGY, + to: "" + }, options || {}); + var opt = this.options; + if (opt.raw && opt.windowBits > 0) { + opt.windowBits = -opt.windowBits; + } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) { + opt.windowBits += 16; + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new ZStream(); + this.strm.avail_out = 0; + var status = zlib_deflate.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy); + if (status !== Z_OK) { + throw new Error(msg[status]); + } + if (opt.header) { + zlib_deflate.deflateSetHeader(this.strm, opt.header); + } + if (opt.dictionary) { + var dict; + if (typeof opt.dictionary === "string") { + dict = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") { + dict = new Uint8Array(opt.dictionary); + } else { + dict = opt.dictionary; + } + status = zlib_deflate.deflateSetDictionary(this.strm, dict); + if (status !== Z_OK) { + throw new Error(msg[status]); + } + this._dict_set = true; + } + } + Deflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var status, _mode; + if (this.ended) { + return false; + } + _mode = mode === ~~mode ? mode : mode === true ? Z_FINISH : Z_NO_FLUSH; + if (typeof data === "string") { + strm.input = strings.string2buf(data); + } else if (toString.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status = zlib_deflate.deflate(strm, _mode); + if (status !== Z_STREAM_END && status !== Z_OK) { + this.onEnd(status); + this.ended = true; + return false; + } + if (strm.avail_out === 0 || strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH)) { + if (this.options.to === "string") { + this.onData(strings.buf2binstring(utils.shrinkBuf(strm.output, strm.next_out))); + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END); + if (_mode === Z_FINISH) { + status = zlib_deflate.deflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === Z_OK; + } + if (_mode === Z_SYNC_FLUSH) { + this.onEnd(Z_OK); + strm.avail_out = 0; + return true; + } + return true; + }; + Deflate.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Deflate.prototype.onEnd = function(status) { + if (status === Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function deflate(input, options) { + var deflator = new Deflate(options); + deflator.push(input, true); + if (deflator.err) { + throw deflator.msg || msg[deflator.err]; + } + return deflator.result; + } + function deflateRaw(input, options) { + options = options || {}; + options.raw = true; + return deflate(input, options); + } + function gzip(input, options) { + options = options || {}; + options.gzip = true; + return deflate(input, options); + } + exports3.Deflate = Deflate; + exports3.deflate = deflate; + exports3.deflateRaw = deflateRaw; + exports3.gzip = gzip; + }, { "./utils/common": 5, "./utils/strings": 6, "./zlib/deflate": 9, "./zlib/messages": 10, "./zlib/zstream": 12 }], 5: [function(require2, module4, exports3) { + "use strict"; + var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined"; + function _has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); + } + exports3.assign = function(obj) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { + continue; + } + if (typeof source !== "object") { + throw new TypeError(source + "must be non-object"); + } + for (var p in source) { + if (_has(source, p)) { + obj[p] = source[p]; + } + } + } + return obj; + }; + exports3.shrinkBuf = function(buf, size) { + if (buf.length === size) { + return buf; + } + if (buf.subarray) { + return buf.subarray(0, size); + } + buf.length = size; + return buf; + }; + var fnTyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs + len), dest_offs); + return; + } + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + flattenChunks: function(chunks) { + var i, l, len, pos, chunk, result; + len = 0; + for (i = 0, l = chunks.length; i < l; i++) { + len += chunks[i].length; + } + result = new Uint8Array(len); + pos = 0; + for (i = 0, l = chunks.length; i < l; i++) { + chunk = chunks[i]; + result.set(chunk, pos); + pos += chunk.length; + } + return result; + } + }; + var fnUntyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + flattenChunks: function(chunks) { + return [].concat.apply([], chunks); + } + }; + exports3.setTyped = function(on) { + if (on) { + exports3.Buf8 = Uint8Array; + exports3.Buf16 = Uint16Array; + exports3.Buf32 = Int32Array; + exports3.assign(exports3, fnTyped); + } else { + exports3.Buf8 = Array; + exports3.Buf16 = Array; + exports3.Buf32 = Array; + exports3.assign(exports3, fnUntyped); + } + }; + exports3.setTyped(TYPED_OK); + }, {}], 6: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("./common"); + var STR_APPLY_OK = true; + var STR_APPLY_UIA_OK = true; + try { + String.fromCharCode.apply(null, [0]); + } catch (__) { + STR_APPLY_OK = false; + } + try { + String.fromCharCode.apply(null, new Uint8Array(1)); + } catch (__) { + STR_APPLY_UIA_OK = false; + } + var _utf8len = new utils.Buf8(256); + for (var q = 0; q < 256; q++) { + _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + _utf8len[254] = _utf8len[254] = 1; + exports3.string2buf = function(str) { + var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0; + for (m_pos = 0; m_pos < str_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4; + } + buf = new utils.Buf8(buf_len); + for (i = 0, m_pos = 0; i < buf_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + if (c < 128) { + buf[i++] = c; + } else if (c < 2048) { + buf[i++] = 192 | c >>> 6; + buf[i++] = 128 | c & 63; + } else if (c < 65536) { + buf[i++] = 224 | c >>> 12; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } else { + buf[i++] = 240 | c >>> 18; + buf[i++] = 128 | c >>> 12 & 63; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } + } + return buf; + }; + function buf2binstring(buf, len) { + if (len < 65534) { + if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) { + return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len)); + } + } + var result = ""; + for (var i = 0; i < len; i++) { + result += String.fromCharCode(buf[i]); + } + return result; + } + exports3.buf2binstring = function(buf) { + return buf2binstring(buf, buf.length); + }; + exports3.binstring2buf = function(str) { + var buf = new utils.Buf8(str.length); + for (var i = 0, len = buf.length; i < len; i++) { + buf[i] = str.charCodeAt(i); + } + return buf; + }; + exports3.buf2string = function(buf, max) { + var i, out, c, c_len; + var len = max || buf.length; + var utf16buf = new Array(len * 2); + for (out = 0, i = 0; i < len; ) { + c = buf[i++]; + if (c < 128) { + utf16buf[out++] = c; + continue; + } + c_len = _utf8len[c]; + if (c_len > 4) { + utf16buf[out++] = 65533; + i += c_len - 1; + continue; + } + c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7; + while (c_len > 1 && i < len) { + c = c << 6 | buf[i++] & 63; + c_len--; + } + if (c_len > 1) { + utf16buf[out++] = 65533; + continue; + } + if (c < 65536) { + utf16buf[out++] = c; + } else { + c -= 65536; + utf16buf[out++] = 55296 | c >> 10 & 1023; + utf16buf[out++] = 56320 | c & 1023; + } + } + return buf2binstring(utf16buf, out); + }; + exports3.utf8border = function(buf, max) { + var pos; + max = max || buf.length; + if (max > buf.length) { + max = buf.length; + } + pos = max - 1; + while (pos >= 0 && (buf[pos] & 192) === 128) { + pos--; + } + if (pos < 0) { + return max; + } + if (pos === 0) { + return max; + } + return pos + _utf8len[buf[pos]] > max ? pos : max; + }; + }, { "./common": 5 }], 7: [function(require2, module4, exports3) { + "use strict"; + function adler32(adler, buf, len, pos) { + var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0; + while (len !== 0) { + n = len > 2e3 ? 2e3 : len; + len -= n; + do { + s1 = s1 + buf[pos++] | 0; + s2 = s2 + s1 | 0; + } while (--n); + s1 %= 65521; + s2 %= 65521; + } + return s1 | s2 << 16 | 0; + } + module4.exports = adler32; + }, {}], 8: [function(require2, module4, exports3) { + "use strict"; + function makeTable() { + var c, table = []; + for (var n = 0; n < 256; n++) { + c = n; + for (var k = 0; k < 8; k++) { + c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1; + } + table[n] = c; + } + return table; + } + var crcTable = makeTable(); + function crc32(crc, buf, len, pos) { + var t = crcTable, end = pos + len; + crc ^= -1; + for (var i = pos; i < end; i++) { + crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255]; + } + return crc ^ -1; + } + module4.exports = crc32; + }, {}], 9: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/common"); + var trees = require2("./trees"); + var adler32 = require2("./adler32"); + var crc32 = require2("./crc32"); + var msg = require2("./messages"); + var Z_NO_FLUSH = 0; + var Z_PARTIAL_FLUSH = 1; + var Z_FULL_FLUSH = 3; + var Z_FINISH = 4; + var Z_BLOCK = 5; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_BUF_ERROR = -5; + var Z_DEFAULT_COMPRESSION = -1; + var Z_FILTERED = 1; + var Z_HUFFMAN_ONLY = 2; + var Z_RLE = 3; + var Z_FIXED = 4; + var Z_DEFAULT_STRATEGY = 0; + var Z_UNKNOWN = 2; + var Z_DEFLATED = 8; + var MAX_MEM_LEVEL = 9; + var MAX_WBITS = 15; + var DEF_MEM_LEVEL = 8; + var LENGTH_CODES = 29; + var LITERALS = 256; + var L_CODES = LITERALS + 1 + LENGTH_CODES; + var D_CODES = 30; + var BL_CODES = 19; + var HEAP_SIZE = 2 * L_CODES + 1; + var MAX_BITS = 15; + var MIN_MATCH = 3; + var MAX_MATCH = 258; + var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1; + var PRESET_DICT = 32; + var INIT_STATE = 42; + var EXTRA_STATE = 69; + var NAME_STATE = 73; + var COMMENT_STATE = 91; + var HCRC_STATE = 103; + var BUSY_STATE = 113; + var FINISH_STATE = 666; + var BS_NEED_MORE = 1; + var BS_BLOCK_DONE = 2; + var BS_FINISH_STARTED = 3; + var BS_FINISH_DONE = 4; + var OS_CODE = 3; + function err(strm, errorCode) { + strm.msg = msg[errorCode]; + return errorCode; + } + function rank(f) { + return (f << 1) - (f > 4 ? 9 : 0); + } + function zero(buf) { + var len = buf.length; + while (--len >= 0) { + buf[len] = 0; + } + } + function flush_pending(strm) { + var s = strm.state; + var len = s.pending; + if (len > strm.avail_out) { + len = strm.avail_out; + } + if (len === 0) { + return; + } + utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); + strm.next_out += len; + s.pending_out += len; + strm.total_out += len; + strm.avail_out -= len; + s.pending -= len; + if (s.pending === 0) { + s.pending_out = 0; + } + } + function flush_block_only(s, last) { + trees._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last); + s.block_start = s.strstart; + flush_pending(s.strm); + } + function put_byte(s, b) { + s.pending_buf[s.pending++] = b; + } + function putShortMSB(s, b) { + s.pending_buf[s.pending++] = b >>> 8 & 255; + s.pending_buf[s.pending++] = b & 255; + } + function read_buf(strm, buf, start, size) { + var len = strm.avail_in; + if (len > size) { + len = size; + } + if (len === 0) { + return 0; + } + strm.avail_in -= len; + utils.arraySet(buf, strm.input, strm.next_in, len, start); + if (strm.state.wrap === 1) { + strm.adler = adler32(strm.adler, buf, len, start); + } else if (strm.state.wrap === 2) { + strm.adler = crc32(strm.adler, buf, len, start); + } + strm.next_in += len; + strm.total_in += len; + return len; + } + function longest_match(s, cur_match) { + var chain_length = s.max_chain_length; + var scan = s.strstart; + var match; + var len; + var best_len = s.prev_length; + var nice_match = s.nice_match; + var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0; + var _win = s.window; + var wmask = s.w_mask; + var prev = s.prev; + var strend = s.strstart + MAX_MATCH; + var scan_end1 = _win[scan + best_len - 1]; + var scan_end = _win[scan + best_len]; + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + if (nice_match > s.lookahead) { + nice_match = s.lookahead; + } + do { + match = cur_match; + if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) { + continue; + } + scan += 2; + match++; + do { + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend); + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + if (len > best_len) { + s.match_start = cur_match; + best_len = len; + if (len >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; + } + function fill_window(s) { + var _w_size = s.w_size; + var p, n, m, more, str; + do { + more = s.window_size - s.lookahead - s.strstart; + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + utils.arraySet(s.window, s.window, _w_size, _w_size, 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + s.block_start -= _w_size; + n = s.hash_size; + p = n; + do { + m = s.head[--p]; + s.head[p] = m >= _w_size ? m - _w_size : 0; + } while (--n); + n = _w_size; + p = n; + do { + m = s.prev[--p]; + s.prev[p] = m >= _w_size ? m - _w_size : 0; + } while (--n); + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n; + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask; + while (s.insert) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + } + function deflate_stored(s, flush) { + var max_block_size = 65535; + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + for (; ; ) { + if (s.lookahead <= 1) { + fill_window(s); + if (s.lookahead === 0 && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + s.strstart += s.lookahead; + s.lookahead = 0; + var max_start = s.block_start + max_block_size; + if (s.strstart === 0 || s.strstart >= max_start) { + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.strstart > s.block_start) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_NEED_MORE; + } + function deflate_fast(s, flush) { + var hash_head; + var bflush; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + } + if (s.match_length >= MIN_MATCH) { + bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) { + s.match_length--; + do { + s.strstart++; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } while (--s.match_length !== 0); + s.strstart++; + } else { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask; + } + } else { + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_slow(s, flush) { + var hash_head; + var bflush; + var max_insert; + for (; ; ) { + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + hash_head = 0; + if (s.lookahead >= MIN_MATCH) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH - 1; + if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) { + s.match_length = longest_match(s, hash_head); + if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) { + s.match_length = MIN_MATCH - 1; + } + } + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH - 1; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } else if (s.match_available) { + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + if (bflush) { + flush_block_only(s, false); + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + if (s.match_available) { + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_rle(s, flush) { + var bflush; + var prev; + var scan, strend; + var _win = s.window; + for (; ; ) { + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; + } + } + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + } while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + } + if (s.match_length >= MIN_MATCH) { + bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + } + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function deflate_huff(s, flush) { + var bflush; + for (; ; ) { + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + break; + } + } + s.match_length = 0; + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + } + s.insert = 0; + if (flush === Z_FINISH) { + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + return BS_FINISH_DONE; + } + if (s.last_lit) { + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } + return BS_BLOCK_DONE; + } + function Config(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; + } + var configuration_table; + configuration_table = [ + new Config(0, 0, 0, 0, deflate_stored), + new Config(4, 4, 8, 4, deflate_fast), + new Config(4, 5, 16, 8, deflate_fast), + new Config(4, 6, 32, 32, deflate_fast), + new Config(4, 4, 16, 16, deflate_slow), + new Config(8, 16, 32, 32, deflate_slow), + new Config(8, 16, 128, 128, deflate_slow), + new Config(8, 32, 128, 256, deflate_slow), + new Config(32, 128, 258, 1024, deflate_slow), + new Config(32, 258, 258, 4096, deflate_slow) + ]; + function lm_init(s) { + s.window_size = 2 * s.w_size; + zero(s.head); + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; + } + function DeflateState() { + this.strm = null; + this.status = 0; + this.pending_buf = null; + this.pending_buf_size = 0; + this.pending_out = 0; + this.pending = 0; + this.wrap = 0; + this.gzhead = null; + this.gzindex = 0; + this.method = Z_DEFLATED; + this.last_flush = -1; + this.w_size = 0; + this.w_bits = 0; + this.w_mask = 0; + this.window = null; + this.window_size = 0; + this.prev = null; + this.head = null; + this.ins_h = 0; + this.hash_size = 0; + this.hash_bits = 0; + this.hash_mask = 0; + this.hash_shift = 0; + this.block_start = 0; + this.match_length = 0; + this.prev_match = 0; + this.match_available = 0; + this.strstart = 0; + this.match_start = 0; + this.lookahead = 0; + this.prev_length = 0; + this.max_chain_length = 0; + this.max_lazy_match = 0; + this.level = 0; + this.strategy = 0; + this.good_match = 0; + this.nice_match = 0; + this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); + this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2); + this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + this.l_desc = null; + this.d_desc = null; + this.bl_desc = null; + this.bl_count = new utils.Buf16(MAX_BITS + 1); + this.heap = new utils.Buf16(2 * L_CODES + 1); + zero(this.heap); + this.heap_len = 0; + this.heap_max = 0; + this.depth = new utils.Buf16(2 * L_CODES + 1); + zero(this.depth); + this.l_buf = 0; + this.lit_bufsize = 0; + this.last_lit = 0; + this.d_buf = 0; + this.opt_len = 0; + this.static_len = 0; + this.matches = 0; + this.insert = 0; + this.bi_buf = 0; + this.bi_valid = 0; + } + function deflateResetKeep(strm) { + var s; + if (!strm || !strm.state) { + return err(strm, Z_STREAM_ERROR); + } + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + s = strm.state; + s.pending = 0; + s.pending_out = 0; + if (s.wrap < 0) { + s.wrap = -s.wrap; + } + s.status = s.wrap ? INIT_STATE : BUSY_STATE; + strm.adler = s.wrap === 2 ? 0 : 1; + s.last_flush = Z_NO_FLUSH; + trees._tr_init(s); + return Z_OK; + } + function deflateReset(strm) { + var ret = deflateResetKeep(strm); + if (ret === Z_OK) { + lm_init(strm.state); + } + return ret; + } + function deflateSetHeader(strm, head) { + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + if (strm.state.wrap !== 2) { + return Z_STREAM_ERROR; + } + strm.state.gzhead = head; + return Z_OK; + } + function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { + if (!strm) { + return Z_STREAM_ERROR; + } + var wrap = 1; + if (level === Z_DEFAULT_COMPRESSION) { + level = 6; + } + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else if (windowBits > 15) { + wrap = 2; + windowBits -= 16; + } + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + return err(strm, Z_STREAM_ERROR); + } + if (windowBits === 8) { + windowBits = 9; + } + var s = new DeflateState(); + strm.state = s; + s.strm = strm; + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + s.window = new utils.Buf8(s.w_size * 2); + s.head = new utils.Buf16(s.hash_size); + s.prev = new utils.Buf16(s.w_size); + s.lit_bufsize = 1 << memLevel + 6; + s.pending_buf_size = s.lit_bufsize * 4; + s.pending_buf = new utils.Buf8(s.pending_buf_size); + s.d_buf = 1 * s.lit_bufsize; + s.l_buf = (1 + 2) * s.lit_bufsize; + s.level = level; + s.strategy = strategy; + s.method = method; + return deflateReset(strm); + } + function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); + } + function deflate(strm, flush) { + var old_flush, s; + var beg, val; + if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) { + return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; + } + s = strm.state; + if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z_FINISH) { + return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR); + } + s.strm = strm; + old_flush = s.last_flush; + s.last_flush = flush; + if (s.status === INIT_STATE) { + if (s.wrap === 2) { + strm.adler = 0; + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + } else { + put_byte(s, (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16)); + put_byte(s, s.gzhead.time & 255); + put_byte(s, s.gzhead.time >> 8 & 255); + put_byte(s, s.gzhead.time >> 16 & 255); + put_byte(s, s.gzhead.time >> 24 & 255); + put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0); + put_byte(s, s.gzhead.os & 255); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 255); + put_byte(s, s.gzhead.extra.length >> 8 & 255); + } + if (s.gzhead.hcrc) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } else { + var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8; + var level_flags = -1; + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= level_flags << 6; + if (s.strstart !== 0) { + header |= PRESET_DICT; + } + header += 31 - header % 31; + s.status = BUSY_STATE; + putShortMSB(s, header); + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + strm.adler = 1; + } + } + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra) { + beg = s.pending; + while (s.gzindex < (s.gzhead.extra.length & 65535)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte(s, s.gzhead.extra[s.gzindex] & 255); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE; + } + } else { + s.status = NAME_STATE; + } + } + if (s.status === NAME_STATE) { + if (s.gzhead.name) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE; + } + } else { + s.status = COMMENT_STATE; + } + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment) { + beg = s.pending; + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE; + } + } else { + s.status = HCRC_STATE; + } + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + strm.adler = 0; + s.status = BUSY_STATE; + } + } else { + s.status = BUSY_STATE; + } + } + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK; + } + } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) { + return err(strm, Z_BUF_ERROR); + } + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR); + } + if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE) { + var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush); + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + } + return Z_OK; + } + if (bstate === BS_BLOCK_DONE) { + if (flush === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } else if (flush !== Z_BLOCK) { + trees._tr_stored_block(s, 0, 0, false); + if (flush === Z_FULL_FLUSH) { + zero(s.head); + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; + return Z_OK; + } + } + } + if (flush !== Z_FINISH) { + return Z_OK; + } + if (s.wrap <= 0) { + return Z_STREAM_END; + } + if (s.wrap === 2) { + put_byte(s, strm.adler & 255); + put_byte(s, strm.adler >> 8 & 255); + put_byte(s, strm.adler >> 16 & 255); + put_byte(s, strm.adler >> 24 & 255); + put_byte(s, strm.total_in & 255); + put_byte(s, strm.total_in >> 8 & 255); + put_byte(s, strm.total_in >> 16 & 255); + put_byte(s, strm.total_in >> 24 & 255); + } else { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 65535); + } + flush_pending(strm); + if (s.wrap > 0) { + s.wrap = -s.wrap; + } + return s.pending !== 0 ? Z_OK : Z_STREAM_END; + } + function deflateEnd(strm) { + var status; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + status = strm.state.status; + if (status !== INIT_STATE && status !== EXTRA_STATE && status !== NAME_STATE && status !== COMMENT_STATE && status !== HCRC_STATE && status !== BUSY_STATE && status !== FINISH_STATE) { + return err(strm, Z_STREAM_ERROR); + } + strm.state = null; + return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; + } + function deflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + var s; + var str, n; + var wrap; + var avail; + var next; + var input; + var tmpDict; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + s = strm.state; + wrap = s.wrap; + if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) { + return Z_STREAM_ERROR; + } + if (wrap === 1) { + strm.adler = adler32(strm.adler, dictionary, dictLength, 0); + } + s.wrap = 0; + if (dictLength >= s.w_size) { + if (wrap === 0) { + zero(s.head); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + tmpDict = new utils.Buf8(s.w_size); + utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + avail = strm.avail_in; + next = strm.next_in; + input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window(s); + while (s.lookahead >= MIN_MATCH) { + str = s.strstart; + n = s.lookahead - (MIN_MATCH - 1); + do { + s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + } while (--n); + s.strstart = str; + s.lookahead = MIN_MATCH - 1; + fill_window(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK; + } + exports3.deflateInit = deflateInit; + exports3.deflateInit2 = deflateInit2; + exports3.deflateReset = deflateReset; + exports3.deflateResetKeep = deflateResetKeep; + exports3.deflateSetHeader = deflateSetHeader; + exports3.deflate = deflate; + exports3.deflateEnd = deflateEnd; + exports3.deflateSetDictionary = deflateSetDictionary; + exports3.deflateInfo = "pako deflate (from Nodeca project)"; + }, { "../utils/common": 5, "./adler32": 7, "./crc32": 8, "./messages": 10, "./trees": 11 }], 10: [function(require2, module4, exports3) { + "use strict"; + module4.exports = { + 2: "need dictionary", + 1: "stream end", + 0: "", + "-1": "file error", + "-2": "stream error", + "-3": "data error", + "-4": "insufficient memory", + "-5": "buffer error", + "-6": "incompatible version" + }; + }, {}], 11: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/common"); + var Z_FIXED = 4; + var Z_BINARY = 0; + var Z_TEXT = 1; + var Z_UNKNOWN = 2; + function zero(buf) { + var len = buf.length; + while (--len >= 0) { + buf[len] = 0; + } + } + var STORED_BLOCK = 0; + var STATIC_TREES = 1; + var DYN_TREES = 2; + var MIN_MATCH = 3; + var MAX_MATCH = 258; + var LENGTH_CODES = 29; + var LITERALS = 256; + var L_CODES = LITERALS + 1 + LENGTH_CODES; + var D_CODES = 30; + var BL_CODES = 19; + var HEAP_SIZE = 2 * L_CODES + 1; + var MAX_BITS = 15; + var Buf_size = 16; + var MAX_BL_BITS = 7; + var END_BLOCK = 256; + var REP_3_6 = 16; + var REPZ_3_10 = 17; + var REPZ_11_138 = 18; + var extra_lbits = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]; + var extra_dbits = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]; + var extra_blbits = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]; + var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; + var DIST_CODE_LEN = 512; + var static_ltree = new Array((L_CODES + 2) * 2); + zero(static_ltree); + var static_dtree = new Array(D_CODES * 2); + zero(static_dtree); + var _dist_code = new Array(DIST_CODE_LEN); + zero(_dist_code); + var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1); + zero(_length_code); + var base_length = new Array(LENGTH_CODES); + zero(base_length); + var base_dist = new Array(D_CODES); + zero(base_dist); + function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) { + this.static_tree = static_tree; + this.extra_bits = extra_bits; + this.extra_base = extra_base; + this.elems = elems; + this.max_length = max_length; + this.has_stree = static_tree && static_tree.length; + } + var static_l_desc; + var static_d_desc; + var static_bl_desc; + function TreeDesc(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; + this.max_code = 0; + this.stat_desc = stat_desc; + } + function d_code(dist) { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; + } + function put_short(s, w) { + s.pending_buf[s.pending++] = w & 255; + s.pending_buf[s.pending++] = w >>> 8 & 255; + } + function send_bits(s, value, length) { + if (s.bi_valid > Buf_size - length) { + s.bi_buf |= value << s.bi_valid & 65535; + put_short(s, s.bi_buf); + s.bi_buf = value >> Buf_size - s.bi_valid; + s.bi_valid += length - Buf_size; + } else { + s.bi_buf |= value << s.bi_valid & 65535; + s.bi_valid += length; + } + } + function send_code(s, c, tree) { + send_bits(s, tree[c * 2], tree[c * 2 + 1]); + } + function bi_reverse(code, len) { + var res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len > 0); + return res >>> 1; + } + function bi_flush(s) { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 255; + s.bi_buf >>= 8; + s.bi_valid -= 8; + } + } + function gen_bitlen(s, desc) { + var tree = desc.dyn_tree; + var max_code = desc.max_code; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var extra = desc.stat_desc.extra_bits; + var base = desc.stat_desc.extra_base; + var max_length = desc.stat_desc.max_length; + var h; + var n, m; + var bits; + var xbits; + var f; + var overflow = 0; + for (bits = 0; bits <= MAX_BITS; bits++) { + s.bl_count[bits] = 0; + } + tree[s.heap[s.heap_max] * 2 + 1] = 0; + for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n * 2 + 1] * 2 + 1] + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n * 2 + 1] = bits; + if (n > max_code) { + continue; + } + s.bl_count[bits]++; + xbits = 0; + if (n >= base) { + xbits = extra[n - base]; + } + f = tree[n * 2]; + s.opt_len += f * (bits + xbits); + if (has_stree) { + s.static_len += f * (stree[n * 2 + 1] + xbits); + } + } + if (overflow === 0) { + return; + } + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { + bits--; + } + s.bl_count[bits]--; + s.bl_count[bits + 1] += 2; + s.bl_count[max_length]--; + overflow -= 2; + } while (overflow > 0); + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > max_code) { + continue; + } + if (tree[m * 2 + 1] !== bits) { + s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2]; + tree[m * 2 + 1] = bits; + } + n--; + } + } + } + function gen_codes(tree, max_code, bl_count) { + var next_code = new Array(MAX_BITS + 1); + var code = 0; + var bits; + var n; + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = code + bl_count[bits - 1] << 1; + } + for (n = 0; n <= max_code; n++) { + var len = tree[n * 2 + 1]; + if (len === 0) { + continue; + } + tree[n * 2] = bi_reverse(next_code[len]++, len); + } + } + function tr_static_init() { + var n; + var bits; + var length; + var code; + var dist; + var bl_count = new Array(MAX_BITS + 1); + length = 0; + for (code = 0; code < LENGTH_CODES - 1; code++) { + base_length[code] = length; + for (n = 0; n < 1 << extra_lbits[code]; n++) { + _length_code[length++] = code; + } + } + _length_code[length - 1] = code; + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < 1 << extra_dbits[code]; n++) { + _dist_code[dist++] = code; + } + } + dist >>= 7; + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < 1 << extra_dbits[code] - 7; n++) { + _dist_code[256 + dist++] = code; + } + } + for (bits = 0; bits <= MAX_BITS; bits++) { + bl_count[bits] = 0; + } + n = 0; + while (n <= 143) { + static_ltree[n * 2 + 1] = 8; + n++; + bl_count[8]++; + } + while (n <= 255) { + static_ltree[n * 2 + 1] = 9; + n++; + bl_count[9]++; + } + while (n <= 279) { + static_ltree[n * 2 + 1] = 7; + n++; + bl_count[7]++; + } + while (n <= 287) { + static_ltree[n * 2 + 1] = 8; + n++; + bl_count[8]++; + } + gen_codes(static_ltree, L_CODES + 1, bl_count); + for (n = 0; n < D_CODES; n++) { + static_dtree[n * 2 + 1] = 5; + static_dtree[n * 2] = bi_reverse(n, 5); + } + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); + static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); + } + function init_block(s) { + var n; + for (n = 0; n < L_CODES; n++) { + s.dyn_ltree[n * 2] = 0; + } + for (n = 0; n < D_CODES; n++) { + s.dyn_dtree[n * 2] = 0; + } + for (n = 0; n < BL_CODES; n++) { + s.bl_tree[n * 2] = 0; + } + s.dyn_ltree[END_BLOCK * 2] = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; + } + function bi_windup(s) { + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; + } + function copy_block(s, buf, len, header) { + bi_windup(s); + if (header) { + put_short(s, len); + put_short(s, ~len); + } + utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); + s.pending += len; + } + function smaller(tree, n, m, depth) { + var _n2 = n * 2; + var _m2 = m * 2; + return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m]; + } + function pqdownheap(s, tree, k) { + var v = s.heap[k]; + var j = k << 1; + while (j <= s.heap_len) { + if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + if (smaller(tree, v, s.heap[j], s.depth)) { + break; + } + s.heap[k] = s.heap[j]; + k = j; + j <<= 1; + } + s.heap[k] = v; + } + function compress_block(s, ltree, dtree) { + var dist; + var lc; + var lx = 0; + var code; + var extra; + if (s.last_lit !== 0) { + do { + dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1]; + lc = s.pending_buf[s.l_buf + lx]; + lx++; + if (dist === 0) { + send_code(s, lc, ltree); + } else { + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); + } + dist--; + code = d_code(dist); + send_code(s, code, dtree); + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); + } + } + } while (lx < s.last_lit); + } + send_code(s, END_BLOCK, ltree); + } + function build_tree(s, desc) { + var tree = desc.dyn_tree; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var elems = desc.stat_desc.elems; + var n, m; + var max_code = -1; + var node; + s.heap_len = 0; + s.heap_max = HEAP_SIZE; + for (n = 0; n < elems; n++) { + if (tree[n * 2] !== 0) { + s.heap[++s.heap_len] = max_code = n; + s.depth[n] = 0; + } else { + tree[n * 2 + 1] = 0; + } + } + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0; + tree[node * 2] = 1; + s.depth[node] = 0; + s.opt_len--; + if (has_stree) { + s.static_len -= stree[node * 2 + 1]; + } + } + desc.max_code = max_code; + for (n = s.heap_len >> 1; n >= 1; n--) { + pqdownheap(s, tree, n); + } + node = elems; + do { + n = s.heap[1]; + s.heap[1] = s.heap[s.heap_len--]; + pqdownheap(s, tree, 1); + m = s.heap[1]; + s.heap[--s.heap_max] = n; + s.heap[--s.heap_max] = m; + tree[node * 2] = tree[n * 2] + tree[m * 2]; + s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; + tree[n * 2 + 1] = tree[m * 2 + 1] = node; + s.heap[1] = node++; + pqdownheap(s, tree, 1); + } while (s.heap_len >= 2); + s.heap[--s.heap_max] = s.heap[1]; + gen_bitlen(s, desc); + gen_codes(tree, max_code, s.bl_count); + } + function scan_tree(s, tree, max_code) { + var n; + var prevlen = -1; + var curlen; + var nextlen = tree[0 * 2 + 1]; + var count = 0; + var max_count = 7; + var min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1] = 65535; + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen === nextlen) { + continue; + } else if (count < min_count) { + s.bl_tree[curlen * 2] += count; + } else if (curlen !== 0) { + if (curlen !== prevlen) { + s.bl_tree[curlen * 2]++; + } + s.bl_tree[REP_3_6 * 2]++; + } else if (count <= 10) { + s.bl_tree[REPZ_3_10 * 2]++; + } else { + s.bl_tree[REPZ_11_138 * 2]++; + } + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + } + function send_tree(s, tree, max_code) { + var n; + var prevlen = -1; + var curlen; + var nextlen = tree[0 * 2 + 1]; + var count = 0; + var max_count = 7; + var min_count = 4; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]; + if (++count < max_count && curlen === nextlen) { + continue; + } else if (count < min_count) { + do { + send_code(s, curlen, s.bl_tree); + } while (--count !== 0); + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count--; + } + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count - 3, 2); + } else if (count <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count - 3, 3); + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count - 11, 7); + } + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + } else { + max_count = 7; + min_count = 4; + } + } + } + function build_bl_tree(s) { + var max_blindex; + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + build_tree(s, s.bl_desc); + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) { + break; + } + } + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + return max_blindex; + } + function send_all_trees(s, lcodes, dcodes, blcodes) { + var rank; + send_bits(s, lcodes - 257, 5); + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); + for (rank = 0; rank < blcodes; rank++) { + send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3); + } + send_tree(s, s.dyn_ltree, lcodes - 1); + send_tree(s, s.dyn_dtree, dcodes - 1); + } + function detect_data_type(s) { + var black_mask = 4093624447; + var n; + for (n = 0; n <= 31; n++, black_mask >>>= 1) { + if (black_mask & 1 && s.dyn_ltree[n * 2] !== 0) { + return Z_BINARY; + } + } + if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) { + return Z_TEXT; + } + for (n = 32; n < LITERALS; n++) { + if (s.dyn_ltree[n * 2] !== 0) { + return Z_TEXT; + } + } + return Z_BINARY; + } + var static_init_done = false; + function _tr_init(s) { + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + s.bi_buf = 0; + s.bi_valid = 0; + init_block(s); + } + function _tr_stored_block(s, buf, stored_len, last) { + send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); + copy_block(s, buf, stored_len, true); + } + function _tr_align(s) { + send_bits(s, STATIC_TREES << 1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); + } + function _tr_flush_block(s, buf, stored_len, last) { + var opt_lenb, static_lenb; + var max_blindex = 0; + if (s.level > 0) { + if (s.strm.data_type === Z_UNKNOWN) { + s.strm.data_type = detect_data_type(s); + } + build_tree(s, s.l_desc); + build_tree(s, s.d_desc); + max_blindex = build_bl_tree(s); + opt_lenb = s.opt_len + 3 + 7 >>> 3; + static_lenb = s.static_len + 3 + 7 >>> 3; + if (static_lenb <= opt_lenb) { + opt_lenb = static_lenb; + } + } else { + opt_lenb = static_lenb = stored_len + 5; + } + if (stored_len + 4 <= opt_lenb && buf !== -1) { + _tr_stored_block(s, buf, stored_len, last); + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + } else { + send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + init_block(s); + if (last) { + bi_windup(s); + } + } + function _tr_tally(s, dist, lc) { + s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 255; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 255; + s.pending_buf[s.l_buf + s.last_lit] = lc & 255; + s.last_lit++; + if (dist === 0) { + s.dyn_ltree[lc * 2]++; + } else { + s.matches++; + dist--; + s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++; + s.dyn_dtree[d_code(dist) * 2]++; + } + return s.last_lit === s.lit_bufsize - 1; + } + exports3._tr_init = _tr_init; + exports3._tr_stored_block = _tr_stored_block; + exports3._tr_flush_block = _tr_flush_block; + exports3._tr_tally = _tr_tally; + exports3._tr_align = _tr_align; + }, { "../utils/common": 5 }], 12: [function(require2, module4, exports3) { + "use strict"; + function ZStream() { + this.input = null; + this.next_in = 0; + this.avail_in = 0; + this.total_in = 0; + this.output = null; + this.next_out = 0; + this.avail_out = 0; + this.total_out = 0; + this.msg = ""; + this.state = null; + this.data_type = 2; + this.adler = 0; + } + module4.exports = ZStream; + }, {}] }, {}, [3])(3); + }); + } +}); + +// node_modules/plantuml-encoder/dist/plantuml-decoder.js +var require_plantuml_decoder = __commonJS({ + "node_modules/plantuml-encoder/dist/plantuml-decoder.js"(exports, module2) { + (function(f) { + if (typeof exports === "object" && typeof module2 !== "undefined") { + module2.exports = f(); + } else if (typeof define === "function" && define.amd) { + define([], f); + } else { + var g; + if (typeof window !== "undefined") { + g = window; + } else if (typeof global !== "undefined") { + g = global; + } else if (typeof self !== "undefined") { + g = self; + } else { + g = this; + } + g.plantumlEncoder = f(); + } + })(function() { + var define2, module3, exports2; + return function() { + function r(e, n, t) { + function o(i2, f) { + if (!n[i2]) { + if (!e[i2]) { + var c = typeof require == "function" && require; + if (!f && c) + return c(i2, true); + if (u) + return u(i2, true); + var a = new Error("Cannot find module '" + i2 + "'"); + throw a.code = "MODULE_NOT_FOUND", a; + } + var p = n[i2] = { exports: {} }; + e[i2][0].call(p.exports, function(r2) { + var n2 = e[i2][1][r2]; + return o(n2 || r2); + }, p, p.exports, r, e, n, t); + } + return n[i2].exports; + } + for (var u = typeof require == "function" && require, i = 0; i < t.length; i++) + o(t[i]); + return o; + } + return r; + }()({ 1: [function(require2, module4, exports3) { + "use strict"; + var pako = require2("pako/lib/inflate.js"); + module4.exports = function(data) { + return pako.inflateRaw(data, { to: "string" }); + }; + }, { "pako/lib/inflate.js": 4 }], 2: [function(require2, module4, exports3) { + "use strict"; + function decode6bit(cc) { + var c = cc.charCodeAt(0); + if (cc === "_") + return 63; + if (cc === "-") + return 62; + if (c >= 97) + return c - 61; + if (c >= 65) + return c - 55; + if (c >= 48) + return c - 48; + return "?"; + } + function extract3bytes(data) { + var c1 = decode6bit(data[0]); + var c2 = decode6bit(data[1]); + var c3 = decode6bit(data[2]); + var c4 = decode6bit(data[3]); + var b1 = c1 << 2 | c2 >> 4 & 63; + var b2 = c2 << 4 & 240 | c3 >> 2 & 15; + var b3 = c3 << 6 & 192 | c4 & 63; + return [b1, b2, b3]; + } + module4.exports = function(data) { + var r = ""; + var i = 0; + for (i = 0; i < data.length; i += 4) { + var t = extract3bytes(data.substring(i, i + 4)); + r = r + String.fromCharCode(t[0]); + r = r + String.fromCharCode(t[1]); + r = r + String.fromCharCode(t[2]); + } + return r; + }; + }, {}], 3: [function(require2, module4, exports3) { + "use strict"; + var inflate = require2("./inflate"); + var decode64 = require2("./decode64"); + module4.exports.decode = function(encoded) { + var deflated = decode64(encoded); + return inflate(deflated); + }; + }, { "./decode64": 2, "./inflate": 1 }], 4: [function(require2, module4, exports3) { + "use strict"; + var zlib_inflate = require2("./zlib/inflate"); + var utils = require2("./utils/common"); + var strings = require2("./utils/strings"); + var c = require2("./zlib/constants"); + var msg = require2("./zlib/messages"); + var ZStream = require2("./zlib/zstream"); + var GZheader = require2("./zlib/gzheader"); + var toString = Object.prototype.toString; + function Inflate(options) { + if (!(this instanceof Inflate)) + return new Inflate(options); + this.options = utils.assign({ + chunkSize: 16384, + windowBits: 0, + to: "" + }, options || {}); + var opt = this.options; + if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) { + opt.windowBits = -opt.windowBits; + if (opt.windowBits === 0) { + opt.windowBits = -15; + } + } + if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) { + opt.windowBits += 32; + } + if (opt.windowBits > 15 && opt.windowBits < 48) { + if ((opt.windowBits & 15) === 0) { + opt.windowBits |= 15; + } + } + this.err = 0; + this.msg = ""; + this.ended = false; + this.chunks = []; + this.strm = new ZStream(); + this.strm.avail_out = 0; + var status = zlib_inflate.inflateInit2(this.strm, opt.windowBits); + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + this.header = new GZheader(); + zlib_inflate.inflateGetHeader(this.strm, this.header); + if (opt.dictionary) { + if (typeof opt.dictionary === "string") { + opt.dictionary = strings.string2buf(opt.dictionary); + } else if (toString.call(opt.dictionary) === "[object ArrayBuffer]") { + opt.dictionary = new Uint8Array(opt.dictionary); + } + if (opt.raw) { + status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary); + if (status !== c.Z_OK) { + throw new Error(msg[status]); + } + } + } + } + Inflate.prototype.push = function(data, mode) { + var strm = this.strm; + var chunkSize = this.options.chunkSize; + var dictionary = this.options.dictionary; + var status, _mode; + var next_out_utf8, tail, utf8str; + var allowBufError = false; + if (this.ended) { + return false; + } + _mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH; + if (typeof data === "string") { + strm.input = strings.binstring2buf(data); + } else if (toString.call(data) === "[object ArrayBuffer]") { + strm.input = new Uint8Array(data); + } else { + strm.input = data; + } + strm.next_in = 0; + strm.avail_in = strm.input.length; + do { + if (strm.avail_out === 0) { + strm.output = new utils.Buf8(chunkSize); + strm.next_out = 0; + strm.avail_out = chunkSize; + } + status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH); + if (status === c.Z_NEED_DICT && dictionary) { + status = zlib_inflate.inflateSetDictionary(this.strm, dictionary); + } + if (status === c.Z_BUF_ERROR && allowBufError === true) { + status = c.Z_OK; + allowBufError = false; + } + if (status !== c.Z_STREAM_END && status !== c.Z_OK) { + this.onEnd(status); + this.ended = true; + return false; + } + if (strm.next_out) { + if (strm.avail_out === 0 || status === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) { + if (this.options.to === "string") { + next_out_utf8 = strings.utf8border(strm.output, strm.next_out); + tail = strm.next_out - next_out_utf8; + utf8str = strings.buf2string(strm.output, next_out_utf8); + strm.next_out = tail; + strm.avail_out = chunkSize - tail; + if (tail) { + utils.arraySet(strm.output, strm.output, next_out_utf8, tail, 0); + } + this.onData(utf8str); + } else { + this.onData(utils.shrinkBuf(strm.output, strm.next_out)); + } + } + } + if (strm.avail_in === 0 && strm.avail_out === 0) { + allowBufError = true; + } + } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END); + if (status === c.Z_STREAM_END) { + _mode = c.Z_FINISH; + } + if (_mode === c.Z_FINISH) { + status = zlib_inflate.inflateEnd(this.strm); + this.onEnd(status); + this.ended = true; + return status === c.Z_OK; + } + if (_mode === c.Z_SYNC_FLUSH) { + this.onEnd(c.Z_OK); + strm.avail_out = 0; + return true; + } + return true; + }; + Inflate.prototype.onData = function(chunk) { + this.chunks.push(chunk); + }; + Inflate.prototype.onEnd = function(status) { + if (status === c.Z_OK) { + if (this.options.to === "string") { + this.result = this.chunks.join(""); + } else { + this.result = utils.flattenChunks(this.chunks); + } + } + this.chunks = []; + this.err = status; + this.msg = this.strm.msg; + }; + function inflate(input, options) { + var inflator = new Inflate(options); + inflator.push(input, true); + if (inflator.err) { + throw inflator.msg || msg[inflator.err]; + } + return inflator.result; + } + function inflateRaw(input, options) { + options = options || {}; + options.raw = true; + return inflate(input, options); + } + exports3.Inflate = Inflate; + exports3.inflate = inflate; + exports3.inflateRaw = inflateRaw; + exports3.ungzip = inflate; + }, { "./utils/common": 5, "./utils/strings": 6, "./zlib/constants": 8, "./zlib/gzheader": 10, "./zlib/inflate": 12, "./zlib/messages": 14, "./zlib/zstream": 15 }], 5: [function(require2, module4, exports3) { + "use strict"; + var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined"; + function _has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); + } + exports3.assign = function(obj) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { + continue; + } + if (typeof source !== "object") { + throw new TypeError(source + "must be non-object"); + } + for (var p in source) { + if (_has(source, p)) { + obj[p] = source[p]; + } + } + } + return obj; + }; + exports3.shrinkBuf = function(buf, size) { + if (buf.length === size) { + return buf; + } + if (buf.subarray) { + return buf.subarray(0, size); + } + buf.length = size; + return buf; + }; + var fnTyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs + len), dest_offs); + return; + } + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + flattenChunks: function(chunks) { + var i, l, len, pos, chunk, result; + len = 0; + for (i = 0, l = chunks.length; i < l; i++) { + len += chunks[i].length; + } + result = new Uint8Array(len); + pos = 0; + for (i = 0, l = chunks.length; i < l; i++) { + chunk = chunks[i]; + result.set(chunk, pos); + pos += chunk.length; + } + return result; + } + }; + var fnUntyped = { + arraySet: function(dest, src, src_offs, len, dest_offs) { + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + flattenChunks: function(chunks) { + return [].concat.apply([], chunks); + } + }; + exports3.setTyped = function(on) { + if (on) { + exports3.Buf8 = Uint8Array; + exports3.Buf16 = Uint16Array; + exports3.Buf32 = Int32Array; + exports3.assign(exports3, fnTyped); + } else { + exports3.Buf8 = Array; + exports3.Buf16 = Array; + exports3.Buf32 = Array; + exports3.assign(exports3, fnUntyped); + } + }; + exports3.setTyped(TYPED_OK); + }, {}], 6: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("./common"); + var STR_APPLY_OK = true; + var STR_APPLY_UIA_OK = true; + try { + String.fromCharCode.apply(null, [0]); + } catch (__) { + STR_APPLY_OK = false; + } + try { + String.fromCharCode.apply(null, new Uint8Array(1)); + } catch (__) { + STR_APPLY_UIA_OK = false; + } + var _utf8len = new utils.Buf8(256); + for (var q = 0; q < 256; q++) { + _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1; + } + _utf8len[254] = _utf8len[254] = 1; + exports3.string2buf = function(str) { + var buf, c, c2, m_pos, i, str_len = str.length, buf_len = 0; + for (m_pos = 0; m_pos < str_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4; + } + buf = new utils.Buf8(buf_len); + for (i = 0, m_pos = 0; i < buf_len; m_pos++) { + c = str.charCodeAt(m_pos); + if ((c & 64512) === 55296 && m_pos + 1 < str_len) { + c2 = str.charCodeAt(m_pos + 1); + if ((c2 & 64512) === 56320) { + c = 65536 + (c - 55296 << 10) + (c2 - 56320); + m_pos++; + } + } + if (c < 128) { + buf[i++] = c; + } else if (c < 2048) { + buf[i++] = 192 | c >>> 6; + buf[i++] = 128 | c & 63; + } else if (c < 65536) { + buf[i++] = 224 | c >>> 12; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } else { + buf[i++] = 240 | c >>> 18; + buf[i++] = 128 | c >>> 12 & 63; + buf[i++] = 128 | c >>> 6 & 63; + buf[i++] = 128 | c & 63; + } + } + return buf; + }; + function buf2binstring(buf, len) { + if (len < 65534) { + if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) { + return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len)); + } + } + var result = ""; + for (var i = 0; i < len; i++) { + result += String.fromCharCode(buf[i]); + } + return result; + } + exports3.buf2binstring = function(buf) { + return buf2binstring(buf, buf.length); + }; + exports3.binstring2buf = function(str) { + var buf = new utils.Buf8(str.length); + for (var i = 0, len = buf.length; i < len; i++) { + buf[i] = str.charCodeAt(i); + } + return buf; + }; + exports3.buf2string = function(buf, max) { + var i, out, c, c_len; + var len = max || buf.length; + var utf16buf = new Array(len * 2); + for (out = 0, i = 0; i < len; ) { + c = buf[i++]; + if (c < 128) { + utf16buf[out++] = c; + continue; + } + c_len = _utf8len[c]; + if (c_len > 4) { + utf16buf[out++] = 65533; + i += c_len - 1; + continue; + } + c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7; + while (c_len > 1 && i < len) { + c = c << 6 | buf[i++] & 63; + c_len--; + } + if (c_len > 1) { + utf16buf[out++] = 65533; + continue; + } + if (c < 65536) { + utf16buf[out++] = c; + } else { + c -= 65536; + utf16buf[out++] = 55296 | c >> 10 & 1023; + utf16buf[out++] = 56320 | c & 1023; + } + } + return buf2binstring(utf16buf, out); + }; + exports3.utf8border = function(buf, max) { + var pos; + max = max || buf.length; + if (max > buf.length) { + max = buf.length; + } + pos = max - 1; + while (pos >= 0 && (buf[pos] & 192) === 128) { + pos--; + } + if (pos < 0) { + return max; + } + if (pos === 0) { + return max; + } + return pos + _utf8len[buf[pos]] > max ? pos : max; + }; + }, { "./common": 5 }], 7: [function(require2, module4, exports3) { + "use strict"; + function adler32(adler, buf, len, pos) { + var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0; + while (len !== 0) { + n = len > 2e3 ? 2e3 : len; + len -= n; + do { + s1 = s1 + buf[pos++] | 0; + s2 = s2 + s1 | 0; + } while (--n); + s1 %= 65521; + s2 %= 65521; + } + return s1 | s2 << 16 | 0; + } + module4.exports = adler32; + }, {}], 8: [function(require2, module4, exports3) { + "use strict"; + module4.exports = { + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + Z_BUF_ERROR: -5, + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + Z_BINARY: 0, + Z_TEXT: 1, + Z_UNKNOWN: 2, + Z_DEFLATED: 8 + }; + }, {}], 9: [function(require2, module4, exports3) { + "use strict"; + function makeTable() { + var c, table = []; + for (var n = 0; n < 256; n++) { + c = n; + for (var k = 0; k < 8; k++) { + c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1; + } + table[n] = c; + } + return table; + } + var crcTable = makeTable(); + function crc32(crc, buf, len, pos) { + var t = crcTable, end = pos + len; + crc ^= -1; + for (var i = pos; i < end; i++) { + crc = crc >>> 8 ^ t[(crc ^ buf[i]) & 255]; + } + return crc ^ -1; + } + module4.exports = crc32; + }, {}], 10: [function(require2, module4, exports3) { + "use strict"; + function GZheader() { + this.text = 0; + this.time = 0; + this.xflags = 0; + this.os = 0; + this.extra = null; + this.extra_len = 0; + this.name = ""; + this.comment = ""; + this.hcrc = 0; + this.done = false; + } + module4.exports = GZheader; + }, {}], 11: [function(require2, module4, exports3) { + "use strict"; + var BAD = 30; + var TYPE = 12; + module4.exports = function inflate_fast(strm, start) { + var state; + var _in; + var last; + var _out; + var beg; + var end; + var dmax; + var wsize; + var whave; + var wnext; + var s_window; + var hold; + var bits; + var lcode; + var dcode; + var lmask; + var dmask; + var here; + var op; + var len; + var dist; + var from; + var from_source; + var input, output; + state = strm.state; + _in = strm.next_in; + input = strm.input; + last = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); + dmax = state.dmax; + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op === 0) { + output[_out++] = here & 65535; + } else if (op & 16) { + len = here & 65535; + op &= 15; + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len += hold & (1 << op) - 1; + hold >>>= op; + bits -= op; + } + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + for (; ; ) { + op = here >>> 24; + hold >>>= op; + bits -= op; + op = here >>> 16 & 255; + if (op & 16) { + dist = here & 65535; + op &= 15; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & (1 << op) - 1; + if (dist > dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break top; + } + hold >>>= op; + bits -= op; + op = _out - beg; + if (dist > op) { + op = dist - op; + if (op > whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break top; + } + } + from = 0; + from_source = s_window; + if (wnext === 0) { + from += wsize - op; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } else if (wnext < op) { + from += wsize + wnext - op; + op -= wnext; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len) { + op = wnext; + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + } else { + from += wnext - op; + if (op < len) { + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; + from_source = output; + } + } + while (len > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len -= 3; + } + if (len) { + output[_out++] = from_source[from++]; + if (len > 1) { + output[_out++] = from_source[from++]; + } + } + } else { + from = _out - dist; + do { + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len -= 3; + } while (len > 2); + if (len) { + output[_out++] = output[from++]; + if (len > 1) { + output[_out++] = output[from++]; + } + } + } + } else if ((op & 64) === 0) { + here = dcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dodist; + } else { + strm.msg = "invalid distance code"; + state.mode = BAD; + break top; + } + break; + } + } else if ((op & 64) === 0) { + here = lcode[(here & 65535) + (hold & (1 << op) - 1)]; + continue dolen; + } else if (op & 32) { + state.mode = TYPE; + break top; + } else { + strm.msg = "invalid literal/length code"; + state.mode = BAD; + break top; + } + break; + } + } while (_in < last && _out < end); + len = bits >> 3; + _in -= len; + bits -= len << 3; + hold &= (1 << bits) - 1; + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last); + strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end); + state.hold = hold; + state.bits = bits; + return; + }; + }, {}], 12: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/common"); + var adler32 = require2("./adler32"); + var crc32 = require2("./crc32"); + var inflate_fast = require2("./inffast"); + var inflate_table = require2("./inftrees"); + var CODES = 0; + var LENS = 1; + var DISTS = 2; + var Z_FINISH = 4; + var Z_BLOCK = 5; + var Z_TREES = 6; + var Z_OK = 0; + var Z_STREAM_END = 1; + var Z_NEED_DICT = 2; + var Z_STREAM_ERROR = -2; + var Z_DATA_ERROR = -3; + var Z_MEM_ERROR = -4; + var Z_BUF_ERROR = -5; + var Z_DEFLATED = 8; + var HEAD = 1; + var FLAGS = 2; + var TIME = 3; + var OS = 4; + var EXLEN = 5; + var EXTRA = 6; + var NAME = 7; + var COMMENT = 8; + var HCRC = 9; + var DICTID = 10; + var DICT = 11; + var TYPE = 12; + var TYPEDO = 13; + var STORED = 14; + var COPY_ = 15; + var COPY = 16; + var TABLE = 17; + var LENLENS = 18; + var CODELENS = 19; + var LEN_ = 20; + var LEN = 21; + var LENEXT = 22; + var DIST = 23; + var DISTEXT = 24; + var MATCH = 25; + var LIT = 26; + var CHECK = 27; + var LENGTH = 28; + var DONE = 29; + var BAD = 30; + var MEM = 31; + var SYNC = 32; + var ENOUGH_LENS = 852; + var ENOUGH_DISTS = 592; + var MAX_WBITS = 15; + var DEF_WBITS = MAX_WBITS; + function zswap32(q) { + return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24); + } + function InflateState() { + this.mode = 0; + this.last = false; + this.wrap = 0; + this.havedict = false; + this.flags = 0; + this.dmax = 0; + this.check = 0; + this.total = 0; + this.head = null; + this.wbits = 0; + this.wsize = 0; + this.whave = 0; + this.wnext = 0; + this.window = null; + this.hold = 0; + this.bits = 0; + this.length = 0; + this.offset = 0; + this.extra = 0; + this.lencode = null; + this.distcode = null; + this.lenbits = 0; + this.distbits = 0; + this.ncode = 0; + this.nlen = 0; + this.ndist = 0; + this.have = 0; + this.next = null; + this.lens = new utils.Buf16(320); + this.work = new utils.Buf16(288); + this.lendyn = null; + this.distdyn = null; + this.sane = 0; + this.back = 0; + this.was = 0; + } + function inflateResetKeep(strm) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ""; + if (state.wrap) { + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null; + state.hold = 0; + state.bits = 0; + state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); + state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); + state.sane = 1; + state.back = -1; + return Z_OK; + } + function inflateReset(strm) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + } + function inflateReset2(strm, windowBits) { + var wrap; + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; + } + } + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); + } + function inflateInit2(strm, windowBits) { + var ret; + var state; + if (!strm) { + return Z_STREAM_ERROR; + } + state = new InflateState(); + strm.state = state; + state.window = null; + ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK) { + strm.state = null; + } + return ret; + } + function inflateInit(strm) { + return inflateInit2(strm, DEF_WBITS); + } + var virgin = true; + var lenfix, distfix; + function fixedtables(state) { + if (virgin) { + var sym; + lenfix = new utils.Buf32(512); + distfix = new utils.Buf32(32); + sym = 0; + while (sym < 144) { + state.lens[sym++] = 8; + } + while (sym < 256) { + state.lens[sym++] = 9; + } + while (sym < 280) { + state.lens[sym++] = 7; + } + while (sym < 288) { + state.lens[sym++] = 8; + } + inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 }); + sym = 0; + while (sym < 32) { + state.lens[sym++] = 5; + } + inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 }); + virgin = false; + } + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; + } + function updatewindow(strm, src, end, copy) { + var dist; + var state = strm.state; + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + state.window = new utils.Buf8(state.wsize); + } + if (copy >= state.wsize) { + utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0); + state.wnext = 0; + state.whave = state.wsize; + } else { + dist = state.wsize - state.wnext; + if (dist > copy) { + dist = copy; + } + utils.arraySet(state.window, src, end - copy, dist, state.wnext); + copy -= dist; + if (copy) { + utils.arraySet(state.window, src, end - copy, copy, 0); + state.wnext = copy; + state.whave = state.wsize; + } else { + state.wnext += dist; + if (state.wnext === state.wsize) { + state.wnext = 0; + } + if (state.whave < state.wsize) { + state.whave += dist; + } + } + } + return 0; + } + function inflate(strm, flush) { + var state; + var input, output; + var next; + var put; + var have, left; + var hold; + var bits; + var _in, _out; + var copy; + var from; + var from_source; + var here = 0; + var here_bits, here_op, here_val; + var last_bits, last_op, last_val; + var len; + var ret; + var hbuf = new utils.Buf8(4); + var opts; + var n; + var order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; + if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (state.mode === TYPE) { + state.mode = TYPEDO; + } + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + _in = have; + _out = left; + ret = Z_OK; + inf_leave: + for (; ; ) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.wrap & 2 && hold === 35615) { + state.check = 0; + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + hold = 0; + bits = 0; + state.mode = FLAGS; + break; + } + state.flags = 0; + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || (((hold & 255) << 8) + (hold >> 8)) % 31) { + strm.msg = "incorrect header check"; + state.mode = BAD; + break; + } + if ((hold & 15) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + hold >>>= 4; + bits -= 4; + len = (hold & 15) + 8; + if (state.wbits === 0) { + state.wbits = len; + } else if (len > state.wbits) { + strm.msg = "invalid window size"; + state.mode = BAD; + break; + } + state.dmax = 1 << len; + strm.adler = state.check = 1; + state.mode = hold & 512 ? DICTID : TYPE; + hold = 0; + bits = 0; + break; + case FLAGS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.flags = hold; + if ((state.flags & 255) !== Z_DEFLATED) { + strm.msg = "unknown compression method"; + state.mode = BAD; + break; + } + if (state.flags & 57344) { + strm.msg = "unknown header flags set"; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = hold >> 8 & 1; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = TIME; + case TIME: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.time = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + hbuf[2] = hold >>> 16 & 255; + hbuf[3] = hold >>> 24 & 255; + state.check = crc32(state.check, hbuf, 4, 0); + } + hold = 0; + bits = 0; + state.mode = OS; + case OS: + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (state.head) { + state.head.xflags = hold & 255; + state.head.os = hold >> 8; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + state.mode = EXLEN; + case EXLEN: + if (state.flags & 1024) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 512) { + hbuf[0] = hold & 255; + hbuf[1] = hold >>> 8 & 255; + state.check = crc32(state.check, hbuf, 2, 0); + } + hold = 0; + bits = 0; + } else if (state.head) { + state.head.extra = null; + } + state.mode = EXTRA; + case EXTRA: + if (state.flags & 1024) { + copy = state.length; + if (copy > have) { + copy = have; + } + if (copy) { + if (state.head) { + len = state.head.extra_len - state.length; + if (!state.head.extra) { + state.head.extra = new Array(state.head.extra_len); + } + utils.arraySet(state.head.extra, input, next, copy, len); + } + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + state.length -= copy; + } + if (state.length) { + break inf_leave; + } + } + state.length = 0; + state.mode = NAME; + case NAME: + if (state.flags & 2048) { + if (have === 0) { + break inf_leave; + } + copy = 0; + do { + len = input[next + copy++]; + if (state.head && len && state.length < 65536) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + case COMMENT: + if (state.flags & 4096) { + if (have === 0) { + break inf_leave; + } + copy = 0; + do { + len = input[next + copy++]; + if (state.head && len && state.length < 65536) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 512) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { + break inf_leave; + } + } else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + case HCRC: + if (state.flags & 512) { + while (bits < 16) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.check & 65535)) { + strm.msg = "header crc mismatch"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + if (state.head) { + state.head.hcrc = state.flags >> 9 & 1; + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE; + break; + case DICTID: + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + strm.adler = state.check = zswap32(hold); + hold = 0; + bits = 0; + state.mode = DICT; + case DICT: + if (state.havedict === 0) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + return Z_NEED_DICT; + } + strm.adler = state.check = 1; + state.mode = TYPE; + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { + break inf_leave; + } + case TYPEDO: + if (state.last) { + hold >>>= bits & 7; + bits -= bits & 7; + state.mode = CHECK; + break; + } + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.last = hold & 1; + hold >>>= 1; + bits -= 1; + switch (hold & 3) { + case 0: + state.mode = STORED; + break; + case 1: + fixedtables(state); + state.mode = LEN_; + if (flush === Z_TREES) { + hold >>>= 2; + bits -= 2; + break inf_leave; + } + break; + case 2: + state.mode = TABLE; + break; + case 3: + strm.msg = "invalid block type"; + state.mode = BAD; + } + hold >>>= 2; + bits -= 2; + break; + case STORED: + hold >>>= bits & 7; + bits -= bits & 7; + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((hold & 65535) !== (hold >>> 16 ^ 65535)) { + strm.msg = "invalid stored block lengths"; + state.mode = BAD; + break; + } + state.length = hold & 65535; + hold = 0; + bits = 0; + state.mode = COPY_; + if (flush === Z_TREES) { + break inf_leave; + } + case COPY_: + state.mode = COPY; + case COPY: + copy = state.length; + if (copy) { + if (copy > have) { + copy = have; + } + if (copy > left) { + copy = left; + } + if (copy === 0) { + break inf_leave; + } + utils.arraySet(output, input, next, copy, put); + have -= copy; + next += copy; + left -= copy; + put += copy; + state.length -= copy; + break; + } + state.mode = TYPE; + break; + case TABLE: + while (bits < 14) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.nlen = (hold & 31) + 257; + hold >>>= 5; + bits -= 5; + state.ndist = (hold & 31) + 1; + hold >>>= 5; + bits -= 5; + state.ncode = (hold & 15) + 4; + hold >>>= 4; + bits -= 4; + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = "too many length or distance symbols"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = LENLENS; + case LENLENS: + while (state.have < state.ncode) { + while (bits < 3) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.lens[order[state.have++]] = hold & 7; + hold >>>= 3; + bits -= 3; + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + state.lencode = state.lendyn; + state.lenbits = 7; + opts = { bits: state.lenbits }; + ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid code lengths set"; + state.mode = BAD; + break; + } + state.have = 0; + state.mode = CODELENS; + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_val < 16) { + hold >>>= here_bits; + bits -= here_bits; + state.lens[state.have++] = here_val; + } else { + if (here_val === 16) { + n = here_bits + 2; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + if (state.have === 0) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + len = state.lens[state.have - 1]; + copy = 3 + (hold & 3); + hold >>>= 2; + bits -= 2; + } else if (here_val === 17) { + n = here_bits + 3; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len = 0; + copy = 3 + (hold & 7); + hold >>>= 3; + bits -= 3; + } else { + n = here_bits + 7; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= here_bits; + bits -= here_bits; + len = 0; + copy = 11 + (hold & 127); + hold >>>= 7; + bits -= 7; + } + if (state.have + copy > state.nlen + state.ndist) { + strm.msg = "invalid bit length repeat"; + state.mode = BAD; + break; + } + while (copy--) { + state.lens[state.have++] = len; + } + } + } + if (state.mode === BAD) { + break; + } + if (state.lens[256] === 0) { + strm.msg = "invalid code -- missing end-of-block"; + state.mode = BAD; + break; + } + state.lenbits = 9; + opts = { bits: state.lenbits }; + ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + if (ret) { + strm.msg = "invalid literal/lengths set"; + state.mode = BAD; + break; + } + state.distbits = 6; + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + state.distbits = opts.bits; + if (ret) { + strm.msg = "invalid distances set"; + state.mode = BAD; + break; + } + state.mode = LEN_; + if (flush === Z_TREES) { + break inf_leave; + } + case LEN_: + state.mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + inflate_fast(strm, _out); + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (; ; ) { + here = state.lencode[hold & (1 << state.lenbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (here_op && (here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + state.mode = LIT; + break; + } + if (here_op & 32) { + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = "invalid literal/length code"; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + case LENEXT: + if (state.extra) { + n = state.extra; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.length += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + state.was = state.length; + state.mode = DIST; + case DIST: + for (; ; ) { + here = state.distcode[hold & (1 << state.distbits) - 1]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if ((here_op & 240) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (; ; ) { + here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)]; + here_bits = here >>> 24; + here_op = here >>> 16 & 255; + here_val = here & 65535; + if (last_bits + here_bits <= bits) { + break; + } + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + hold >>>= last_bits; + bits -= last_bits; + state.back += last_bits; + } + hold >>>= here_bits; + bits -= here_bits; + state.back += here_bits; + if (here_op & 64) { + strm.msg = "invalid distance code"; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = here_op & 15; + state.mode = DISTEXT; + case DISTEXT: + if (state.extra) { + n = state.extra; + while (bits < n) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + state.offset += hold & (1 << state.extra) - 1; + hold >>>= state.extra; + bits -= state.extra; + state.back += state.extra; + } + if (state.offset > state.dmax) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + state.mode = MATCH; + case MATCH: + if (left === 0) { + break inf_leave; + } + copy = _out - left; + if (state.offset > copy) { + copy = state.offset - copy; + if (copy > state.whave) { + if (state.sane) { + strm.msg = "invalid distance too far back"; + state.mode = BAD; + break; + } + } + if (copy > state.wnext) { + copy -= state.wnext; + from = state.wsize - copy; + } else { + from = state.wnext - copy; + } + if (copy > state.length) { + copy = state.length; + } + from_source = state.window; + } else { + from_source = output; + from = put - state.offset; + copy = state.length; + } + if (copy > left) { + copy = left; + } + left -= copy; + state.length -= copy; + do { + output[put++] = from_source[from++]; + } while (--copy); + if (state.length === 0) { + state.mode = LEN; + } + break; + case LIT: + if (left === 0) { + break inf_leave; + } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold |= input[next++] << bits; + bits += 8; + } + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out); + } + _out = left; + if ((state.flags ? hold : zswap32(hold)) !== state.check) { + strm.msg = "incorrect data check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = LENGTH; + case LENGTH: + if (state.wrap && state.flags) { + while (bits < 32) { + if (have === 0) { + break inf_leave; + } + have--; + hold += input[next++] << bits; + bits += 8; + } + if (hold !== (state.total & 4294967295)) { + strm.msg = "incorrect length check"; + state.mode = BAD; + break; + } + hold = 0; + bits = 0; + } + state.mode = DONE; + case DONE: + ret = Z_STREAM_END; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR; + break inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; + } + } + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + if (state.wsize || _out !== strm.avail_out && state.mode < BAD && (state.mode < CHECK || flush !== Z_FINISH)) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { + state.mode = MEM; + return Z_MEM_ERROR; + } + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if ((_in === 0 && _out === 0 || flush === Z_FINISH) && ret === Z_OK) { + ret = Z_BUF_ERROR; + } + return ret; + } + function inflateEnd(strm) { + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + var state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK; + } + function inflateGetHeader(strm, head) { + var state; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if ((state.wrap & 2) === 0) { + return Z_STREAM_ERROR; + } + state.head = head; + head.done = false; + return Z_OK; + } + function inflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + var state; + var dictid; + var ret; + if (!strm || !strm.state) { + return Z_STREAM_ERROR; + } + state = strm.state; + if (state.wrap !== 0 && state.mode !== DICT) { + return Z_STREAM_ERROR; + } + if (state.mode === DICT) { + dictid = 1; + dictid = adler32(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR; + } + } + ret = updatewindow(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM; + return Z_MEM_ERROR; + } + state.havedict = 1; + return Z_OK; + } + exports3.inflateReset = inflateReset; + exports3.inflateReset2 = inflateReset2; + exports3.inflateResetKeep = inflateResetKeep; + exports3.inflateInit = inflateInit; + exports3.inflateInit2 = inflateInit2; + exports3.inflate = inflate; + exports3.inflateEnd = inflateEnd; + exports3.inflateGetHeader = inflateGetHeader; + exports3.inflateSetDictionary = inflateSetDictionary; + exports3.inflateInfo = "pako inflate (from Nodeca project)"; + }, { "../utils/common": 5, "./adler32": 7, "./crc32": 9, "./inffast": 11, "./inftrees": 13 }], 13: [function(require2, module4, exports3) { + "use strict"; + var utils = require2("../utils/common"); + var MAXBITS = 15; + var ENOUGH_LENS = 852; + var ENOUGH_DISTS = 592; + var CODES = 0; + var LENS = 1; + var DISTS = 2; + var lbase = [ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 13, + 15, + 17, + 19, + 23, + 27, + 31, + 35, + 43, + 51, + 59, + 67, + 83, + 99, + 115, + 131, + 163, + 195, + 227, + 258, + 0, + 0 + ]; + var lext = [ + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 16, + 17, + 17, + 17, + 17, + 18, + 18, + 18, + 18, + 19, + 19, + 19, + 19, + 20, + 20, + 20, + 20, + 21, + 21, + 21, + 21, + 16, + 72, + 78 + ]; + var dbase = [ + 1, + 2, + 3, + 4, + 5, + 7, + 9, + 13, + 17, + 25, + 33, + 49, + 65, + 97, + 129, + 193, + 257, + 385, + 513, + 769, + 1025, + 1537, + 2049, + 3073, + 4097, + 6145, + 8193, + 12289, + 16385, + 24577, + 0, + 0 + ]; + var dext = [ + 16, + 16, + 16, + 16, + 17, + 17, + 18, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 22, + 22, + 23, + 23, + 24, + 24, + 25, + 25, + 26, + 26, + 27, + 27, + 28, + 28, + 29, + 29, + 64, + 64 + ]; + module4.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) { + var bits = opts.bits; + var len = 0; + var sym = 0; + var min = 0, max = 0; + var root = 0; + var curr = 0; + var drop = 0; + var left = 0; + var used = 0; + var huff = 0; + var incr; + var fill; + var low; + var mask; + var next; + var base = null; + var base_index = 0; + var end; + var count = new utils.Buf16(MAXBITS + 1); + var offs = new utils.Buf16(MAXBITS + 1); + var extra = null; + var extra_index = 0; + var here_bits, here_op, here_val; + for (len = 0; len <= MAXBITS; len++) { + count[len] = 0; + } + for (sym = 0; sym < codes; sym++) { + count[lens[lens_index + sym]]++; + } + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { + break; + } + } + if (root > max) { + root = max; + } + if (max === 0) { + table[table_index++] = 1 << 24 | 64 << 16 | 0; + table[table_index++] = 1 << 24 | 64 << 16 | 0; + opts.bits = 1; + return 0; + } + for (min = 1; min < max; min++) { + if (count[min] !== 0) { + break; + } + } + if (root < min) { + root = min; + } + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) { + return -1; + } + } + if (left > 0 && (type === CODES || max !== 1)) { + return -1; + } + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) { + offs[len + 1] = offs[len] + count[len]; + } + for (sym = 0; sym < codes; sym++) { + if (lens[lens_index + sym] !== 0) { + work[offs[lens[lens_index + sym]]++] = sym; + } + } + if (type === CODES) { + base = extra = work; + end = 19; + } else if (type === LENS) { + base = lbase; + base_index -= 257; + extra = lext; + extra_index -= 257; + end = 256; + } else { + base = dbase; + extra = dext; + end = -1; + } + huff = 0; + sym = 0; + len = min; + next = table_index; + curr = root; + drop = 0; + low = -1; + used = 1 << root; + mask = used - 1; + if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) { + return 1; + } + for (; ; ) { + here_bits = len - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } else { + here_op = 32 + 64; + here_val = 0; + } + incr = 1 << len - drop; + fill = 1 << curr; + min = fill; + do { + fill -= incr; + table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0; + } while (fill !== 0); + incr = 1 << len - 1; + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + sym++; + if (--count[len] === 0) { + if (len === max) { + break; + } + len = lens[lens_index + work[sym]]; + } + if (len > root && (huff & mask) !== low) { + if (drop === 0) { + drop = root; + } + next += min; + curr = len - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) { + break; + } + curr++; + left <<= 1; + } + used += 1 << curr; + if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) { + return 1; + } + low = huff & mask; + table[low] = root << 24 | curr << 16 | next - table_index | 0; + } + } + if (huff !== 0) { + table[next + huff] = len - drop << 24 | 64 << 16 | 0; + } + opts.bits = root; + return 0; + }; + }, { "../utils/common": 5 }], 14: [function(require2, module4, exports3) { + "use strict"; + module4.exports = { + 2: "need dictionary", + 1: "stream end", + 0: "", + "-1": "file error", + "-2": "stream error", + "-3": "data error", + "-4": "insufficient memory", + "-5": "buffer error", + "-6": "incompatible version" + }; + }, {}], 15: [function(require2, module4, exports3) { + "use strict"; + function ZStream() { + this.input = null; + this.next_in = 0; + this.avail_in = 0; + this.total_in = 0; + this.output = null; + this.next_out = 0; + this.avail_out = 0; + this.total_out = 0; + this.msg = ""; + this.state = null; + this.data_type = 2; + this.adler = 0; + } + module4.exports = ZStream; + }, {}] }, {}, [3])(3); + }); + } +}); + +// node_modules/plantuml-encoder/browser-index.js +var require_browser_index = __commonJS({ + "node_modules/plantuml-encoder/browser-index.js"(exports, module2) { + module2.exports = { + encode: require_plantuml_encoder().encode, + decode: require_plantuml_decoder().decode + }; + } +}); + +// node_modules/localforage/dist/localforage.js +var require_localforage = __commonJS({ + "node_modules/localforage/dist/localforage.js"(exports, module2) { + (function(f) { + if (typeof exports === "object" && typeof module2 !== "undefined") { + module2.exports = f(); + } else if (typeof define === "function" && define.amd) { + define([], f); + } else { + var g; + if (typeof window !== "undefined") { + g = window; + } else if (typeof global !== "undefined") { + g = global; + } else if (typeof self !== "undefined") { + g = self; + } else { + g = this; + } + g.localforage = f(); + } + })(function() { + var define2, module3, exports2; + return function e(t, n, r) { + function s(o2, u) { + if (!n[o2]) { + if (!t[o2]) { + var a = typeof require == "function" && require; + if (!u && a) + return a(o2, true); + if (i) + return i(o2, true); + var f = new Error("Cannot find module '" + o2 + "'"); + throw f.code = "MODULE_NOT_FOUND", f; + } + var l = n[o2] = { exports: {} }; + t[o2][0].call(l.exports, function(e2) { + var n2 = t[o2][1][e2]; + return s(n2 ? n2 : e2); + }, l, l.exports, e, t, n, r); + } + return n[o2].exports; + } + var i = typeof require == "function" && require; + for (var o = 0; o < r.length; o++) + s(r[o]); + return s; + }({ 1: [function(_dereq_, module4, exports3) { + (function(global2) { + "use strict"; + var Mutation = global2.MutationObserver || global2.WebKitMutationObserver; + var scheduleDrain; + { + if (Mutation) { + var called = 0; + var observer = new Mutation(nextTick); + var element = global2.document.createTextNode(""); + observer.observe(element, { + characterData: true + }); + scheduleDrain = function() { + element.data = called = ++called % 2; + }; + } else if (!global2.setImmediate && typeof global2.MessageChannel !== "undefined") { + var channel = new global2.MessageChannel(); + channel.port1.onmessage = nextTick; + scheduleDrain = function() { + channel.port2.postMessage(0); + }; + } else if ("document" in global2 && "onreadystatechange" in global2.document.createElement("script")) { + scheduleDrain = function() { + var scriptEl = global2.document.createElement("script"); + scriptEl.onreadystatechange = function() { + nextTick(); + scriptEl.onreadystatechange = null; + scriptEl.parentNode.removeChild(scriptEl); + scriptEl = null; + }; + global2.document.documentElement.appendChild(scriptEl); + }; + } else { + scheduleDrain = function() { + setTimeout(nextTick, 0); + }; + } + } + var draining; + var queue = []; + function nextTick() { + draining = true; + var i, oldQueue; + var len = queue.length; + while (len) { + oldQueue = queue; + queue = []; + i = -1; + while (++i < len) { + oldQueue[i](); + } + len = queue.length; + } + draining = false; + } + module4.exports = immediate; + function immediate(task) { + if (queue.push(task) === 1 && !draining) { + scheduleDrain(); + } + } + }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}); + }, {}], 2: [function(_dereq_, module4, exports3) { + "use strict"; + var immediate = _dereq_(1); + function INTERNAL() { + } + var handlers = {}; + var REJECTED = ["REJECTED"]; + var FULFILLED = ["FULFILLED"]; + var PENDING = ["PENDING"]; + module4.exports = Promise2; + function Promise2(resolver) { + if (typeof resolver !== "function") { + throw new TypeError("resolver must be a function"); + } + this.state = PENDING; + this.queue = []; + this.outcome = void 0; + if (resolver !== INTERNAL) { + safelyResolveThenable(this, resolver); + } + } + Promise2.prototype["catch"] = function(onRejected) { + return this.then(null, onRejected); + }; + Promise2.prototype.then = function(onFulfilled, onRejected) { + if (typeof onFulfilled !== "function" && this.state === FULFILLED || typeof onRejected !== "function" && this.state === REJECTED) { + return this; + } + var promise = new this.constructor(INTERNAL); + if (this.state !== PENDING) { + var resolver = this.state === FULFILLED ? onFulfilled : onRejected; + unwrap(promise, resolver, this.outcome); + } else { + this.queue.push(new QueueItem(promise, onFulfilled, onRejected)); + } + return promise; + }; + function QueueItem(promise, onFulfilled, onRejected) { + this.promise = promise; + if (typeof onFulfilled === "function") { + this.onFulfilled = onFulfilled; + this.callFulfilled = this.otherCallFulfilled; + } + if (typeof onRejected === "function") { + this.onRejected = onRejected; + this.callRejected = this.otherCallRejected; + } + } + QueueItem.prototype.callFulfilled = function(value) { + handlers.resolve(this.promise, value); + }; + QueueItem.prototype.otherCallFulfilled = function(value) { + unwrap(this.promise, this.onFulfilled, value); + }; + QueueItem.prototype.callRejected = function(value) { + handlers.reject(this.promise, value); + }; + QueueItem.prototype.otherCallRejected = function(value) { + unwrap(this.promise, this.onRejected, value); + }; + function unwrap(promise, func, value) { + immediate(function() { + var returnValue; + try { + returnValue = func(value); + } catch (e) { + return handlers.reject(promise, e); + } + if (returnValue === promise) { + handlers.reject(promise, new TypeError("Cannot resolve promise with itself")); + } else { + handlers.resolve(promise, returnValue); + } + }); + } + handlers.resolve = function(self2, value) { + var result = tryCatch(getThen, value); + if (result.status === "error") { + return handlers.reject(self2, result.value); + } + var thenable = result.value; + if (thenable) { + safelyResolveThenable(self2, thenable); + } else { + self2.state = FULFILLED; + self2.outcome = value; + var i = -1; + var len = self2.queue.length; + while (++i < len) { + self2.queue[i].callFulfilled(value); + } + } + return self2; + }; + handlers.reject = function(self2, error) { + self2.state = REJECTED; + self2.outcome = error; + var i = -1; + var len = self2.queue.length; + while (++i < len) { + self2.queue[i].callRejected(error); + } + return self2; + }; + function getThen(obj) { + var then = obj && obj.then; + if (obj && (typeof obj === "object" || typeof obj === "function") && typeof then === "function") { + return function appyThen() { + then.apply(obj, arguments); + }; + } + } + function safelyResolveThenable(self2, thenable) { + var called = false; + function onError(value) { + if (called) { + return; + } + called = true; + handlers.reject(self2, value); + } + function onSuccess(value) { + if (called) { + return; + } + called = true; + handlers.resolve(self2, value); + } + function tryToUnwrap() { + thenable(onSuccess, onError); + } + var result = tryCatch(tryToUnwrap); + if (result.status === "error") { + onError(result.value); + } + } + function tryCatch(func, value) { + var out = {}; + try { + out.value = func(value); + out.status = "success"; + } catch (e) { + out.status = "error"; + out.value = e; + } + return out; + } + Promise2.resolve = resolve; + function resolve(value) { + if (value instanceof this) { + return value; + } + return handlers.resolve(new this(INTERNAL), value); + } + Promise2.reject = reject; + function reject(reason) { + var promise = new this(INTERNAL); + return handlers.reject(promise, reason); + } + Promise2.all = all; + function all(iterable) { + var self2 = this; + if (Object.prototype.toString.call(iterable) !== "[object Array]") { + return this.reject(new TypeError("must be an array")); + } + var len = iterable.length; + var called = false; + if (!len) { + return this.resolve([]); + } + var values = new Array(len); + var resolved = 0; + var i = -1; + var promise = new this(INTERNAL); + while (++i < len) { + allResolver(iterable[i], i); + } + return promise; + function allResolver(value, i2) { + self2.resolve(value).then(resolveFromAll, function(error) { + if (!called) { + called = true; + handlers.reject(promise, error); + } + }); + function resolveFromAll(outValue) { + values[i2] = outValue; + if (++resolved === len && !called) { + called = true; + handlers.resolve(promise, values); + } + } + } + } + Promise2.race = race; + function race(iterable) { + var self2 = this; + if (Object.prototype.toString.call(iterable) !== "[object Array]") { + return this.reject(new TypeError("must be an array")); + } + var len = iterable.length; + var called = false; + if (!len) { + return this.resolve([]); + } + var i = -1; + var promise = new this(INTERNAL); + while (++i < len) { + resolver(iterable[i]); + } + return promise; + function resolver(value) { + self2.resolve(value).then(function(response) { + if (!called) { + called = true; + handlers.resolve(promise, response); + } + }, function(error) { + if (!called) { + called = true; + handlers.reject(promise, error); + } + }); + } + } + }, { "1": 1 }], 3: [function(_dereq_, module4, exports3) { + (function(global2) { + "use strict"; + if (typeof global2.Promise !== "function") { + global2.Promise = _dereq_(2); + } + }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}); + }, { "2": 2 }], 4: [function(_dereq_, module4, exports3) { + "use strict"; + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function getIDB() { + try { + if (typeof indexedDB !== "undefined") { + return indexedDB; + } + if (typeof webkitIndexedDB !== "undefined") { + return webkitIndexedDB; + } + if (typeof mozIndexedDB !== "undefined") { + return mozIndexedDB; + } + if (typeof OIndexedDB !== "undefined") { + return OIndexedDB; + } + if (typeof msIndexedDB !== "undefined") { + return msIndexedDB; + } + } catch (e) { + return; + } + } + var idb = getIDB(); + function isIndexedDBValid() { + try { + if (!idb || !idb.open) { + return false; + } + var isSafari = typeof openDatabase !== "undefined" && /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent) && !/BlackBerry/.test(navigator.platform); + var hasFetch = typeof fetch === "function" && fetch.toString().indexOf("[native code") !== -1; + return (!isSafari || hasFetch) && typeof indexedDB !== "undefined" && typeof IDBKeyRange !== "undefined"; + } catch (e) { + return false; + } + } + function createBlob(parts, properties) { + parts = parts || []; + properties = properties || {}; + try { + return new Blob(parts, properties); + } catch (e) { + if (e.name !== "TypeError") { + throw e; + } + var Builder = typeof BlobBuilder !== "undefined" ? BlobBuilder : typeof MSBlobBuilder !== "undefined" ? MSBlobBuilder : typeof MozBlobBuilder !== "undefined" ? MozBlobBuilder : WebKitBlobBuilder; + var builder = new Builder(); + for (var i = 0; i < parts.length; i += 1) { + builder.append(parts[i]); + } + return builder.getBlob(properties.type); + } + } + if (typeof Promise === "undefined") { + _dereq_(3); + } + var Promise$1 = Promise; + function executeCallback(promise, callback) { + if (callback) { + promise.then(function(result) { + callback(null, result); + }, function(error) { + callback(error); + }); + } + } + function executeTwoCallbacks(promise, callback, errorCallback) { + if (typeof callback === "function") { + promise.then(callback); + } + if (typeof errorCallback === "function") { + promise["catch"](errorCallback); + } + } + function normalizeKey(key2) { + if (typeof key2 !== "string") { + console.warn(key2 + " used as a key, but it is not a string."); + key2 = String(key2); + } + return key2; + } + function getCallback() { + if (arguments.length && typeof arguments[arguments.length - 1] === "function") { + return arguments[arguments.length - 1]; + } + } + var DETECT_BLOB_SUPPORT_STORE = "local-forage-detect-blob-support"; + var supportsBlobs = void 0; + var dbContexts = {}; + var toString = Object.prototype.toString; + var READ_ONLY = "readonly"; + var READ_WRITE = "readwrite"; + function _binStringToArrayBuffer(bin) { + var length2 = bin.length; + var buf = new ArrayBuffer(length2); + var arr = new Uint8Array(buf); + for (var i = 0; i < length2; i++) { + arr[i] = bin.charCodeAt(i); + } + return buf; + } + function _checkBlobSupportWithoutCaching(idb2) { + return new Promise$1(function(resolve) { + var txn = idb2.transaction(DETECT_BLOB_SUPPORT_STORE, READ_WRITE); + var blob = createBlob([""]); + txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, "key"); + txn.onabort = function(e) { + e.preventDefault(); + e.stopPropagation(); + resolve(false); + }; + txn.oncomplete = function() { + var matchedChrome = navigator.userAgent.match(/Chrome\/(\d+)/); + var matchedEdge = navigator.userAgent.match(/Edge\//); + resolve(matchedEdge || !matchedChrome || parseInt(matchedChrome[1], 10) >= 43); + }; + })["catch"](function() { + return false; + }); + } + function _checkBlobSupport(idb2) { + if (typeof supportsBlobs === "boolean") { + return Promise$1.resolve(supportsBlobs); + } + return _checkBlobSupportWithoutCaching(idb2).then(function(value) { + supportsBlobs = value; + return supportsBlobs; + }); + } + function _deferReadiness(dbInfo) { + var dbContext = dbContexts[dbInfo.name]; + var deferredOperation = {}; + deferredOperation.promise = new Promise$1(function(resolve, reject) { + deferredOperation.resolve = resolve; + deferredOperation.reject = reject; + }); + dbContext.deferredOperations.push(deferredOperation); + if (!dbContext.dbReady) { + dbContext.dbReady = deferredOperation.promise; + } else { + dbContext.dbReady = dbContext.dbReady.then(function() { + return deferredOperation.promise; + }); + } + } + function _advanceReadiness(dbInfo) { + var dbContext = dbContexts[dbInfo.name]; + var deferredOperation = dbContext.deferredOperations.pop(); + if (deferredOperation) { + deferredOperation.resolve(); + return deferredOperation.promise; + } + } + function _rejectReadiness(dbInfo, err) { + var dbContext = dbContexts[dbInfo.name]; + var deferredOperation = dbContext.deferredOperations.pop(); + if (deferredOperation) { + deferredOperation.reject(err); + return deferredOperation.promise; + } + } + function _getConnection(dbInfo, upgradeNeeded) { + return new Promise$1(function(resolve, reject) { + dbContexts[dbInfo.name] = dbContexts[dbInfo.name] || createDbContext(); + if (dbInfo.db) { + if (upgradeNeeded) { + _deferReadiness(dbInfo); + dbInfo.db.close(); + } else { + return resolve(dbInfo.db); + } + } + var dbArgs = [dbInfo.name]; + if (upgradeNeeded) { + dbArgs.push(dbInfo.version); + } + var openreq = idb.open.apply(idb, dbArgs); + if (upgradeNeeded) { + openreq.onupgradeneeded = function(e) { + var db = openreq.result; + try { + db.createObjectStore(dbInfo.storeName); + if (e.oldVersion <= 1) { + db.createObjectStore(DETECT_BLOB_SUPPORT_STORE); + } + } catch (ex) { + if (ex.name === "ConstraintError") { + console.warn('The database "' + dbInfo.name + '" has been upgraded from version ' + e.oldVersion + " to version " + e.newVersion + ', but the storage "' + dbInfo.storeName + '" already exists.'); + } else { + throw ex; + } + } + }; + } + openreq.onerror = function(e) { + e.preventDefault(); + reject(openreq.error); + }; + openreq.onsuccess = function() { + var db = openreq.result; + db.onversionchange = function(e) { + e.target.close(); + }; + resolve(db); + _advanceReadiness(dbInfo); + }; + }); + } + function _getOriginalConnection(dbInfo) { + return _getConnection(dbInfo, false); + } + function _getUpgradedConnection(dbInfo) { + return _getConnection(dbInfo, true); + } + function _isUpgradeNeeded(dbInfo, defaultVersion) { + if (!dbInfo.db) { + return true; + } + var isNewStore = !dbInfo.db.objectStoreNames.contains(dbInfo.storeName); + var isDowngrade = dbInfo.version < dbInfo.db.version; + var isUpgrade = dbInfo.version > dbInfo.db.version; + if (isDowngrade) { + if (dbInfo.version !== defaultVersion) { + console.warn('The database "' + dbInfo.name + `" can't be downgraded from version ` + dbInfo.db.version + " to version " + dbInfo.version + "."); + } + dbInfo.version = dbInfo.db.version; + } + if (isUpgrade || isNewStore) { + if (isNewStore) { + var incVersion = dbInfo.db.version + 1; + if (incVersion > dbInfo.version) { + dbInfo.version = incVersion; + } + } + return true; + } + return false; + } + function _encodeBlob(blob) { + return new Promise$1(function(resolve, reject) { + var reader = new FileReader(); + reader.onerror = reject; + reader.onloadend = function(e) { + var base64 = btoa(e.target.result || ""); + resolve({ + __local_forage_encoded_blob: true, + data: base64, + type: blob.type + }); + }; + reader.readAsBinaryString(blob); + }); + } + function _decodeBlob(encodedBlob) { + var arrayBuff = _binStringToArrayBuffer(atob(encodedBlob.data)); + return createBlob([arrayBuff], { type: encodedBlob.type }); + } + function _isEncodedBlob(value) { + return value && value.__local_forage_encoded_blob; + } + function _fullyReady(callback) { + var self2 = this; + var promise = self2._initReady().then(function() { + var dbContext = dbContexts[self2._dbInfo.name]; + if (dbContext && dbContext.dbReady) { + return dbContext.dbReady; + } + }); + executeTwoCallbacks(promise, callback, callback); + return promise; + } + function _tryReconnect(dbInfo) { + _deferReadiness(dbInfo); + var dbContext = dbContexts[dbInfo.name]; + var forages = dbContext.forages; + for (var i = 0; i < forages.length; i++) { + var forage = forages[i]; + if (forage._dbInfo.db) { + forage._dbInfo.db.close(); + forage._dbInfo.db = null; + } + } + dbInfo.db = null; + return _getOriginalConnection(dbInfo).then(function(db) { + dbInfo.db = db; + if (_isUpgradeNeeded(dbInfo)) { + return _getUpgradedConnection(dbInfo); + } + return db; + }).then(function(db) { + dbInfo.db = dbContext.db = db; + for (var i2 = 0; i2 < forages.length; i2++) { + forages[i2]._dbInfo.db = db; + } + })["catch"](function(err) { + _rejectReadiness(dbInfo, err); + throw err; + }); + } + function createTransaction(dbInfo, mode, callback, retries) { + if (retries === void 0) { + retries = 1; + } + try { + var tx = dbInfo.db.transaction(dbInfo.storeName, mode); + callback(null, tx); + } catch (err) { + if (retries > 0 && (!dbInfo.db || err.name === "InvalidStateError" || err.name === "NotFoundError")) { + return Promise$1.resolve().then(function() { + if (!dbInfo.db || err.name === "NotFoundError" && !dbInfo.db.objectStoreNames.contains(dbInfo.storeName) && dbInfo.version <= dbInfo.db.version) { + if (dbInfo.db) { + dbInfo.version = dbInfo.db.version + 1; + } + return _getUpgradedConnection(dbInfo); + } + }).then(function() { + return _tryReconnect(dbInfo).then(function() { + createTransaction(dbInfo, mode, callback, retries - 1); + }); + })["catch"](callback); + } + callback(err); + } + } + function createDbContext() { + return { + forages: [], + db: null, + dbReady: null, + deferredOperations: [] + }; + } + function _initStorage(options) { + var self2 = this; + var dbInfo = { + db: null + }; + if (options) { + for (var i in options) { + dbInfo[i] = options[i]; + } + } + var dbContext = dbContexts[dbInfo.name]; + if (!dbContext) { + dbContext = createDbContext(); + dbContexts[dbInfo.name] = dbContext; + } + dbContext.forages.push(self2); + if (!self2._initReady) { + self2._initReady = self2.ready; + self2.ready = _fullyReady; + } + var initPromises = []; + function ignoreErrors() { + return Promise$1.resolve(); + } + for (var j = 0; j < dbContext.forages.length; j++) { + var forage = dbContext.forages[j]; + if (forage !== self2) { + initPromises.push(forage._initReady()["catch"](ignoreErrors)); + } + } + var forages = dbContext.forages.slice(0); + return Promise$1.all(initPromises).then(function() { + dbInfo.db = dbContext.db; + return _getOriginalConnection(dbInfo); + }).then(function(db) { + dbInfo.db = db; + if (_isUpgradeNeeded(dbInfo, self2._defaultConfig.version)) { + return _getUpgradedConnection(dbInfo); + } + return db; + }).then(function(db) { + dbInfo.db = dbContext.db = db; + self2._dbInfo = dbInfo; + for (var k = 0; k < forages.length; k++) { + var forage2 = forages[k]; + if (forage2 !== self2) { + forage2._dbInfo.db = dbInfo.db; + forage2._dbInfo.version = dbInfo.version; + } + } + }); + } + function getItem2(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.get(key2); + req.onsuccess = function() { + var value = req.result; + if (value === void 0) { + value = null; + } + if (_isEncodedBlob(value)) { + value = _decodeBlob(value); + } + resolve(value); + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function iterate(iterator, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.openCursor(); + var iterationNumber = 1; + req.onsuccess = function() { + var cursor = req.result; + if (cursor) { + var value = cursor.value; + if (_isEncodedBlob(value)) { + value = _decodeBlob(value); + } + var result = iterator(value, cursor.key, iterationNumber++); + if (result !== void 0) { + resolve(result); + } else { + cursor["continue"](); + } + } else { + resolve(); + } + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function setItem2(key2, value, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + var dbInfo; + self2.ready().then(function() { + dbInfo = self2._dbInfo; + if (toString.call(value) === "[object Blob]") { + return _checkBlobSupport(dbInfo.db).then(function(blobSupport) { + if (blobSupport) { + return value; + } + return _encodeBlob(value); + }); + } + return value; + }).then(function(value2) { + createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + if (value2 === null) { + value2 = void 0; + } + var req = store.put(value2, key2); + transaction.oncomplete = function() { + if (value2 === void 0) { + value2 = null; + } + resolve(value2); + }; + transaction.onabort = transaction.onerror = function() { + var err2 = req.error ? req.error : req.transaction.error; + reject(err2); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function removeItem(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store["delete"](key2); + transaction.oncomplete = function() { + resolve(); + }; + transaction.onerror = function() { + reject(req.error); + }; + transaction.onabort = function() { + var err2 = req.error ? req.error : req.transaction.error; + reject(err2); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function clear(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_WRITE, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.clear(); + transaction.oncomplete = function() { + resolve(); + }; + transaction.onabort = transaction.onerror = function() { + var err2 = req.error ? req.error : req.transaction.error; + reject(err2); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function length(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.count(); + req.onsuccess = function() { + resolve(req.result); + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function key(n, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + if (n < 0) { + resolve(null); + return; + } + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var advanced = false; + var req = store.openKeyCursor(); + req.onsuccess = function() { + var cursor = req.result; + if (!cursor) { + resolve(null); + return; + } + if (n === 0) { + resolve(cursor.key); + } else { + if (!advanced) { + advanced = true; + cursor.advance(n); + } else { + resolve(cursor.key); + } + } + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function keys(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + createTransaction(self2._dbInfo, READ_ONLY, function(err, transaction) { + if (err) { + return reject(err); + } + try { + var store = transaction.objectStore(self2._dbInfo.storeName); + var req = store.openKeyCursor(); + var keys2 = []; + req.onsuccess = function() { + var cursor = req.result; + if (!cursor) { + resolve(keys2); + return; + } + keys2.push(cursor.key); + cursor["continue"](); + }; + req.onerror = function() { + reject(req.error); + }; + } catch (e) { + reject(e); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function dropInstance(options, callback) { + callback = getCallback.apply(this, arguments); + var currentConfig = this.config(); + options = typeof options !== "function" && options || {}; + if (!options.name) { + options.name = options.name || currentConfig.name; + options.storeName = options.storeName || currentConfig.storeName; + } + var self2 = this; + var promise; + if (!options.name) { + promise = Promise$1.reject("Invalid arguments"); + } else { + var isCurrentDb = options.name === currentConfig.name && self2._dbInfo.db; + var dbPromise = isCurrentDb ? Promise$1.resolve(self2._dbInfo.db) : _getOriginalConnection(options).then(function(db) { + var dbContext = dbContexts[options.name]; + var forages = dbContext.forages; + dbContext.db = db; + for (var i = 0; i < forages.length; i++) { + forages[i]._dbInfo.db = db; + } + return db; + }); + if (!options.storeName) { + promise = dbPromise.then(function(db) { + _deferReadiness(options); + var dbContext = dbContexts[options.name]; + var forages = dbContext.forages; + db.close(); + for (var i = 0; i < forages.length; i++) { + var forage = forages[i]; + forage._dbInfo.db = null; + } + var dropDBPromise = new Promise$1(function(resolve, reject) { + var req = idb.deleteDatabase(options.name); + req.onerror = function() { + var db2 = req.result; + if (db2) { + db2.close(); + } + reject(req.error); + }; + req.onblocked = function() { + console.warn('dropInstance blocked for database "' + options.name + '" until all open connections are closed'); + }; + req.onsuccess = function() { + var db2 = req.result; + if (db2) { + db2.close(); + } + resolve(db2); + }; + }); + return dropDBPromise.then(function(db2) { + dbContext.db = db2; + for (var i2 = 0; i2 < forages.length; i2++) { + var _forage = forages[i2]; + _advanceReadiness(_forage._dbInfo); + } + })["catch"](function(err) { + (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function() { + }); + throw err; + }); + }); + } else { + promise = dbPromise.then(function(db) { + if (!db.objectStoreNames.contains(options.storeName)) { + return; + } + var newVersion = db.version + 1; + _deferReadiness(options); + var dbContext = dbContexts[options.name]; + var forages = dbContext.forages; + db.close(); + for (var i = 0; i < forages.length; i++) { + var forage = forages[i]; + forage._dbInfo.db = null; + forage._dbInfo.version = newVersion; + } + var dropObjectPromise = new Promise$1(function(resolve, reject) { + var req = idb.open(options.name, newVersion); + req.onerror = function(err) { + var db2 = req.result; + db2.close(); + reject(err); + }; + req.onupgradeneeded = function() { + var db2 = req.result; + db2.deleteObjectStore(options.storeName); + }; + req.onsuccess = function() { + var db2 = req.result; + db2.close(); + resolve(db2); + }; + }); + return dropObjectPromise.then(function(db2) { + dbContext.db = db2; + for (var j = 0; j < forages.length; j++) { + var _forage2 = forages[j]; + _forage2._dbInfo.db = db2; + _advanceReadiness(_forage2._dbInfo); + } + })["catch"](function(err) { + (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function() { + }); + throw err; + }); + }); + } + } + executeCallback(promise, callback); + return promise; + } + var asyncStorage = { + _driver: "asyncStorage", + _initStorage, + _support: isIndexedDBValid(), + iterate, + getItem: getItem2, + setItem: setItem2, + removeItem, + clear, + length, + key, + keys, + dropInstance + }; + function isWebSQLValid() { + return typeof openDatabase === "function"; + } + var BASE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var BLOB_TYPE_PREFIX = "~~local_forage_type~"; + var BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/; + var SERIALIZED_MARKER = "__lfsc__:"; + var SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER.length; + var TYPE_ARRAYBUFFER = "arbf"; + var TYPE_BLOB = "blob"; + var TYPE_INT8ARRAY = "si08"; + var TYPE_UINT8ARRAY = "ui08"; + var TYPE_UINT8CLAMPEDARRAY = "uic8"; + var TYPE_INT16ARRAY = "si16"; + var TYPE_INT32ARRAY = "si32"; + var TYPE_UINT16ARRAY = "ur16"; + var TYPE_UINT32ARRAY = "ui32"; + var TYPE_FLOAT32ARRAY = "fl32"; + var TYPE_FLOAT64ARRAY = "fl64"; + var TYPE_SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER_LENGTH + TYPE_ARRAYBUFFER.length; + var toString$1 = Object.prototype.toString; + function stringToBuffer(serializedString) { + var bufferLength = serializedString.length * 0.75; + var len = serializedString.length; + var i; + var p = 0; + var encoded1, encoded2, encoded3, encoded4; + if (serializedString[serializedString.length - 1] === "=") { + bufferLength--; + if (serializedString[serializedString.length - 2] === "=") { + bufferLength--; + } + } + var buffer = new ArrayBuffer(bufferLength); + var bytes = new Uint8Array(buffer); + for (i = 0; i < len; i += 4) { + encoded1 = BASE_CHARS.indexOf(serializedString[i]); + encoded2 = BASE_CHARS.indexOf(serializedString[i + 1]); + encoded3 = BASE_CHARS.indexOf(serializedString[i + 2]); + encoded4 = BASE_CHARS.indexOf(serializedString[i + 3]); + bytes[p++] = encoded1 << 2 | encoded2 >> 4; + bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2; + bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63; + } + return buffer; + } + function bufferToString(buffer) { + var bytes = new Uint8Array(buffer); + var base64String = ""; + var i; + for (i = 0; i < bytes.length; i += 3) { + base64String += BASE_CHARS[bytes[i] >> 2]; + base64String += BASE_CHARS[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4]; + base64String += BASE_CHARS[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6]; + base64String += BASE_CHARS[bytes[i + 2] & 63]; + } + if (bytes.length % 3 === 2) { + base64String = base64String.substring(0, base64String.length - 1) + "="; + } else if (bytes.length % 3 === 1) { + base64String = base64String.substring(0, base64String.length - 2) + "=="; + } + return base64String; + } + function serialize(value, callback) { + var valueType = ""; + if (value) { + valueType = toString$1.call(value); + } + if (value && (valueType === "[object ArrayBuffer]" || value.buffer && toString$1.call(value.buffer) === "[object ArrayBuffer]")) { + var buffer; + var marker = SERIALIZED_MARKER; + if (value instanceof ArrayBuffer) { + buffer = value; + marker += TYPE_ARRAYBUFFER; + } else { + buffer = value.buffer; + if (valueType === "[object Int8Array]") { + marker += TYPE_INT8ARRAY; + } else if (valueType === "[object Uint8Array]") { + marker += TYPE_UINT8ARRAY; + } else if (valueType === "[object Uint8ClampedArray]") { + marker += TYPE_UINT8CLAMPEDARRAY; + } else if (valueType === "[object Int16Array]") { + marker += TYPE_INT16ARRAY; + } else if (valueType === "[object Uint16Array]") { + marker += TYPE_UINT16ARRAY; + } else if (valueType === "[object Int32Array]") { + marker += TYPE_INT32ARRAY; + } else if (valueType === "[object Uint32Array]") { + marker += TYPE_UINT32ARRAY; + } else if (valueType === "[object Float32Array]") { + marker += TYPE_FLOAT32ARRAY; + } else if (valueType === "[object Float64Array]") { + marker += TYPE_FLOAT64ARRAY; + } else { + callback(new Error("Failed to get type for BinaryArray")); + } + } + callback(marker + bufferToString(buffer)); + } else if (valueType === "[object Blob]") { + var fileReader = new FileReader(); + fileReader.onload = function() { + var str = BLOB_TYPE_PREFIX + value.type + "~" + bufferToString(this.result); + callback(SERIALIZED_MARKER + TYPE_BLOB + str); + }; + fileReader.readAsArrayBuffer(value); + } else { + try { + callback(JSON.stringify(value)); + } catch (e) { + console.error("Couldn't convert value into a JSON string: ", value); + callback(null, e); + } + } + } + function deserialize(value) { + if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== SERIALIZED_MARKER) { + return JSON.parse(value); + } + var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH); + var type = value.substring(SERIALIZED_MARKER_LENGTH, TYPE_SERIALIZED_MARKER_LENGTH); + var blobType; + if (type === TYPE_BLOB && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) { + var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX); + blobType = matcher[1]; + serializedString = serializedString.substring(matcher[0].length); + } + var buffer = stringToBuffer(serializedString); + switch (type) { + case TYPE_ARRAYBUFFER: + return buffer; + case TYPE_BLOB: + return createBlob([buffer], { type: blobType }); + case TYPE_INT8ARRAY: + return new Int8Array(buffer); + case TYPE_UINT8ARRAY: + return new Uint8Array(buffer); + case TYPE_UINT8CLAMPEDARRAY: + return new Uint8ClampedArray(buffer); + case TYPE_INT16ARRAY: + return new Int16Array(buffer); + case TYPE_UINT16ARRAY: + return new Uint16Array(buffer); + case TYPE_INT32ARRAY: + return new Int32Array(buffer); + case TYPE_UINT32ARRAY: + return new Uint32Array(buffer); + case TYPE_FLOAT32ARRAY: + return new Float32Array(buffer); + case TYPE_FLOAT64ARRAY: + return new Float64Array(buffer); + default: + throw new Error("Unkown type: " + type); + } + } + var localforageSerializer = { + serialize, + deserialize, + stringToBuffer, + bufferToString + }; + function createDbTable(t, dbInfo, callback, errorCallback) { + t.executeSql("CREATE TABLE IF NOT EXISTS " + dbInfo.storeName + " (id INTEGER PRIMARY KEY, key unique, value)", [], callback, errorCallback); + } + function _initStorage$1(options) { + var self2 = this; + var dbInfo = { + db: null + }; + if (options) { + for (var i in options) { + dbInfo[i] = typeof options[i] !== "string" ? options[i].toString() : options[i]; + } + } + var dbInfoPromise = new Promise$1(function(resolve, reject) { + try { + dbInfo.db = openDatabase(dbInfo.name, String(dbInfo.version), dbInfo.description, dbInfo.size); + } catch (e) { + return reject(e); + } + dbInfo.db.transaction(function(t) { + createDbTable(t, dbInfo, function() { + self2._dbInfo = dbInfo; + resolve(); + }, function(t2, error) { + reject(error); + }); + }, reject); + }); + dbInfo.serializer = localforageSerializer; + return dbInfoPromise; + } + function tryExecuteSql(t, dbInfo, sqlStatement, args, callback, errorCallback) { + t.executeSql(sqlStatement, args, callback, function(t2, error) { + if (error.code === error.SYNTAX_ERR) { + t2.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name = ?", [dbInfo.storeName], function(t3, results) { + if (!results.rows.length) { + createDbTable(t3, dbInfo, function() { + t3.executeSql(sqlStatement, args, callback, errorCallback); + }, errorCallback); + } else { + errorCallback(t3, error); + } + }, errorCallback); + } else { + errorCallback(t2, error); + } + }, errorCallback); + } + function getItem$1(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT * FROM " + dbInfo.storeName + " WHERE key = ? LIMIT 1", [key2], function(t2, results) { + var result = results.rows.length ? results.rows.item(0).value : null; + if (result) { + result = dbInfo.serializer.deserialize(result); + } + resolve(result); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function iterate$1(iterator, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT * FROM " + dbInfo.storeName, [], function(t2, results) { + var rows = results.rows; + var length2 = rows.length; + for (var i = 0; i < length2; i++) { + var item = rows.item(i); + var result = item.value; + if (result) { + result = dbInfo.serializer.deserialize(result); + } + result = iterator(result, item.key, i + 1); + if (result !== void 0) { + resolve(result); + return; + } + } + resolve(); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function _setItem(key2, value, callback, retriesLeft) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + if (value === void 0) { + value = null; + } + var originalValue = value; + var dbInfo = self2._dbInfo; + dbInfo.serializer.serialize(value, function(value2, error) { + if (error) { + reject(error); + } else { + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "INSERT OR REPLACE INTO " + dbInfo.storeName + " (key, value) VALUES (?, ?)", [key2, value2], function() { + resolve(originalValue); + }, function(t2, error2) { + reject(error2); + }); + }, function(sqlError) { + if (sqlError.code === sqlError.QUOTA_ERR) { + if (retriesLeft > 0) { + resolve(_setItem.apply(self2, [key2, originalValue, callback, retriesLeft - 1])); + return; + } + reject(sqlError); + } + }); + } + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function setItem$1(key2, value, callback) { + return _setItem.apply(this, [key2, value, callback, 1]); + } + function removeItem$1(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "DELETE FROM " + dbInfo.storeName + " WHERE key = ?", [key2], function() { + resolve(); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function clear$1(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "DELETE FROM " + dbInfo.storeName, [], function() { + resolve(); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function length$1(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT COUNT(key) as c FROM " + dbInfo.storeName, [], function(t2, results) { + var result = results.rows.item(0).c; + resolve(result); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function key$1(n, callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT key FROM " + dbInfo.storeName + " WHERE id = ? LIMIT 1", [n + 1], function(t2, results) { + var result = results.rows.length ? results.rows.item(0).key : null; + resolve(result); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function keys$1(callback) { + var self2 = this; + var promise = new Promise$1(function(resolve, reject) { + self2.ready().then(function() { + var dbInfo = self2._dbInfo; + dbInfo.db.transaction(function(t) { + tryExecuteSql(t, dbInfo, "SELECT key FROM " + dbInfo.storeName, [], function(t2, results) { + var keys2 = []; + for (var i = 0; i < results.rows.length; i++) { + keys2.push(results.rows.item(i).key); + } + resolve(keys2); + }, function(t2, error) { + reject(error); + }); + }); + })["catch"](reject); + }); + executeCallback(promise, callback); + return promise; + } + function getAllStoreNames(db) { + return new Promise$1(function(resolve, reject) { + db.transaction(function(t) { + t.executeSql("SELECT name FROM sqlite_master WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'", [], function(t2, results) { + var storeNames = []; + for (var i = 0; i < results.rows.length; i++) { + storeNames.push(results.rows.item(i).name); + } + resolve({ + db, + storeNames + }); + }, function(t2, error) { + reject(error); + }); + }, function(sqlError) { + reject(sqlError); + }); + }); + } + function dropInstance$1(options, callback) { + callback = getCallback.apply(this, arguments); + var currentConfig = this.config(); + options = typeof options !== "function" && options || {}; + if (!options.name) { + options.name = options.name || currentConfig.name; + options.storeName = options.storeName || currentConfig.storeName; + } + var self2 = this; + var promise; + if (!options.name) { + promise = Promise$1.reject("Invalid arguments"); + } else { + promise = new Promise$1(function(resolve) { + var db; + if (options.name === currentConfig.name) { + db = self2._dbInfo.db; + } else { + db = openDatabase(options.name, "", "", 0); + } + if (!options.storeName) { + resolve(getAllStoreNames(db)); + } else { + resolve({ + db, + storeNames: [options.storeName] + }); + } + }).then(function(operationInfo) { + return new Promise$1(function(resolve, reject) { + operationInfo.db.transaction(function(t) { + function dropTable(storeName) { + return new Promise$1(function(resolve2, reject2) { + t.executeSql("DROP TABLE IF EXISTS " + storeName, [], function() { + resolve2(); + }, function(t2, error) { + reject2(error); + }); + }); + } + var operations = []; + for (var i = 0, len = operationInfo.storeNames.length; i < len; i++) { + operations.push(dropTable(operationInfo.storeNames[i])); + } + Promise$1.all(operations).then(function() { + resolve(); + })["catch"](function(e) { + reject(e); + }); + }, function(sqlError) { + reject(sqlError); + }); + }); + }); + } + executeCallback(promise, callback); + return promise; + } + var webSQLStorage = { + _driver: "webSQLStorage", + _initStorage: _initStorage$1, + _support: isWebSQLValid(), + iterate: iterate$1, + getItem: getItem$1, + setItem: setItem$1, + removeItem: removeItem$1, + clear: clear$1, + length: length$1, + key: key$1, + keys: keys$1, + dropInstance: dropInstance$1 + }; + function isLocalStorageValid() { + try { + return typeof localStorage !== "undefined" && "setItem" in localStorage && !!localStorage.setItem; + } catch (e) { + return false; + } + } + function _getKeyPrefix(options, defaultConfig) { + var keyPrefix = options.name + "/"; + if (options.storeName !== defaultConfig.storeName) { + keyPrefix += options.storeName + "/"; + } + return keyPrefix; + } + function checkIfLocalStorageThrows() { + var localStorageTestKey = "_localforage_support_test"; + try { + localStorage.setItem(localStorageTestKey, true); + localStorage.removeItem(localStorageTestKey); + return false; + } catch (e) { + return true; + } + } + function _isLocalStorageUsable() { + return !checkIfLocalStorageThrows() || localStorage.length > 0; + } + function _initStorage$2(options) { + var self2 = this; + var dbInfo = {}; + if (options) { + for (var i in options) { + dbInfo[i] = options[i]; + } + } + dbInfo.keyPrefix = _getKeyPrefix(options, self2._defaultConfig); + if (!_isLocalStorageUsable()) { + return Promise$1.reject(); + } + self2._dbInfo = dbInfo; + dbInfo.serializer = localforageSerializer; + return Promise$1.resolve(); + } + function clear$2(callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var keyPrefix = self2._dbInfo.keyPrefix; + for (var i = localStorage.length - 1; i >= 0; i--) { + var key2 = localStorage.key(i); + if (key2.indexOf(keyPrefix) === 0) { + localStorage.removeItem(key2); + } + } + }); + executeCallback(promise, callback); + return promise; + } + function getItem$2(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var result = localStorage.getItem(dbInfo.keyPrefix + key2); + if (result) { + result = dbInfo.serializer.deserialize(result); + } + return result; + }); + executeCallback(promise, callback); + return promise; + } + function iterate$2(iterator, callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var keyPrefix = dbInfo.keyPrefix; + var keyPrefixLength = keyPrefix.length; + var length2 = localStorage.length; + var iterationNumber = 1; + for (var i = 0; i < length2; i++) { + var key2 = localStorage.key(i); + if (key2.indexOf(keyPrefix) !== 0) { + continue; + } + var value = localStorage.getItem(key2); + if (value) { + value = dbInfo.serializer.deserialize(value); + } + value = iterator(value, key2.substring(keyPrefixLength), iterationNumber++); + if (value !== void 0) { + return value; + } + } + }); + executeCallback(promise, callback); + return promise; + } + function key$2(n, callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var result; + try { + result = localStorage.key(n); + } catch (error) { + result = null; + } + if (result) { + result = result.substring(dbInfo.keyPrefix.length); + } + return result; + }); + executeCallback(promise, callback); + return promise; + } + function keys$2(callback) { + var self2 = this; + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + var length2 = localStorage.length; + var keys2 = []; + for (var i = 0; i < length2; i++) { + var itemKey = localStorage.key(i); + if (itemKey.indexOf(dbInfo.keyPrefix) === 0) { + keys2.push(itemKey.substring(dbInfo.keyPrefix.length)); + } + } + return keys2; + }); + executeCallback(promise, callback); + return promise; + } + function length$2(callback) { + var self2 = this; + var promise = self2.keys().then(function(keys2) { + return keys2.length; + }); + executeCallback(promise, callback); + return promise; + } + function removeItem$2(key2, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = self2.ready().then(function() { + var dbInfo = self2._dbInfo; + localStorage.removeItem(dbInfo.keyPrefix + key2); + }); + executeCallback(promise, callback); + return promise; + } + function setItem$2(key2, value, callback) { + var self2 = this; + key2 = normalizeKey(key2); + var promise = self2.ready().then(function() { + if (value === void 0) { + value = null; + } + var originalValue = value; + return new Promise$1(function(resolve, reject) { + var dbInfo = self2._dbInfo; + dbInfo.serializer.serialize(value, function(value2, error) { + if (error) { + reject(error); + } else { + try { + localStorage.setItem(dbInfo.keyPrefix + key2, value2); + resolve(originalValue); + } catch (e) { + if (e.name === "QuotaExceededError" || e.name === "NS_ERROR_DOM_QUOTA_REACHED") { + reject(e); + } + reject(e); + } + } + }); + }); + }); + executeCallback(promise, callback); + return promise; + } + function dropInstance$2(options, callback) { + callback = getCallback.apply(this, arguments); + options = typeof options !== "function" && options || {}; + if (!options.name) { + var currentConfig = this.config(); + options.name = options.name || currentConfig.name; + options.storeName = options.storeName || currentConfig.storeName; + } + var self2 = this; + var promise; + if (!options.name) { + promise = Promise$1.reject("Invalid arguments"); + } else { + promise = new Promise$1(function(resolve) { + if (!options.storeName) { + resolve(options.name + "/"); + } else { + resolve(_getKeyPrefix(options, self2._defaultConfig)); + } + }).then(function(keyPrefix) { + for (var i = localStorage.length - 1; i >= 0; i--) { + var key2 = localStorage.key(i); + if (key2.indexOf(keyPrefix) === 0) { + localStorage.removeItem(key2); + } + } + }); + } + executeCallback(promise, callback); + return promise; + } + var localStorageWrapper = { + _driver: "localStorageWrapper", + _initStorage: _initStorage$2, + _support: isLocalStorageValid(), + iterate: iterate$2, + getItem: getItem$2, + setItem: setItem$2, + removeItem: removeItem$2, + clear: clear$2, + length: length$2, + key: key$2, + keys: keys$2, + dropInstance: dropInstance$2 + }; + var sameValue = function sameValue2(x, y) { + return x === y || typeof x === "number" && typeof y === "number" && isNaN(x) && isNaN(y); + }; + var includes = function includes2(array, searchElement) { + var len = array.length; + var i = 0; + while (i < len) { + if (sameValue(array[i], searchElement)) { + return true; + } + i++; + } + return false; + }; + var isArray = Array.isArray || function(arg) { + return Object.prototype.toString.call(arg) === "[object Array]"; + }; + var DefinedDrivers = {}; + var DriverSupport = {}; + var DefaultDrivers = { + INDEXEDDB: asyncStorage, + WEBSQL: webSQLStorage, + LOCALSTORAGE: localStorageWrapper + }; + var DefaultDriverOrder = [DefaultDrivers.INDEXEDDB._driver, DefaultDrivers.WEBSQL._driver, DefaultDrivers.LOCALSTORAGE._driver]; + var OptionalDriverMethods = ["dropInstance"]; + var LibraryMethods = ["clear", "getItem", "iterate", "key", "keys", "length", "removeItem", "setItem"].concat(OptionalDriverMethods); + var DefaultConfig = { + description: "", + driver: DefaultDriverOrder.slice(), + name: "localforage", + size: 4980736, + storeName: "keyvaluepairs", + version: 1 + }; + function callWhenReady(localForageInstance, libraryMethod) { + localForageInstance[libraryMethod] = function() { + var _args = arguments; + return localForageInstance.ready().then(function() { + return localForageInstance[libraryMethod].apply(localForageInstance, _args); + }); + }; + } + function extend() { + for (var i = 1; i < arguments.length; i++) { + var arg = arguments[i]; + if (arg) { + for (var _key in arg) { + if (arg.hasOwnProperty(_key)) { + if (isArray(arg[_key])) { + arguments[0][_key] = arg[_key].slice(); + } else { + arguments[0][_key] = arg[_key]; + } + } + } + } + } + return arguments[0]; + } + var LocalForage = function() { + function LocalForage2(options) { + _classCallCheck(this, LocalForage2); + for (var driverTypeKey in DefaultDrivers) { + if (DefaultDrivers.hasOwnProperty(driverTypeKey)) { + var driver = DefaultDrivers[driverTypeKey]; + var driverName = driver._driver; + this[driverTypeKey] = driverName; + if (!DefinedDrivers[driverName]) { + this.defineDriver(driver); + } + } + } + this._defaultConfig = extend({}, DefaultConfig); + this._config = extend({}, this._defaultConfig, options); + this._driverSet = null; + this._initDriver = null; + this._ready = false; + this._dbInfo = null; + this._wrapLibraryMethodsWithReady(); + this.setDriver(this._config.driver)["catch"](function() { + }); + } + LocalForage2.prototype.config = function config(options) { + if ((typeof options === "undefined" ? "undefined" : _typeof(options)) === "object") { + if (this._ready) { + return new Error("Can't call config() after localforage has been used."); + } + for (var i in options) { + if (i === "storeName") { + options[i] = options[i].replace(/\W/g, "_"); + } + if (i === "version" && typeof options[i] !== "number") { + return new Error("Database version must be a number."); + } + this._config[i] = options[i]; + } + if ("driver" in options && options.driver) { + return this.setDriver(this._config.driver); + } + return true; + } else if (typeof options === "string") { + return this._config[options]; + } else { + return this._config; + } + }; + LocalForage2.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) { + var promise = new Promise$1(function(resolve, reject) { + try { + var driverName = driverObject._driver; + var complianceError = new Error("Custom driver not compliant; see https://mozilla.github.io/localForage/#definedriver"); + if (!driverObject._driver) { + reject(complianceError); + return; + } + var driverMethods = LibraryMethods.concat("_initStorage"); + for (var i = 0, len = driverMethods.length; i < len; i++) { + var driverMethodName = driverMethods[i]; + var isRequired = !includes(OptionalDriverMethods, driverMethodName); + if ((isRequired || driverObject[driverMethodName]) && typeof driverObject[driverMethodName] !== "function") { + reject(complianceError); + return; + } + } + var configureMissingMethods = function configureMissingMethods2() { + var methodNotImplementedFactory = function methodNotImplementedFactory2(methodName) { + return function() { + var error = new Error("Method " + methodName + " is not implemented by the current driver"); + var promise2 = Promise$1.reject(error); + executeCallback(promise2, arguments[arguments.length - 1]); + return promise2; + }; + }; + for (var _i = 0, _len = OptionalDriverMethods.length; _i < _len; _i++) { + var optionalDriverMethod = OptionalDriverMethods[_i]; + if (!driverObject[optionalDriverMethod]) { + driverObject[optionalDriverMethod] = methodNotImplementedFactory(optionalDriverMethod); + } + } + }; + configureMissingMethods(); + var setDriverSupport = function setDriverSupport2(support) { + if (DefinedDrivers[driverName]) { + console.info("Redefining LocalForage driver: " + driverName); + } + DefinedDrivers[driverName] = driverObject; + DriverSupport[driverName] = support; + resolve(); + }; + if ("_support" in driverObject) { + if (driverObject._support && typeof driverObject._support === "function") { + driverObject._support().then(setDriverSupport, reject); + } else { + setDriverSupport(!!driverObject._support); + } + } else { + setDriverSupport(true); + } + } catch (e) { + reject(e); + } + }); + executeTwoCallbacks(promise, callback, errorCallback); + return promise; + }; + LocalForage2.prototype.driver = function driver() { + return this._driver || null; + }; + LocalForage2.prototype.getDriver = function getDriver(driverName, callback, errorCallback) { + var getDriverPromise = DefinedDrivers[driverName] ? Promise$1.resolve(DefinedDrivers[driverName]) : Promise$1.reject(new Error("Driver not found.")); + executeTwoCallbacks(getDriverPromise, callback, errorCallback); + return getDriverPromise; + }; + LocalForage2.prototype.getSerializer = function getSerializer(callback) { + var serializerPromise = Promise$1.resolve(localforageSerializer); + executeTwoCallbacks(serializerPromise, callback); + return serializerPromise; + }; + LocalForage2.prototype.ready = function ready(callback) { + var self2 = this; + var promise = self2._driverSet.then(function() { + if (self2._ready === null) { + self2._ready = self2._initDriver(); + } + return self2._ready; + }); + executeTwoCallbacks(promise, callback, callback); + return promise; + }; + LocalForage2.prototype.setDriver = function setDriver(drivers, callback, errorCallback) { + var self2 = this; + if (!isArray(drivers)) { + drivers = [drivers]; + } + var supportedDrivers = this._getSupportedDrivers(drivers); + function setDriverToConfig() { + self2._config.driver = self2.driver(); + } + function extendSelfWithDriver(driver) { + self2._extend(driver); + setDriverToConfig(); + self2._ready = self2._initStorage(self2._config); + return self2._ready; + } + function initDriver(supportedDrivers2) { + return function() { + var currentDriverIndex = 0; + function driverPromiseLoop() { + while (currentDriverIndex < supportedDrivers2.length) { + var driverName = supportedDrivers2[currentDriverIndex]; + currentDriverIndex++; + self2._dbInfo = null; + self2._ready = null; + return self2.getDriver(driverName).then(extendSelfWithDriver)["catch"](driverPromiseLoop); + } + setDriverToConfig(); + var error = new Error("No available storage method found."); + self2._driverSet = Promise$1.reject(error); + return self2._driverSet; + } + return driverPromiseLoop(); + }; + } + var oldDriverSetDone = this._driverSet !== null ? this._driverSet["catch"](function() { + return Promise$1.resolve(); + }) : Promise$1.resolve(); + this._driverSet = oldDriverSetDone.then(function() { + var driverName = supportedDrivers[0]; + self2._dbInfo = null; + self2._ready = null; + return self2.getDriver(driverName).then(function(driver) { + self2._driver = driver._driver; + setDriverToConfig(); + self2._wrapLibraryMethodsWithReady(); + self2._initDriver = initDriver(supportedDrivers); + }); + })["catch"](function() { + setDriverToConfig(); + var error = new Error("No available storage method found."); + self2._driverSet = Promise$1.reject(error); + return self2._driverSet; + }); + executeTwoCallbacks(this._driverSet, callback, errorCallback); + return this._driverSet; + }; + LocalForage2.prototype.supports = function supports(driverName) { + return !!DriverSupport[driverName]; + }; + LocalForage2.prototype._extend = function _extend(libraryMethodsAndProperties) { + extend(this, libraryMethodsAndProperties); + }; + LocalForage2.prototype._getSupportedDrivers = function _getSupportedDrivers(drivers) { + var supportedDrivers = []; + for (var i = 0, len = drivers.length; i < len; i++) { + var driverName = drivers[i]; + if (this.supports(driverName)) { + supportedDrivers.push(driverName); + } + } + return supportedDrivers; + }; + LocalForage2.prototype._wrapLibraryMethodsWithReady = function _wrapLibraryMethodsWithReady() { + for (var i = 0, len = LibraryMethods.length; i < len; i++) { + callWhenReady(this, LibraryMethods[i]); + } + }; + LocalForage2.prototype.createInstance = function createInstance(options) { + return new LocalForage2(options); + }; + return LocalForage2; + }(); + var localforage_js = new LocalForage(); + module4.exports = localforage_js; + }, { "3": 3 }] }, {}, [4])(4); + }); + } +}); + +// src/main.ts +__export(exports, { + default: () => PlantumlPlugin +}); +var import_obsidian6 = __toModule(require("obsidian")); + +// src/settings.ts +var import_obsidian = __toModule(require("obsidian")); +var DEFAULT_SETTINGS = { + server_url: "https://www.plantuml.com/plantuml", + header: "", + debounce: 3, + localJar: "", + javaPath: "java", + dotPath: "dot", + defaultProcessor: "png", + cache: 60, + exportPath: "" +}; +var PlantUMLSettingsTab = class extends import_obsidian.PluginSettingTab { + constructor(plugin) { + super(plugin.app, plugin); + this.plugin = plugin; + } + display() { + const { containerEl } = this; + containerEl.empty(); + new import_obsidian.Setting(containerEl).setName("Server URL").setDesc("PlantUML Server URL").addText((text) => text.setPlaceholder(DEFAULT_SETTINGS.server_url).setValue(this.plugin.settings.server_url).onChange((value) => __async(this, null, function* () { + this.plugin.settings.server_url = value; + yield this.plugin.saveSettings(); + }))); + if (import_obsidian.Platform.isDesktopApp) { + const jarDesc = new DocumentFragment(); + jarDesc.createDiv().innerHTML = "Path to local JAR
Supports:"; + new import_obsidian.Setting(containerEl).setName("Local JAR").setDesc(jarDesc).addText((text) => text.setPlaceholder(DEFAULT_SETTINGS.localJar).setValue(this.plugin.settings.localJar).onChange((value) => __async(this, null, function* () { + this.plugin.settings.localJar = value; + yield this.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Java path").setDesc("Path to Java executable").addText((text) => text.setPlaceholder(DEFAULT_SETTINGS.javaPath).setValue(this.plugin.settings.javaPath).onChange((value) => __async(this, null, function* () { + this.plugin.settings.javaPath = value; + yield this.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Dot path").setDesc("Path to dot executable").addText((text) => text.setPlaceholder(DEFAULT_SETTINGS.dotPath).setValue(this.plugin.settings.dotPath).onChange((value) => __async(this, null, function* () { + this.plugin.settings.dotPath = value; + yield this.plugin.saveSettings(); + }))); + new import_obsidian.Setting(containerEl).setName("Diagram export path").setDesc("Path where exported diagrams will be saved relative to the vault root. Leave blank to save along side the note.").addText((text) => text.setPlaceholder(DEFAULT_SETTINGS.exportPath).setValue(this.plugin.settings.exportPath).onChange((value) => __async(this, null, function* () { + this.plugin.settings.exportPath = value; + yield this.plugin.saveSettings(); + }))); + } + new import_obsidian.Setting(containerEl).setName("Default processor for includes").setDesc("Any .pu/.puml files linked will use this processor").addDropdown((dropdown) => { + dropdown.addOption("png", "PNG").addOption("svg", "SVG").setValue(this.plugin.settings.defaultProcessor).onChange((value) => __async(this, null, function* () { + this.plugin.settings.defaultProcessor = value; + yield this.plugin.saveSettings(); + })); + }); + new import_obsidian.Setting(containerEl).setName("Header").setDesc("Included at the head in every diagram. Useful for specifying a common theme (.puml file)").addTextArea((text) => { + text.setPlaceholder("!include https://raw.githubusercontent.com/....puml\n").setValue(this.plugin.settings.header).onChange((value) => __async(this, null, function* () { + this.plugin.settings.header = value; + yield this.plugin.saveSettings(); + })); + text.inputEl.setAttr("rows", 4); + text.inputEl.addClass("puml-settings-area"); + }); + new import_obsidian.Setting(containerEl).setName("Cache").setDesc("in days. Only applicable when generating diagrams locally").addSlider((slider) => { + slider.setLimits(10, 360, 10).setValue(this.plugin.settings.cache).setDynamicTooltip().onChange((value) => __async(this, null, function* () { + this.plugin.settings.cache = value; + yield this.plugin.saveSettings(); + })); + }); + new import_obsidian.Setting(containerEl).setName("Debounce").setDesc("How often should the diagram refresh in seconds").addText((text) => text.setPlaceholder(String(DEFAULT_SETTINGS.debounce)).setValue(String(this.plugin.settings.debounce)).onChange((value) => __async(this, null, function* () { + if (!isNaN(Number(value)) || value === void 0) { + this.plugin.settings.debounce = Number(value || DEFAULT_SETTINGS.debounce); + yield this.plugin.saveSettings(); + } else { + new import_obsidian.Notice("Please specify a valid number"); + } + }))); + } +}; + +// src/processors/localProcessors.ts +var plantuml = __toModule(require_browser_index()); + +// src/functions.ts +var Replacer = class { + constructor(plugin) { + this.plugin = plugin; + } + replaceNonBreakingSpaces(text) { + const lines = text.split(/\r?\n/); + const resultLines = []; + if (text.startsWith("@startmindmap")) { + for (const line of lines) { + resultLines.push(line.replace(/\s+/g, " ")); + } + } else { + resultLines.push(...lines); + } + const result = resultLines.join("\r\n"); + return result.replace(/ /gi, " "); + } + replaceLinks(text, path, filetype) { + return text.replace(/\[\[\[([\s\S]*?)\]\]\]/g, (_, args) => { + const split = args.split("|"); + const file = this.plugin.app.metadataCache.getFirstLinkpathDest(split[0], path); + if (!file) { + return "File with name: " + split[0] + " not found"; + } + let alias = file.basename; + if (filetype === "png") { + const url = this.plugin.app.getObsidianUrl(file); + if (split[1]) { + alias = split[1]; + } + return "[[" + url + " " + alias + "]]"; + } + return "[[" + file.basename + "]]"; + }); + } + getFullPath(path) { + if (path.length === 0) { + return this.plugin.app.vault.adapter.getFullPath(""); + } + const file = this.plugin.app.vault.getAbstractFileByPath(path); + if (!file) { + return this.plugin.app.vault.adapter.getFullPath(""); + } + const folder = this.plugin.app.vault.getDirectParent(file); + return this.plugin.app.vault.adapter.getFullPath(folder.path); + } + getPath(ctx) { + return this.getFullPath(ctx ? ctx.sourcePath : ""); + } +}; +function insertImageWithMap(el, image, map, encodedDiagram) { + el.empty(); + const img = document.createElement("img"); + if (image.startsWith("http")) { + img.src = image; + } else { + img.src = "data:image/png;base64," + image; + } + img.useMap = "#" + encodedDiagram; + if (map.contains("map")) { + el.innerHTML = map; + el.children[0].setAttr("name", encodedDiagram); + } + el.appendChild(img); +} +function insertAsciiImage(el, image) { + el.empty(); + const pre = document.createElement("pre"); + const code = document.createElement("code"); + pre.appendChild(code); + code.setText(image); + el.appendChild(pre); +} +function insertSvgImage(el, image) { + el.empty(); + const parser = new DOMParser(); + const svg = parser.parseFromString(image, "image/svg+xml"); + const links = svg.getElementsByTagName("a"); + for (let i = 0; i < links.length; i++) { + const link = links[i]; + link.addClass("internal-link"); + } + el.insertAdjacentHTML("beforeend", svg.documentElement.outerHTML); +} + +// src/const.ts +var LOGO_SVG = ''; +var OutputType = /* @__PURE__ */ ((OutputType2) => { + OutputType2["PNG"] = "png"; + OutputType2["SVG"] = "svg"; + OutputType2["ASCII"] = "txt"; + return OutputType2; +})(OutputType || {}); + +// src/processors/localProcessors.ts +var localforage = __toModule(require_localforage()); +var LocalProcessors = class { + constructor(plugin) { + this.ascii = (source, el, ctx) => __async(this, null, function* () { + const encodedDiagram = plantuml.encode(source); + const item = yield localforage.getItem("ascii-" + encodedDiagram); + if (item) { + insertAsciiImage(el, item); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + return; + } + const image = yield this.generateLocalImage(source, OutputType.ASCII, this.plugin.replacer.getPath(ctx)); + insertAsciiImage(el, image); + yield localforage.setItem("ascii-" + encodedDiagram, image); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + }); + this.png = (source, el, ctx) => __async(this, null, function* () { + const encodedDiagram = plantuml.encode(source); + const item = yield localforage.getItem("png-" + encodedDiagram); + if (item) { + const map2 = yield localforage.getItem("map-" + encodedDiagram); + insertImageWithMap(el, item, map2, encodedDiagram); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + return; + } + const path = this.plugin.replacer.getPath(ctx); + const image = yield this.generateLocalImage(source, OutputType.PNG, path); + const map = yield this.generateLocalMap(source, path); + yield localforage.setItem("png-" + encodedDiagram, image); + yield localforage.setItem("map-" + encodedDiagram, map); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + insertImageWithMap(el, image, map, encodedDiagram); + }); + this.svg = (source, el, ctx) => __async(this, null, function* () { + const encodedDiagram = plantuml.encode(source); + const item = yield localforage.getItem("svg-" + encodedDiagram); + if (item) { + insertSvgImage(el, item); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + return; + } + const image = yield this.generateLocalImage(source, OutputType.SVG, this.plugin.replacer.getPath(ctx)); + yield localforage.setItem("svg-" + encodedDiagram, image); + yield localforage.setItem("ts-" + encodedDiagram, Date.now()); + insertSvgImage(el, image); + }); + this.plugin = plugin; + } + generateLocalMap(source, path) { + return __async(this, null, function* () { + const { exec } = require("child_process"); + const args = this.resolveLocalJarCmd().concat(["-pipemap"]); + const child = exec(args.join(" "), { encoding: "binary", cwd: path }); + let stdout = ""; + if (child.stdout) { + child.stdout.on("data", (data) => { + stdout += data; + }); + } + return new Promise((resolve, reject) => { + child.on("error", reject); + child.on("close", (code) => { + if (code === 0) { + resolve(stdout); + return; + } else if (code === 1) { + console.log(stdout); + reject(new Error(`an error occurred`)); + } else { + reject(new Error(`child exited with code ${code}`)); + } + }); + child.stdin.write(source); + child.stdin.end(); + }); + }); + } + generateLocalImage(source, type, path) { + return __async(this, null, function* () { + const { ChildProcess, exec } = require("child_process"); + const args = this.resolveLocalJarCmd().concat(["-t" + type, "-pipe"]); + let child; + if (type === OutputType.PNG) { + child = exec(args.join(" "), { encoding: "binary", cwd: path }); + } else { + child = exec(args.join(" "), { encoding: "utf-8", cwd: path }); + } + let stdout; + let stderr; + if (child.stdout) { + child.stdout.on("data", (data) => { + if (stdout === void 0) { + stdout = data; + } else + stdout += data; + }); + } + if (child.stderr) { + child.stderr.on("data", (data) => { + if (stderr === void 0) { + stderr = data; + } else + stderr += data; + }); + } + return new Promise((resolve, reject) => { + child.on("error", reject); + child.on("close", (code) => { + if (stdout === void 0) { + return; + } + if (code === 0) { + if (type === OutputType.PNG) { + const buf = new Buffer(stdout, "binary"); + resolve(buf.toString("base64")); + return; + } + resolve(stdout); + return; + } else if (code === 1) { + console.error(stdout); + reject(new Error(stderr)); + } else { + if (type === OutputType.PNG) { + const buf = new Buffer(stdout, "binary"); + resolve(buf.toString("base64")); + return; + } + resolve(stdout); + return; + } + }); + child.stdin.write(source, "utf-8"); + child.stdin.end(); + }); + }); + } + resolveLocalJarCmd() { + const jarFromSettings = this.plugin.settings.localJar; + const { isAbsolute, resolve } = require("path"); + const { userInfo } = require("os"); + let jarFullPath; + const path = this.plugin.replacer.getFullPath(""); + if (jarFromSettings[0] === "~") { + jarFullPath = userInfo().homedir + jarFromSettings.slice(1); + } else { + if (isAbsolute(jarFromSettings)) { + jarFullPath = jarFromSettings; + } else { + jarFullPath = resolve(path, jarFromSettings); + } + } + if (jarFullPath.length == 0) { + throw Error("Invalid local jar file"); + } + if (jarFullPath.endsWith(".jar")) { + return [ + this.plugin.settings.javaPath, + "-jar", + '"' + jarFullPath + '"', + "-Djava.awt.headless=true", + "-charset", + "utf-8", + "-graphvizdot", + '"' + this.plugin.settings.dotPath + '"' + ]; + } + return [ + jarFullPath, + "-Djava.awt.headless=true", + "-charset", + "utf-8", + "-graphvizdot", + '"' + this.plugin.settings.dotPath + '"' + ]; + } +}; + +// src/processors/debouncedProcessors.ts +var import_obsidian2 = __toModule(require("obsidian")); + +// node_modules/uuid/dist/esm-browser/rng.js +var getRandomValues; +var rnds8 = new Uint8Array(16); +function rng() { + if (!getRandomValues) { + getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== "undefined" && typeof msCrypto.getRandomValues === "function" && msCrypto.getRandomValues.bind(msCrypto); + if (!getRandomValues) { + throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported"); + } + } + return getRandomValues(rnds8); +} + +// node_modules/uuid/dist/esm-browser/regex.js +var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; + +// node_modules/uuid/dist/esm-browser/validate.js +function validate(uuid) { + return typeof uuid === "string" && regex_default.test(uuid); +} +var validate_default = validate; + +// node_modules/uuid/dist/esm-browser/stringify.js +var byteToHex = []; +for (i = 0; i < 256; ++i) { + byteToHex.push((i + 256).toString(16).substr(1)); +} +var i; +function stringify(arr) { + var offset = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0; + var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); + if (!validate_default(uuid)) { + throw TypeError("Stringified UUID is invalid"); + } + return uuid; +} +var stringify_default = stringify; + +// node_modules/uuid/dist/esm-browser/v4.js +function v4(options, buf, offset) { + options = options || {}; + var rnds = options.random || (options.rng || rng)(); + rnds[6] = rnds[6] & 15 | 64; + rnds[8] = rnds[8] & 63 | 128; + if (buf) { + offset = offset || 0; + for (var i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + return buf; + } + return stringify_default(rnds); +} +var v4_default = v4; + +// src/processors/debouncedProcessors.ts +var DebouncedProcessors = class { + constructor(plugin) { + this.SECONDS_TO_MS_FACTOR = 1e3; + this.debounceMap = /* @__PURE__ */ new Map(); + this.default = (source, el, ctx) => __async(this, null, function* () { + yield this.png(source, el, ctx); + }); + this.png = (source, el, ctx) => __async(this, null, function* () { + yield this.processor(source, el, ctx, "png", this.plugin.getProcessor().png); + }); + this.ascii = (source, el, ctx) => __async(this, null, function* () { + yield this.processor(source, el, ctx, "ascii", this.plugin.getProcessor().ascii); + }); + this.svg = (source, el, ctx) => __async(this, null, function* () { + yield this.processor(source, el, ctx, "svg", this.plugin.getProcessor().svg); + }); + this.processor = (source, el, ctx, filetype, processor) => __async(this, null, function* () { + const originalSource = source; + el.dataset.filetype = filetype; + el.createEl("h6", { text: "Generating PlantUML diagram", cls: "puml-loading" }); + if (el.dataset.plantumlDebounce) { + const debounceId = el.dataset.plantumlDebounce; + if (this.debounceMap.has(debounceId)) { + this.debounceMap.get(debounceId)(source, el, ctx); + } + } else { + const func = (0, import_obsidian2.debounce)(processor, this.debounceTime, true); + const uuid = v4_default(); + el.dataset.plantumlDebouce = uuid; + this.debounceMap.set(uuid, func); + source = this.plugin.replacer.replaceNonBreakingSpaces(source); + source = this.plugin.replacer.replaceLinks(source, this.plugin.replacer.getPath(ctx), filetype); + source = this.plugin.settings.header + "\r\n" + source; + yield processor(source, el, ctx); + el.addEventListener("contextmenu", (event) => { + const menu = new import_obsidian2.Menu().addItem((item) => { + item.setTitle("Copy diagram source").setIcon("clipboard-copy").onClick(() => __async(this, null, function* () { + yield navigator.clipboard.writeText(originalSource); + })); + }).addItem((item) => { + item.setTitle("Copy diagram").setIcon("image").onClick(() => __async(this, null, function* () { + console.log(el); + const img = el.querySelector("img"); + if (img) { + this.renderToBlob(img, "An error occurred while copying image to clipboard", (blob) => __async(this, null, function* () { + yield navigator.clipboard.write([ + new ClipboardItem({ + "image/png": blob + }) + ]); + new import_obsidian2.Notice("Diagram copied to clipboard"); + })); + } + const svg = el.querySelector("svg"); + if (svg) { + yield navigator.clipboard.writeText(svg.outerHTML); + new import_obsidian2.Notice("Diagram copied to clipboard"); + } + const code = el.querySelector("code"); + if (code) { + yield navigator.clipboard.writeText(code.innerText); + new import_obsidian2.Notice("Diagram copied to clipboard"); + } + })); + }).addItem((item) => { + item.setTitle("Export diagram").setIcon("image-file").onClick(() => __async(this, null, function* () { + const img = el.querySelector("img"); + if (img) { + this.renderToBlob(img, "An error occurred while exporting the diagram", (blob) => __async(this, null, function* () { + const filename = yield this.getFilePath(source, ctx, "png"); + const buffer = yield blob.arrayBuffer(); + const file = this.getFile(filename); + if (file) { + yield this.plugin.app.vault.modifyBinary(file, buffer); + } else { + yield this.plugin.app.vault.createBinary(filename, buffer); + } + new import_obsidian2.Notice(`Diagram exported to '${filename}'`); + })); + } + const svg = el.querySelector("svg"); + if (svg) { + yield this.saveTextFile(source, ctx, "svg", svg.outerHTML); + } + const code = el.querySelector("code"); + if (code) { + yield this.saveTextFile(source, ctx, "txt", code.innerText); + } + })); + }); + menu.showAtMouseEvent(event); + }); + } + }); + this.renderToBlob = (img, errorMessage, handleBlob) => { + const image = new Image(); + image.crossOrigin = "anonymous"; + image.src = img.src; + image.addEventListener("load", () => { + const canvas = document.createElement("canvas"); + canvas.width = image.width; + canvas.height = image.height; + const ctx = canvas.getContext("2d"); + ctx.fillStyle = "#fff"; + ctx.fillRect(0, 0, canvas.width, canvas.height); + ctx.drawImage(image, 0, 0); + try { + canvas.toBlob((blob) => __async(this, null, function* () { + try { + yield handleBlob(blob); + } catch (error) { + new import_obsidian2.Notice(errorMessage); + console.error(error); + } + })); + } catch (error) { + new import_obsidian2.Notice(errorMessage); + console.error(error); + } + }); + }; + this.getFilename = (source, ctx) => { + const startuml = source.match(/@startuml (.+)/i); + if ((startuml == null ? void 0 : startuml.length) >= 2) { + return `${startuml[1].trim()}`; + } + const now = new Date().toISOString().replace(/[:T]+/g, "-"); + const filename = this.plugin.app.vault.getAbstractFileByPath(ctx.sourcePath).name; + return `${filename.substring(0, filename.lastIndexOf("."))}-${now.substring(0, now.lastIndexOf("."))}`; + }; + this.getFolder = (ctx) => __async(this, null, function* () { + let exportPath = this.plugin.settings.exportPath; + if (!exportPath.startsWith("/")) { + const documentPath = this.plugin.app.vault.getAbstractFileByPath(ctx.sourcePath).parent; + exportPath = `${documentPath.path}/${exportPath}`; + } + const exists = yield this.plugin.app.vault.adapter.exists(exportPath); + if (!exists) { + this.plugin.app.vault.createFolder(exportPath); + } + return exportPath; + }); + this.getFilePath = (source, ctx, type) => __async(this, null, function* () { + const filename = this.getFilename(source, ctx); + const path = yield this.getFolder(ctx); + return `${path}${filename}.${type}`; + }); + this.getFile = (fileName) => { + let fName = fileName; + if (fName.startsWith("/")) { + fName = fName.substring(1); + } + const folderOrFile = this.plugin.app.vault.getAbstractFileByPath(fName); + if (folderOrFile instanceof import_obsidian2.TFile) { + return folderOrFile; + } + return void 0; + }; + this.saveTextFile = (source, ctx, type, data) => __async(this, null, function* () { + try { + const filename = yield this.getFilePath(source, ctx, type); + const file = this.getFile(filename); + if (file) { + yield this.plugin.app.vault.modify(file, data); + } else { + yield this.plugin.app.vault.create(filename, data); + } + new import_obsidian2.Notice(`Diagram exported to '${filename}'`); + } catch (error) { + new import_obsidian2.Notice("An error occurred while while exporting the diagram"); + console.error(error); + } + }); + this.plugin = plugin; + const debounceTime = plugin.settings.debounce; + this.debounceTime = debounceTime * this.SECONDS_TO_MS_FACTOR; + } +}; + +// src/processors/serverProcessor.ts +var import_obsidian3 = __toModule(require("obsidian")); +var plantuml2 = __toModule(require_browser_index()); +var ServerProcessor = class { + constructor(plugin) { + this.svg = (source, el, _) => __async(this, null, function* () { + let url = this.plugin.settings.server_url; + if (url.length == 0) { + url = DEFAULT_SETTINGS.server_url; + } + const imageUrlBase = url + "/svg/"; + const encodedDiagram = plantuml2.encode(source); + (0, import_obsidian3.request)({ url: imageUrlBase + encodedDiagram, method: "GET" }).then((value) => { + insertSvgImage(el, value); + }).catch((error) => { + if (error) + console.error(error); + }); + }); + this.png = (source, el, _) => __async(this, null, function* () { + let url = this.plugin.settings.server_url; + if (url.length == 0) { + url = DEFAULT_SETTINGS.server_url; + } + const imageUrlBase = url + "/png/"; + const encodedDiagram = plantuml2.encode(source); + const image = imageUrlBase + encodedDiagram; + const mapUrlBase = url + "/map/"; + const map = yield (0, import_obsidian3.request)({ url: mapUrlBase + encodedDiagram, method: "GET" }); + insertImageWithMap(el, image, map, encodedDiagram); + }); + this.ascii = (source, el, _) => __async(this, null, function* () { + let url = this.plugin.settings.server_url; + if (url.length == 0) { + url = DEFAULT_SETTINGS.server_url; + } + const asciiUrlBase = url + "/txt/"; + const encodedDiagram = plantuml2.encode(source); + const result = yield (0, import_obsidian3.request)({ url: asciiUrlBase + encodedDiagram }); + if (result.startsWith("\uFFFDPNG")) { + const text = document.createElement("p"); + text.style.color = "red"; + text.innerText = "Your configured PlantUML Server does not support ASCII Art"; + el.appendChild(text); + return; + } + insertAsciiImage(el, result); + }); + this.plugin = plugin; + } +}; + +// src/PumlView.ts +var import_obsidian4 = __toModule(require("obsidian")); +var import_view = __toModule(require("@codemirror/view")); +var import_state = __toModule(require("@codemirror/state")); +var import_search = __toModule(require("@codemirror/search")); +var import_commands = __toModule(require("@codemirror/commands")); +var VIEW_TYPE = "plantuml"; +var views = []; +var syncAnnotation = import_state.Annotation.define(); +function syncDispatch(from) { + return (tr) => { + views[from].update([tr]); + if (tr.changes && tr.annotation && !tr.changes.empty && !tr.annotation(syncAnnotation)) { + for (let i = 0; i < views.length; i++) { + if (i !== from) { + views[i].dispatch({ + changes: tr.changes, + annotations: syncAnnotation.of(true) + }); + } + } + } + }; +} +var PumlView = class extends import_obsidian4.TextFileView { + constructor(leaf, plugin) { + super(leaf); + this.dispatchId = -1; + this.extensions = [ + (0, import_view.highlightActiveLine)(), + (0, import_view.highlightActiveLineGutter)(), + (0, import_search.highlightSelectionMatches)(), + (0, import_view.drawSelection)(), + import_view.keymap.of([...import_commands.defaultKeymap, import_commands.indentWithTab]), + (0, import_commands.history)(), + (0, import_search.search)(), + import_view.EditorView.updateListener.of((v) => __async(this, null, function* () { + if (v.docChanged) { + this.requestSave(); + yield this.renderPreview(); + } + })) + ]; + this.plugin = plugin; + this.debounced = (0, import_obsidian4.debounce)(this.plugin.getProcessor().png, this.plugin.settings.debounce * 1e3, true); + this.sourceEl = this.contentEl.createDiv({ cls: "plantuml-source-view", attr: { "style": "display: block" } }); + this.previewEl = this.contentEl.createDiv({ cls: "plantuml-preview-view", attr: { "style": "display: none" } }); + const vault = this.app.vault; + if (vault.getConfig("showLineNumber")) { + this.extensions.push((0, import_view.lineNumbers)()); + } + if (vault.getConfig("lineWrap")) { + this.extensions.push(import_view.EditorView.lineWrapping); + } + this.editor = new import_view.EditorView({ + state: import_state.EditorState.create({ + extensions: this.extensions, + doc: this.data + }), + parent: this.sourceEl, + dispatch: syncDispatch(views.length) + }); + this.dispatchId = views.push(this.editor) - 1; + } + getViewType() { + return VIEW_TYPE; + } + getState() { + return super.getState(); + } + setState(state, result) { + if (state.mode === "preview") { + this.currentView = "preview"; + (0, import_obsidian4.setIcon)(this.changeModeButton, "pencil"); + this.changeModeButton.setAttribute("aria-label", "Edit (Ctrl+Click to edit in new pane)"); + this.previewEl.style.setProperty("display", "block"); + this.sourceEl.style.setProperty("display", "none"); + this.renderPreview(); + } else { + this.currentView = "source"; + (0, import_obsidian4.setIcon)(this.changeModeButton, "lines-of-text"); + this.changeModeButton.setAttribute("aria-label", "Preview (Ctrl+Click to open in new pane)"); + this.previewEl.style.setProperty("display", "none"); + this.sourceEl.style.setProperty("display", "block"); + } + return super.setState(state, result); + } + onload() { + return __async(this, null, function* () { + this.changeModeButton = this.addAction("lines-of-text", "Preview (Ctrl+Click to open in new pane)", (evt) => this.switchMode(evt), 17); + const defaultViewMode = this.app.vault.getConfig("defaultViewMode"); + this.currentView = defaultViewMode; + yield this.setState(__spreadProps(__spreadValues({}, this.getState()), { mode: defaultViewMode }), {}); + }); + } + onunload() { + views.remove(views[this.dispatchId]); + this.editor.destroy(); + } + switchMode(arg) { + return __async(this, null, function* () { + let mode = arg; + if (!mode || mode instanceof MouseEvent) + mode = this.currentView === "source" ? "preview" : "source"; + if (arg instanceof MouseEvent) { + if (import_obsidian4.Keymap.isModEvent(arg)) { + this.app.workspace.duplicateLeaf(this.leaf).then(() => __async(this, null, function* () { + var _a, _b; + const viewState = (_a = this.app.workspace.activeLeaf) == null ? void 0 : _a.getViewState(); + if (viewState) { + viewState.state = __spreadProps(__spreadValues({}, viewState.state), { mode }); + yield (_b = this.app.workspace.activeLeaf) == null ? void 0 : _b.setViewState(viewState); + } + })); + } else { + yield this.setState(__spreadProps(__spreadValues({}, this.getState()), { mode }), {}); + } + } + }); + } + getViewData() { + return this.editor.state.sliceDoc(); + } + setViewData(data, clear) { + return __async(this, null, function* () { + this.data = data; + if (clear) { + this.editor.setState(import_state.EditorState.create({ + doc: data, + extensions: this.extensions + })); + } else { + this.editor.dispatch({ + changes: { + from: 0, + to: this.editor.state.doc.length, + insert: data + } + }); + } + if (this.currentView === "preview") + this.renderPreview(); + }); + } + clear() { + this.previewEl.empty(); + this.data = null; + } + getDisplayText() { + if (this.file) + return this.file.basename; + else + return "PlantUML (no file)"; + } + canAcceptExtension(extension) { + return extension == "puml"; + } + getIcon() { + return "document-plantuml"; + } + renderPreview() { + return __async(this, null, function* () { + if (this.currentView !== "preview") + return; + this.previewEl.empty(); + const loadingHeader = this.previewEl.createEl("h1", { text: "Loading" }); + const previewDiv = this.previewEl.createDiv(); + this.debounced(this.getViewData(), previewDiv, null); + loadingHeader.remove(); + }); + } +}; + +// src/main.ts +var import_localforage = __toModule(require_localforage()); + +// src/embed.ts +var import_obsidian5 = __toModule(require("obsidian")); +var PumlEmbed = class extends import_obsidian5.Component { + constructor(plugin, file, ctx) { + super(); + this.plugin = plugin; + this.file = file; + this.ctx = ctx; + } + loadFile() { + return __async(this, null, function* () { + const data = yield this.plugin.app.vault.cachedRead(this.file); + yield this.plugin.getProcessor().png(data, this.ctx.containerEl, null); + }); + } +}; + +// src/main.ts +var PlantumlPlugin = class extends import_obsidian6.Plugin { + constructor() { + super(...arguments); + this.hover = { + linkText: null, + sourcePath: null + }; + } + getProcessor() { + if (import_obsidian6.Platform.isMobileApp) { + return this.serverProcessor; + } + if (this.settings.localJar.length > 0) { + return this.localProcessor; + } + return this.serverProcessor; + } + onload() { + return __async(this, null, function* () { + console.log("loading plugin plantuml"); + yield this.loadSettings(); + this.addSettingTab(new PlantUMLSettingsTab(this)); + this.replacer = new Replacer(this); + this.serverProcessor = new ServerProcessor(this); + if (import_obsidian6.Platform.isDesktopApp) { + this.localProcessor = new LocalProcessors(this); + } + const processor = new DebouncedProcessors(this); + (0, import_obsidian6.addIcon)("document-" + VIEW_TYPE, LOGO_SVG); + this.registerView(VIEW_TYPE, (leaf) => { + return new PumlView(leaf, this); + }); + this.registerExtensions(["puml", "pu"], VIEW_TYPE); + this.registerMarkdownCodeBlockProcessor("plantuml", processor.default); + this.registerMarkdownCodeBlockProcessor("plantuml-png", processor.png); + this.registerMarkdownCodeBlockProcessor("plantuml-ascii", processor.ascii); + this.registerMarkdownCodeBlockProcessor("plantuml-svg", processor.svg); + this.registerMarkdownCodeBlockProcessor("puml", processor.default); + this.registerMarkdownCodeBlockProcessor("puml-png", processor.png); + this.registerMarkdownCodeBlockProcessor("puml-svg", processor.svg); + this.registerMarkdownCodeBlockProcessor("puml-ascii", processor.ascii); + this.registerMarkdownCodeBlockProcessor("plantuml-map", processor.png); + this.app.embedRegistry.registerExtensions(["puml", "pu"], (ctx, file, subpath) => new PumlEmbed(this, file, ctx)); + this.cleanupLocalStorage(); + import_localforage.default.config({ + name: "puml", + description: "PlantUML plugin" + }); + yield this.cleanupCache(); + this.observer = new MutationObserver((mutation) => __async(this, null, function* () { + if (mutation.length !== 1) + return; + if (mutation[0].addedNodes.length !== 1) + return; + if (this.hover.linkText === null) + return; + if (mutation[0].addedNodes[0].className !== "popover hover-popover file-embed is-loaded") + return; + const file = this.app.metadataCache.getFirstLinkpathDest(this.hover.linkText, this.hover.sourcePath); + if (!file) + return; + if (file.extension !== "puml" && file.extension !== "pu") + return; + const fileContent = yield this.app.vault.read(file); + const imgDiv = createDiv(); + if (this.settings.defaultProcessor === "png") { + yield this.getProcessor().png(fileContent, imgDiv, null); + } else { + yield this.getProcessor().svg(fileContent, imgDiv, null); + } + const node = mutation[0].addedNodes[0]; + node.empty(); + const div = createDiv("", (element) => __async(this, null, function* () { + element.appendChild(imgDiv); + element.setAttribute("src", file.path); + element.onClickEvent((event) => { + event.stopImmediatePropagation(); + const leaf = this.app.workspace.getLeaf(event.ctrlKey); + leaf.setViewState({ + type: VIEW_TYPE, + state: { file: file.path } + }); + }); + })); + node.appendChild(div); + })); + this.registerEvent(this.app.workspace.on("hover-link", (event) => __async(this, null, function* () { + const linkText = event.linktext; + if (!linkText) + return; + const sourcePath = event.sourcePath; + if (!linkText.endsWith(".puml") && !linkText.endsWith(".pu")) { + return; + } + this.hover.linkText = linkText; + this.hover.sourcePath = sourcePath; + }))); + this.observer.observe(document, { childList: true, subtree: true }); + }); + } + cleanupCache() { + return __async(this, null, function* () { + yield import_localforage.default.iterate((value, key) => { + if (key.startsWith("ts-")) { + const encoded = key.split("-")[1]; + if (value < new Date().getTime() - this.settings.cache * 24 * 60 * 60 * 1e3) { + import_localforage.default.removeItem("png-" + encoded); + import_localforage.default.removeItem("svg-" + encoded); + import_localforage.default.removeItem("map-" + encoded); + import_localforage.default.removeItem("ascii-" + encoded); + } + } + }); + }); + } + cleanupLocalStorage() { + for (const key of Object.keys(localStorage)) { + if (key.endsWith("-map") || key.endsWith("-png") || key.endsWith("-svg") || key.endsWith("ascii")) { + localStorage.removeItem(key); + } + } + } + onunload() { + return __async(this, null, function* () { + console.log("unloading plugin plantuml"); + this.observer.disconnect(); + this.app.embedRegistry.unregisterExtensions(["puml", "pu"]); + }); + } + loadSettings() { + return __async(this, null, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + }); + } + saveSettings() { + return __async(this, null, function* () { + yield this.saveData(this.settings); + }); + } + onExternalSettingsChange() { + return __async(this, null, function* () { + yield this.loadSettings(); + }); + } +}; +/*! + localForage -- Offline Storage, Improved + Version 1.10.0 + https://localforage.github.io/localForage + (c) 2013-2017 Mozilla, Apache License 2.0 +*/ + + +/* nosourcemap */ \ No newline at end of file diff --git a/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/manifest.json b/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/manifest.json new file mode 100644 index 0000000..32e010e --- /dev/null +++ b/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-plantuml", + "name": "PlantUML", + "version": "1.8.0", + "minAppVersion": "1.5.7", + "description": "Render PlantUML Diagrams", + "author": "Johannes Theiner", + "authorUrl": "https://github.com/joethei/", + "isDesktopOnly": false +} diff --git a/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/styles.css b/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/styles.css new file mode 100644 index 0000000..78e8487 --- /dev/null +++ b/docs/Action Rog/.obsidian/plugins/obsidian-plantuml/styles.css @@ -0,0 +1,38 @@ +.puml-settings-area { + margin-left: 5px; + margin-right: 5px; + font-size: 14px; + width: 100%; +} + +.plantuml-source-view .cm-activeLine { + background-color: unset !important; +} + +.plantuml-source-view .cm-gutters { + background-color: unset !important; +} + +.plantuml-source-view .cm-cursor { + border-left: 1.2px solid var(--text-muted); +} + +.plantuml-source-view .cm-selectionBackground { + background-color: var(--text-selection) !important; +} + +.puml-loading { + color: var(--text-accent); +} + +.internal-embed.file-embed[src$=".puml"] { + display: none; +} + +.internal-embed.file-embed[src$=".pu"] { + display: none; +} + +.puml-error { + color: var(--text-error); +} diff --git a/docs/Action Rog/.obsidian/types.json b/docs/Action Rog/.obsidian/types.json new file mode 100644 index 0000000..75d9195 --- /dev/null +++ b/docs/Action Rog/.obsidian/types.json @@ -0,0 +1,8 @@ +{ + "types": { + "aliases": "aliases", + "cssclasses": "multitext", + "tags": "tags", + "linked_node": "multitext" + } +} \ No newline at end of file diff --git a/docs/Action Rog/.obsidian/workspace.json b/docs/Action Rog/.obsidian/workspace.json index efa7057..8c2b6c6 100644 --- a/docs/Action Rog/.obsidian/workspace.json +++ b/docs/Action Rog/.obsidian/workspace.json @@ -8,27 +8,70 @@ "type": "tabs", "children": [ { - "id": "fae3dd60da6746c9", + "id": "9747d8f3d23d735d", "type": "leaf", "state": { "type": "markdown", "state": { - "file": "Спелы/Начинания/Начинания.md", + "file": "Спелы/Начинания/Первичные/Свет.md", "mode": "source", "source": false }, "icon": "lucide-file", - "title": "Начинания" + "title": "Свет" + } + }, + { + "id": "16b27a146bf966cf", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "Спелы/Дерево прокачки/Свет/Быстрый свет.md", + "mode": "source", + "source": false + }, + "icon": "lucide-file", + "title": "Быстрый свет" + } + }, + { + "id": "e954d8b221d4ff0f", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "Спелы/Дерево прокачки/Свет/Быстрый свет.md", + "mode": "source", + "source": false + }, + "icon": "lucide-file", + "title": "Быстрый свет" + } + }, + { + "id": "28c85d9f345100ed", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "Спелы/Дерево прокачки/Свет/Базовый Свет.md", + "mode": "source", + "source": false + }, + "icon": "lucide-file", + "title": "Базовый Свет" } } - ] + ], + "currentTab": 3 }, { - "id": "6748dc81c9835180", + "id": "bddcd9d224afca83", "type": "tabs", "children": [ { - "id": "4f0d6c50d2adef92", + "id": "fae3dd60da6746c9", "type": "leaf", "state": { "type": "graph", @@ -110,7 +153,6 @@ "state": { "type": "backlink", "state": { - "file": "Спелы/Начинания/Начинания.md", "collapseAll": false, "extraContext": false, "sortOrder": "alphabetical", @@ -120,7 +162,7 @@ "unlinkedCollapsed": true }, "icon": "links-coming-in", - "title": "Обратные ссылки для Начинания" + "title": "Обратные ссылки" } }, { @@ -129,12 +171,11 @@ "state": { "type": "outgoing-link", "state": { - "file": "Спелы/Начинания/Начинания.md", "linksCollapsed": false, "unlinkedCollapsed": true }, "icon": "links-going-out", - "title": "Исходящие ссылки из Начинания" + "title": "Исходящие ссылки" } }, { @@ -172,13 +213,12 @@ "state": { "type": "outline", "state": { - "file": "Спелы/Начинания/Начинания.md", "followCursor": false, "showSearch": false, "searchQuery": "" }, "icon": "lucide-list", - "title": "Структура Начинания" + "title": "Структура" } } ] @@ -202,11 +242,20 @@ }, "active": "fae3dd60da6746c9", "lastOpenFiles": [ - "Спелы/Начинания/Вторичные/Вода.md", + "Спелы/Дерево прокачки/Свет/Базовый Свет.md", + "Статус эфекты/Ослепление.md", + "Спелы/Дерево прокачки/Свет/Слепящая вспышка.md", + "Спелы/Дерево прокачки/Свет/Радиус чистоты.md", + "Спелы/Дерево прокачки/Свет/Быстрый свет.md", + "Спелы/Начинания/Первичные/Свет.md", + "Спелы/Дерево прокачки/Свет/Яркое сияние.md", + "Спелы/Дерево прокачки/Свет", + "Спелы/Дерево прокачки", + "Статус эфекты", "Спелы/Начинания/Начинания.md", + "Спелы/Начинания/Вторичные/Вода.md", "Спелы/Начинания/Первичные/Жизнь.md", "Спелы/Начинания/Первичные/Вода.md", - "Спелы/Начинания/Первичные/Свет.md", "Спелы/Лужа.md", "Pasted image 20260118235438.png", "Спелы/Начинания/Вторичные/Бладмаг.md", @@ -225,7 +274,6 @@ "Спелы/Начинания/Первичные/Воздух.md", "Спелы/Начинания/Первичные/Земля.md", "Спелы/Начинания", - "Добро пожаловать.md", "Спелы" ] } \ No newline at end of file diff --git a/docs/Action Rog/Спелы/Дерево прокачки/Свет/Базовый Свет.md b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Базовый Свет.md new file mode 100644 index 0000000..2cba2a3 --- /dev/null +++ b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Базовый Свет.md @@ -0,0 +1,11 @@ +--- +Тип ноды: Начинание +tags: +Начинание: "[[Свет]]" +node_id: LIGHT_001 +linked_node: + - "[[Яркое сияние]]" + - "[[Яркое сияние]]" + - "[[Быстрый свет]]" +--- +Дает возможность использовать начинание [[Свет]] \ No newline at end of file diff --git a/docs/Action Rog/Спелы/Дерево прокачки/Свет/Быстрый свет.md b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Быстрый свет.md new file mode 100644 index 0000000..3e10b16 --- /dev/null +++ b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Быстрый свет.md @@ -0,0 +1,8 @@ +--- +Тип ноды: Passive +Начинание: "[[Свет]]" +node_id: LIGHT_016 +linked_node: + - "[[Слепящая вспышка]]" +--- ++40% скорости атаки, -20% урона \ No newline at end of file diff --git a/docs/Action Rog/Спелы/Дерево прокачки/Свет/Радиус чистоты.md b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Радиус чистоты.md new file mode 100644 index 0000000..0825656 --- /dev/null +++ b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Радиус чистоты.md @@ -0,0 +1,8 @@ +--- +Тип ноды: Passive +Начинание: "[[Свет]]" +node_id: LIGHT_003 +linked_node: + - "[[Слепящая вспышка]]" +--- ++50% урона от умений начинания [[Свет]] , -30% урона от умений начинания [[Тьма]] \ No newline at end of file diff --git a/docs/Action Rog/Спелы/Дерево прокачки/Свет/Слепящая вспышка.md b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Слепящая вспышка.md new file mode 100644 index 0000000..abc359a --- /dev/null +++ b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Слепящая вспышка.md @@ -0,0 +1,9 @@ +--- +Тип ноды: Passive +Начинание: "[[Свет]]" +node_id: LIGHT_006 +linked_node: +--- ++100% длительность [[Ослепление]], -30% урон +Если взят [[Радиус чистоты]]: +50% радиус [[Ослепление]] +Если взят [[Быстрый свет]]: враги под эффектом [[Ослепление]] получают +30% урона \ No newline at end of file diff --git a/docs/Action Rog/Спелы/Дерево прокачки/Свет/Яркое сияние.md b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Яркое сияние.md new file mode 100644 index 0000000..c24e2ad --- /dev/null +++ b/docs/Action Rog/Спелы/Дерево прокачки/Свет/Яркое сияние.md @@ -0,0 +1,7 @@ +--- +Тип ноды: Passive +Начинание: "[[Свет]]" +node_id: LIGHT_002 +linked_node: +--- ++50% радиус спелов, -25% урона \ No newline at end of file diff --git a/docs/Action Rog/Спелы/Начинания/Первичные/Свет.md b/docs/Action Rog/Спелы/Начинания/Первичные/Свет.md index de1e80d..af35d0e 100644 --- a/docs/Action Rog/Спелы/Начинания/Первичные/Свет.md +++ b/docs/Action Rog/Спелы/Начинания/Первичные/Свет.md @@ -1,10 +1,172 @@ ### **Философия элемента:** -Свет — это не только «святая магия». Это **ясность, скорость, чистота, иллюзия, откровение и неумолимая энергия**. Он может исцелять, но может и испепелять без тени сомнения. +Свет — это не только «святая магия». Это **ясность, скорость, чистота, иллюзия, откровение и неумолимая энергия**. Он может исцелять, но может и испепелять без тени сомнения. ### **Основные свойства (базовые эффекты)** -- **Ослепление:** Враги временно теряют точность, замедляются или бьют наугад. -- **Очищение:** Снятие негативных эффектов (яды, проклятия, ослабления) с себя и союзников. -- **Отражение:** Кратковременные щиты, отражающие часть урона или проекций обратно во врага. -- **Скорость:** Краткий, но значительный буст к скорости атаки, передвижения или восстановления способностей. \ No newline at end of file +- **Ослепление:** Враги временно теряют точность, замедляются или бьют наугад. +- **Очищение:** Снятие негативных эффектов (яды, проклятия, ослабления) с себя и союзников. +- **Отражение:** Кратковременные щиты, отражающие часть урона или проекций обратно во врага. +- **Скорость:** Краткий, но значительный буст к скорости атаки, передвижения или восстановления способностей. + +--- + +## Дерево прокачки + +### Граф дерева прокачки + +```plantuml +@startuml +skinparam defaultFontSize 9 +skinparam node { + BackgroundColor #FFD700 + BorderColor #000000 +} + +' Стартовая нода +node LIGHT_001 as "LIGHT_001\nБазовый Свет" + +' Первый уровень +node LIGHT_002 as "LIGHT_002\nЯркое сияние" +node LIGHT_003 as "LIGHT_003\nРадиус чистоты" +node LIGHT_016 as "LIGHT_016\nБыстрый свет" +node LIGHT_026 as "LIGHT_026\nСвященное сияние" + +' Второй уровень +node LIGHT_004 as "LIGHT_004\nОчищающий свет" +node LIGHT_005 as "LIGHT_005\nОтражающий щит" +node LIGHT_017 as "LIGHT_017\nСветовая скорость" +node LIGHT_027 as "LIGHT_027\nСвятая чистота" + +' Третий уровень - ноды с множественными входами +node LIGHT_006 as "LIGHT_006\nСлепящая вспышка" +node LIGHT_007 as "LIGHT_007\nСветовая аура" +node LIGHT_008 as "LIGHT_008\nЗеркальный барьер" +node LIGHT_018 as "LIGHT_018\nМолниеносный удар" +node LIGHT_028 as "LIGHT_028\nСвященное горение" + +' Четвертый уровень +node LIGHT_009 as "LIGHT_009\nРасширенный горизонт" +node LIGHT_010 as "LIGHT_010\nСлепящая чистота" +node LIGHT_011 as "LIGHT_011\nСвященное отражение" +node LIGHT_019 as "LIGHT_019\nВетер света" +node LIGHT_020 as "LIGHT_020\nЭнергетический импульс" +node LIGHT_029 as "LIGHT_029\nЗащитный свет" +node LIGHT_030 as "LIGHT_030\nОчищающее сияние" + +' Пятый уровень +node LIGHT_012 as "LIGHT_012\nМолниеносное ослепление" +node LIGHT_013 as "LIGHT_013\nСвятая ясность" +node LIGHT_021 as "LIGHT_021\nСветовой вихрь" +node LIGHT_022 as "LIGHT_022\nУскорение времени" +node LIGHT_031 as "LIGHT_031\nСвященный барьер" +node LIGHT_032 as "LIGHT_032\nСвятая аура" + +' Шестой уровень +node LIGHT_014 as "LIGHT_014\nАбсолютная скорость" +node LIGHT_015 as "LIGHT_015\nБожественная чистота" +node LIGHT_023 as "LIGHT_023\nЭлектрический разряд" +node LIGHT_024 as "LIGHT_024\nСкорость мысли" +node LIGHT_033 as "LIGHT_033\nБожественная защита" +node LIGHT_034 as "LIGHT_034\nКрестоносец света" + +' Финальные ноды +node LIGHT_025 as "LIGHT_025\nМолниеносный свет" +node LIGHT_035 as "LIGHT_035\nСвет паладина" + +' Связи от стартовой ноды +LIGHT_001 --> LIGHT_002 +LIGHT_001 --> LIGHT_003 +LIGHT_001 --> LIGHT_016 +LIGHT_001 --> LIGHT_026 + +' Связи первого уровня +LIGHT_002 --> LIGHT_004 +LIGHT_002 --> LIGHT_005 +LIGHT_016 --> LIGHT_017 +LIGHT_026 --> LIGHT_027 + +' Связи второго уровня - множественные входы +LIGHT_003 --> LIGHT_006 +LIGHT_016 --> LIGHT_006 +LIGHT_004 --> LIGHT_007 +LIGHT_005 --> LIGHT_008 +LIGHT_017 --> LIGHT_018 +LIGHT_027 --> LIGHT_028 + +' Связи третьего уровня +LIGHT_006 --> LIGHT_009 +LIGHT_007 --> LIGHT_010 +LIGHT_008 --> LIGHT_011 +LIGHT_018 --> LIGHT_019 +LIGHT_018 --> LIGHT_020 +LIGHT_028 --> LIGHT_029 +LIGHT_028 --> LIGHT_030 + +' Связи четвертого уровня - множественные входы +LIGHT_009 --> LIGHT_012 +LIGHT_010 --> LIGHT_012 +LIGHT_010 --> LIGHT_013 +LIGHT_011 --> LIGHT_013 +LIGHT_011 --> LIGHT_015 +LIGHT_019 --> LIGHT_021 +LIGHT_020 --> LIGHT_022 +LIGHT_029 --> LIGHT_031 +LIGHT_030 --> LIGHT_032 + +' Связи пятого уровня +LIGHT_012 --> LIGHT_014 +LIGHT_013 --> LIGHT_015 +LIGHT_021 --> LIGHT_023 +LIGHT_022 --> LIGHT_024 +LIGHT_031 --> LIGHT_033 +LIGHT_032 --> LIGHT_034 + +' Связи шестого уровня - множественные входы +LIGHT_014 --> LIGHT_025 +LIGHT_024 --> LIGHT_025 +LIGHT_015 --> LIGHT_035 +LIGHT_034 --> LIGHT_035 + +@enduml +``` + +### Таблица нод + +| ID | Название | Описание эффекта | Условные эффекты | +| ------------- | ----------------------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| **LIGHT_001** | Базовый Свет | Дает доступ к начинанию Свет | — | +| **LIGHT_002** | Яркое сияние | +50% урона от света, -30% урона от тьмы | — | +| **LIGHT_003** | Радиус чистоты | +50% радиус спелов, -25% урона | — | +| **LIGHT_004** | Очищающий свет | Очищенные эффекты наносят урон врагам в радиусе 5м | — | +| **LIGHT_005** | Отражающий щит | Отраженный урон увеличивается на 50% | — | +| **LIGHT_006** | Слепящая вспышка | +100% длительность ослепления, -30% урон | Если взят **Радиус чистоты (LIGHT_003)**: +50% радиус ослепления
Если взят **Быстрый свет (LIGHT_016)**: ослепленные враги получают +30% урона | +| **LIGHT_007** | Световая аура | Постоянное очищение негативных эффектов в радиусе 3м вокруг персонажа | — | +| **LIGHT_008** | Зеркальный барьер | При отражении урона создается временный щит на 2 секунды | — | +| **LIGHT_009** | Расширенный горизонт | +100% радиус спелов, -50% урон | — | +| **LIGHT_010** | Слепящая чистота | Ослепление + Очищение: ослепленные враги теряют все баффы | — | +| **LIGHT_011** | Священное отражение | Отражение + Святость: отраженный урон наносит дополнительный урон от святости | — | +| **LIGHT_012** | Молниеносное ослепление | Ослепление + Скорость: ослепление распространяется быстрее | Если взят **Расширенный горизонт (LIGHT_009)**: +50% радиус распространения ослепления
Если взят **Слепящая чистота (LIGHT_010)**: ослепленные враги теряют баффы | +| **LIGHT_013** | Святая ясность | Ослепление + Святость: ослепление наносит урон от святости | Если взят **Слепящая чистота (LIGHT_010)**: ослепленные враги теряют баффы
Если взят **Священное отражение (LIGHT_011)**: отраженный урон также наносит урон от святости | +| **LIGHT_014** | Абсолютная скорость | Скорость + Ослепление: ускорение увеличивает длительность ослепления | Если взят **Молниеносное ослепление (LIGHT_012)**: ослепление распространяется быстрее
Если взят **Скорость мысли (LIGHT_024)**: скорость применения спелов увеличивается на 20% | +| **LIGHT_015** | Божественная чистота | Очищение + Святость: очищение наносит урон от святости всем врагам в радиусе | Если взят **Святая ясность (LIGHT_013)**: ослепление также наносит урон
Если взят **Крестоносец света (LIGHT_034)**: все эффекты света усиливаются | +| **LIGHT_016** | Быстрый свет | +40% скорости атаки, -20% урона | — | +| **LIGHT_017** | Световая скорость | +50% скорость передвижения, -30% урон | — | +| **LIGHT_018** | Молниеносный удар | Каждая атака имеет 20% шанс нанести дополнительный урон от молнии | — | +| **LIGHT_019** | Ветер света | При движении оставляются световые следы, наносящие урон | — | +| **LIGHT_020** | Энергетический импульс | При использовании спела скорость восстановления способностей увеличивается на 30% на 3 секунды | — | +| **LIGHT_021** | Световой вихрь | При быстром движении создается вихрь света, наносящий урон врагам | Если взят **Ветер света (LIGHT_019)**: следы также усиливаются
Если взят **Молниеносный удар (LIGHT_018)**: каждая атака вихря имеет шанс нанести дополнительный урон | +| **LIGHT_022** | Ускорение времени | При ускорении враги в радиусе замедляются на 30% | Если взят **Энергетический импульс (LIGHT_020)**: скорость восстановления увеличивается на 20%
Если взят **Световая скорость (LIGHT_017)**: скорость передвижения увеличивается на 15% | +| **LIGHT_023** | Электрический разряд | Критические удары создают электрические разряды, наносящие урон в радиусе | Если взят **Световой вихрь (LIGHT_021)**: вихрь также создает разряды
Если взят **Молниеносный удар (LIGHT_018)**: шанс критического удара увеличивается на 10% | +| **LIGHT_024** | Скорость мысли | +100% скорость применения спелов, -50% урон | — | +| **LIGHT_025** | Молниеносный свет | Открывает доступ к вторичному начинанию Молния | Если взят **Абсолютная скорость (LIGHT_014)**: ослепление также усиливается
Если взят **Скорость мысли (LIGHT_024)**: скорость применения спелов увеличивается на 30% | +| **LIGHT_026** | Священное сияние | Урон светом вызывает священное горение | — | +| **LIGHT_027** | Святая чистота | Очищение + Святость: очищение наносит урон от святости | — | +| **LIGHT_028** | Священное горение | +50% урона от святости, -30% урона от тьмы | — | +| **LIGHT_029** | Защитный свет | При получении урона создается щит, наносящий урон от святости атакующим | Если взят **Священное горение (LIGHT_028)**: длительность щита увеличивается на 1 секунду
Если взят **Священное сияние (LIGHT_026)**: урон от священного горения увеличивается на 10% | +| **LIGHT_030** | Очищающее сияние | Очищение создает священное сияние, наносящее урон врагам | Если взят **Святая чистота (LIGHT_027)**: радиус сияния увеличивается на 1м
Если взят **Священное горение (LIGHT_028)**: урон сияния увеличивается на 5% | +| **LIGHT_031** | Священный барьер | Щиты наносят урон от святости всем врагам в радиусе | Если взят **Защитный свет (LIGHT_029)**: при получении урона также создается щит
Если взят **Отражающий щит (LIGHT_005)**: отраженный урон также усиливается | +| **LIGHT_032** | Святая аура | Постоянный урон от святости в радиусе вокруг персонажа | Если взят **Очищающее сияние (LIGHT_030)**: очищение также создает сияние
Если взят **Священное горение (LIGHT_028)**: радиус ауры увеличивается на 1м | +| **LIGHT_033** | Божественная защита | +50% защита, -30% скорость передвижения | — | +| **LIGHT_034** | Крестоносец света | Комбо Свет + Святость: все эффекты света наносят дополнительный урон от святости | Если взят **Священный барьер (LIGHT_031)**: щиты также усиливаются
Если взят **Святая аура (LIGHT_032)**: аура также усиливается | +| **LIGHT_035** | Свет паладина | Открывает доступ к вторичному начинанию Паладин | Если взят **Божественная чистота (LIGHT_015)**: все эффекты очищения усиливаются
Если взят **Крестоносец света (LIGHT_034)**: все эффекты света усиливаются | diff --git a/docs/Action Rog/Статус эфекты/Ослепление.md b/docs/Action Rog/Статус эфекты/Ослепление.md new file mode 100644 index 0000000..aeddabb --- /dev/null +++ b/docs/Action Rog/Статус эфекты/Ослепление.md @@ -0,0 +1 @@ +Находясь под эффектом ослепления персонаж промахивается атаками в 10% случаев. \ No newline at end of file