prehistoric-systems/itty-bitty
1
0
Fork 0
mirror of https://github.com/arfct/itty-bitty.git synced 2026-03-11 08:54:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Licenses, remove extra files

Browse source
This commit is contained in:
Nicholas Jitkoff 2018-07-04 11:03:21 -07:00
parent 6b7513f1dd
commit da68c69908
11 changed files with 41 additions and 5724 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
LICENSE Normal file
View file

@ -0,0 +1,20 @@
© 2018 Nicholas Jitkoff
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

2
edit.html
View file

@ -4,7 +4,7 @@
<meta name="viewport" content="width=device-width">
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; connect-src https://codepen.io; style-src 'unsafe-inline' 'self'">
<title>itty.bitty</title>
<script src="src/lzma_worker-min.js"></script>
<script src="lzma/lzma_worker-min.js"></script>
<script src="jquery-3.3.1.min.js"></script>
<script src="data.js"></script>
<script src="edit.js"></script>

20
lzma/LICENSE Normal file
View file

@ -0,0 +1,20 @@
© 2016 Nathan Rugg <nmrugg@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

0
src/lzma-d-min.js → lzma/lzma-d-min.js vendored
View file

0
src/lzma_worker-min.js → lzma/lzma_worker-min.js vendored
View file

1
src/lzma-c-min.js vendored
View file

File diff suppressed because one or more lines are too long

2021
src/lzma-c.js
View file

File diff suppressed because it is too large Load diff

878
src/lzma-d.js
View file

@ -1,878 +0,0 @@
///NOTE: This file was generated by minify.js from lzma_worker.js. Do not modify.
/// © 2015 Nathan Rugg <nmrugg@gmail.com> | MIT
/// See LICENSE for more details.
/* jshint noarg:true, boss:true, unused:strict, strict:true, undef:true, noarg: true, forin:true, evil:true, newcap:false, -W041, -W021, worker:true, browser:true, node:true */
/* global setImmediate, setTimeout, window, onmessage */
var LZMA = (function () {
"use strict";
var
/** ds */
action_decompress = 2,
/** de */
action_progress = 3,
wait = typeof setImmediate == "function" ? setImmediate : setTimeout,
__4294967296 = 4294967296,
N1_longLit = [4294967295, -__4294967296],
P0_longLit = [0, 0],
P1_longLit = [1, 0];
function update_progress(percent, cbn) {
postMessage({
action: action_progress,
cbn: cbn,
result: percent
});
}
function initDim(len) {
///NOTE: This is MUCH faster than "new Array(len)" in newer versions of v8 (starting with Node.js 0.11.15, which uses v8 3.28.73).
var a = [];
a[len - 1] = undefined;
return a;
}
function add(a, b) {
return create(a[0] + b[0], a[1] + b[1]);
}
function compare(a, b) {
var nega, negb;
if (a[0] == b[0] && a[1] == b[1]) {
return 0;
}
nega = a[1] < 0;
negb = b[1] < 0;
if (nega && !negb) {
return -1;
}
if (!nega && negb) {
return 1;
}
if (sub(a, b)[1] < 0) {
return -1;
}
return 1;
}
function create(valueLow, valueHigh) {
var diffHigh, diffLow;
valueHigh %= 1.8446744073709552E19;
valueLow %= 1.8446744073709552E19;
diffHigh = valueHigh % __4294967296;
diffLow = Math.floor(valueLow / __4294967296) * __4294967296;
valueHigh = valueHigh - diffHigh + diffLow;
valueLow = valueLow - diffLow + diffHigh;
while (valueLow < 0) {
valueLow += __4294967296;
valueHigh -= __4294967296;
}
while (valueLow > 4294967295) {
valueLow -= __4294967296;
valueHigh += __4294967296;
}
valueHigh = valueHigh % 1.8446744073709552E19;
while (valueHigh > 9223372032559808512) {
valueHigh -= 1.8446744073709552E19;
}
while (valueHigh < -9223372036854775808) {
valueHigh += 1.8446744073709552E19;
}
return [valueLow, valueHigh];
}
function fromInt(value) {
if (value >= 0) {
return [value, 0];
} else {
return [value + __4294967296, -__4294967296];
}
}
function lowBits_0(a) {
if (a[0] >= 2147483648) {
return ~~Math.max(Math.min(a[0] - __4294967296, 2147483647), -2147483648);
} else {
return ~~Math.max(Math.min(a[0], 2147483647), -2147483648);
}
}
function sub(a, b) {
return create(a[0] - b[0], a[1] - b[1]);
}
function $ByteArrayInputStream(this$static, buf) {
this$static.buf = buf;
this$static.pos = 0;
this$static.count = buf.length;
return this$static;
}
/** ds */
function $read(this$static) {
if (this$static.pos >= this$static.count)
return -1;
return this$static.buf[this$static.pos++] & 255;
}
/** de */
function $ByteArrayOutputStream(this$static) {
this$static.buf = initDim(32);
this$static.count = 0;
return this$static;
}
function $toByteArray(this$static) {
var data = this$static.buf;
data.length = this$static.count;
return data;
}
function $write_0(this$static, buf, off, len) {
arraycopy(buf, off, this$static.buf, this$static.count, len);
this$static.count += len;
}
function arraycopy(src, srcOfs, dest, destOfs, len) {
for (var i = 0; i < len; ++i) {
dest[destOfs + i] = src[srcOfs + i];
}
}
/** ds */
function $init_0(this$static, input, output) {
var decoder,
hex_length = "",
i,
properties = [],
r,
tmp_length;
for (i = 0; i < 5; ++i) {
r = $read(input);
if (r == -1)
throw new Error("truncated input");
properties[i] = r << 24 >> 24;
}
decoder = $Decoder({});
if (!$SetDecoderProperties(decoder, properties)) {
throw new Error("corrupted input");
}
for (i = 0; i < 64; i += 8) {
r = $read(input);
if (r == -1)
throw new Error("truncated input");
r = r.toString(16);
if (r.length == 1) r = "0" + r;
hex_length = r + "" + hex_length;
}
/// Was the length set in the header (if it was compressed from a stream, the length is all f"s).
if (/^0+$|^f+$/i.test(hex_length)) {
/// The length is unknown, so set to -1.
this$static.length_0 = N1_longLit;
} else {
///NOTE: If there is a problem with the decoder because of the length, you can always set the length to -1 (N1_longLit) which means unknown.
tmp_length = parseInt(hex_length, 16);
/// If the length is too long to handle, just set it to unknown.
if (tmp_length > 4294967295) {
this$static.length_0 = N1_longLit;
} else {
this$static.length_0 = fromInt(tmp_length);
}
}
this$static.chunker = $CodeInChunks(decoder, input, output, this$static.length_0);
}
function $LZMAByteArrayDecompressor(this$static, data) {
this$static.output = $ByteArrayOutputStream({});
$init_0(this$static, $ByteArrayInputStream({}, data), this$static.output);
return this$static;
}
/** de */
/** ds */
function $CopyBlock(this$static, distance, len) {
var pos = this$static._pos - distance - 1;
if (pos < 0) {
pos += this$static._windowSize;
}
for (; len != 0; --len) {
if (pos >= this$static._windowSize) {
pos = 0;
}
this$static._buffer[this$static._pos++] = this$static._buffer[pos++];
if (this$static._pos >= this$static._windowSize) {
$Flush_0(this$static);
}
}
}
function $Create_5(this$static, windowSize) {
if (this$static._buffer == null || this$static._windowSize != windowSize) {
this$static._buffer = initDim(windowSize);
}
this$static._windowSize = windowSize;
this$static._pos = 0;
this$static._streamPos = 0;
}
function $Flush_0(this$static) {
var size = this$static._pos - this$static._streamPos;
if (!size) {
return;
}
$write_0(this$static._stream, this$static._buffer, this$static._streamPos, size);
if (this$static._pos >= this$static._windowSize) {
this$static._pos = 0;
}
this$static._streamPos = this$static._pos;
}
function $GetByte(this$static, distance) {
var pos = this$static._pos - distance - 1;
if (pos < 0) {
pos += this$static._windowSize;
}
return this$static._buffer[pos];
}
function $PutByte(this$static, b) {
this$static._buffer[this$static._pos++] = b;
if (this$static._pos >= this$static._windowSize) {
$Flush_0(this$static);
}
}
function $ReleaseStream(this$static) {
$Flush_0(this$static);
this$static._stream = null;
}
/** de */
function GetLenToPosState(len) {
len -= 2;
if (len < 4) {
return len;
}
return 3;
}
function StateUpdateChar(index) {
if (index < 4) {
return 0;
}
if (index < 10) {
return index - 3;
}
return index - 6;
}
/** ds */
function $Chunker(this$static, decoder) {
this$static.decoder = decoder;
this$static.encoder = null;
this$static.alive = 1;
return this$static;
}
/** de */
function $processChunk(this$static) {
if (!this$static.alive) {
throw new Error("bad state");
}
if (this$static.encoder) {
throw new Error("No encoding");
} else {
/// co:throw new Error("No decoding");
/** ds */
$processDecoderChunk(this$static);
/** de */
}
return this$static.alive;
}
/** ds */
function $processDecoderChunk(this$static) {
var result = $CodeOneChunk(this$static.decoder);
if (result == -1) {
throw new Error("corrupted input");
}
this$static.inBytesProcessed = N1_longLit;
this$static.outBytesProcessed = this$static.decoder.nowPos64;
if (result || compare(this$static.decoder.outSize, P0_longLit) >= 0 && compare(this$static.decoder.nowPos64, this$static.decoder.outSize) >= 0) {
$Flush_0(this$static.decoder.m_OutWindow);
$ReleaseStream(this$static.decoder.m_OutWindow);
this$static.decoder.m_RangeDecoder.Stream = null;
this$static.alive = 0;
}
}
/** de */
/** ds */
function $CodeInChunks(this$static, inStream, outStream, outSize) {
this$static.m_RangeDecoder.Stream = inStream;
$ReleaseStream(this$static.m_OutWindow);
this$static.m_OutWindow._stream = outStream;
$Init_1(this$static);
this$static.state = 0;
this$static.rep0 = 0;
this$static.rep1 = 0;
this$static.rep2 = 0;
this$static.rep3 = 0;
this$static.outSize = outSize;
this$static.nowPos64 = P0_longLit;
this$static.prevByte = 0;
return $Chunker({}, this$static);
}
function $CodeOneChunk(this$static) {
var decoder2, distance, len, numDirectBits, posSlot, posState;
posState = lowBits_0(this$static.nowPos64) & this$static.m_PosStateMask;
if (!$DecodeBit(this$static.m_RangeDecoder, this$static.m_IsMatchDecoders, (this$static.state << 4) + posState)) {
decoder2 = $GetDecoder(this$static.m_LiteralDecoder, lowBits_0(this$static.nowPos64), this$static.prevByte);
if (this$static.state < 7) {
this$static.prevByte = $DecodeNormal(decoder2, this$static.m_RangeDecoder);
} else {
this$static.prevByte = $DecodeWithMatchByte(decoder2, this$static.m_RangeDecoder, $GetByte(this$static.m_OutWindow, this$static.rep0));
}
$PutByte(this$static.m_OutWindow, this$static.prevByte);
this$static.state = StateUpdateChar(this$static.state);
this$static.nowPos64 = add(this$static.nowPos64, P1_longLit);
} else {
if ($DecodeBit(this$static.m_RangeDecoder, this$static.m_IsRepDecoders, this$static.state)) {
len = 0;
if (!$DecodeBit(this$static.m_RangeDecoder, this$static.m_IsRepG0Decoders, this$static.state)) {
if (!$DecodeBit(this$static.m_RangeDecoder, this$static.m_IsRep0LongDecoders, (this$static.state << 4) + posState)) {
this$static.state = this$static.state < 7?9:11;
len = 1;
}
} else {
if (!$DecodeBit(this$static.m_RangeDecoder, this$static.m_IsRepG1Decoders, this$static.state)) {
distance = this$static.rep1;
} else {
if (!$DecodeBit(this$static.m_RangeDecoder, this$static.m_IsRepG2Decoders, this$static.state)) {
distance = this$static.rep2;
} else {
distance = this$static.rep3;
this$static.rep3 = this$static.rep2;
}
this$static.rep2 = this$static.rep1;
}
this$static.rep1 = this$static.rep0;
this$static.rep0 = distance;
}
if (!len) {
len = $Decode(this$static.m_RepLenDecoder, this$static.m_RangeDecoder, posState) + 2;
this$static.state = this$static.state < 7?8:11;
}
} else {
this$static.rep3 = this$static.rep2;
this$static.rep2 = this$static.rep1;
this$static.rep1 = this$static.rep0;
len = 2 + $Decode(this$static.m_LenDecoder, this$static.m_RangeDecoder, posState);
this$static.state = this$static.state < 7?7:10;
posSlot = $Decode_0(this$static.m_PosSlotDecoder[GetLenToPosState(len)], this$static.m_RangeDecoder);
if (posSlot >= 4) {
numDirectBits = (posSlot >> 1) - 1;
this$static.rep0 = (2 | posSlot & 1) << numDirectBits;
if (posSlot < 14) {
this$static.rep0 += ReverseDecode(this$static.m_PosDecoders, this$static.rep0 - posSlot - 1, this$static.m_RangeDecoder, numDirectBits);
} else {
this$static.rep0 += $DecodeDirectBits(this$static.m_RangeDecoder, numDirectBits - 4) << 4;
this$static.rep0 += $ReverseDecode(this$static.m_PosAlignDecoder, this$static.m_RangeDecoder);
if (this$static.rep0 < 0) {
if (this$static.rep0 == -1) {
return 1;
}
return -1;
}
}
} else
this$static.rep0 = posSlot;
}
if (compare(fromInt(this$static.rep0), this$static.nowPos64) >= 0 || this$static.rep0 >= this$static.m_DictionarySizeCheck) {
return -1;
}
$CopyBlock(this$static.m_OutWindow, this$static.rep0, len);
this$static.nowPos64 = add(this$static.nowPos64, fromInt(len));
this$static.prevByte = $GetByte(this$static.m_OutWindow, 0);
}
return 0;
}
function $Decoder(this$static) {
this$static.m_OutWindow = {};
this$static.m_RangeDecoder = {};
this$static.m_IsMatchDecoders = initDim(192);
this$static.m_IsRepDecoders = initDim(12);
this$static.m_IsRepG0Decoders = initDim(12);
this$static.m_IsRepG1Decoders = initDim(12);
this$static.m_IsRepG2Decoders = initDim(12);
this$static.m_IsRep0LongDecoders = initDim(192);
this$static.m_PosSlotDecoder = initDim(4);
this$static.m_PosDecoders = initDim(114);
this$static.m_PosAlignDecoder = $BitTreeDecoder({}, 4);
this$static.m_LenDecoder = $Decoder$LenDecoder({});
this$static.m_RepLenDecoder = $Decoder$LenDecoder({});
this$static.m_LiteralDecoder = {};
for (var i = 0; i < 4; ++i) {
this$static.m_PosSlotDecoder[i] = $BitTreeDecoder({}, 6);
}
return this$static;
}
function $Init_1(this$static) {
this$static.m_OutWindow._streamPos = 0;
this$static.m_OutWindow._pos = 0;
InitBitModels(this$static.m_IsMatchDecoders);
InitBitModels(this$static.m_IsRep0LongDecoders);
InitBitModels(this$static.m_IsRepDecoders);
InitBitModels(this$static.m_IsRepG0Decoders);
InitBitModels(this$static.m_IsRepG1Decoders);
InitBitModels(this$static.m_IsRepG2Decoders);
InitBitModels(this$static.m_PosDecoders);
$Init_0(this$static.m_LiteralDecoder);
for (var i = 0; i < 4; ++i) {
InitBitModels(this$static.m_PosSlotDecoder[i].Models);
}
$Init(this$static.m_LenDecoder);
$Init(this$static.m_RepLenDecoder);
InitBitModels(this$static.m_PosAlignDecoder.Models);
$Init_8(this$static.m_RangeDecoder);
}
function $SetDecoderProperties(this$static, properties) {
var dictionarySize, i, lc, lp, pb, remainder, val;
if (properties.length < 5)
return 0;
val = properties[0] & 255;
lc = val % 9;
remainder = ~~(val / 9);
lp = remainder % 5;
pb = ~~(remainder / 5);
dictionarySize = 0;
for (i = 0; i < 4; ++i) {
dictionarySize += (properties[1 + i] & 255) << i * 8;
}
///NOTE: If the input is bad, it might call for an insanely large dictionary size, which would crash the script.
if (dictionarySize > 99999999 || !$SetLcLpPb(this$static, lc, lp, pb)) {
return 0;
}
return $SetDictionarySize(this$static, dictionarySize);
}
function $SetDictionarySize(this$static, dictionarySize) {
if (dictionarySize < 0) {
return 0;
}
if (this$static.m_DictionarySize != dictionarySize) {
this$static.m_DictionarySize = dictionarySize;
this$static.m_DictionarySizeCheck = Math.max(this$static.m_DictionarySize, 1);
$Create_5(this$static.m_OutWindow, Math.max(this$static.m_DictionarySizeCheck, 4096));
}
return 1;
}
function $SetLcLpPb(this$static, lc, lp, pb) {
if (lc > 8 || lp > 4 || pb > 4) {
return 0;
}
$Create_0(this$static.m_LiteralDecoder, lp, lc);
var numPosStates = 1 << pb;
$Create(this$static.m_LenDecoder, numPosStates);
$Create(this$static.m_RepLenDecoder, numPosStates);
this$static.m_PosStateMask = numPosStates - 1;
return 1;
}
function $Create(this$static, numPosStates) {
for (; this$static.m_NumPosStates < numPosStates; ++this$static.m_NumPosStates) {
this$static.m_LowCoder[this$static.m_NumPosStates] = $BitTreeDecoder({}, 3);
this$static.m_MidCoder[this$static.m_NumPosStates] = $BitTreeDecoder({}, 3);
}
}
function $Decode(this$static, rangeDecoder, posState) {
if (!$DecodeBit(rangeDecoder, this$static.m_Choice, 0)) {
return $Decode_0(this$static.m_LowCoder[posState], rangeDecoder);
}
var symbol = 8;
if (!$DecodeBit(rangeDecoder, this$static.m_Choice, 1)) {
symbol += $Decode_0(this$static.m_MidCoder[posState], rangeDecoder);
} else {
symbol += 8 + $Decode_0(this$static.m_HighCoder, rangeDecoder);
}
return symbol;
}
function $Decoder$LenDecoder(this$static) {
this$static.m_Choice = initDim(2);
this$static.m_LowCoder = initDim(16);
this$static.m_MidCoder = initDim(16);
this$static.m_HighCoder = $BitTreeDecoder({}, 8);
this$static.m_NumPosStates = 0;
return this$static;
}
function $Init(this$static) {
InitBitModels(this$static.m_Choice);
for (var posState = 0; posState < this$static.m_NumPosStates; ++posState) {
InitBitModels(this$static.m_LowCoder[posState].Models);
InitBitModels(this$static.m_MidCoder[posState].Models);
}
InitBitModels(this$static.m_HighCoder.Models);
}
function $Create_0(this$static, numPosBits, numPrevBits) {
var i, numStates;
if (this$static.m_Coders != null && this$static.m_NumPrevBits == numPrevBits && this$static.m_NumPosBits == numPosBits)
return;
this$static.m_NumPosBits = numPosBits;
this$static.m_PosMask = (1 << numPosBits) - 1;
this$static.m_NumPrevBits = numPrevBits;
numStates = 1 << this$static.m_NumPrevBits + this$static.m_NumPosBits;
this$static.m_Coders = initDim(numStates);
for (i = 0; i < numStates; ++i)
this$static.m_Coders[i] = $Decoder$LiteralDecoder$Decoder2({});
}
function $GetDecoder(this$static, pos, prevByte) {
return this$static.m_Coders[((pos & this$static.m_PosMask) << this$static.m_NumPrevBits) + ((prevByte & 255) >>> 8 - this$static.m_NumPrevBits)];
}
function $Init_0(this$static) {
var i, numStates;
numStates = 1 << this$static.m_NumPrevBits + this$static.m_NumPosBits;
for (i = 0; i < numStates; ++i) {
InitBitModels(this$static.m_Coders[i].m_Decoders);
}
}
function $DecodeNormal(this$static, rangeDecoder) {
var symbol = 1;
do {
symbol = symbol << 1 | $DecodeBit(rangeDecoder, this$static.m_Decoders, symbol);
} while (symbol < 256);
return symbol << 24 >> 24;
}
function $DecodeWithMatchByte(this$static, rangeDecoder, matchByte) {
var bit, matchBit, symbol = 1;
do {
matchBit = matchByte >> 7 & 1;
matchByte <<= 1;
bit = $DecodeBit(rangeDecoder, this$static.m_Decoders, (1 + matchBit << 8) + symbol);
symbol = symbol << 1 | bit;
if (matchBit != bit) {
while (symbol < 256) {
symbol = symbol << 1 | $DecodeBit(rangeDecoder, this$static.m_Decoders, symbol);
}
break;
}
} while (symbol < 256);
return symbol << 24 >> 24;
}
function $Decoder$LiteralDecoder$Decoder2(this$static) {
this$static.m_Decoders = initDim(768);
return this$static;
}
/** de */
/** ds */
function $BitTreeDecoder(this$static, numBitLevels) {
this$static.NumBitLevels = numBitLevels;
this$static.Models = initDim(1 << numBitLevels);
return this$static;
}
function $Decode_0(this$static, rangeDecoder) {
var bitIndex, m = 1;
for (bitIndex = this$static.NumBitLevels; bitIndex != 0; --bitIndex) {
m = (m << 1) + $DecodeBit(rangeDecoder, this$static.Models, m);
}
return m - (1 << this$static.NumBitLevels);
}
function $ReverseDecode(this$static, rangeDecoder) {
var bit, bitIndex, m = 1, symbol = 0;
for (bitIndex = 0; bitIndex < this$static.NumBitLevels; ++bitIndex) {
bit = $DecodeBit(rangeDecoder, this$static.Models, m);
m <<= 1;
m += bit;
symbol |= bit << bitIndex;
}
return symbol;
}
function ReverseDecode(Models, startIndex, rangeDecoder, NumBitLevels) {
var bit, bitIndex, m = 1, symbol = 0;
for (bitIndex = 0; bitIndex < NumBitLevels; ++bitIndex) {
bit = $DecodeBit(rangeDecoder, Models, startIndex + m);
m <<= 1;
m += bit;
symbol |= bit << bitIndex;
}
return symbol;
}
/** de */
/** ds */
function $DecodeBit(this$static, probs, index) {
var newBound, prob = probs[index];
newBound = (this$static.Range >>> 11) * prob;
if ((this$static.Code ^ -2147483648) < (newBound ^ -2147483648)) {
this$static.Range = newBound;
probs[index] = prob + (2048 - prob >>> 5) << 16 >> 16;
if (!(this$static.Range & -16777216)) {
this$static.Code = this$static.Code << 8 | $read(this$static.Stream);
this$static.Range <<= 8;
}
return 0;
} else {
this$static.Range -= newBound;
this$static.Code -= newBound;
probs[index] = prob - (prob >>> 5) << 16 >> 16;
if (!(this$static.Range & -16777216)) {
this$static.Code = this$static.Code << 8 | $read(this$static.Stream);
this$static.Range <<= 8;
}
return 1;
}
}
function $DecodeDirectBits(this$static, numTotalBits) {
var i, t, result = 0;
for (i = numTotalBits; i != 0; --i) {
this$static.Range >>>= 1;
t = this$static.Code - this$static.Range >>> 31;
this$static.Code -= this$static.Range & t - 1;
result = result << 1 | 1 - t;
if (!(this$static.Range & -16777216)) {
this$static.Code = this$static.Code << 8 | $read(this$static.Stream);
this$static.Range <<= 8;
}
}
return result;
}
function $Init_8(this$static) {
this$static.Code = 0;
this$static.Range = -1;
for (var i = 0; i < 5; ++i) {
this$static.Code = this$static.Code << 8 | $read(this$static.Stream);
}
}
/** de */
function InitBitModels(probs) {
for (var i = probs.length - 1; i >= 0; --i) {
probs[i] = 1024;
}
}
/** ds */
function decode(utf) {
var i = 0, j = 0, x, y, z, l = utf.length, buf = [], charCodes = [];
for (; i < l; ++i, ++j) {
x = utf[i] & 255;
if (!(x & 128)) {
if (!x) {
/// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf;
}
charCodes[j] = x;
} else if ((x & 224) == 192) {
if (i + 1 >= l) {
/// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf;
}
y = utf[++i] & 255;
if ((y & 192) != 128) {
/// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf;
}
charCodes[j] = ((x & 31) << 6) | (y & 63);
} else if ((x & 240) == 224) {
if (i + 2 >= l) {
/// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf;
}
y = utf[++i] & 255;
if ((y & 192) != 128) {
/// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf;
}
z = utf[++i] & 255;
if ((z & 192) != 128) {
/// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf;
}
charCodes[j] = ((x & 15) << 12) | ((y & 63) << 6) | (z & 63);
} else {
/// It appears that this is binary data, so it cannot be converted to a string, so just send it back.
return utf;
}
if (j == 16383) {
buf.push(String.fromCharCode.apply(String, charCodes));
j = -1;
}
}
if (j > 0) {
charCodes.length = j;
buf.push(String.fromCharCode.apply(String, charCodes));
}
return buf.join("");
}
/** de */
function toDouble(a) {
return a[1] + a[0];
}
/** ds */
function decompress(byte_arr, on_finish, on_progress) {
var this$static = {},
percent,
cbn, /// A callback number should be supplied instead of on_finish() if we are using Web Workers.
has_progress,
len,
sync = typeof on_finish == "undefined" && typeof on_progress == "undefined";
if (typeof on_finish != "function") {
cbn = on_finish;
on_finish = on_progress = 0;
}
on_progress = on_progress || function(percent) {
if (typeof cbn == "undefined")
return;
return update_progress(has_progress ? percent : -1, cbn);
};
on_finish = on_finish || function(res, err) {
if (typeof cbn == "undefined")
return;
return postMessage({
action: action_decompress,
cbn: cbn,
result: res,
error: err
});
};
if (sync) {
this$static.d = $LZMAByteArrayDecompressor({}, byte_arr);
while ($processChunk(this$static.d.chunker));
return decode($toByteArray(this$static.d.output));
}
try {
this$static.d = $LZMAByteArrayDecompressor({}, byte_arr);
len = toDouble(this$static.d.length_0);
///NOTE: If the data was created via a stream, it will not have a length value, and therefore we can't calculate the progress.
has_progress = len > -1;
on_progress(0);
} catch (err) {
return on_finish(null, err);
}
function do_action() {
try {
var res, i = 0, start = (new Date()).getTime();
while ($processChunk(this$static.d.chunker)) {
if (++i % 1000 == 0 && (new Date()).getTime() - start > 200) {
if (has_progress) {
percent = toDouble(this$static.d.chunker.decoder.nowPos64) / len;
/// If about 200 miliseconds have passed, update the progress.
on_progress(percent);
}
///NOTE: This allows other code to run, like the browser to update.
wait(do_action, 0);
return 0;
}
}
on_progress(1);
res = decode($toByteArray(this$static.d.output));
/// delay so we don’t catch errors from the on_finish handler
wait(on_finish.bind(null, res), 0);
} catch (err) {
on_finish(null, err);
}
}
///NOTE: We need to wait to make sure it is always async.
wait(do_action, 0);
}
/** de */
/// If we're in a Web Worker, create the onmessage() communication channel.
///NOTE: This seems to be the most reliable way to detect this.
if (typeof onmessage != "undefined" && (typeof window == "undefined" || typeof window.document == "undefined")) {
(function () {
/* jshint -W020 */
/// Create the global onmessage function.
onmessage = function (e) {
if (e && e.data) {
/// co:if (e.data.action == action_compress) {
/// co: LZMA.compress(e.data.data, e.data.mode, e.data.cbn);
/// co:}
if (e.data.action == action_decompress) {
LZMA.decompress(e.data.data, e.data.cbn);
}
}
};
}());
}
return {
/// co:compress: compress
decompress: decompress
};
}());
/// This is used by browsers that do not support web workers (and possibly Node.js).
this.LZMA = this.LZMA_WORKER = LZMA;

2
src/lzma-min.js vendored
View file

@ -1,2 +0,0 @@
//! © 2015 Nathan Rugg <nmrugg@gmail.com> | MIT
"undefined"==typeof Worker||"undefined"!=typeof location&&"file:"===location.protocol?"undefined"!=typeof global&&"undefined"!=typeof require?this.LZMA=function(n){return require(n||"./lzma_worker.js").LZMA}:"undefined"!=typeof window&&window.document?!function(){function n(n){var e;return r(n),e={compress:function(n,r,t,i){o.LZMA_WORKER?o.LZMA_WORKER.compress(n,r,t,i):setTimeout(function(){e.compress(n,r,t,i)},50)},decompress:function(n,r,t){o.LZMA_WORKER?o.LZMA_WORKER.decompress(n,r,t):setTimeout(function(){e.decompress(n,r,t)},50)},worker:function(){return null}}}var o,e=this,r=function(o){var r=document.createElement("script");r.type="text/javascript",r.src=o,r.onload=function(){e.LZMA=n},document.getElementsByTagName("head")[0].appendChild(r)};"undefined"!=typeof window?o=window:global&&(o=global),e.LZMA=n}():console.error("Can't load the worker. Sorry."):this.LZMA=function(n){var o=1,e=2,r=3,t={},i=new Worker(n||"./lzma_worker-min.js");return i.onmessage=function(n){n.data.action===r?t[n.data.cbn]&&"function"==typeof t[n.data.cbn].on_progress&&t[n.data.cbn].on_progress(n.data.result):t[n.data.cbn]&&"function"==typeof t[n.data.cbn].on_finish&&(t[n.data.cbn].on_finish(n.data.result,n.data.error),delete t[n.data.cbn])},i.onerror=function(n){var o=Error(n.message+" ("+n.filename+":"+n.lineno+")");for(var e in t)t[e].on_finish(null,o);console.error("Uncaught error in lzma_worker",o)},function(){function n(n,o,e,r,a){var c;do c=Math.floor(1e7*Math.random());while(void 0!==t[c]);t[c]={on_finish:r,on_progress:a},i.postMessage({action:n,cbn:c,data:o,mode:e})}return{compress:function(e,r,t,i){n(o,e,r,t,i)},decompress:function(o,r,t){n(e,o,!1,r,t)},worker:function(){return i}}}()};

153
src/lzma.js
View file

@ -1,153 +0,0 @@
//! © 2015 Nathan Rugg <nmrugg@gmail.com> | MIT
/// See LICENSE for more details.
// jshint bitwise:true, curly:true, eqeqeq:true, forin:true, immed:true, latedef:true, newcap:true, noarg:true, noempty:true, nonew:true, onevar:true, plusplus:true, quotmark:double, undef:true, unused:strict, browser: true, node: true
/// Does the environment support web workers? If not, let's load the worker manually (without polluting the global scope).
if (typeof Worker === "undefined" || (typeof location !== "undefined" && location.protocol === "file:")) {
/// Is this Node.js?
if (typeof global !== "undefined" && typeof require !== "undefined") {
this.LZMA = function (lzma_path) {
return require(lzma_path || "./lzma_worker.js").LZMA;
};
/// Is this a browser?
} else if (typeof window !== "undefined" && window.document) {
(function () {
var that = this,
global_var,
req = function req(path) {
var script_tag = document.createElement("script");
script_tag.type ="text/javascript";
script_tag.src = path;
script_tag.onload = function () {
/// Make sure this LZMA variable doesn't get overwritten by the worker's.
that.LZMA = non_worker_lzma;
};
document.getElementsByTagName("head")[0].appendChild(script_tag);
};
/// Determine the global variable (it's called "window" in browsers, "global" in Node.js).
if (typeof window !== "undefined") {
global_var = window;
} else if (global) {
global_var = global;
}
function non_worker_lzma(path) {
var fake_lzma;
req(path);
fake_lzma = {
compress: function compress(mixed, mode, on_finish, on_progress) {
if (global_var.LZMA_WORKER) {
global_var.LZMA_WORKER.compress(mixed, mode, on_finish, on_progress);
} else {
/// Wait
setTimeout(function ()
{
fake_lzma.compress(mixed, mode, on_finish, on_progress);
}, 50);
}
},
decompress: function decompress(byte_arr, on_finish, on_progress) {
if (global_var.LZMA_WORKER) {
global_var.LZMA_WORKER.decompress(byte_arr, on_finish, on_progress);
} else {
/// Wait
setTimeout(function ()
{
fake_lzma.decompress(byte_arr, on_finish, on_progress);
}, 50);
}
},
worker: function worker () {
return null;
}
};
return fake_lzma;
}
that.LZMA = non_worker_lzma;
}());
} else {
/// It doesn't seem to be either Node.js or a browser.
console.error("Can't load the worker. Sorry.");
}
} else {
/// Let's use Web Workers.
///NOTE: The "this" keyword is the global context ("window" variable) if loaded via a <script> tag
/// or the function context if loaded as a module (e.g., in Node.js).
this.LZMA = function (lzma_path) {
var action_compress = 1,
action_decompress = 2,
action_progress = 3,
callback_obj = {},
///NOTE: Node.js needs something like "./" or "../" at the beginning.
lzma_worker = new Worker(lzma_path || "./lzma_worker-min.js");
lzma_worker.onmessage = function onmessage(e) {
if (e.data.action === action_progress) {
if (callback_obj[e.data.cbn] && typeof callback_obj[e.data.cbn].on_progress === "function") {
callback_obj[e.data.cbn].on_progress(e.data.result);
}
} else {
if (callback_obj[e.data.cbn] && typeof callback_obj[e.data.cbn].on_finish === "function") {
callback_obj[e.data.cbn].on_finish(e.data.result, e.data.error);
/// Since the (de)compression is complete, the callbacks are no longer needed.
delete callback_obj[e.data.cbn];
}
}
};
/// Very simple error handling.
lzma_worker.onerror = function(event) {
var err = new Error(event.message + " (" + event.filename + ":" + event.lineno + ")");
for (var cbn in callback_obj) {
callback_obj[cbn].on_finish(null, err);
}
console.error('Uncaught error in lzma_worker', err);
};
return (function () {
function send_to_worker(action, data, mode, on_finish, on_progress) {
var cbn;
do {
cbn = Math.floor(Math.random() * (10000000));
} while(typeof callback_obj[cbn] !== "undefined");
callback_obj[cbn] = {
on_finish: on_finish,
on_progress: on_progress
};
lzma_worker.postMessage({
action: action, /// action_compress = 1, action_decompress = 2, action_progress = 3
cbn: cbn, /// callback number
data: data,
mode: mode
});
}
return {
compress: function compress(mixed, mode, on_finish, on_progress) {
send_to_worker(action_compress, mixed, mode, on_finish, on_progress);
},
decompress: function decompress(byte_arr, on_finish, on_progress) {
send_to_worker(action_decompress, byte_arr, false, on_finish, on_progress);
},
worker: function worker() {
return lzma_worker;
}
};
}());
};
}

2668
src/lzma_worker.js
View file

File diff suppressed because it is too large Load diff