2b:null 2c:["$","title",null,{"children":"PlantUML | Sébastien Pierre | Observable"}] 31:Ta20,class Node { constructor(id, label = undefined, stereotype=undefined) { this.label = safetext(label || id); this.stereotype = stereotype || "rectangle"; this.id = safekey(id, ""); this.rel = []; this.children = undefined; this.value = undefined; } as(stereotype) { // We support the using UML factory functions for as: node.as(UML.Actor) if (typeof stereotype === "function" && stereotype.stereotype) { stereotype = stereotype.stereotype; } if (typeof stereotype == "string") { this.stereotype = stereotype || this.stereotype; } return this; } setValue(value) {this.value=value;return this} set(...children) { this.children = filter(children, _ => _ && _ instanceof Node); return this; } walk(functor, depth = 0, index = 0) { functor(this, depth, index); const n = this.children ? this.children.length : 0; if (n > 0) { for (let i = 0; i < n; i++) { this.children[i].walk(functor, depth + 1, i); } } return this; } to(term, direction = "up", label = null) { term = term instanceof Node ? term.id : term; this.rel.push( `${this.id} .${direction}.-> ${safekey(term, "")}` + (label ? ": " + safetext(label) : "") ); return this; } toUp(term, label) { return this.to(term, "up", label); } toTop(term, label) { return this.toUp(term, label); } fromTop(term, label) { return term.toTop(this, label); } toDown(term, label) { return this.to(term, "down", label); } toBottom(term, label) { return this.toDown(term, label); } fromBottom(term, label) { return term.toBottom(this, label); } toLeft(term, label) { return this.to(term, "left", label); } fromLeft(term, label) { return term.toLeft(this, label); } toRight(term, label) { return this.to(term, "right", label); } fromRight(term, label) { return term.toRight(this, label); } note(text, orientation = "up") { this.rel.push(` note ${orientation} of ${this.id} ${text} end note`); return this; } noteTop(note) { return this.noteUp(note); } noteBottom(note) { return this.noteDown(note); } noteUp(note) { return this.note(note, "top"); } noteDown(note) { return this.note(note, "bottom"); } noteLeft(note) { return this.note(note, "left"); } noteRight(note) { return this.note(note, "right"); } toDefinition() { return `${this.stereotype} ${this.id} as "${this.label}"`; } toRelations() { return this.rel.join("\n"); } }32:T410,ArchimateStereotypes = ({ "Business:Biz": [ "Actor", "Role", "Interface", "Collaboration", "Service", "Process", "Function", "Interaction", "Event", "Object", "Product", "Contract", "Representation" ], "Application:App": [ "Component", "Interface", "Collaboration", "Service", "Process", "Function", "Interaction", "Event", "Data Object" ], "Technology:Tech": [ "Node", "Device", "System Software", "Interface", "Collaboration", "Path", "Network", "Service", "Process", "Function", "Interaction", "Event", "Artifact" ], "Physical:Phys": ["Equipement", "Facility", "Distribution", "Material"], "Motivation:Motiv": [ "Stakeholder", "Driver", "Assessment", "Goal", "Outcome", "Requirement", "Constraint", "Principle", "Value", "Meaning" ], "Strategy:Strat": [ "Resource", "Capability", "Value Stream", "Course Of Action" ] })33:T4e1,base64 = (()=>{ const 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 '?'; } const append3bytes = (b1, b2, b3) => { let c1 = b1 >> 2; let c2 = ((b1 & 0x3) << 4) | (b2 >> 4); let c3 = ((b2 & 0xF) << 2) | (b3 >> 6); let c4 = b3 & 0x3F; let r = ""; r += encode6bit(c1 & 0x3F); r += encode6bit(c2 & 0x3F); r += encode6bit(c3 & 0x3F); r += encode6bit(c4 & 0x3F); return r; } return data => { let r = ""; for (let 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; } })()34:Tcfe2,deflate = { /* Copyright (C) 1999 Masanao Izumo * Version: 1.0.1 * LastModified: Dec 25 1999 */ /* Interface: * data = zip_deflate(src); */ /* constant parameters */ var zip_WSIZE = 32768; // Sliding Window size var zip_STORED_BLOCK = 0; var zip_STATIC_TREES = 1; var zip_DYN_TREES = 2; /* for deflate */ var zip_DEFAULT_LEVEL = 6; var zip_FULL_SEARCH = true; var zip_INBUFSIZ = 32768; // Input buffer size var zip_INBUF_EXTRA = 64; // Extra buffer var zip_OUTBUFSIZ = 1024 * 8; var zip_window_size = 2 * zip_WSIZE; var zip_MIN_MATCH = 3; var zip_MAX_MATCH = 258; var zip_BITS = 16; // for SMALL_MEM var zip_LIT_BUFSIZE = 0x2000; var zip_HASH_BITS = 13; // for MEDIUM_MEM // var zip_LIT_BUFSIZE = 0x4000; // var zip_HASH_BITS = 14; // for BIG_MEM // var zip_LIT_BUFSIZE = 0x8000; // var zip_HASH_BITS = 15; if(zip_LIT_BUFSIZE > zip_INBUFSIZ) alert("error: zip_INBUFSIZ is too small"); if((zip_WSIZE<<1) > (1< zip_BITS-1) alert("error: zip_HASH_BITS is too large"); if(zip_HASH_BITS < 8 || zip_MAX_MATCH != 258) alert("error: Code too clever"); var zip_DIST_BUFSIZE = zip_LIT_BUFSIZE; var zip_HASH_SIZE = 1 << zip_HASH_BITS; var zip_HASH_MASK = zip_HASH_SIZE - 1; var zip_WMASK = zip_WSIZE - 1; var zip_NIL = 0; // Tail of hash chains var zip_TOO_FAR = 4096; var zip_MIN_LOOKAHEAD = zip_MAX_MATCH + zip_MIN_MATCH + 1; var zip_MAX_DIST = zip_WSIZE - zip_MIN_LOOKAHEAD; var zip_SMALLEST = 1; var zip_MAX_BITS = 15; var zip_MAX_BL_BITS = 7; var zip_LENGTH_CODES = 29; var zip_LITERALS =256; var zip_END_BLOCK = 256; var zip_L_CODES = zip_LITERALS + 1 + zip_LENGTH_CODES; var zip_D_CODES = 30; var zip_BL_CODES = 19; var zip_REP_3_6 = 16; var zip_REPZ_3_10 = 17; var zip_REPZ_11_138 = 18; var zip_HEAP_SIZE = 2 * zip_L_CODES + 1; var zip_H_SHIFT = parseInt((zip_HASH_BITS + zip_MIN_MATCH - 1) / zip_MIN_MATCH); /* variables */ var zip_free_queue; var zip_qhead, zip_qtail; var zip_initflag; var zip_outbuf = null; var zip_outcnt, zip_outoff; var zip_complete; var zip_window; var zip_d_buf; var zip_l_buf; var zip_prev; var zip_bi_buf; var zip_bi_valid; var zip_block_start; var zip_ins_h; var zip_hash_head; var zip_prev_match; var zip_match_available; var zip_match_length; var zip_prev_length; var zip_strstart; var zip_match_start; var zip_eofile; var zip_lookahead; var zip_max_chain_length; var zip_max_lazy_match; var zip_compr_level; var zip_good_match; var zip_nice_match; var zip_dyn_ltree; var zip_dyn_dtree; var zip_static_ltree; var zip_static_dtree; var zip_bl_tree; var zip_l_desc; var zip_d_desc; var zip_bl_desc; var zip_bl_count; var zip_heap; var zip_heap_len; var zip_heap_max; var zip_depth; var zip_length_code; var zip_dist_code; var zip_base_length; var zip_base_dist; var zip_flag_buf; var zip_last_lit; var zip_last_dist; var zip_last_flags; var zip_flags; var zip_flag_bit; var zip_opt_len; var zip_static_len; var zip_deflate_data; var zip_deflate_pos; /* constant tables */ var zip_extra_lbits = new Array( 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 zip_extra_dbits = new Array( 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 zip_extra_blbits = new Array( 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7); var zip_bl_order = new Array( 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15); var zip_configuration_table = new Array( new zip_DeflateConfiguration(0, 0, 0, 0), new zip_DeflateConfiguration(4, 4, 8, 4), new zip_DeflateConfiguration(4, 5, 16, 8), new zip_DeflateConfiguration(4, 6, 32, 32), new zip_DeflateConfiguration(4, 4, 16, 16), new zip_DeflateConfiguration(8, 16, 32, 32), new zip_DeflateConfiguration(8, 16, 128, 128), new zip_DeflateConfiguration(8, 32, 128, 256), new zip_DeflateConfiguration(32, 128, 258, 1024), new zip_DeflateConfiguration(32, 258, 258, 4096)); /* objects (deflate) */ function zip_DeflateCT() { this.fc = 0; // frequency count or bit string this.dl = 0; // father node in Huffman tree or length of bit string } function zip_DeflateTreeDesc() { this.dyn_tree = null; // the dynamic tree this.static_tree = null; // corresponding static tree or NULL this.extra_bits = null; // extra bits for each code or NULL this.extra_base = 0; // base index for extra_bits this.elems = 0; // max number of elements in the tree this.max_length = 0; // max bit length for the codes this.max_code = 0; // largest code with non zero frequency } /* Values for max_lazy_match, good_match and max_chain_length, depending on * the desired pack level (0..9). The values given below have been tuned to * exclude worst case performance for pathological files. Better values may be * found for specific files. */ function zip_DeflateConfiguration(a, b, c, d) { this.good_length = a; // reduce lazy search above this match length this.max_lazy = b; // do not perform lazy search above this match length this.nice_length = c; // quit search above this match length this.max_chain = d; } function zip_DeflateBuffer() { this.next = null; this.len = 0; this.ptr = new Array(zip_OUTBUFSIZ); this.off = 0; } /* routines (deflate) */ function zip_deflate_start(level) { var i; if(!level) level = zip_DEFAULT_LEVEL; else if(level < 1) level = 1; else if(level > 9) level = 9; zip_compr_level = level; zip_initflag = false; zip_eofile = false; if(zip_outbuf != null) return; zip_free_queue = zip_qhead = zip_qtail = null; zip_outbuf = new Array(zip_OUTBUFSIZ); zip_window = new Array(zip_window_size); zip_d_buf = new Array(zip_DIST_BUFSIZE); zip_l_buf = new Array(zip_INBUFSIZ + zip_INBUF_EXTRA); zip_prev = new Array(1 << zip_BITS); zip_dyn_ltree = new Array(zip_HEAP_SIZE); for(i = 0; i < zip_HEAP_SIZE; i++) zip_dyn_ltree[i] = new zip_DeflateCT(); zip_dyn_dtree = new Array(2*zip_D_CODES+1); for(i = 0; i < 2*zip_D_CODES+1; i++) zip_dyn_dtree[i] = new zip_DeflateCT(); zip_static_ltree = new Array(zip_L_CODES+2); for(i = 0; i < zip_L_CODES+2; i++) zip_static_ltree[i] = new zip_DeflateCT(); zip_static_dtree = new Array(zip_D_CODES); for(i = 0; i < zip_D_CODES; i++) zip_static_dtree[i] = new zip_DeflateCT(); zip_bl_tree = new Array(2*zip_BL_CODES+1); for(i = 0; i < 2*zip_BL_CODES+1; i++) zip_bl_tree[i] = new zip_DeflateCT(); zip_l_desc = new zip_DeflateTreeDesc(); zip_d_desc = new zip_DeflateTreeDesc(); zip_bl_desc = new zip_DeflateTreeDesc(); zip_bl_count = new Array(zip_MAX_BITS+1); zip_heap = new Array(2*zip_L_CODES+1); zip_depth = new Array(2*zip_L_CODES+1); zip_length_code = new Array(zip_MAX_MATCH-zip_MIN_MATCH+1); zip_dist_code = new Array(512); zip_base_length = new Array(zip_LENGTH_CODES); zip_base_dist = new Array(zip_D_CODES); zip_flag_buf = new Array(parseInt(zip_LIT_BUFSIZE / 8)); } function zip_deflate_end() { zip_free_queue = zip_qhead = zip_qtail = null; zip_outbuf = null; zip_window = null; zip_d_buf = null; zip_l_buf = null; zip_prev = null; zip_dyn_ltree = null; zip_dyn_dtree = null; zip_static_ltree = null; zip_static_dtree = null; zip_bl_tree = null; zip_l_desc = null; zip_d_desc = null; zip_bl_desc = null; zip_bl_count = null; zip_heap = null; zip_depth = null; zip_length_code = null; zip_dist_code = null; zip_base_length = null; zip_base_dist = null; zip_flag_buf = null; } function zip_reuse_queue(p) { p.next = zip_free_queue; zip_free_queue = p; } function zip_new_queue() { var p; if(zip_free_queue != null) { p = zip_free_queue; zip_free_queue = zip_free_queue.next; } else p = new zip_DeflateBuffer(); p.next = null; p.len = p.off = 0; return p; } function zip_head1(i) { return zip_prev[zip_WSIZE + i]; } function zip_head2(i, val) { return zip_prev[zip_WSIZE + i] = val; } /* put_byte is used for the compressed output, put_ubyte for the * uncompressed output. However unlzw() uses window for its * suffix table instead of its output buffer, so it does not use put_ubyte * (to be cleaned up). */ function zip_put_byte(c) { zip_outbuf[zip_outoff + zip_outcnt++] = c; if(zip_outoff + zip_outcnt == zip_OUTBUFSIZ) zip_qoutbuf(); } /* Output a 16 bit value, lsb first */ function zip_put_short(w) { w &= 0xffff; if(zip_outoff + zip_outcnt < zip_OUTBUFSIZ - 2) { zip_outbuf[zip_outoff + zip_outcnt++] = (w & 0xff); zip_outbuf[zip_outoff + zip_outcnt++] = (w >>> 8); } else { zip_put_byte(w & 0xff); zip_put_byte(w >>> 8); } } /* ========================================================================== * Insert string s in the dictionary and set match_head to the previous head * of the hash chain (the most recent string with same hash key). Return * the previous length of the hash chain. * IN assertion: all calls to to INSERT_STRING are made with consecutive * input characters and the first MIN_MATCH bytes of s are valid * (except for the last MIN_MATCH-1 bytes of the input file). */ function zip_INSERT_STRING() { zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[zip_strstart + zip_MIN_MATCH - 1] & 0xff)) & zip_HASH_MASK; zip_hash_head = zip_head1(zip_ins_h); zip_prev[zip_strstart & zip_WMASK] = zip_hash_head; zip_head2(zip_ins_h, zip_strstart); } /* Send a code of the given tree. c and tree must not have side effects */ function zip_SEND_CODE(c, tree) { zip_send_bits(tree[c].fc, tree[c].dl); } /* Mapping from a distance to a distance code. dist is the distance - 1 and * must not have side effects. dist_code[256] and dist_code[257] are never * used. */ function zip_D_CODE(dist) { return (dist < 256 ? zip_dist_code[dist] : zip_dist_code[256 + (dist>>7)]) & 0xff; } /* ========================================================================== * Compares to subtrees, using the tree depth as tie breaker when * the subtrees have equal frequency. This minimizes the worst case length. */ function zip_SMALLER(tree, n, m) { return tree[n].fc < tree[m].fc || (tree[n].fc == tree[m].fc && zip_depth[n] <= zip_depth[m]); } /* ========================================================================== * read string data */ function zip_read_buff(buff, offset, n) { var i; for(i = 0; i < n && zip_deflate_pos < zip_deflate_data.length; i++) buff[offset + i] = zip_deflate_data.charCodeAt(zip_deflate_pos++) & 0xff; return i; } /* ========================================================================== * Initialize the "longest match" routines for a new file */ function zip_lm_init() { var j; /* Initialize the hash table. */ for(j = 0; j < zip_HASH_SIZE; j++) // zip_head2(j, zip_NIL); zip_prev[zip_WSIZE + j] = 0; /* prev will be initialized on the fly */ /* Set the default configuration parameters: */ zip_max_lazy_match = zip_configuration_table[zip_compr_level].max_lazy; zip_good_match = zip_configuration_table[zip_compr_level].good_length; if(!zip_FULL_SEARCH) zip_nice_match = zip_configuration_table[zip_compr_level].nice_length; zip_max_chain_length = zip_configuration_table[zip_compr_level].max_chain; zip_strstart = 0; zip_block_start = 0; zip_lookahead = zip_read_buff(zip_window, 0, 2 * zip_WSIZE); if(zip_lookahead <= 0) { zip_eofile = true; zip_lookahead = 0; return; } zip_eofile = false; /* Make sure that we always have enough lookahead. This is important * if input comes from a device such as a tty. */ while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile) zip_fill_window(); /* If lookahead < MIN_MATCH, ins_h is garbage, but this is * not important since only literal bytes will be emitted. */ zip_ins_h = 0; for(j = 0; j < zip_MIN_MATCH - 1; j++) { // UPDATE_HASH(ins_h, window[j]); zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[j] & 0xff)) & zip_HASH_MASK; } } /* ========================================================================== * Set match_start to the longest match starting at the given string and * return its length. Matches shorter or equal to prev_length are discarded, * in which case the result is equal to prev_length and match_start is * garbage. * IN assertions: cur_match is the head of the hash chain for the current * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 */ function zip_longest_match(cur_match) { var chain_length = zip_max_chain_length; // max hash chain length var scanp = zip_strstart; // current string var matchp; // matched string var len; // length of current match var best_len = zip_prev_length; // best match length so far /* Stop when cur_match becomes <= limit. To simplify the code, * we prevent matches with the string of window index 0. */ var limit = (zip_strstart > zip_MAX_DIST ? zip_strstart - zip_MAX_DIST : zip_NIL); var strendp = zip_strstart + zip_MAX_MATCH; var scan_end1 = zip_window[scanp + best_len - 1]; var scan_end = zip_window[scanp + best_len]; /* Do not waste too much time if we already have a good match: */ if(zip_prev_length >= zip_good_match) chain_length >>= 2; // Assert(encoder->strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead"); do { // Assert(cur_match < encoder->strstart, "no future"); matchp = cur_match; /* Skip to next match if the match length cannot increase * or if the match length is less than 2: */ if(zip_window[matchp + best_len] != scan_end || zip_window[matchp + best_len - 1] != scan_end1 || zip_window[matchp] != zip_window[scanp] || zip_window[++matchp] != zip_window[scanp + 1]) { continue; } /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that * the hash keys are equal and that HASH_BITS >= 8. */ scanp += 2; matchp++; /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ do { } while(zip_window[++scanp] == zip_window[++matchp] && zip_window[++scanp] == zip_window[++matchp] && zip_window[++scanp] == zip_window[++matchp] && zip_window[++scanp] == zip_window[++matchp] && zip_window[++scanp] == zip_window[++matchp] && zip_window[++scanp] == zip_window[++matchp] && zip_window[++scanp] == zip_window[++matchp] && zip_window[++scanp] == zip_window[++matchp] && scanp < strendp); len = zip_MAX_MATCH - (strendp - scanp); scanp = strendp - zip_MAX_MATCH; if(len > best_len) { zip_match_start = cur_match; best_len = len; if(zip_FULL_SEARCH) { if(len >= zip_MAX_MATCH) break; } else { if(len >= zip_nice_match) break; } scan_end1 = zip_window[scanp + best_len-1]; scan_end = zip_window[scanp + best_len]; } } while((cur_match = zip_prev[cur_match & zip_WMASK]) > limit && --chain_length != 0); return best_len; } /* ========================================================================== * Fill the window when the lookahead becomes insufficient. * Updates strstart and lookahead, and sets eofile if end of input file. * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0 * OUT assertions: at least one byte has been read, or eofile is set; * file reads are performed for at least two bytes (required for the * translate_eol option). */ function zip_fill_window() { var n, m; // Amount of free space at the end of the window. var more = zip_window_size - zip_lookahead - zip_strstart; /* If the window is almost full and there is insufficient lookahead, * move the upper half to the lower one to make room in the upper half. */ if(more == -1) { /* Very unlikely, but possible on 16 bit machine if strstart == 0 * and lookahead == 1 (input done one byte at time) */ more--; } else if(zip_strstart >= zip_WSIZE + zip_MAX_DIST) { /* By the IN assertion, the window is not empty so we can't confuse * more == 0 with more == 64K on a 16 bit machine. */ // Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM"); // System.arraycopy(window, WSIZE, window, 0, WSIZE); for(n = 0; n < zip_WSIZE; n++) zip_window[n] = zip_window[n + zip_WSIZE]; zip_match_start -= zip_WSIZE; zip_strstart -= zip_WSIZE; /* we now have strstart >= MAX_DIST: */ zip_block_start -= zip_WSIZE; for(n = 0; n < zip_HASH_SIZE; n++) { m = zip_head1(n); zip_head2(n, m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL); } for(n = 0; n < zip_WSIZE; n++) { /* If n is not on any hash chain, prev[n] is garbage but * its value will never be used. */ m = zip_prev[n]; zip_prev[n] = (m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL); } more += zip_WSIZE; } // At this point, more >= 2 if(!zip_eofile) { n = zip_read_buff(zip_window, zip_strstart + zip_lookahead, more); if(n <= 0) zip_eofile = true; else zip_lookahead += n; } } /* ========================================================================== * Processes a new input file and return its compressed length. This * function does not perform lazy evaluationof matches and inserts * new strings in the dictionary only for unmatched strings or for short * matches. It is used only for the fast compression options. */ function zip_deflate_fast() { while(zip_lookahead != 0 && zip_qhead == null) { var flush; // set if current block must be flushed /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ zip_INSERT_STRING(); /* Find the longest match, discarding those <= prev_length. * At this point we have always match_length < MIN_MATCH */ if(zip_hash_head != zip_NIL && zip_strstart - zip_hash_head <= zip_MAX_DIST) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ zip_match_length = zip_longest_match(zip_hash_head); /* longest_match() sets match_start */ if(zip_match_length > zip_lookahead) zip_match_length = zip_lookahead; } if(zip_match_length >= zip_MIN_MATCH) { // check_match(strstart, match_start, match_length); flush = zip_ct_tally(zip_strstart - zip_match_start, zip_match_length - zip_MIN_MATCH); zip_lookahead -= zip_match_length; /* Insert new strings in the hash table only if the match length * is not too large. This saves time but degrades compression. */ if(zip_match_length <= zip_max_lazy_match) { zip_match_length--; // string at strstart already in hash table do { zip_strstart++; zip_INSERT_STRING(); /* strstart never exceeds WSIZE-MAX_MATCH, so there are * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH * these bytes are garbage, but it does not matter since * the next lookahead bytes will be emitted as literals. */ } while(--zip_match_length != 0); zip_strstart++; } else { zip_strstart += zip_match_length; zip_match_length = 0; zip_ins_h = zip_window[zip_strstart] & 0xff; // UPDATE_HASH(ins_h, window[strstart + 1]); zip_ins_h = ((zip_ins_h< zip_lookahead) zip_match_length = zip_lookahead; /* Ignore a length 3 match if it is too distant: */ if(zip_match_length == zip_MIN_MATCH && zip_strstart - zip_match_start > zip_TOO_FAR) { /* If prev_match is also MIN_MATCH, match_start is garbage * but we will ignore the current match anyway. */ zip_match_length--; } } /* If there was a match at the previous step and the current * match is not better, output the previous match: */ if(zip_prev_length >= zip_MIN_MATCH && zip_match_length <= zip_prev_length) { var flush; // set if current block must be flushed // check_match(strstart - 1, prev_match, prev_length); flush = zip_ct_tally(zip_strstart - 1 - zip_prev_match, zip_prev_length - zip_MIN_MATCH); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. */ zip_lookahead -= zip_prev_length - 1; zip_prev_length -= 2; do { zip_strstart++; zip_INSERT_STRING(); /* strstart never exceeds WSIZE-MAX_MATCH, so there are * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH * these bytes are garbage, but it does not matter since the * next lookahead bytes will always be emitted as literals. */ } while(--zip_prev_length != 0); zip_match_available = 0; zip_match_length = zip_MIN_MATCH - 1; zip_strstart++; if(flush) { zip_flush_block(0); zip_block_start = zip_strstart; } } else if(zip_match_available != 0) { /* If there was no match at the previous position, output a * single literal. If there was a match but the current match * is longer, truncate the previous match to a single literal. */ if(zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff)) { zip_flush_block(0); zip_block_start = zip_strstart; } zip_strstart++; zip_lookahead--; } else { /* There is no previous match to compare with, wait for * the next step to decide. */ zip_match_available = 1; zip_strstart++; zip_lookahead--; } /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the next match, plus MIN_MATCH bytes to insert the * string following the next match. */ while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile) zip_fill_window(); } } function zip_init_deflate() { if(zip_eofile) return; zip_bi_buf = 0; zip_bi_valid = 0; zip_ct_init(); zip_lm_init(); zip_qhead = null; zip_outcnt = 0; zip_outoff = 0; if(zip_compr_level <= 3) { zip_prev_length = zip_MIN_MATCH - 1; zip_match_length = 0; } else { zip_match_length = zip_MIN_MATCH - 1; zip_match_available = 0; } zip_complete = false; } /* ========================================================================== * Same as above, but achieves better compression. We use a lazy * evaluation for matches: a match is finally adopted only if there is * no better match at the next window position. */ function zip_deflate_internal(buff, off, buff_size) { var n; if(!zip_initflag) { zip_init_deflate(); zip_initflag = true; if(zip_lookahead == 0) { // empty zip_complete = true; return 0; } } if((n = zip_qcopy(buff, off, buff_size)) == buff_size) return buff_size; if(zip_complete) return n; if(zip_compr_level <= 3) // optimized for speed zip_deflate_fast(); else zip_deflate_better(); if(zip_lookahead == 0) { if(zip_match_available != 0) zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff); zip_flush_block(1); zip_complete = true; } return n + zip_qcopy(buff, n + off, buff_size - n); } function zip_qcopy(buff, off, buff_size) { var n, i, j; n = 0; while(zip_qhead != null && n < buff_size) { i = buff_size - n; if(i > zip_qhead.len) i = zip_qhead.len; // System.arraycopy(qhead.ptr, qhead.off, buff, off + n, i); for(j = 0; j < i; j++) buff[off + n + j] = zip_qhead.ptr[zip_qhead.off + j]; zip_qhead.off += i; zip_qhead.len -= i; n += i; if(zip_qhead.len == 0) { var p; p = zip_qhead; zip_qhead = zip_qhead.next; zip_reuse_queue(p); } } if(n == buff_size) return n; if(zip_outoff < zip_outcnt) { i = buff_size - n; if(i > zip_outcnt - zip_outoff) i = zip_outcnt - zip_outoff; // System.arraycopy(outbuf, outoff, buff, off + n, i); for(j = 0; j < i; j++) buff[off + n + j] = zip_outbuf[zip_outoff + j]; zip_outoff += i; n += i; if(zip_outcnt == zip_outoff) zip_outcnt = zip_outoff = 0; } return n; } /* ========================================================================== * Allocate the match buffer, initialize the various tables and save the * location of the internal file attribute (ascii/binary) and method * (DEFLATE/STORE). */ function zip_ct_init() { var n; // iterates over tree elements var bits; // bit counter var length; // length value var code; // code value var dist; // distance index if(zip_static_dtree[0].dl != 0) return; // ct_init already called zip_l_desc.dyn_tree = zip_dyn_ltree; zip_l_desc.static_tree = zip_static_ltree; zip_l_desc.extra_bits = zip_extra_lbits; zip_l_desc.extra_base = zip_LITERALS + 1; zip_l_desc.elems = zip_L_CODES; zip_l_desc.max_length = zip_MAX_BITS; zip_l_desc.max_code = 0; zip_d_desc.dyn_tree = zip_dyn_dtree; zip_d_desc.static_tree = zip_static_dtree; zip_d_desc.extra_bits = zip_extra_dbits; zip_d_desc.extra_base = 0; zip_d_desc.elems = zip_D_CODES; zip_d_desc.max_length = zip_MAX_BITS; zip_d_desc.max_code = 0; zip_bl_desc.dyn_tree = zip_bl_tree; zip_bl_desc.static_tree = null; zip_bl_desc.extra_bits = zip_extra_blbits; zip_bl_desc.extra_base = 0; zip_bl_desc.elems = zip_BL_CODES; zip_bl_desc.max_length = zip_MAX_BL_BITS; zip_bl_desc.max_code = 0; // Initialize the mapping length (0..255) -> length code (0..28) length = 0; for(code = 0; code < zip_LENGTH_CODES-1; code++) { zip_base_length[code] = length; for(n = 0; n < (1< dist code (0..29) */ dist = 0; for(code = 0 ; code < 16; code++) { zip_base_dist[code] = dist; for(n = 0; n < (1<>= 7; // from now on, all distances are divided by 128 for( ; code < zip_D_CODES; code++) { zip_base_dist[code] = dist << 7; for(n = 0; n < (1<<(zip_extra_dbits[code]-7)); n++) zip_dist_code[256 + dist++] = code; } // Assert (dist == 256, "ct_init: 256+dist != 512"); // Construct the codes of the static literal tree for(bits = 0; bits <= zip_MAX_BITS; bits++) zip_bl_count[bits] = 0; n = 0; while(n <= 143) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; } while(n <= 255) { zip_static_ltree[n++].dl = 9; zip_bl_count[9]++; } while(n <= 279) { zip_static_ltree[n++].dl = 7; zip_bl_count[7]++; } while(n <= 287) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; } /* Codes 286 and 287 do not exist, but we must include them in the * tree construction to get a canonical Huffman tree (longest code * all ones) */ zip_gen_codes(zip_static_ltree, zip_L_CODES + 1); /* The static distance tree is trivial: */ for(n = 0; n < zip_D_CODES; n++) { zip_static_dtree[n].dl = 5; zip_static_dtree[n].fc = zip_bi_reverse(n, 5); } // Initialize the first block of the first file: zip_init_block(); } /* ========================================================================== * Initialize a new block. */ function zip_init_block() { var n; // iterates over tree elements // Initialize the trees. for(n = 0; n < zip_L_CODES; n++) zip_dyn_ltree[n].fc = 0; for(n = 0; n < zip_D_CODES; n++) zip_dyn_dtree[n].fc = 0; for(n = 0; n < zip_BL_CODES; n++) zip_bl_tree[n].fc = 0; zip_dyn_ltree[zip_END_BLOCK].fc = 1; zip_opt_len = zip_static_len = 0; zip_last_lit = zip_last_dist = zip_last_flags = 0; zip_flags = 0; zip_flag_bit = 1; } /* ========================================================================== * Restore the heap property by moving down the tree starting at node k, * exchanging a node with the smallest of its two sons if necessary, stopping * when the heap property is re-established (each father smaller than its * two sons). */ function zip_pqdownheap( tree, // the tree to restore k) { // node to move down var v = zip_heap[k]; var j = k << 1; // left son of k while(j <= zip_heap_len) { // Set j to the smallest of the two sons: if(j < zip_heap_len && zip_SMALLER(tree, zip_heap[j + 1], zip_heap[j])) j++; // Exit if v is smaller than both sons if(zip_SMALLER(tree, v, zip_heap[j])) break; // Exchange v with the smallest son zip_heap[k] = zip_heap[j]; k = j; // And continue down the tree, setting j to the left son of k j <<= 1; } zip_heap[k] = v; } /* ========================================================================== * Compute the optimal bit lengths for a tree and update the total bit length * for the current block. * IN assertion: the fields freq and dad are set, heap[heap_max] and * above are the tree nodes sorted by increasing frequency. * OUT assertions: the field len is set to the optimal bit length, the * array bl_count contains the frequencies for each bit length. * The length opt_len is updated; static_len is also updated if stree is * not null. */ function zip_gen_bitlen(desc) { // the tree descriptor var tree = desc.dyn_tree; var extra = desc.extra_bits; var base = desc.extra_base; var max_code = desc.max_code; var max_length = desc.max_length; var stree = desc.static_tree; var h; // heap index var n, m; // iterate over the tree elements var bits; // bit length var xbits; // extra bits var f; // frequency var overflow = 0; // number of elements with bit length too large for(bits = 0; bits <= zip_MAX_BITS; bits++) zip_bl_count[bits] = 0; /* In a first pass, compute the optimal bit lengths (which may * overflow in the case of the bit length tree). */ tree[zip_heap[zip_heap_max]].dl = 0; // root of the heap for(h = zip_heap_max + 1; h < zip_HEAP_SIZE; h++) { n = zip_heap[h]; bits = tree[tree[n].dl].dl + 1; if(bits > max_length) { bits = max_length; overflow++; } tree[n].dl = bits; // We overwrite tree[n].dl which is no longer needed if(n > max_code) continue; // not a leaf node zip_bl_count[bits]++; xbits = 0; if(n >= base) xbits = extra[n - base]; f = tree[n].fc; zip_opt_len += f * (bits + xbits); if(stree != null) zip_static_len += f * (stree[n].dl + xbits); } if(overflow == 0) return; // This happens for example on obj2 and pic of the Calgary corpus // Find the first bit length which could increase: do { bits = max_length - 1; while(zip_bl_count[bits] == 0) bits--; zip_bl_count[bits]--; // move one leaf down the tree zip_bl_count[bits + 1] += 2; // move one overflow item as its brother zip_bl_count[max_length]--; /* The brother of the overflow item also moves one step up, * but this does not affect bl_count[max_length] */ overflow -= 2; } while(overflow > 0); /* Now recompute all bit lengths, scanning in increasing frequency. * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all * lengths instead of fixing only the wrong ones. This idea is taken * from 'ar' written by Haruhiko Okumura.) */ for(bits = max_length; bits != 0; bits--) { n = zip_bl_count[bits]; while(n != 0) { m = zip_heap[--h]; if(m > max_code) continue; if(tree[m].dl != bits) { zip_opt_len += (bits - tree[m].dl) * tree[m].fc; tree[m].fc = bits; } n--; } } } /* ========================================================================== * Generate the codes for a given tree and bit counts (which need not be * optimal). * IN assertion: the array bl_count contains the bit length statistics for * the given tree and the field len is set for all tree elements. * OUT assertion: the field code is set for all tree elements of non * zero code length. */ function zip_gen_codes(tree, // the tree to decorate max_code) { // largest code with non zero frequency var next_code = new Array(zip_MAX_BITS+1); // next code value for each bit length var code = 0; // running code value var bits; // bit index var n; // code index /* The distribution counts are first used to generate the code values * without bit reversal. */ for(bits = 1; bits <= zip_MAX_BITS; bits++) { code = ((code + zip_bl_count[bits-1]) << 1); next_code[bits] = code; } /* Check that the bit counts in bl_count are consistent. The last code * must be all ones. */ // Assert (code + encoder->bl_count[MAX_BITS]-1 == (1<> 1; n >= 1; n--) zip_pqdownheap(tree, n); /* Construct the Huffman tree by repeatedly combining the least two * frequent nodes. */ do { n = zip_heap[zip_SMALLEST]; zip_heap[zip_SMALLEST] = zip_heap[zip_heap_len--]; zip_pqdownheap(tree, zip_SMALLEST); m = zip_heap[zip_SMALLEST]; // m = node of next least frequency // keep the nodes sorted by frequency zip_heap[--zip_heap_max] = n; zip_heap[--zip_heap_max] = m; // Create a new node father of n and m tree[node].fc = tree[n].fc + tree[m].fc; // depth[node] = (char)(MAX(depth[n], depth[m]) + 1); if(zip_depth[n] > zip_depth[m] + 1) zip_depth[node] = zip_depth[n]; else zip_depth[node] = zip_depth[m] + 1; tree[n].dl = tree[m].dl = node; // and insert the new node in the heap zip_heap[zip_SMALLEST] = node++; zip_pqdownheap(tree, zip_SMALLEST); } while(zip_heap_len >= 2); zip_heap[--zip_heap_max] = zip_heap[zip_SMALLEST]; /* At this point, the fields freq and dad are set. We can now * generate the bit lengths. */ zip_gen_bitlen(desc); // The field len is now set, we can generate the bit codes zip_gen_codes(tree, max_code); } /* ========================================================================== * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. Updates opt_len to take into account the repeat * counts. (The contribution of the bit length codes will be added later * during the construction of bl_tree.) */ function zip_scan_tree(tree,// the tree to be scanned max_code) { // and its largest code of non zero frequency var n; // iterates over all tree elements var prevlen = -1; // last emitted length var curlen; // length of current code var nextlen = tree[0].dl; // length of next code var count = 0; // repeat count of the current code var max_count = 7; // max repeat count var min_count = 4; // min repeat count if(nextlen == 0) { max_count = 138; min_count = 3; } tree[max_code + 1].dl = 0xffff; // guard for(n = 0; n <= max_code; n++) { curlen = nextlen; nextlen = tree[n + 1].dl; if(++count < max_count && curlen == nextlen) continue; else if(count < min_count) zip_bl_tree[curlen].fc += count; else if(curlen != 0) { if(curlen != prevlen) zip_bl_tree[curlen].fc++; zip_bl_tree[zip_REP_3_6].fc++; } else if(count <= 10) zip_bl_tree[zip_REPZ_3_10].fc++; else zip_bl_tree[zip_REPZ_11_138].fc++; 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; } } } /* ========================================================================== * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ function zip_send_tree(tree, // the tree to be scanned max_code) { // and its largest code of non zero frequency var n; // iterates over all tree elements var prevlen = -1; // last emitted length var curlen; // length of current code var nextlen = tree[0].dl; // length of next code var count = 0; // repeat count of the current code var max_count = 7; // max repeat count var min_count = 4; // min repeat count /* tree[max_code+1].dl = -1; */ /* guard already set */ if(nextlen == 0) { max_count = 138; min_count = 3; } for(n = 0; n <= max_code; n++) { curlen = nextlen; nextlen = tree[n+1].dl; if(++count < max_count && curlen == nextlen) { continue; } else if(count < min_count) { do { zip_SEND_CODE(curlen, zip_bl_tree); } while(--count != 0); } else if(curlen != 0) { if(curlen != prevlen) { zip_SEND_CODE(curlen, zip_bl_tree); count--; } // Assert(count >= 3 && count <= 6, " 3_6?"); zip_SEND_CODE(zip_REP_3_6, zip_bl_tree); zip_send_bits(count - 3, 2); } else if(count <= 10) { zip_SEND_CODE(zip_REPZ_3_10, zip_bl_tree); zip_send_bits(count-3, 3); } else { zip_SEND_CODE(zip_REPZ_11_138, zip_bl_tree); zip_send_bits(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; } } } /* ========================================================================== * Construct the Huffman tree for the bit lengths and return the index in * bl_order of the last bit length code to send. */ function zip_build_bl_tree() { var max_blindex; // index of last bit length code of non zero freq // Determine the bit length frequencies for literal and distance trees zip_scan_tree(zip_dyn_ltree, zip_l_desc.max_code); zip_scan_tree(zip_dyn_dtree, zip_d_desc.max_code); // Build the bit length tree: zip_build_tree(zip_bl_desc); /* opt_len now includes the length of the tree representations, except * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. */ /* Determine the number of bit length codes to send. The pkzip format * requires that at least 4 bit length codes be sent. (appnote.txt says * 3 but the actual value used is 4.) */ for(max_blindex = zip_BL_CODES-1; max_blindex >= 3; max_blindex--) { if(zip_bl_tree[zip_bl_order[max_blindex]].dl != 0) break; } /* Update opt_len to include the bit length tree and counts */ zip_opt_len += 3*(max_blindex+1) + 5+5+4; // Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", // encoder->opt_len, encoder->static_len)); return max_blindex; } /* ========================================================================== * Send the header for a block using dynamic Huffman trees: the counts, the * lengths of the bit length codes, the literal tree and the distance tree. * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ function zip_send_all_trees(lcodes, dcodes, blcodes) { // number of codes for each tree var rank; // index in bl_order // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, // "too many codes"); // Tracev((stderr, "\nbl counts: ")); zip_send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt zip_send_bits(dcodes-1, 5); zip_send_bits(blcodes-4, 4); // not -3 as stated in appnote.txt for(rank = 0; rank < blcodes; rank++) { // Tracev((stderr, "\nbl code %2d ", bl_order[rank])); zip_send_bits(zip_bl_tree[zip_bl_order[rank]].dl, 3); } // send the literal tree zip_send_tree(zip_dyn_ltree,lcodes-1); // send the distance tree zip_send_tree(zip_dyn_dtree,dcodes-1); } /* ========================================================================== * Determine the best encoding for the current block: dynamic trees, static * trees or store, and output the encoded block to the zip file. */ function zip_flush_block(eof) { // true if this is the last block for a file var opt_lenb, static_lenb; // opt_len and static_len in bytes var max_blindex; // index of last bit length code of non zero freq var stored_len; // length of input block stored_len = zip_strstart - zip_block_start; zip_flag_buf[zip_last_flags] = zip_flags; // Save the flags for the last 8 items // Construct the literal and distance trees zip_build_tree(zip_l_desc); // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", // encoder->opt_len, encoder->static_len)); zip_build_tree(zip_d_desc); // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", // encoder->opt_len, encoder->static_len)); /* At this point, opt_len and static_len are the total bit lengths of * the compressed block data, excluding the tree representations. */ /* Build the bit length tree for the above two trees, and get the index * in bl_order of the last bit length code to send. */ max_blindex = zip_build_bl_tree(); // Determine the best encoding. Compute first the block length in bytes opt_lenb = (zip_opt_len +3+7)>>3; static_lenb = (zip_static_len+3+7)>>3; // Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ", // opt_lenb, encoder->opt_len, // static_lenb, encoder->static_len, stored_len, // encoder->last_lit, encoder->last_dist)); if(static_lenb <= opt_lenb) opt_lenb = static_lenb; if(stored_len + 4 <= opt_lenb // 4: two words for the lengths && zip_block_start >= 0) { var i; /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. * Otherwise we can't have processed more than WSIZE input bytes since * the last block flush, because compression would have been * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to * transform a block into a stored block. */ zip_send_bits((zip_STORED_BLOCK<<1)+eof, 3); /* send block type */ zip_bi_windup(); /* align on byte boundary */ zip_put_short(stored_len); zip_put_short(~stored_len); // copy block /* p = &window[block_start]; for(i = 0; i < stored_len; i++) put_byte(p[i]); */ for(i = 0; i < stored_len; i++) zip_put_byte(zip_window[zip_block_start + i]); } else if(static_lenb == opt_lenb) { zip_send_bits((zip_STATIC_TREES<<1)+eof, 3); zip_compress_block(zip_static_ltree, zip_static_dtree); } else { zip_send_bits((zip_DYN_TREES<<1)+eof, 3); zip_send_all_trees(zip_l_desc.max_code+1, zip_d_desc.max_code+1, max_blindex+1); zip_compress_block(zip_dyn_ltree, zip_dyn_dtree); } zip_init_block(); if(eof != 0) zip_bi_windup(); } /* ========================================================================== * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ function zip_ct_tally( dist, // distance of matched string lc) { // match length-MIN_MATCH or unmatched char (if dist==0) zip_l_buf[zip_last_lit++] = lc; if(dist == 0) { // lc is the unmatched char zip_dyn_ltree[lc].fc++; } else { // Here, lc is the match length - MIN_MATCH dist--; // dist = match distance - 1 // Assert((ush)dist < (ush)MAX_DIST && // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && // (ush)D_CODE(dist) < (ush)D_CODES, "ct_tally: bad match"); zip_dyn_ltree[zip_length_code[lc]+zip_LITERALS+1].fc++; zip_dyn_dtree[zip_D_CODE(dist)].fc++; zip_d_buf[zip_last_dist++] = dist; zip_flags |= zip_flag_bit; } zip_flag_bit <<= 1; // Output the flags if they fill a byte if((zip_last_lit & 7) == 0) { zip_flag_buf[zip_last_flags++] = zip_flags; zip_flags = 0; zip_flag_bit = 1; } // Try to guess if it is profitable to stop the current block here if(zip_compr_level > 2 && (zip_last_lit & 0xfff) == 0) { // Compute an upper bound for the compressed length var out_length = zip_last_lit * 8; var in_length = zip_strstart - zip_block_start; var dcode; for(dcode = 0; dcode < zip_D_CODES; dcode++) { out_length += zip_dyn_dtree[dcode].fc * (5 + zip_extra_dbits[dcode]); } out_length >>= 3; // Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ", // encoder->last_lit, encoder->last_dist, in_length, out_length, // 100L - out_length*100L/in_length)); if(zip_last_dist < parseInt(zip_last_lit/2) && out_length < parseInt(in_length/2)) return true; } return (zip_last_lit == zip_LIT_BUFSIZE-1 || zip_last_dist == zip_DIST_BUFSIZE); /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K * on 16 bit machines and because stored blocks are restricted to * 64K-1 bytes. */ } /* ========================================================================== * Send the block data compressed using the given Huffman trees */ function zip_compress_block( ltree, // literal tree dtree) { // distance tree var dist; // distance of matched string var lc; // match length or unmatched char (if dist == 0) var lx = 0; // running index in l_buf var dx = 0; // running index in d_buf var fx = 0; // running index in flag_buf var flag = 0; // current flags var code; // the code to send var extra; // number of extra bits to send if(zip_last_lit != 0) do { if((lx & 7) == 0) flag = zip_flag_buf[fx++]; lc = zip_l_buf[lx++] & 0xff; if((flag & 1) == 0) { zip_SEND_CODE(lc, ltree); /* send a literal byte */ // Tracecv(isgraph(lc), (stderr," '%c' ", lc)); } else { // Here, lc is the match length - MIN_MATCH code = zip_length_code[lc]; zip_SEND_CODE(code+zip_LITERALS+1, ltree); // send the length code extra = zip_extra_lbits[code]; if(extra != 0) { lc -= zip_base_length[code]; zip_send_bits(lc, extra); // send the extra length bits } dist = zip_d_buf[dx++]; // Here, dist is the match distance - 1 code = zip_D_CODE(dist); // Assert (code < D_CODES, "bad d_code"); zip_SEND_CODE(code, dtree); // send the distance code extra = zip_extra_dbits[code]; if(extra != 0) { dist -= zip_base_dist[code]; zip_send_bits(dist, extra); // send the extra distance bits } } // literal or match pair ? flag >>= 1; } while(lx < zip_last_lit); zip_SEND_CODE(zip_END_BLOCK, ltree); } /* ========================================================================== * Send a value on a given number of bits. * IN assertion: length <= 16 and value fits in length bits. */ var zip_Buf_size = 16; // bit size of bi_buf function zip_send_bits( value, // value to send length) { // number of bits /* If not enough room in bi_buf, use (valid) bits from bi_buf and * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) * unused bits in value. */ if(zip_bi_valid > zip_Buf_size - length) { zip_bi_buf |= (value << zip_bi_valid); zip_put_short(zip_bi_buf); zip_bi_buf = (value >> (zip_Buf_size - zip_bi_valid)); zip_bi_valid += length - zip_Buf_size; } else { zip_bi_buf |= value << zip_bi_valid; zip_bi_valid += length; } } /* ========================================================================== * Reverse the first len bits of a code, using straightforward code (a faster * method would use a table) * IN assertion: 1 <= len <= 15 */ function zip_bi_reverse( code, // the value to invert len) { // its bit length var res = 0; do { res |= code & 1; code >>= 1; res <<= 1; } while(--len > 0); return res >> 1; } /* ========================================================================== * Write out any remaining bits in an incomplete byte. */ function zip_bi_windup() { if(zip_bi_valid > 8) { zip_put_short(zip_bi_buf); } else if(zip_bi_valid > 0) { zip_put_byte(zip_bi_buf); } zip_bi_buf = 0; zip_bi_valid = 0; } function zip_qoutbuf() { if(zip_outcnt != 0) { var q, i; q = zip_new_queue(); if(zip_qhead == null) zip_qhead = zip_qtail = q; else zip_qtail = zip_qtail.next = q; q.len = zip_outcnt - zip_outoff; // System.arraycopy(zip_outbuf, zip_outoff, q.ptr, 0, q.len); for(i = 0; i < q.len; i++) q.ptr[i] = zip_outbuf[zip_outoff + i]; zip_outcnt = zip_outoff = 0; } } function zip_deflate(str, level) { var out, buff; var i, j; zip_deflate_data = str; zip_deflate_pos = 0; if(typeof level == "undefined") level = zip_DEFAULT_LEVEL; zip_deflate_start(level); buff = new Array(1024); out = ""; while((i = zip_deflate_internal(buff, 0, buff.length)) > 0) { for(j = 0; j < i; j++) out += String.fromCharCode(buff[j]); } zip_deflate_data = null; // G.C. return out; } return zip_deflate; }; 35:[] 2f:{"id":"1feb9005f0327a42","slug":"plantuml","title":"PlantUML","thumbnail":"770532deb9f0f38e4bb85acad4e5d8f3cfd95b2c3ca6ac2cab325c3634bc33c2","access_level":"public","create_time":"$D2020-08-26T00:14:23.264Z","update_time":"$D2022-02-12T23:29:49.689Z","view_time":null,"first_public_time":"$D2020-08-26T02:06:19.075Z","fork":false,"stars":8,"starred":false,"owner":{"type":"team","id":"cc0ce9489265b441","login":"sebastien","name":"Sébastien Pierre","avatar_url":"https://avatars-next.observableusercontent.com/e328f33fe583d34ba96f68fa91d451af121df97e58a4f7b231c86f5293028a53","tier":"starter_2024"},"version":1108,"publish_version":1108,"role":null,"authored":false,"authors":[{"type":"individual","id":"7083c0770e4c8937","login":"sebastien","name":"Sébastien Pierre","avatar_url":"https://avatars-next.observableusercontent.com/e328f33fe583d34ba96f68fa91d451af121df97e58a4f7b231c86f5293028a53","tier":null}],"members":[{"type":"individual","id":"7083c0770e4c8937","login":"sebastien","name":"Sébastien Pierre","avatar_url":"https://avatars-next.observableusercontent.com/e328f33fe583d34ba96f68fa91d451af121df97e58a4f7b231c86f5293028a53","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"subscribed":null,"forks":10,"collection":{"id":"3abee56c402c8942","slug":"libraries","title":"Libraries","owner":{"id":"cc0ce9489265b441","login":"sebastien","name":"Sébastien Pierre"}},"type":"notebook","body":{"title":"PlantUML","cells":[{"id":0,"value":"md`# PlantUML\n\nThis notebook provides high level functions to create and work with PlantUML diagrams. Here's what it offers in a nutshell:\n\n- A \\`plantuml\\` template string function that you can use to render PlantUML code and wrap the result in a simple widget.\n- A **declarative API** that allows you to create a graph structure of your diagram and then render it.\n\nThe first function is the *plantuml* string prefix that can be used to output a PlantUML diagram.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":185,"value":"plantuml`\n@startuml\nAlice -> Bob: Authentication Request\nBob --> Alice: Authentication Response\n\nAlice -> Bob: Another authentication Request\nAlice <-- Bob: Another authentication Response\n@enduml\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":938,"value":"md`There is also a **declarative API** that makes it possible to write graphs using code, enabling reuse and automated processing.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1095,"value":"md`Here is an example using Archimate stereotypes to define a microservices architecture`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":326,"value":"Viewer(graph(\n Archimate.Tech.Interface(\"Client API\")\n .toRight(\"Microservice\", \"HTTPS\"),\n Archimate.Tech.Service(\"Microservice\")\n .toDown(\"Data Store\", \"DB connector\"),\n Archimate.Tech.Service(\"Data Store\")), {title:\"Microservices Architecture\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1098,"value":"md`Here is an example of describing a hierarchy as a mind map`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":454,"value":"Viewer(mindmap(\"Reporting Channels\", ...nodes({\n Metrics: {\n Performance: null,\n Operations: null\n },\n Errors: {\n Warning: null,\n Error: null,\n Exception: null\n },\n Events: {\n Service: {\n Available: null,\n Unavailable: null\n },\n User: {\n Connected: null,\n Disconnected: null\n }\n }\n })\n ), {title:\"Logging & Monitoring Topic Tree\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1099,"value":"md`Here is an example of illustrating specific data structures`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1057,"value":"Viewer(jsonmodel([\n {\n type:\"Event\",\n source:\"application.component\",\n timestamp:\"2021-04-06T12:00:00\",\n code:200,\n message:\"User has logged in\",\n context:{\n userID:\"12312\",\n },\n },\n {\n type:\"Metric\",\n channel:\"user.login\",\n timestamp:\"2021-04-06T12:00:00\",\n source:\"application.component\",\n value:1,\n\n }\n]), {title:\"Logging & Monitoring Data Structures\"})","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":996,"value":"md`## UML Symbols`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1004,"value":"md`We support the complete set of stereotypes defined in PlantUML's [deployment diagrams](https://plantuml.com/deployment-diagram), which covers most of UML.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1022,"value":"html.table(\n html.thead(\n html.tr(html.th(\"Stereotype\"), html.th(\"Symbol\"))),\n html.tbody(\n map(UMLStereotypes, (v,i) => html.tr(html.td(v), html.td(html.code(\"UML.\"+v))))))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":376,"value":"md`## Archimate Symbols`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":396,"value":"md`The \\`Archimate\\` symbol contains a catalogue of ready to be used Archimate stereotypes. For a full list and definition, checkout this compact [Archimate Reference by GoodEA](https://www.goodea.eu/archimate/reference/).`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":348,"value":"html.table(\n html.thead(\n html.tr(html.th(\"Layer\"), html.th(\"Stereotype\"), html.th(\"Symbol\"))),\n html.tbody(\n map(\n reduce(ArchimateStereotypes, (r,v,k ) => \n concat(r, map(v, (_,i) => ({\n layer : k.split(\":\")[0],\n index : i,\n symbol: _,\n name : safekey(last(k.split(\":\")), \"\") + \".\" + safekey(_, \"\")\n }) )), []),\n ({layer,index,symbol,name}) => html.tr(html.th(index === 0 ? layer : \"\"), html.td(symbol), html.td(html.code(name))))))\n ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":399,"value":"md`## Graph and node creation\n\nThe *graph*, *group* and *node* functions act as factory functions to create a PlantUML graph that then can be rendered using the *Viewer* function.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":260,"value":"graph = (...nodes) => new Graph().set(...nodes)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1043,"value":"jsonmodel = (...value) => new JSONModel(name).set(...(map(value, _ => new Node().setValue(_))))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":451,"value":"mindmap = (name, ...nodes) => new MindMap(name).set(...nodes)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":262,"value":"node = (...args) => new Node(...args)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":264,"value":"group = (name, ...args) => new Group(name).set(...args)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":487,"value":"md`The \\`nodes(data)\\` function takes a map of strings and will create the corresponding hierarchy`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":458,"value":"nodes = (() => {\n const nodes = data => {\n if (typeof data === \"object\") {\n return reduce(data, (r, v, k) => {\n r.push(new Node(k).set(...nodes(v)))\n return r\n }, []);\n } else {\n return [];\n }\n };\n return nodes;\n})()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":298,"value":"md`## Model`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":270,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":293,"value":"class Group extends Node {\n constructor(id,label){\n super(id,label);\n this.children = []\n }\n\n toDefinition() {\n return [\n `package \"${this.label}\" {`,\n ...(this.children.map(_ => _.toDefinition())),\n \"}\"\n ].join(\"\\n\");\n }\n \n toRelations() {\n return this.children.map(_ => _.toRelations()).join(\"\\n\")\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":272,"value":"class Graph extends Group {\n toSource() {\n return [\n`@startuml\n!includeurl https://raw.githubusercontent.com/ebbypeter/Archimate-PlantUML/master/Archimate.puml\n\nskinparam {\n shadowing false\n defaultFontColor DarkSlateGrey\n ArchimateBorderColor Transparent\n NoteBorderColor Gold\n NoteBackgroundColor BUSINESS\n NoteFontColor DarkGoldenRod\n PackageBorderColor LightGrey\n PackageFontColor Grey\n TitleFontSize 20\n TitleFontName Arial\n TitleFontStyle bold\n DefaultFontName Arial\n DefaultFontSize 13\n LineColor red\n}`,\n ...(this.children.map(_ => _.toDefinition())),\n ...(this.children.map(_ => _.toRelations())),\n\"@enduml\",\n ].join(\"\\n\")\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1053,"value":"class JSONModel extends Graph {\n // SEE: https://plantuml.com/json\n toSource() {\n return [\n`@startjson\n\n`,\n ...(this.children.map(_ => JSON.stringify(_.value))),\n\"@endjson\",\n ].join(\"\\n\")\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":382,"value":"class MindMap extends Graph {\n toSource() {\n const res = [\"@startmindmap\"];\n const depthTmpl = \"*********************\";\n this.walk((node, depth) =>\n res.push(`${depthTmpl.substring(0, depth + 1)} ${node.label}`)\n );\n res.push(\"@endmindmap\");\n return res.join(\"\\n\");\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":998,"value":"md`## UML Extension`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1001,"value":"UMLStereotypes = ([\n \"Actor\",\n \"Agent\",\n \"Artifact\",\n \"Boundary\",\n \"Card\",\n \"Circle\",\n \"Cloud\",\n \"Collections\",\n \"Component\",\n \"Control\",\n \"Database\",\n \"Entity\",\n \"File\",\n \"Folder\",\n \"Frame\",\n \"Hexagon\",\n \"Inteface\",\n \"Label\",\n \"Node\",\n \"Package\",\n \"Queue\",\n \"Rectangle\",\n \"Stack\",\n \"Storage\",\n \"UseCase\"])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1012,"value":"UML = reduce(UMLStereotypes, (r,v,k)=>{\n const [stereotype,alias] = v.split(\":\");\n const f = (id,label) => new Node(id,label,stereotype);\n f.stereotype = stereotype;\n r[safekey(stereotype,\"\")] = r[safekey(alias||stereotype, \"\")] = f;\n}, {})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":481,"value":"md`### Archimate Extension`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":274,"value":"class ArchimateNode extends Node {\n constructor(id,label,layer,stereotype){\n super(id,label);\n this.layer = layer\n this.stereotype = safekey(stereotype, \"-\").toLowerCase()\n }\n toDefinition() {\n return `archimate #${this.layer} \"${this.label}\" as ${this.id} <<${this.layer.toLowerCase()}-${this.stereotype}>>`\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":342,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":276,"value":"Archimate = reduce(ArchimateStereotypes, (r,v,k)=>{\n const [layer, alias] = k.split(\":\");\n r[layer] = r[alias||layer] = reduce(v, \n (r,v) => {\n const [stereotype,alias] = v.split(\":\");\n r[safekey(stereotype,\"\")] = r[safekey(alias||stereotype, \"\")] = \n ((id,label) => new ArchimateNode(id,label,layer,stereotype))\n }, {});})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":221,"value":"md`\n## Implementation\n\nThe main entry point is the *plantuml(...text)* function that renders the PlantUML text and wraps the result in the *Viewer* object.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":2,"value":"// From: https://observablehq.com/@karlerasmus/plantuml-in-observable\nplantuml = async (chunks, ...values) => {\n const options = merge({}, Options);\n return Viewer(chunks.reduce((r,v,i) => {\n r.push(v);\n maptype(values[i], {\n \"object\" : _ => Object.assign(options, _),\n \"string\" : _ => r.push(_)\n })\n return r;\n }, []).join(\"\"), options)}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":146,"value":"Viewer = async (source, options = undefined) => {\n source = source && source instanceof Graph ? source.toSource() : source;\n options = merge(options || {}, Options);\n const { id, width, height, node } = await render(source);\n return html.div(\n { style: \"text-align:center;width:100%;\" },\n options.title &&\n html.h4({ style: \"margin:20px 0px;max-width:100%;\" }, options.title),\n html.div(\n { style: \"display:block;margin:auto;overflow:auto;\" },\n node.children[0]\n ),\n options.footer &&\n html.div(\n { style: \"padding-bottom:10px;\" },\n html.small(\n html.em(width, \" × \", height),\n \" diagram, view as \",\n html.a({ href: `${options.server}/svg/${id}` }, \"SVG\"),\n \", \",\n html.a({ href: `${options.server}/png/${id}` }, \"PNG\"),\n \", \",\n html.a({ href: `${options.server}/txt/${id}` }, \"ASCII\"),\n \" or \",\n html.a({ href: `${options.server}/uml/${id}` }, \"source\")\n )\n )\n );\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":110,"value":"md`The *render(source)* function returns an SVG fragment representing the rendered source file.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":31,"value":"render = (source, config=Options) => {\n // https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/btoa\n const id = encode(source)\n const url = `${config.server}/svg/${id}${config.cache ? `?nocache=${Date.now()}` : \"\"}` \n return fetch(url).then(response => response.text()).then(text => {\n const node = document.createElement(\"div\");\n node.innerHTML = text.replace(/^<\\?xml version=\\\"1.0\\\".+\\?>/, '').replace(/^\\n/, '');\n const svg = node.children[0]\n return {\n node,\n id,\n width :parseInt(svg.getAttribute(\"width\")),\n height :parseInt(svg.getAttribute(\"height\")),\n }\n });\n }","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":106,"value":"md`\n### PlantUML Source Encoding\n\nIn order to be rendered, the PlantUML source code needs to be to be encoded as described [here](https://plantuml.com/text-encoding). The *encode(source)* does just that, however the process is sadly not very easy to do with stock browser API or existing NPM modules, so the *base64* and *deflate* were pasted almost as-is from Karl Rasum's [PlantUML in Observable](https://observablehq.com/@karlerasmus/plantuml-in-observable) -- hopefully these can be replaced with modules and browser API in the future.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":36,"value":"encode = text => base64(deflate(unescape(encodeURIComponent(text)), 9))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":46,"value":"$33","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":101,"value":"$34","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":229,"value":"md`\n### PlantUML rendering\n\nThe rendering of the PlantUML diagram is done through the main PlantUML rendering server, but it is possible to change to a different server\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":11,"value":"Options = ({\n server: \"https://www.plantuml.com/plantuml\",\n footer: true,\n cache : true,\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":23,"value":"md`We import a few convenience functions for the UML viewer component.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":296,"value":"md`## Utilities`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":266,"value":"safetext = (()=>{\n const RE_NEWLINES = new RegExp(\"\\n\", \"g\")\n return _ => (\"\"+_).replace(RE_NEWLINES, \"\\\\n\")\n})()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":8,"value":"md`\n# References\n\n- [PlantUML in Observable](https://observablehq.com/@karlerasmus/plantuml-in-observable), the original implementation of the plantuml function, and in particular the PlantUML text encoding functions.\n- [PlantUML text encoding](https://plantuml.com/text-encoding), for the specification of PlantUML's encoding for communicating graphs to the server for rendering.\n- [Archimate support in PlantUML](https://plantuml.com/archimate-diagram), including the list of supported symbols.\n- [GoodEA's Archimate Reference](https://www.goodea.eu/archimate/reference/), a clear, concise and visual summary of the key Archimate symbols/stereotypes.\n- [Hello, Pintora](https://observablehq.com/@triptych/hello-pintora), a notebook that uses a different tool (Pintora) with similar goals.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":280,"value":"md`\n## Dependencies\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5,"value":"import {\n html,\n merge,\n maptype,\n safekey,\n reduce,\n map,\n filter,\n bool,\n concat,\n last,\n effect\n} from \"@sebastien/boilerplate\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"}],"files":"$W35","stdlib":"1","titling":"auto"}} 30:"$2f:body"