diff --git a/README b/README index 95f2867..ccd8ed0 100644 --- a/README +++ b/README @@ -53,7 +53,7 @@ Documentation `cb` - The callback function to invoke when the tags are loaded. `options` - Optional parameters. `options.tags` - The array of tags and/or shortcuts to read from the ID3 block. Default value is: `["title", "artist", "album", "track"]` - `options.dataReader` - The function used to create the data reader out of a url. It receives (`url`, `success`: callback function that returns the data reader, `fail`: callback function to inform an error setting up the reader). By default it will be BufferedBinaryAjax. + `options.dataReader` - The function used to create the data reader out of a url. It receives (`url`, `success`: callback function that returns the data reader, `fail`: callback function to inform an error setting up the reader). `ID3.getAllTags(url)` `url` - The URL of the mp3 file to read, this must be the same value given to `ID3.loadTags()`. diff --git a/builder/JSBuilder.py b/builder/JSBuilder.py new file mode 100644 index 0000000..128c32c --- /dev/null +++ b/builder/JSBuilder.py @@ -0,0 +1,91 @@ +# python builder by Andrea Giammarchi +# Mit Style License +# Note: this is not "extreme performances oriented" Python code +# it should work on Python 2.6+ tho +import gzip, os, sys, string, re + +# I know this sucks but it kinda worked cross .py version ... +def fullPath(file): + i = len(os.path.split(sys.argv[0])[-1:][0]) + return os.path.realpath(os.path.join(os.getcwd(), sys.argv[0][:-i], file)) + +# this could be surely optimized ... +def getSize(file): + i = 0 + sufix = ['bytes', 'Kb', 'Mb'] + size = os.path.getsize(fullPath(file)) + while 1023.0 < size: + size = size / 1024.0 + i = i + 1 + return str(round(size, 2)) + ' ' + sufix[i] + +# this is a handy shortcut ... +def read(file): + f = open(fullPath(file), 'r') + content = f.read() + f.close() + return content + +# ... as well as this one +def write(file, content): + f = open(fullPath(file), 'w') + f.write(content) + f.close() + +# well ... this simply works as well :-D +def compile(copyright, fullName, minName, files, search=None, replace=None): + + # create a copyright compatible with both YUICompressor and Google Closure Compiler + multiCopyright = "\n".join([ + '/**'+ copyright+'*/\n' + ]) + + #copy the list temporarely + files = files[:] + + # read all files + for i in range(len(files)): + files[i] = read('../' + 'src/' + files[i]) + + # address the whole content + content = multiCopyright + "\n".join(files) + files = [] # just in case ... + + # replace something if necessary + if search != None: + for i in range(len(search)): + content = string.replace(content, search[i], replace[i]) + + # strip out code that should not be in the minified version + cleanContent = re.sub(r'//\^[^\x00]*?//\$[^\n\r]+', '', content) + + # write the whole (cleaned) content + write('../' + fullName, cleanContent) + + # MINIFY! + + # YUICompressor [faster, less greedy, bigger size] + # os.system('java -jar "' + fullPath('jar/yuicompressor-2.4.6.jar') + '" --type=js "' + fullPath('../' + fullName) + '" -o "' + fullPath('../' + minName) + '"') + + # Uglify JS [good performances, mediumly greedy, medium size] + # os.system('java -jar "' + fullPath('jar/js.jar') + '" "' + fullPath('uglify-js/exec.js') + '" "' + fullPath('uglify-js/uglify.js') + '" "' + fullPath('../' + fullName) + '" "' + copyright + '" > "' + fullPath('../' + minName) + '"') + + # Google Closure Compiler [slowest, more greedy, smaller size] + os.system('java -jar "' + fullPath('jar/compiler.jar') + '" --compilation_level=ADVANCED_OPTIMIZATIONS --language_in ECMASCRIPT5_STRICT --js "' + fullPath('../' + fullName) + '" --js_output_file "' + fullPath('../' + minName) + '"') + + # put back code that should have not been included in the minified version + write('../' + fullName, content) + + # create the gzip version + content = read('../' + minName) + tmp = gzip.open(fullPath('../' + minName + '.gz'), 'w') + tmp.write(content) + tmp.close() + + # print out the result of all precedent operations + print('Full size: ' + getSize('../' + fullName)) + print('Minified size: ' + getSize('../' + minName)) + print('Min + Gzip size: ' + getSize('../' + minName + '.gz')) + + # remove the gzipped version + os.remove(fullPath('../' + minName + '.gz')) diff --git a/builder/build.py b/builder/build.py new file mode 100644 index 0000000..dc51a92 --- /dev/null +++ b/builder/build.py @@ -0,0 +1,32 @@ +# JSBuilder example + +# project name (from the root folder) +copyright = '' +max_js = 'dist/id3.js' +min_js = 'dist/id3.min.js' + +# file list (from the root/src folder) +files = [ + "stringutils.js", + "binaryfile.js", + "filereader.js", + "base64.js", + "id3.js", + "id3v1.js", + "id3v2.js", + "id3v2frames.js", + "id4.js" +] + +# execute the task +import JSBuilder +JSBuilder.compile( + copyright, + max_js, + min_js, + files +) + +# let me read the result ... +import time +time.sleep(2) \ No newline at end of file diff --git a/builder/jar/compiler.jar b/builder/jar/compiler.jar new file mode 100644 index 0000000..09ac825 Binary files /dev/null and b/builder/jar/compiler.jar differ diff --git a/builder/jar/js.jar b/builder/jar/js.jar new file mode 100644 index 0000000..878b0d9 Binary files /dev/null and b/builder/jar/js.jar differ diff --git a/builder/jar/yuicompressor-2.4.6.jar b/builder/jar/yuicompressor-2.4.6.jar new file mode 100644 index 0000000..61f6318 Binary files /dev/null and b/builder/jar/yuicompressor-2.4.6.jar differ diff --git a/builder/uglify-js/exec.js b/builder/uglify-js/exec.js new file mode 100644 index 0000000..9962849 --- /dev/null +++ b/builder/uglify-js/exec.js @@ -0,0 +1,3 @@ +// readFile("tmp.js") +load(arguments[0]); +print("/*" + arguments[2] + "*/" + Uglify.uglify(readFile(arguments[1]))) \ No newline at end of file diff --git a/builder/uglify-js/uglify.js b/builder/uglify-js/uglify.js new file mode 100644 index 0000000..7dedfc3 --- /dev/null +++ b/builder/uglify-js/uglify.js @@ -0,0 +1,3022 @@ +var Uglify = {}; + +(function () { + /*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + + This version is suitable for Node.js. With minimal changes (the + exports stuff) it should work on any JS platform. + + This file contains the tokenizer/parser. It is a port to JavaScript + of parse-js [1], a JavaScript parser library written in Common Lisp + by Marijn Haverbeke. Thank you Marijn! + + [1] http://marijn.haverbeke.nl/parse-js/ + + Exported functions: + + - tokenizer(code) -- returns a function. Call the returned + function to fetch the next token. + + - parse(code) -- returns an AST of the given JavaScript code. + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2010 (c) Mihai Bazon + Based on parse-js (http://marijn.haverbeke.nl/parse-js/). + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + + /* -----[ Tokenizer (constants) ]----- */ + + var KEYWORDS = array_to_hash([ + "break", + "case", + "catch", + "const", + "continue", + "default", + "delete", + "do", + "else", + "finally", + "for", + "function", + "if", + "in", + "instanceof", + "new", + "return", + "switch", + "throw", + "try", + "typeof", + "var", + "void", + "while", + "with" + ]); + + var RESERVED_WORDS = array_to_hash([ + "abstract", + "boolean", + "byte", + "char", + "class", + "debugger", + "double", + "enum", + "export", + "extends", + "final", + "float", + "goto", + "implements", + "import", + "int", + "interface", + "long", + "native", + "package", + "private", + "protected", + "public", + "short", + "static", + "super", + "synchronized", + "throws", + "transient", + "volatile" + ]); + + var KEYWORDS_BEFORE_EXPRESSION = array_to_hash([ + "return", + "new", + "delete", + "throw", + "else", + "case" + ]); + + var KEYWORDS_ATOM = array_to_hash([ + "false", + "null", + "true", + "undefined" + ]); + + var OPERATOR_CHARS = array_to_hash(characters("+-*&%=<>!?|~^")); + + var RE_HEX_NUMBER = /^0x[0-9a-f]+$/i; + var RE_OCT_NUMBER = /^0[0-7]+$/; + var RE_DEC_NUMBER = /^\d*\.?\d*(?:e[+-]?\d*(?:\d\.?|\.?\d)\d*)?$/i; + + var OPERATORS = array_to_hash([ + "in", + "instanceof", + "typeof", + "new", + "void", + "delete", + "++", + "--", + "+", + "-", + "!", + "~", + "&", + "|", + "^", + "*", + "/", + "%", + ">>", + "<<", + ">>>", + "<", + ">", + "<=", + ">=", + "==", + "===", + "!=", + "!==", + "?", + "=", + "+=", + "-=", + "/=", + "*=", + "%=", + ">>=", + "<<=", + ">>>=", + "|=", + "^=", + "&=", + "&&", + "||" + ]); + + var WHITESPACE_CHARS = array_to_hash(characters(" \u00a0\n\r\t\f\v\u200b")); + + var PUNC_BEFORE_EXPRESSION = array_to_hash(characters("[{}(,.;:")); + + var PUNC_CHARS = array_to_hash(characters("[]{}(),;:")); + + var REGEXP_MODIFIERS = array_to_hash(characters("gmsiy")); + + /* -----[ Tokenizer ]----- */ + + // regexps adapted from http://xregexp.com/plugins/#unicode + var UNICODE = { + letter: new RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0523\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971\\u0972\\u097B-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D3D\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC\\u0EDD\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8B\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10D0-\\u10FA\\u10FC\\u1100-\\u1159\\u115F-\\u11A2\\u11A8-\\u11F9\\u1200-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u1676\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19A9\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u2094\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2C6F\\u2C71-\\u2C7D\\u2C80-\\u2CE4\\u2D00-\\u2D25\\u2D30-\\u2D65\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31B7\\u31F0-\\u31FF\\u3400\\u4DB5\\u4E00\\u9FC3\\uA000-\\uA48C\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA65F\\uA662-\\uA66E\\uA67F-\\uA697\\uA717-\\uA71F\\uA722-\\uA788\\uA78B\\uA78C\\uA7FB-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA90A-\\uA925\\uA930-\\uA946\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAC00\\uD7A3\\uF900-\\uFA2D\\uFA30-\\uFA6A\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]"), + non_spacing_mark: new RegExp("[\\u0300-\\u036F\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065E\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0900-\\u0902\\u093C\\u0941-\\u0948\\u094D\\u0951-\\u0955\\u0962\\u0963\\u0981\\u09BC\\u09C1-\\u09C4\\u09CD\\u09E2\\u09E3\\u0A01\\u0A02\\u0A3C\\u0A41\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81\\u0A82\\u0ABC\\u0AC1-\\u0AC5\\u0AC7\\u0AC8\\u0ACD\\u0AE2\\u0AE3\\u0B01\\u0B3C\\u0B3F\\u0B41-\\u0B44\\u0B4D\\u0B56\\u0B62\\u0B63\\u0B82\\u0BC0\\u0BCD\\u0C3E-\\u0C40\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0CBC\\u0CBF\\u0CC6\\u0CCC\\u0CCD\\u0CE2\\u0CE3\\u0D41-\\u0D44\\u0D4D\\u0D62\\u0D63\\u0DCA\\u0DD2-\\u0DD4\\u0DD6\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F71-\\u0F7E\\u0F80-\\u0F84\\u0F86\\u0F87\\u0F90-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102D-\\u1030\\u1032-\\u1037\\u1039\\u103A\\u103D\\u103E\\u1058\\u1059\\u105E-\\u1060\\u1071-\\u1074\\u1082\\u1085\\u1086\\u108D\\u109D\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B7-\\u17BD\\u17C6\\u17C9-\\u17D3\\u17DD\\u180B-\\u180D\\u18A9\\u1920-\\u1922\\u1927\\u1928\\u1932\\u1939-\\u193B\\u1A17\\u1A18\\u1A56\\u1A58-\\u1A5E\\u1A60\\u1A62\\u1A65-\\u1A6C\\u1A73-\\u1A7C\\u1A7F\\u1B00-\\u1B03\\u1B34\\u1B36-\\u1B3A\\u1B3C\\u1B42\\u1B6B-\\u1B73\\u1B80\\u1B81\\u1BA2-\\u1BA5\\u1BA8\\u1BA9\\u1C2C-\\u1C33\\u1C36\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE0\\u1CE2-\\u1CE8\\u1CED\\u1DC0-\\u1DE6\\u1DFD-\\u1DFF\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F\\uA67C\\uA67D\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA825\\uA826\\uA8C4\\uA8E0-\\uA8F1\\uA926-\\uA92D\\uA947-\\uA951\\uA980-\\uA982\\uA9B3\\uA9B6-\\uA9B9\\uA9BC\\uAA29-\\uAA2E\\uAA31\\uAA32\\uAA35\\uAA36\\uAA43\\uAA4C\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uABE5\\uABE8\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE26]"), + space_combining_mark: new RegExp("[\\u0903\\u093E-\\u0940\\u0949-\\u094C\\u094E\\u0982\\u0983\\u09BE-\\u09C0\\u09C7\\u09C8\\u09CB\\u09CC\\u09D7\\u0A03\\u0A3E-\\u0A40\\u0A83\\u0ABE-\\u0AC0\\u0AC9\\u0ACB\\u0ACC\\u0B02\\u0B03\\u0B3E\\u0B40\\u0B47\\u0B48\\u0B4B\\u0B4C\\u0B57\\u0BBE\\u0BBF\\u0BC1\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCC\\u0BD7\\u0C01-\\u0C03\\u0C41-\\u0C44\\u0C82\\u0C83\\u0CBE\\u0CC0-\\u0CC4\\u0CC7\\u0CC8\\u0CCA\\u0CCB\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D40\\u0D46-\\u0D48\\u0D4A-\\u0D4C\\u0D57\\u0D82\\u0D83\\u0DCF-\\u0DD1\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0F3E\\u0F3F\\u0F7F\\u102B\\u102C\\u1031\\u1038\\u103B\\u103C\\u1056\\u1057\\u1062-\\u1064\\u1067-\\u106D\\u1083\\u1084\\u1087-\\u108C\\u108F\\u109A-\\u109C\\u17B6\\u17BE-\\u17C5\\u17C7\\u17C8\\u1923-\\u1926\\u1929-\\u192B\\u1930\\u1931\\u1933-\\u1938\\u19B0-\\u19C0\\u19C8\\u19C9\\u1A19-\\u1A1B\\u1A55\\u1A57\\u1A61\\u1A63\\u1A64\\u1A6D-\\u1A72\\u1B04\\u1B35\\u1B3B\\u1B3D-\\u1B41\\u1B43\\u1B44\\u1B82\\u1BA1\\u1BA6\\u1BA7\\u1BAA\\u1C24-\\u1C2B\\u1C34\\u1C35\\u1CE1\\u1CF2\\uA823\\uA824\\uA827\\uA880\\uA881\\uA8B4-\\uA8C3\\uA952\\uA953\\uA983\\uA9B4\\uA9B5\\uA9BA\\uA9BB\\uA9BD-\\uA9C0\\uAA2F\\uAA30\\uAA33\\uAA34\\uAA4D\\uAA7B\\uABE3\\uABE4\\uABE6\\uABE7\\uABE9\\uABEA\\uABEC]"), + connector_punctuation: new RegExp("[\\u005F\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F]") + }; + + function is_letter(ch) { + return UNICODE.letter.test(ch); + }; + + function is_digit(ch) { + ch = ch.charCodeAt(0); + return ch >= 48 && ch <= 57; //XXX: find out if "UnicodeDigit" means something else than 0..9 + }; + + function is_alphanumeric_char(ch) { + return is_digit(ch) || is_letter(ch); + }; + + function is_unicode_combining_mark(ch) { + return UNICODE.non_spacing_mark.test(ch) || UNICODE.space_combining_mark.test(ch); + }; + + function is_unicode_connector_punctuation(ch) { + return UNICODE.connector_punctuation.test(ch); + }; + + function is_identifier_start(ch) { + return ch == "$" || ch == "_" || is_letter(ch); + }; + + function is_identifier_char(ch) { + return is_identifier_start(ch) + || is_unicode_combining_mark(ch) + || is_digit(ch) + || is_unicode_connector_punctuation(ch) + || ch == "\u200c" // zero-width non-joiner + || ch == "\u200d" // zero-width joiner (in my ECMA-262 PDF, this is also 200c) + ; + }; + + function parse_js_number(num) { + if (RE_HEX_NUMBER.test(num)) { + return parseInt(num.substr(2), 16); + } else if (RE_OCT_NUMBER.test(num)) { + return parseInt(num.substr(1), 8); + } else if (RE_DEC_NUMBER.test(num)) { + return parseFloat(num); + } + }; + + function JS_Parse_Error(message, line, col, pos) { + this.message = message; + this.line = line; + this.col = col; + this.pos = pos; + try { + ({})(); + } catch(ex) { + this.stack = ex.stack; + }; + }; + + JS_Parse_Error.prototype.toString = function() { + return this.message + " (line: " + this.line + ", col: " + this.col + ", pos: " + this.pos + ")" + "\n\n" + this.stack; + }; + + function js_error(message, line, col, pos) { + throw new JS_Parse_Error(message, line, col, pos); + }; + + function is_token(token, type, val) { + return token.type == type && (val == null || token.value == val); + }; + + var EX_EOF = {}; + + function tokenizer($TEXT) { + + var S = { + text : $TEXT.replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, ''), + pos : 0, + tokpos : 0, + line : 0, + tokline : 0, + col : 0, + tokcol : 0, + newline_before : false, + regex_allowed : false, + comments_before : [] + }; + + function peek() { return S.text.charAt(S.pos); }; + + function next(signal_eof) { + var ch = S.text.charAt(S.pos++); + if (signal_eof && !ch) + throw EX_EOF; + if (ch == "\n") { + S.newline_before = true; + ++S.line; + S.col = 0; + } else { + ++S.col; + } + return ch; + }; + + function eof() { + return !S.peek(); + }; + + function find(what, signal_eof) { + var pos = S.text.indexOf(what, S.pos); + if (signal_eof && pos == -1) throw EX_EOF; + return pos; + }; + + function start_token() { + S.tokline = S.line; + S.tokcol = S.col; + S.tokpos = S.pos; + }; + + function token(type, value, is_comment) { + S.regex_allowed = ((type == "operator" && !HOP(UNARY_POSTFIX, value)) || + (type == "keyword" && HOP(KEYWORDS_BEFORE_EXPRESSION, value)) || + (type == "punc" && HOP(PUNC_BEFORE_EXPRESSION, value))); + var ret = { + type : type, + value : value, + line : S.tokline, + col : S.tokcol, + pos : S.tokpos, + nlb : S.newline_before + }; + if (!is_comment) { + ret.comments_before = S.comments_before; + S.comments_before = []; + } + S.newline_before = false; + return ret; + }; + + function skip_whitespace() { + while (HOP(WHITESPACE_CHARS, peek())) + next(); + }; + + function read_while(pred) { + var ret = "", ch = peek(), i = 0; + while (ch && pred(ch, i++)) { + ret += next(); + ch = peek(); + } + return ret; + }; + + function parse_error(err) { + js_error(err, S.tokline, S.tokcol, S.tokpos); + }; + + function read_num(prefix) { + var has_e = false, after_e = false, has_x = false, has_dot = prefix == "."; + var num = read_while(function(ch, i){ + if (ch == "x" || ch == "X") { + if (has_x) return false; + return has_x = true; + } + if (!has_x && (ch == "E" || ch == "e")) { + if (has_e) return false; + return has_e = after_e = true; + } + if (ch == "-") { + if (after_e || (i == 0 && !prefix)) return true; + return false; + } + if (ch == "+") return after_e; + after_e = false; + if (ch == ".") { + if (!has_dot && !has_x) + return has_dot = true; + return false; + } + return is_alphanumeric_char(ch); + }); + if (prefix) + num = prefix + num; + var valid = parse_js_number(num); + if (!isNaN(valid)) { + return token("num", valid); + } else { + parse_error("Invalid syntax: " + num); + } + }; + + function read_escaped_char() { + var ch = next(true); + switch (ch) { + case "n" : return "\n"; + case "r" : return "\r"; + case "t" : return "\t"; + case "b" : return "\b"; + case "v" : return "\v"; + case "f" : return "\f"; + case "0" : return "\0"; + case "x" : return String.fromCharCode(hex_bytes(2)); + case "u" : return String.fromCharCode(hex_bytes(4)); + default : return ch; + } + }; + + function hex_bytes(n) { + var num = 0; + for (; n > 0; --n) { + var digit = parseInt(next(true), 16); + if (isNaN(digit)) + parse_error("Invalid hex-character pattern in string"); + num = (num << 4) | digit; + } + return num; + }; + + function read_string() { + return with_eof_error("Unterminated string constant", function(){ + var quote = next(), ret = ""; + for (;;) { + var ch = next(true); + if (ch == "\\") ch = read_escaped_char(); + else if (ch == quote) break; + ret += ch; + } + return token("string", ret); + }); + }; + + function read_line_comment() { + next(); + var i = find("\n"), ret; + if (i == -1) { + ret = S.text.substr(S.pos); + S.pos = S.text.length; + } else { + ret = S.text.substring(S.pos, i); + S.pos = i; + } + return token("comment1", ret, true); + }; + + function read_multiline_comment() { + next(); + return with_eof_error("Unterminated multiline comment", function(){ + var i = find("*/", true), + text = S.text.substring(S.pos, i), + tok = token("comment2", text, true); + S.pos = i + 2; + S.line += text.split("\n").length - 1; + S.newline_before = text.indexOf("\n") >= 0; + + // https://github.com/mishoo/UglifyJS/issues/#issue/100 + if (/^@cc_on/i.test(text)) { + warn("WARNING: at line " + S.line); + warn("*** Found \"conditional comment\": " + text); + warn("*** UglifyJS DISCARDS ALL COMMENTS. This means your code might no longer work properly in Internet Explorer."); + } + + return tok; + }); + }; + + function read_name() { + var backslash = false, name = "", ch; + while ((ch = peek()) != null) { + if (!backslash) { + if (ch == "\\") backslash = true, next(); + else if (is_identifier_char(ch)) name += next(); + else break; + } + else { + if (ch != "u") parse_error("Expecting UnicodeEscapeSequence -- uXXXX"); + ch = read_escaped_char(); + if (!is_identifier_char(ch)) parse_error("Unicode char: " + ch.charCodeAt(0) + " is not valid in identifier"); + name += ch; + backslash = false; + } + } + return name; + }; + + function read_regexp() { + return with_eof_error("Unterminated regular expression", function(){ + var prev_backslash = false, regexp = "", ch, in_class = false; + while ((ch = next(true))) if (prev_backslash) { + regexp += "\\" + ch; + prev_backslash = false; + } else if (ch == "[") { + in_class = true; + regexp += ch; + } else if (ch == "]" && in_class) { + in_class = false; + regexp += ch; + } else if (ch == "/" && !in_class) { + break; + } else if (ch == "\\") { + prev_backslash = true; + } else { + regexp += ch; + } + var mods = read_name(); + return token("regexp", [ regexp, mods ]); + }); + }; + + function read_operator(prefix) { + function grow(op) { + if (!peek()) return op; + var bigger = op + peek(); + if (HOP(OPERATORS, bigger)) { + next(); + return grow(bigger); + } else { + return op; + } + }; + return token("operator", grow(prefix || next())); + }; + + function handle_slash() { + next(); + var regex_allowed = S.regex_allowed; + switch (peek()) { + case "/": + S.comments_before.push(read_line_comment()); + S.regex_allowed = regex_allowed; + return next_token(); + case "*": + S.comments_before.push(read_multiline_comment()); + S.regex_allowed = regex_allowed; + return next_token(); + } + return S.regex_allowed ? read_regexp() : read_operator("/"); + }; + + function handle_dot() { + next(); + return is_digit(peek()) + ? read_num(".") + : token("punc", "."); + }; + + function read_word() { + var word = read_name(); + return !HOP(KEYWORDS, word) + ? token("name", word) + : HOP(OPERATORS, word) + ? token("operator", word) + : HOP(KEYWORDS_ATOM, word) + ? token("atom", word) + : token("keyword", word); + }; + + function with_eof_error(eof_error, cont) { + try { + return cont(); + } catch(ex) { + if (ex === EX_EOF) parse_error(eof_error); + else throw ex; + } + }; + + function next_token(force_regexp) { + if (force_regexp) + return read_regexp(); + skip_whitespace(); + start_token(); + var ch = peek(); + if (!ch) return token("eof"); + if (is_digit(ch)) return read_num(); + if (ch == '"' || ch == "'") return read_string(); + if (HOP(PUNC_CHARS, ch)) return token("punc", next()); + if (ch == ".") return handle_dot(); + if (ch == "/") return handle_slash(); + if (HOP(OPERATOR_CHARS, ch)) return read_operator(); + if (ch == "\\" || is_identifier_start(ch)) return read_word(); + parse_error("Unexpected character '" + ch + "'"); + }; + + next_token.context = function(nc) { + if (nc) S = nc; + return S; + }; + + return next_token; + + }; + + /* -----[ Parser (constants) ]----- */ + + var UNARY_PREFIX = array_to_hash([ + "typeof", + "void", + "delete", + "--", + "++", + "!", + "~", + "-", + "+" + ]); + + var UNARY_POSTFIX = array_to_hash([ "--", "++" ]); + + var ASSIGNMENT = (function(a, ret, i){ + while (i < a.length) { + ret[a[i]] = a[i].substr(0, a[i].length - 1); + i++; + } + return ret; + })( + ["+=", "-=", "/=", "*=", "%=", ">>=", "<<=", ">>>=", "|=", "^=", "&="], + { "=": true }, + 0 + ); + + var PRECEDENCE = (function(a, ret){ + for (var i = 0, n = 1; i < a.length; ++i, ++n) { + var b = a[i]; + for (var j = 0; j < b.length; ++j) { + ret[b[j]] = n; + } + } + return ret; + })( + [ + ["||"], + ["&&"], + ["|"], + ["^"], + ["&"], + ["==", "===", "!=", "!=="], + ["<", ">", "<=", ">=", "in", "instanceof"], + [">>", "<<", ">>>"], + ["+", "-"], + ["*", "/", "%"] + ], + {} + ); + + var STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ]); + + var ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "string", "regexp", "name" ]); + + /* -----[ Parser ]----- */ + + function NodeWithToken(str, start, end) { + this.name = str; + this.start = start; + this.end = end; + }; + + NodeWithToken.prototype.toString = function() { return this.name; }; + + function parse($TEXT, exigent_mode, embed_tokens) { + + var S = { + input : typeof $TEXT == "string" ? tokenizer($TEXT, true) : $TEXT, + token : null, + prev : null, + peeked : null, + in_function : 0, + in_loop : 0, + labels : [] + }; + + S.token = next(); + + function is(type, value) { + return is_token(S.token, type, value); + }; + + function peek() { return S.peeked || (S.peeked = S.input()); }; + + function next() { + S.prev = S.token; + if (S.peeked) { + S.token = S.peeked; + S.peeked = null; + } else { + S.token = S.input(); + } + return S.token; + }; + + function prev() { + return S.prev; + }; + + function croak(msg, line, col, pos) { + var ctx = S.input.context(); + js_error(msg, + line != null ? line : ctx.tokline, + col != null ? col : ctx.tokcol, + pos != null ? pos : ctx.tokpos); + }; + + function token_error(token, msg) { + croak(msg, token.line, token.col); + }; + + function unexpected(token) { + if (token == null) + token = S.token; + token_error(token, "Unexpected token: " + token.type + " (" + token.value + ")"); + }; + + function expect_token(type, val) { + if (is(type, val)) { + return next(); + } + token_error(S.token, "Unexpected token " + S.token.type + ", expected " + type); + }; + + function expect(punc) { return expect_token("punc", punc); }; + + function can_insert_semicolon() { + return !exigent_mode && ( + S.token.nlb || is("eof") || is("punc", "}") + ); + }; + + function semicolon() { + if (is("punc", ";")) next(); + else if (!can_insert_semicolon()) unexpected(); + }; + + function as() { + return slice(arguments); + }; + + function parenthesised() { + expect("("); + var ex = expression(); + expect(")"); + return ex; + }; + + function add_tokens(str, start, end) { + return str instanceof NodeWithToken ? str : new NodeWithToken(str, start, end); + }; + + function maybe_embed_tokens(parser) { + if (embed_tokens) return function() { + var start = S.token; + var ast = parser.apply(this, arguments); + ast[0] = add_tokens(ast[0], start, prev()); + return ast; + }; + else return parser; + }; + + var statement = maybe_embed_tokens(function() { + if (is("operator", "/")) { + S.peeked = null; + S.token = S.input(true); // force regexp + } + switch (S.token.type) { + case "num": + case "string": + case "regexp": + case "operator": + case "atom": + return simple_statement(); + + case "name": + return is_token(peek(), "punc", ":") + ? labeled_statement(prog1(S.token.value, next, next)) + : simple_statement(); + + case "punc": + switch (S.token.value) { + case "{": + return as("block", block_()); + case "[": + case "(": + return simple_statement(); + case ";": + next(); + return as("block"); + default: + unexpected(); + } + + case "keyword": + switch (prog1(S.token.value, next)) { + case "break": + return break_cont("break"); + + case "continue": + return break_cont("continue"); + + case "debugger": + semicolon(); + return as("debugger"); + + case "do": + return (function(body){ + expect_token("keyword", "while"); + return as("do", prog1(parenthesised, semicolon), body); + })(in_loop(statement)); + + case "for": + return for_(); + + case "function": + return function_(true); + + case "if": + return if_(); + + case "return": + if (S.in_function == 0) + croak("'return' outside of function"); + return as("return", + is("punc", ";") + ? (next(), null) + : can_insert_semicolon() + ? null + : prog1(expression, semicolon)); + + case "switch": + return as("switch", parenthesised(), switch_block_()); + + case "throw": + return as("throw", prog1(expression, semicolon)); + + case "try": + return try_(); + + case "var": + return prog1(var_, semicolon); + + case "const": + return prog1(const_, semicolon); + + case "while": + return as("while", parenthesised(), in_loop(statement)); + + case "with": + return as("with", parenthesised(), statement()); + + default: + unexpected(); + } + } + }); + + function labeled_statement(label) { + S.labels.push(label); + var start = S.token, stat = statement(); + if (exigent_mode && !HOP(STATEMENTS_WITH_LABELS, stat[0])) + unexpected(start); + S.labels.pop(); + return as("label", label, stat); + }; + + function simple_statement() { + return as("stat", prog1(expression, semicolon)); + }; + + function break_cont(type) { + var name; + if (!can_insert_semicolon()) { + name = is("name") ? S.token.value : null; + } + if (name != null) { + next(); + if (!member(name, S.labels)) + croak("Label " + name + " without matching loop or statement"); + } + else if (S.in_loop == 0) + croak(type + " not inside a loop or switch"); + semicolon(); + return as(type, name); + }; + + function for_() { + expect("("); + var init = null; + if (!is("punc", ";")) { + init = is("keyword", "var") + ? (next(), var_(true)) + : expression(true, true); + if (is("operator", "in")) + return for_in(init); + } + return regular_for(init); + }; + + function regular_for(init) { + expect(";"); + var test = is("punc", ";") ? null : expression(); + expect(";"); + var step = is("punc", ")") ? null : expression(); + expect(")"); + return as("for", init, test, step, in_loop(statement)); + }; + + function for_in(init) { + var lhs = init[0] == "var" ? as("name", init[1][0]) : init; + next(); + var obj = expression(); + expect(")"); + return as("for-in", init, lhs, obj, in_loop(statement)); + }; + + var function_ = maybe_embed_tokens(function(in_statement) { + var name = is("name") ? prog1(S.token.value, next) : null; + if (in_statement && !name) + unexpected(); + expect("("); + return as(in_statement ? "defun" : "function", + name, + // arguments + (function(first, a){ + while (!is("punc", ")")) { + if (first) first = false; else expect(","); + if (!is("name")) unexpected(); + a.push(S.token.value); + next(); + } + next(); + return a; + })(true, []), + // body + (function(){ + ++S.in_function; + var loop = S.in_loop; + S.in_loop = 0; + var a = block_(); + --S.in_function; + S.in_loop = loop; + return a; + })()); + }); + + function if_() { + var cond = parenthesised(), body = statement(), belse; + if (is("keyword", "else")) { + next(); + belse = statement(); + } + return as("if", cond, body, belse); + }; + + function block_() { + expect("{"); + var a = []; + while (!is("punc", "}")) { + if (is("eof")) unexpected(); + a.push(statement()); + } + next(); + return a; + }; + + var switch_block_ = curry(in_loop, function(){ + expect("{"); + var a = [], cur = null; + while (!is("punc", "}")) { + if (is("eof")) unexpected(); + if (is("keyword", "case")) { + next(); + cur = []; + a.push([ expression(), cur ]); + expect(":"); + } + else if (is("keyword", "default")) { + next(); + expect(":"); + cur = []; + a.push([ null, cur ]); + } + else { + if (!cur) unexpected(); + cur.push(statement()); + } + } + next(); + return a; + }); + + function try_() { + var body = block_(), bcatch, bfinally; + if (is("keyword", "catch")) { + next(); + expect("("); + if (!is("name")) + croak("Name expected"); + var name = S.token.value; + next(); + expect(")"); + bcatch = [ name, block_() ]; + } + if (is("keyword", "finally")) { + next(); + bfinally = block_(); + } + if (!bcatch && !bfinally) + croak("Missing catch/finally blocks"); + return as("try", body, bcatch, bfinally); + }; + + function vardefs(no_in) { + var a = []; + for (;;) { + if (!is("name")) + unexpected(); + var name = S.token.value; + next(); + if (is("operator", "=")) { + next(); + a.push([ name, expression(false, no_in) ]); + } else { + a.push([ name ]); + } + if (!is("punc", ",")) + break; + next(); + } + return a; + }; + + function var_(no_in) { + return as("var", vardefs(no_in)); + }; + + function const_() { + return as("const", vardefs()); + }; + + function new_() { + var newexp = expr_atom(false), args; + if (is("punc", "(")) { + next(); + args = expr_list(")"); + } else { + args = []; + } + return subscripts(as("new", newexp, args), true); + }; + + var expr_atom = maybe_embed_tokens(function(allow_calls) { + if (is("operator", "new")) { + next(); + return new_(); + } + if (is("operator") && HOP(UNARY_PREFIX, S.token.value)) { + return make_unary("unary-prefix", + prog1(S.token.value, next), + expr_atom(allow_calls)); + } + if (is("punc")) { + switch (S.token.value) { + case "(": + next(); + return subscripts(prog1(expression, curry(expect, ")")), allow_calls); + case "[": + next(); + return subscripts(array_(), allow_calls); + case "{": + next(); + return subscripts(object_(), allow_calls); + } + unexpected(); + } + if (is("keyword", "function")) { + next(); + return subscripts(function_(false), allow_calls); + } + if (HOP(ATOMIC_START_TOKEN, S.token.type)) { + var atom = S.token.type == "regexp" + ? as("regexp", S.token.value[0], S.token.value[1]) + : as(S.token.type, S.token.value); + return subscripts(prog1(atom, next), allow_calls); + } + unexpected(); + }); + + function expr_list(closing, allow_trailing_comma, allow_empty) { + var first = true, a = []; + while (!is("punc", closing)) { + if (first) first = false; else expect(","); + if (allow_trailing_comma && is("punc", closing)) break; + if (is("punc", ",") && allow_empty) { + a.push([ "atom", "undefined" ]); + } else { + a.push(expression(false)); + } + } + next(); + return a; + }; + + function array_() { + return as("array", expr_list("]", !exigent_mode, true)); + }; + + function object_() { + var first = true, a = []; + while (!is("punc", "}")) { + if (first) first = false; else expect(","); + if (!exigent_mode && is("punc", "}")) + // allow trailing comma + break; + var type = S.token.type; + var name = as_property_name(); + if (type == "name" && (name == "get" || name == "set") && !is("punc", ":")) { + a.push([ as_name(), function_(false), name ]); + } else { + expect(":"); + a.push([ name, expression(false) ]); + } + } + next(); + return as("object", a); + }; + + function as_property_name() { + switch (S.token.type) { + case "num": + case "string": + return prog1(S.token.value, next); + } + return as_name(); + }; + + function as_name() { + switch (S.token.type) { + case "name": + case "operator": + case "keyword": + case "atom": + return prog1(S.token.value, next); + default: + unexpected(); + } + }; + + function subscripts(expr, allow_calls) { + if (is("punc", ".")) { + next(); + return subscripts(as("dot", expr, as_name()), allow_calls); + } + if (is("punc", "[")) { + next(); + return subscripts(as("sub", expr, prog1(expression, curry(expect, "]"))), allow_calls); + } + if (allow_calls && is("punc", "(")) { + next(); + return subscripts(as("call", expr, expr_list(")")), true); + } + if (allow_calls && is("operator") && HOP(UNARY_POSTFIX, S.token.value)) { + return prog1(curry(make_unary, "unary-postfix", S.token.value, expr), + next); + } + return expr; + }; + + function make_unary(tag, op, expr) { + if ((op == "++" || op == "--") && !is_assignable(expr)) + croak("Invalid use of " + op + " operator"); + return as(tag, op, expr); + }; + + function expr_op(left, min_prec, no_in) { + var op = is("operator") ? S.token.value : null; + if (op && op == "in" && no_in) op = null; + var prec = op != null ? PRECEDENCE[op] : null; + if (prec != null && prec > min_prec) { + next(); + var right = expr_op(expr_atom(true), prec, no_in); + return expr_op(as("binary", op, left, right), min_prec, no_in); + } + return left; + }; + + function expr_ops(no_in) { + return expr_op(expr_atom(true), 0, no_in); + }; + + function maybe_conditional(no_in) { + var expr = expr_ops(no_in); + if (is("operator", "?")) { + next(); + var yes = expression(false); + expect(":"); + return as("conditional", expr, yes, expression(false, no_in)); + } + return expr; + }; + + function is_assignable(expr) { + if (!exigent_mode) return true; + switch (expr[0]) { + case "dot": + case "sub": + case "new": + case "call": + return true; + case "name": + return expr[1] != "this"; + } + }; + + function maybe_assign(no_in) { + var left = maybe_conditional(no_in), val = S.token.value; + if (is("operator") && HOP(ASSIGNMENT, val)) { + if (is_assignable(left)) { + next(); + return as("assign", ASSIGNMENT[val], left, maybe_assign(no_in)); + } + croak("Invalid assignment"); + } + return left; + }; + + var expression = maybe_embed_tokens(function(commas, no_in) { + if (arguments.length == 0) + commas = true; + var expr = maybe_assign(no_in); + if (commas && is("punc", ",")) { + next(); + return as("seq", expr, expression(true, no_in)); + } + return expr; + }); + + function in_loop(cont) { + try { + ++S.in_loop; + return cont(); + } finally { + --S.in_loop; + } + }; + + return as("toplevel", (function(a){ + while (!is("eof")) + a.push(statement()); + return a; + })([])); + + }; + + /* -----[ Utilities ]----- */ + + function curry(f) { + var args = slice(arguments, 1); + return function() { return f.apply(this, args.concat(slice(arguments))); }; + }; + + function prog1(ret) { + if (ret instanceof Function) + ret = ret(); + for (var i = 1, n = arguments.length; --n > 0; ++i) + arguments[i](); + return ret; + }; + + function array_to_hash(a) { + var ret = {}; + for (var i = 0; i < a.length; ++i) + ret[a[i]] = true; + return ret; + }; + + function slice(a, start) { + return Array.prototype.slice.call(a, start == null ? 0 : start); + }; + + function characters(str) { + return str.split(""); + }; + + function member(name, array) { + for (var i = array.length; --i >= 0;) + if (array[i] === name) + return true; + return false; + }; + + function HOP(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); + }; + + var warn = function() {}; + + /* -----[ Exports ]----- */ + + Uglify.tokenizer = tokenizer; + Uglify.parse = parse; + Uglify.slice = slice; + Uglify.curry = curry; + Uglify.member = member; + Uglify.array_to_hash = array_to_hash; + Uglify.PRECEDENCE = PRECEDENCE; + Uglify.KEYWORDS_ATOM = KEYWORDS_ATOM; + Uglify.RESERVED_WORDS = RESERVED_WORDS; + Uglify.KEYWORDS = KEYWORDS; + Uglify.ATOMIC_START_TOKEN = ATOMIC_START_TOKEN; + Uglify.OPERATORS = OPERATORS; + Uglify.is_alphanumeric_char = is_alphanumeric_char; + Uglify.set_logger = function(logger) { + warn = logger; + }; +}()); + +(function () { + /*********************************************************************** + + A JavaScript tokenizer / parser / beautifier / compressor. + + This version is suitable for Node.js. With minimal changes (the + exports stuff) it should work on any JS platform. + + This file implements some AST processors. They work on data built + by parse-js. + + Exported functions: + + - ast_mangle(ast, options) -- mangles the variable/function names + in the AST. Returns an AST. + + - ast_squeeze(ast) -- employs various optimizations to make the + final generated code even smaller. Returns an AST. + + - gen_code(ast, options) -- generates JS code from the AST. Pass + true (or an object, see the code for some options) as second + argument to get "pretty" (indented) code. + + -------------------------------- (C) --------------------------------- + + Author: Mihai Bazon + + http://mihai.bazon.net/blog + + Distributed under the BSD license: + + Copyright 2010 (c) Mihai Bazon + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above + copyright notice, this list of conditions and the following + disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials + provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, + OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF + THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + + ***********************************************************************/ + + var jsp = Uglify, + slice = jsp.slice, + member = jsp.member, + PRECEDENCE = jsp.PRECEDENCE, + OPERATORS = jsp.OPERATORS; + + /* -----[ helper for AST traversal ]----- */ + + function ast_walker(ast) { + function _vardefs(defs) { + return [ this[0], MAP(defs, function(def){ + var a = [ def[0] ]; + if (def.length > 1) + a[1] = walk(def[1]); + return a; + }) ]; + }; + function _block(statements) { + var out = [ this[0] ]; + if (statements != null) + out.push(MAP(statements, walk)); + return out; + }; + var walkers = { + "string": function(str) { + return [ this[0], str ]; + }, + "num": function(num) { + return [ this[0], num ]; + }, + "name": function(name) { + return [ this[0], name ]; + }, + "toplevel": function(statements) { + return [ this[0], MAP(statements, walk) ]; + }, + "block": _block, + "splice": _block, + "var": _vardefs, + "const": _vardefs, + "try": function(t, c, f) { + return [ + this[0], + MAP(t, walk), + c != null ? [ c[0], MAP(c[1], walk) ] : null, + f != null ? MAP(f, walk) : null + ]; + }, + "throw": function(expr) { + return [ this[0], walk(expr) ]; + }, + "new": function(ctor, args) { + return [ this[0], walk(ctor), MAP(args, walk) ]; + }, + "switch": function(expr, body) { + return [ this[0], walk(expr), MAP(body, function(branch){ + return [ branch[0] ? walk(branch[0]) : null, + MAP(branch[1], walk) ]; + }) ]; + }, + "break": function(label) { + return [ this[0], label ]; + }, + "continue": function(label) { + return [ this[0], label ]; + }, + "conditional": function(cond, t, e) { + return [ this[0], walk(cond), walk(t), walk(e) ]; + }, + "assign": function(op, lvalue, rvalue) { + return [ this[0], op, walk(lvalue), walk(rvalue) ]; + }, + "dot": function(expr) { + return [ this[0], walk(expr) ].concat(slice(arguments, 1)); + }, + "call": function(expr, args) { + return [ this[0], walk(expr), MAP(args, walk) ]; + }, + "function": function(name, args, body) { + return [ this[0], name, args.slice(), MAP(body, walk) ]; + }, + "defun": function(name, args, body) { + return [ this[0], name, args.slice(), MAP(body, walk) ]; + }, + "if": function(conditional, t, e) { + return [ this[0], walk(conditional), walk(t), walk(e) ]; + }, + "for": function(init, cond, step, block) { + return [ this[0], walk(init), walk(cond), walk(step), walk(block) ]; + }, + "for-in": function(vvar, key, hash, block) { + return [ this[0], walk(vvar), walk(key), walk(hash), walk(block) ]; + }, + "while": function(cond, block) { + return [ this[0], walk(cond), walk(block) ]; + }, + "do": function(cond, block) { + return [ this[0], walk(cond), walk(block) ]; + }, + "return": function(expr) { + return [ this[0], walk(expr) ]; + }, + "binary": function(op, left, right) { + return [ this[0], op, walk(left), walk(right) ]; + }, + "unary-prefix": function(op, expr) { + return [ this[0], op, walk(expr) ]; + }, + "unary-postfix": function(op, expr) { + return [ this[0], op, walk(expr) ]; + }, + "sub": function(expr, subscript) { + return [ this[0], walk(expr), walk(subscript) ]; + }, + "object": function(props) { + return [ this[0], MAP(props, function(p){ + return p.length == 2 + ? [ p[0], walk(p[1]) ] + : [ p[0], walk(p[1]), p[2] ]; // get/set-ter + }) ]; + }, + "regexp": function(rx, mods) { + return [ this[0], rx, mods ]; + }, + "array": function(elements) { + return [ this[0], MAP(elements, walk) ]; + }, + "stat": function(stat) { + return [ this[0], walk(stat) ]; + }, + "seq": function() { + return [ this[0] ].concat(MAP(slice(arguments), walk)); + }, + "label": function(name, block) { + return [ this[0], name, walk(block) ]; + }, + "with": function(expr, block) { + return [ this[0], walk(expr), walk(block) ]; + }, + "atom": function(name) { + return [ this[0], name ]; + } + }; + + var user = {}; + var stack = []; + function walk(ast) { + if (ast == null) + return null; + try { + stack.push(ast); + var type = ast[0]; + var gen = user[type]; + if (gen) { + var ret = gen.apply(ast, ast.slice(1)); + if (ret != null) + return ret; + } + gen = walkers[type]; + return gen.apply(ast, ast.slice(1)); + } finally { + stack.pop(); + } + }; + + function with_walkers(walkers, cont){ + var save = {}, i; + for (i in walkers) if (HOP(walkers, i)) { + save[i] = user[i]; + user[i] = walkers[i]; + } + var ret = cont(); + for (i in save) if (HOP(save, i)) { + if (!save[i]) delete user[i]; + else user[i] = save[i]; + } + return ret; + }; + + return { + walk: walk, + with_walkers: with_walkers, + parent: function() { + return stack[stack.length - 2]; // last one is current node + }, + stack: function() { + return stack; + } + }; + }; + + /* -----[ Scope and mangling ]----- */ + + function Scope(parent) { + this.names = {}; // names defined in this scope + this.mangled = {}; // mangled names (orig.name => mangled) + this.rev_mangled = {}; // reverse lookup (mangled => orig.name) + this.cname = -1; // current mangled name + this.refs = {}; // names referenced from this scope + this.uses_with = false; // will become TRUE if with() is detected in this or any subscopes + this.uses_eval = false; // will become TRUE if eval() is detected in this or any subscopes + this.parent = parent; // parent scope + this.children = []; // sub-scopes + if (parent) { + this.level = parent.level + 1; + parent.children.push(this); + } else { + this.level = 0; + } + }; + + var base54 = (function(){ + var DIGITS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"; + return function(num) { + var ret = ""; + do { + ret = DIGITS.charAt(num % 54) + ret; + num = Math.floor(num / 54); + } while (num > 0); + return ret; + }; + })(); + + Scope.prototype = { + has: function(name) { + for (var s = this; s; s = s.parent) + if (HOP(s.names, name)) + return s; + }, + has_mangled: function(mname) { + for (var s = this; s; s = s.parent) + if (HOP(s.rev_mangled, mname)) + return s; + }, + toJSON: function() { + return { + names: this.names, + uses_eval: this.uses_eval, + uses_with: this.uses_with + }; + }, + + next_mangled: function() { + // we must be careful that the new mangled name: + // + // 1. doesn't shadow a mangled name from a parent + // scope, unless we don't reference the original + // name from this scope OR from any sub-scopes! + // This will get slow. + // + // 2. doesn't shadow an original name from a parent + // scope, in the event that the name is not mangled + // in the parent scope and we reference that name + // here OR IN ANY SUBSCOPES! + // + // 3. doesn't shadow a name that is referenced but not + // defined (possibly global defined elsewhere). + for (;;) { + var m = base54(++this.cname), prior; + + // case 1. + prior = this.has_mangled(m); + if (prior && this.refs[prior.rev_mangled[m]] === prior) + continue; + + // case 2. + prior = this.has(m); + if (prior && prior !== this && this.refs[m] === prior && !prior.has_mangled(m)) + continue; + + // case 3. + if (HOP(this.refs, m) && this.refs[m] == null) + continue; + + // I got "do" once. :-/ + if (!is_identifier(m)) + continue; + + return m; + } + }, + get_mangled: function(name, newMangle) { + if (this.uses_eval || this.uses_with) return name; // no mangle if eval or with is in use + var s = this.has(name); + if (!s) return name; // not in visible scope, no mangle + if (HOP(s.mangled, name)) return s.mangled[name]; // already mangled in this scope + if (!newMangle) return name; // not found and no mangling requested + + var m = s.next_mangled(); + s.rev_mangled[m] = name; + return s.mangled[name] = m; + }, + define: function(name) { + if (name != null) + return this.names[name] = name; + } + }; + + function ast_add_scope(ast) { + + var current_scope = null; + var w = ast_walker(), walk = w.walk; + var having_eval = []; + + function with_new_scope(cont) { + current_scope = new Scope(current_scope); + var ret = current_scope.body = cont(); + ret.scope = current_scope; + current_scope = current_scope.parent; + return ret; + }; + + function define(name) { + return current_scope.define(name); + }; + + function reference(name) { + current_scope.refs[name] = true; + }; + + function _lambda(name, args, body) { + var is_defun = this[0] == "defun"; + return [ this[0], is_defun ? define(name) : name, args, with_new_scope(function(){ + if (!is_defun) define(name); + MAP(args, define); + return MAP(body, walk); + })]; + }; + + return with_new_scope(function(){ + // process AST + var ret = w.with_walkers({ + "function": _lambda, + "defun": _lambda, + "with": function(expr, block) { + for (var s = current_scope; s; s = s.parent) + s.uses_with = true; + }, + "var": function(defs) { + MAP(defs, function(d){ define(d[0]) }); + }, + "const": function(defs) { + MAP(defs, function(d){ define(d[0]) }); + }, + "try": function(t, c, f) { + if (c != null) return [ + this[0], + MAP(t, walk), + [ define(c[0]), MAP(c[1], walk) ], + f != null ? MAP(f, walk) : null + ]; + }, + "name": function(name) { + if (name == "eval") + having_eval.push(current_scope); + reference(name); + } + }, function(){ + return walk(ast); + }); + + // the reason why we need an additional pass here is + // that names can be used prior to their definition. + + // scopes where eval was detected and their parents + // are marked with uses_eval, unless they define the + // "eval" name. + MAP(having_eval, function(scope){ + if (!scope.has("eval")) while (scope) { + scope.uses_eval = true; + scope = scope.parent; + } + }); + + // for referenced names it might be useful to know + // their origin scope. current_scope here is the + // toplevel one. + function fixrefs(scope, i) { + // do children first; order shouldn't matter + for (i = scope.children.length; --i >= 0;) + fixrefs(scope.children[i]); + for (i in scope.refs) if (HOP(scope.refs, i)) { + // find origin scope and propagate the reference to origin + for (var origin = scope.has(i), s = scope; s; s = s.parent) { + s.refs[i] = origin; + if (s === origin) break; + } + } + }; + fixrefs(current_scope); + + return ret; + }); + + }; + + /* -----[ mangle names ]----- */ + + function ast_mangle(ast, options) { + var w = ast_walker(), walk = w.walk, scope; + options = options || {}; + + function get_mangled(name, newMangle) { + if (!options.toplevel && !scope.parent) return name; // don't mangle toplevel + if (options.except && member(name, options.except)) + return name; + return scope.get_mangled(name, newMangle); + }; + + function get_define(name) { + if (options.defines) { + // we always lookup a defined symbol for the current scope FIRST, so declared + // vars trump a DEFINE symbol, but if no such var is found, then match a DEFINE value + if (!scope.has(name)) { + if (HOP(options.defines, name)) { + return options.defines[name]; + } + } + return null; + } + }; + + function _lambda(name, args, body) { + var is_defun = this[0] == "defun"; + if (is_defun && name) name = get_mangled(name); + body = with_scope(body.scope, function(){ + if (!is_defun && name) name = get_mangled(name); + args = MAP(args, function(name){ return get_mangled(name) }); + return MAP(body, walk); + }); + return [ this[0], name, args, body ]; + }; + + function with_scope(s, cont) { + var _scope = scope; + scope = s; + for (var i in s.names) if (HOP(s.names, i)) { + get_mangled(i, true); + } + var ret = cont(); + ret.scope = s; + scope = _scope; + return ret; + }; + + function _vardefs(defs) { + return [ this[0], MAP(defs, function(d){ + return [ get_mangled(d[0]), walk(d[1]) ]; + }) ]; + }; + + return w.with_walkers({ + "function": _lambda, + "defun": function() { + // move function declarations to the top when + // they are not in some block. + var ast = _lambda.apply(this, arguments); + switch (w.parent()[0]) { + case "toplevel": + case "function": + case "defun": + return MAP.at_top(ast); + } + return ast; + }, + "var": _vardefs, + "const": _vardefs, + "name": function(name) { + return get_define(name) || [ this[0], get_mangled(name) ]; + }, + "try": function(t, c, f) { + return [ this[0], + MAP(t, walk), + c != null ? [ get_mangled(c[0]), MAP(c[1], walk) ] : null, + f != null ? MAP(f, walk) : null ]; + }, + "toplevel": function(body) { + var self = this; + return with_scope(self.scope, function(){ + return [ self[0], MAP(body, walk) ]; + }); + } + }, function() { + return walk(ast_add_scope(ast)); + }); + }; + + /* -----[ + - compress foo["bar"] into foo.bar, + - remove block brackets {} where possible + - join consecutive var declarations + - various optimizations for IFs: + - if (cond) foo(); else bar(); ==> cond?foo():bar(); + - if (cond) foo(); ==> cond&&foo(); + - if (foo) return bar(); else return baz(); ==> return foo?bar():baz(); // also for throw + - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()} + ]----- */ + + var warn = function(){}; + + function best_of(ast1, ast2) { + return gen_code(ast1).length > gen_code(ast2[0] == "stat" ? ast2[1] : ast2).length ? ast2 : ast1; + }; + + function last_stat(b) { + if (b[0] == "block" && b[1] && b[1].length > 0) + return b[1][b[1].length - 1]; + return b; + } + + function aborts(t) { + if (t) { + t = last_stat(t); + if (t[0] == "return" || t[0] == "break" || t[0] == "continue" || t[0] == "throw") + return true; + } + }; + + function boolean_expr(expr) { + return ( (expr[0] == "unary-prefix" + && member(expr[1], [ "!", "delete" ])) || + + (expr[0] == "binary" + && member(expr[1], [ "in", "instanceof", "==", "!=", "===", "!==", "<", "<=", ">=", ">" ])) || + + (expr[0] == "binary" + && member(expr[1], [ "&&", "||" ]) + && boolean_expr(expr[2]) + && boolean_expr(expr[3])) || + + (expr[0] == "conditional" + && boolean_expr(expr[2]) + && boolean_expr(expr[3])) || + + (expr[0] == "assign" + && expr[1] === true + && boolean_expr(expr[3])) || + + (expr[0] == "seq" + && boolean_expr(expr[expr.length - 1])) + ); + }; + + function make_conditional(c, t, e) { + var make_real_conditional = function() { + if (c[0] == "unary-prefix" && c[1] == "!") { + return e ? [ "conditional", c[2], e, t ] : [ "binary", "||", c[2], t ]; + } else { + return e ? [ "conditional", c, t, e ] : [ "binary", "&&", c, t ]; + } + }; + // shortcut the conditional if the expression has a constant value + return when_constant(c, function(ast, val){ + warn_unreachable(val ? e : t); + return (val ? t : e); + }, make_real_conditional); + }; + + function empty(b) { + return !b || (b[0] == "block" && (!b[1] || b[1].length == 0)); + }; + + function is_string(node) { + return (node[0] == "string" || + node[0] == "unary-prefix" && node[1] == "typeof" || + node[0] == "binary" && node[1] == "+" && + (is_string(node[2]) || is_string(node[3]))); + }; + + var when_constant = (function(){ + + var $NOT_CONSTANT = {}; + + // this can only evaluate constant expressions. If it finds anything + // not constant, it throws $NOT_CONSTANT. + function evaluate(expr) { + switch (expr[0]) { + case "string": + case "num": + return expr[1]; + case "name": + case "atom": + switch (expr[1]) { + case "true": return true; + case "false": return false; + } + break; + case "unary-prefix": + switch (expr[1]) { + case "!": return !evaluate(expr[2]); + case "typeof": return typeof evaluate(expr[2]); + case "~": return ~evaluate(expr[2]); + case "-": return -evaluate(expr[2]); + case "+": return +evaluate(expr[2]); + } + break; + case "binary": + var left = expr[2], right = expr[3]; + switch (expr[1]) { + case "&&" : return evaluate(left) && evaluate(right); + case "||" : return evaluate(left) || evaluate(right); + case "|" : return evaluate(left) | evaluate(right); + case "&" : return evaluate(left) & evaluate(right); + case "^" : return evaluate(left) ^ evaluate(right); + case "+" : return evaluate(left) + evaluate(right); + case "*" : return evaluate(left) * evaluate(right); + case "/" : return evaluate(left) / evaluate(right); + case "-" : return evaluate(left) - evaluate(right); + case "<<" : return evaluate(left) << evaluate(right); + case ">>" : return evaluate(left) >> evaluate(right); + case ">>>" : return evaluate(left) >>> evaluate(right); + case "==" : return evaluate(left) == evaluate(right); + case "===" : return evaluate(left) === evaluate(right); + case "!=" : return evaluate(left) != evaluate(right); + case "!==" : return evaluate(left) !== evaluate(right); + case "<" : return evaluate(left) < evaluate(right); + case "<=" : return evaluate(left) <= evaluate(right); + case ">" : return evaluate(left) > evaluate(right); + case ">=" : return evaluate(left) >= evaluate(right); + case "in" : return evaluate(left) in evaluate(right); + case "instanceof" : return evaluate(left) instanceof evaluate(right); + } + } + throw $NOT_CONSTANT; + }; + + return function(expr, yes, no) { + try { + var val = evaluate(expr), ast; + switch (typeof val) { + case "string": ast = [ "string", val ]; break; + case "number": ast = [ "num", val ]; break; + case "boolean": ast = [ "name", String(val) ]; break; + default: throw new Error("Can't handle constant of type: " + (typeof val)); + } + return yes.call(expr, ast, val); + } catch(ex) { + if (ex === $NOT_CONSTANT) { + if (expr[0] == "binary" + && (expr[1] == "===" || expr[1] == "!==") + && ((is_string(expr[2]) && is_string(expr[3])) + || (boolean_expr(expr[2]) && boolean_expr(expr[3])))) { + expr[1] = expr[1].substr(0, 2); + } + else if (no && expr[0] == "binary" + && (expr[1] == "||" || expr[1] == "&&")) { + // the whole expression is not constant but the lval may be... + try { + var lval = evaluate(expr[2]); + expr = ((expr[1] == "&&" && (lval ? expr[3] : lval)) || + (expr[1] == "||" && (lval ? lval : expr[3])) || + expr); + } catch(ex2) { + // IGNORE... lval is not constant + } + } + return no ? no.call(expr, expr) : null; + } + else throw ex; + } + }; + + })(); + + function warn_unreachable(ast) { + if (!empty(ast)) + warn("Dropping unreachable code: " + gen_code(ast, true)); + }; + + function ast_squeeze(ast, options) { + options = defaults(options, { + make_seqs : true, + dead_code : true, + keep_comps : true, + no_warnings : false + }); + + var w = ast_walker(), walk = w.walk, scope; + + function negate(c) { + var not_c = [ "unary-prefix", "!", c ]; + switch (c[0]) { + case "unary-prefix": + return c[1] == "!" && boolean_expr(c[2]) ? c[2] : not_c; + case "seq": + c = slice(c); + c[c.length - 1] = negate(c[c.length - 1]); + return c; + case "conditional": + return best_of(not_c, [ "conditional", c[1], negate(c[2]), negate(c[3]) ]); + case "binary": + var op = c[1], left = c[2], right = c[3]; + if (!options.keep_comps) switch (op) { + case "<=" : return [ "binary", ">", left, right ]; + case "<" : return [ "binary", ">=", left, right ]; + case ">=" : return [ "binary", "<", left, right ]; + case ">" : return [ "binary", "<=", left, right ]; + } + switch (op) { + case "==" : return [ "binary", "!=", left, right ]; + case "!=" : return [ "binary", "==", left, right ]; + case "===" : return [ "binary", "!==", left, right ]; + case "!==" : return [ "binary", "===", left, right ]; + case "&&" : return best_of(not_c, [ "binary", "||", negate(left), negate(right) ]); + case "||" : return best_of(not_c, [ "binary", "&&", negate(left), negate(right) ]); + } + break; + } + return not_c; + }; + + function with_scope(s, cont) { + var _scope = scope; + scope = s; + var ret = cont(); + ret.scope = s; + scope = _scope; + return ret; + }; + + function rmblock(block) { + if (block != null && block[0] == "block" && block[1]) { + if (block[1].length == 1) + block = block[1][0]; + else if (block[1].length == 0) + block = [ "block" ]; + } + return block; + }; + + function _lambda(name, args, body) { + var is_defun = this[0] == "defun"; + body = with_scope(body.scope, function(){ + var ret = tighten(MAP(body, walk), "lambda"); + if (!is_defun && name && !HOP(scope.refs, name)) + name = null; + return ret; + }); + return [ this[0], name, args, body ]; + }; + + // we get here for blocks that have been already transformed. + // this function does a few things: + // 1. discard useless blocks + // 2. join consecutive var declarations + // 3. remove obviously dead code + // 4. transform consecutive statements using the comma operator + // 5. if block_type == "lambda" and it detects constructs like if(foo) return ... - rewrite like if (!foo) { ... } + function tighten(statements, block_type) { + statements = statements.reduce(function(a, stat){ + if (stat[0] == "block") { + if (stat[1]) { + a.push.apply(a, stat[1]); + } + } else { + a.push(stat); + } + return a; + }, []); + + statements = (function(a, prev){ + statements.forEach(function(cur){ + if (prev && ((cur[0] == "var" && prev[0] == "var") || + (cur[0] == "const" && prev[0] == "const"))) { + prev[1] = prev[1].concat(cur[1]); + } else { + a.push(cur); + prev = cur; + } + }); + return a; + })([]); + + if (options.dead_code) statements = (function(a, has_quit){ + statements.forEach(function(st){ + if (has_quit) { + if (member(st[0], [ "function", "defun" , "var", "const" ])) { + a.push(st); + } + else if (!options.no_warnings) + warn_unreachable(st); + } + else { + a.push(st); + if (member(st[0], [ "return", "throw", "break", "continue" ])) + has_quit = true; + } + }); + return a; + })([]); + + if (options.make_seqs) statements = (function(a, prev) { + statements.forEach(function(cur){ + if (prev && prev[0] == "stat" && cur[0] == "stat") { + prev[1] = [ "seq", prev[1], cur[1] ]; + } else { + a.push(cur); + prev = cur; + } + }); + return a; + })([]); + + if (block_type == "lambda") statements = (function(i, a, stat){ + while (i < statements.length) { + stat = statements[i++]; + if (stat[0] == "if" && !stat[3]) { + if (stat[2][0] == "return" && stat[2][1] == null) { + a.push(make_if(negate(stat[1]), [ "block", statements.slice(i) ])); + break; + } + var last = last_stat(stat[2]); + if (last[0] == "return" && last[1] == null) { + a.push(make_if(stat[1], [ "block", stat[2][1].slice(0, -1) ], [ "block", statements.slice(i) ])); + break; + } + } + a.push(stat); + } + return a; + })(0, []); + + return statements; + }; + + function make_if(c, t, e) { + return when_constant(c, function(ast, val){ + if (val) { + warn_unreachable(e); + return t; + } else { + warn_unreachable(t); + return e; + } + }, function() { + return make_real_if(c, t, e); + }); + }; + + function make_real_if(c, t, e) { + c = walk(c); + t = walk(t); + e = walk(e); + + if (empty(t)) { + c = negate(c); + t = e; + e = null; + } else if (empty(e)) { + e = null; + } else { + // if we have both else and then, maybe it makes sense to switch them? + (function(){ + var a = gen_code(c); + var n = negate(c); + var b = gen_code(n); + if (b.length < a.length) { + var tmp = t; + t = e; + e = tmp; + c = n; + } + })(); + } + if (empty(e) && empty(t)) + return [ "stat", c ]; + var ret = [ "if", c, t, e ]; + if (t[0] == "if" && empty(t[3]) && empty(e)) { + ret = best_of(ret, walk([ "if", [ "binary", "&&", c, t[1] ], t[2] ])); + } + else if (t[0] == "stat") { + if (e) { + if (e[0] == "stat") { + ret = best_of(ret, [ "stat", make_conditional(c, t[1], e[1]) ]); + } + } + else { + ret = best_of(ret, [ "stat", make_conditional(c, t[1]) ]); + } + } + else if (e && t[0] == e[0] && (t[0] == "return" || t[0] == "throw") && t[1] && e[1]) { + ret = best_of(ret, [ t[0], make_conditional(c, t[1], e[1] ) ]); + } + else if (e && aborts(t)) { + ret = [ [ "if", c, t ] ]; + if (e[0] == "block") { + if (e[1]) ret = ret.concat(e[1]); + } + else { + ret.push(e); + } + ret = walk([ "block", ret ]); + } + else if (t && aborts(e)) { + ret = [ [ "if", negate(c), e ] ]; + if (t[0] == "block") { + if (t[1]) ret = ret.concat(t[1]); + } else { + ret.push(t); + } + ret = walk([ "block", ret ]); + } + return ret; + }; + + function _do_while(cond, body) { + return when_constant(cond, function(cond, val){ + if (!val) { + warn_unreachable(body); + return [ "block" ]; + } else { + return [ "for", null, null, null, walk(body) ]; + } + }); + }; + + return w.with_walkers({ + "sub": function(expr, subscript) { + if (subscript[0] == "string") { + var name = subscript[1]; + if (is_identifier(name)) + return [ "dot", walk(expr), name ]; + else if (/^[1-9][0-9]*$/.test(name) || name === "0") + return [ "sub", walk(expr), [ "num", parseInt(name, 10) ] ]; + } + }, + "if": make_if, + "toplevel": function(body) { + return [ "toplevel", with_scope(this.scope, function(){ + return tighten(MAP(body, walk)); + }) ]; + }, + "switch": function(expr, body) { + var last = body.length - 1; + return [ "switch", walk(expr), MAP(body, function(branch, i){ + var block = tighten(MAP(branch[1], walk)); + if (i == last && block.length > 0) { + var node = block[block.length - 1]; + if (node[0] == "break" && !node[1]) + block.pop(); + } + return [ branch[0] ? walk(branch[0]) : null, block ]; + }) ]; + }, + "function": _lambda, + "defun": _lambda, + "block": function(body) { + if (body) return rmblock([ "block", tighten(MAP(body, walk)) ]); + }, + "binary": function(op, left, right) { + return when_constant([ "binary", op, walk(left), walk(right) ], function yes(c){ + return best_of(walk(c), this); + }, function no() { + return this; + }); + }, + "conditional": function(c, t, e) { + return make_conditional(walk(c), walk(t), walk(e)); + }, + "try": function(t, c, f) { + return [ + "try", + tighten(MAP(t, walk)), + c != null ? [ c[0], tighten(MAP(c[1], walk)) ] : null, + f != null ? tighten(MAP(f, walk)) : null + ]; + }, + "unary-prefix": function(op, expr) { + expr = walk(expr); + var ret = [ "unary-prefix", op, expr ]; + if (op == "!") + ret = best_of(ret, negate(expr)); + return when_constant(ret, function(ast, val){ + return walk(ast); // it's either true or false, so minifies to !0 or !1 + }, function() { return ret }); + }, + "name": function(name) { + switch (name) { + case "true": return [ "unary-prefix", "!", [ "num", 0 ]]; + case "false": return [ "unary-prefix", "!", [ "num", 1 ]]; + } + }, + "new": function(ctor, args) { + if (ctor[0] == "name" && ctor[1] == "Array" && !scope.has("Array")) { + if (args.length != 1) { + return [ "array", args ]; + } else { + return [ "call", [ "name", "Array" ], args ]; + } + } + }, + "call": function(expr, args) { + if (expr[0] == "name" && expr[1] == "Array" && args.length != 1 && !scope.has("Array")) { + return [ "array", args ]; + } + }, + "while": _do_while + }, function() { + return walk(ast_add_scope(ast)); + }); + }; + + /* -----[ re-generate code from the AST ]----- */ + + var DOT_CALL_NO_PARENS = jsp.array_to_hash([ + "name", + "array", + "object", + "string", + "dot", + "sub", + "call", + "regexp" + ]); + + function make_string(str, ascii_only) { + var dq = 0, sq = 0; + str = str.replace(/[\\\b\f\n\r\t\x22\x27\u2028\u2029]/g, function(s){ + switch (s) { + case "\\": return "\\\\"; + case "\b": return "\\b"; + case "\f": return "\\f"; + case "\n": return "\\n"; + case "\r": return "\\r"; + case "\t": return "\\t"; + case "\u2028": return "\\u2028"; + case "\u2029": return "\\u2029"; + case '"': ++dq; return '"'; + case "'": ++sq; return "'"; + } + return s; + }); + if (ascii_only) str = to_ascii(str); + if (dq > sq) return "'" + str.replace(/\x27/g, "\\'") + "'"; + else return '"' + str.replace(/\x22/g, '\\"') + '"'; + }; + + function to_ascii(str) { + return str.replace(/[\u0080-\uffff]/g, function(ch) { + var code = ch.charCodeAt(0).toString(16); + while (code.length < 4) code = "0" + code; + return "\\u" + code; + }); + }; + + var SPLICE_NEEDS_BRACKETS = jsp.array_to_hash([ "if", "while", "do", "for", "for-in", "with" ]); + + function gen_code(ast, options) { + options = defaults(options, { + indent_start : 0, + indent_level : 4, + quote_keys : false, + space_colon : false, + beautify : false, + ascii_only : false + }); + var beautify = !!options.beautify; + var indentation = 0, + newline = beautify ? "\n" : "", + space = beautify ? " " : ""; + + function encode_string(str) { + return make_string(str, options.ascii_only); + }; + + function make_name(name) { + name = name.toString(); + if (options.ascii_only) + name = to_ascii(name); + return name; + }; + + function indent(line) { + if (line == null) + line = ""; + if (beautify) + line = repeat_string(" ", options.indent_start + indentation * options.indent_level) + line; + return line; + }; + + function with_indent(cont, incr) { + if (incr == null) incr = 1; + indentation += incr; + try { return cont.apply(null, slice(arguments, 1)); } + finally { indentation -= incr; } + }; + + function add_spaces(a) { + if (beautify) + return a.join(" "); + var b = []; + for (var i = 0; i < a.length; ++i) { + var next = a[i + 1]; + b.push(a[i]); + if (next && + ((/[a-z0-9_\x24]$/i.test(a[i].toString()) && /^[a-z0-9_\x24]/i.test(next.toString())) || + (/[\+\-]$/.test(a[i].toString()) && /^[\+\-]/.test(next.toString())))) { + b.push(" "); + } + } + return b.join(""); + }; + + function add_commas(a) { + return a.join("," + space); + }; + + function parenthesize(expr) { + var gen = make(expr); + for (var i = 1; i < arguments.length; ++i) { + var el = arguments[i]; + if ((el instanceof Function && el(expr)) || expr[0] == el) + return "(" + gen + ")"; + } + return gen; + }; + + function best_of(a) { + if (a.length == 1) { + return a[0]; + } + if (a.length == 2) { + var b = a[1]; + a = a[0]; + return a.length <= b.length ? a : b; + } + return best_of([ a[0], best_of(a.slice(1)) ]); + }; + + function needs_parens(expr) { + if (expr[0] == "function" || expr[0] == "object") { + // dot/call on a literal function requires the + // function literal itself to be parenthesized + // only if it's the first "thing" in a + // statement. This means that the parent is + // "stat", but it could also be a "seq" and + // we're the first in this "seq" and the + // parent is "stat", and so on. Messy stuff, + // but it worths the trouble. + var a = slice($stack), self = a.pop(), p = a.pop(); + while (p) { + if (p[0] == "stat") return true; + if (((p[0] == "seq" || p[0] == "call" || p[0] == "dot" || p[0] == "sub" || p[0] == "conditional") && p[1] === self) || + ((p[0] == "binary" || p[0] == "assign" || p[0] == "unary-postfix") && p[2] === self)) { + self = p; + p = a.pop(); + } else { + return false; + } + } + } + return !HOP(DOT_CALL_NO_PARENS, expr[0]); + }; + + function make_num(num) { + var str = num.toString(10), a = [ str.replace(/^0\./, ".") ], m; + if (Math.floor(num) === num) { + a.push("0x" + num.toString(16).toLowerCase(), // probably pointless + "0" + num.toString(8)); // same. + if ((m = /^(.*?)(0+)$/.exec(num))) { + a.push(m[1] + "e" + m[2].length); + } + } else if ((m = /^0?\.(0+)(.*)$/.exec(num))) { + a.push(m[2] + "e-" + (m[1].length + m[2].length), + str.substr(str.indexOf("."))); + } + return best_of(a); + }; + + var generators = { + "string": encode_string, + "num": make_num, + "name": make_name, + "toplevel": function(statements) { + return make_block_statements(statements) + .join(newline + newline); + }, + "splice": function(statements) { + var parent = $stack[$stack.length - 2][0]; + if (HOP(SPLICE_NEEDS_BRACKETS, parent)) { + // we need block brackets in this case + return make_block.apply(this, arguments); + } else { + return MAP(make_block_statements(statements, true), + function(line, i) { + // the first line is already indented + return i > 0 ? indent(line) : line; + }).join(newline); + } + }, + "block": make_block, + "var": function(defs) { + return "var " + add_commas(MAP(defs, make_1vardef)) + ";"; + }, + "const": function(defs) { + return "const " + add_commas(MAP(defs, make_1vardef)) + ";"; + }, + "try": function(tr, ca, fi) { + var out = [ "try", make_block(tr) ]; + if (ca) out.push("catch", "(" + ca[0] + ")", make_block(ca[1])); + if (fi) out.push("finally", make_block(fi)); + return add_spaces(out); + }, + "throw": function(expr) { + return add_spaces([ "throw", make(expr) ]) + ";"; + }, + "new": function(ctor, args) { + args = args.length > 0 ? "(" + add_commas(MAP(args, make)) + ")" : ""; + return add_spaces([ "new", parenthesize(ctor, "seq", "binary", "conditional", "assign", function(expr){ + var w = ast_walker(), has_call = {}; + try { + w.with_walkers({ + "call": function() { throw has_call }, + "function": function() { return this } + }, function(){ + w.walk(expr); + }); + } catch(ex) { + if (ex === has_call) + return true; + throw ex; + } + }) + args ]); + }, + "switch": function(expr, body) { + return add_spaces([ "switch", "(" + make(expr) + ")", make_switch_block(body) ]); + }, + "break": function(label) { + var out = "break"; + if (label != null) + out += " " + make_name(label); + return out + ";"; + }, + "continue": function(label) { + var out = "continue"; + if (label != null) + out += " " + make_name(label); + return out + ";"; + }, + "conditional": function(co, th, el) { + return add_spaces([ parenthesize(co, "assign", "seq", "conditional"), "?", + parenthesize(th, "seq"), ":", + parenthesize(el, "seq") ]); + }, + "assign": function(op, lvalue, rvalue) { + if (op && op !== true) op += "="; + else op = "="; + return add_spaces([ make(lvalue), op, parenthesize(rvalue, "seq") ]); + }, + "dot": function(expr) { + var out = make(expr), i = 1; + if (expr[0] == "num") { + if (!/\./.test(expr[1])) + out += "."; + } else if (needs_parens(expr)) + out = "(" + out + ")"; + while (i < arguments.length) + out += "." + make_name(arguments[i++]); + return out; + }, + "call": function(func, args) { + var f = make(func); + if (needs_parens(func)) + f = "(" + f + ")"; + return f + "(" + add_commas(MAP(args, function(expr){ + return parenthesize(expr, "seq"); + })) + ")"; + }, + "function": make_function, + "defun": make_function, + "if": function(co, th, el) { + var out = [ "if", "(" + make(co) + ")", el ? make_then(th) : make(th) ]; + if (el) { + out.push("else", make(el)); + } + return add_spaces(out); + }, + "for": function(init, cond, step, block) { + var out = [ "for" ]; + init = (init != null ? make(init) : "").replace(/;*\s*$/, ";" + space); + cond = (cond != null ? make(cond) : "").replace(/;*\s*$/, ";" + space); + step = (step != null ? make(step) : "").replace(/;*\s*$/, ""); + var args = init + cond + step; + if (args == "; ; ") args = ";;"; + out.push("(" + args + ")", make(block)); + return add_spaces(out); + }, + "for-in": function(vvar, key, hash, block) { + return add_spaces([ "for", "(" + + (vvar ? make(vvar).replace(/;+$/, "") : make(key)), + "in", + make(hash) + ")", make(block) ]); + }, + "while": function(condition, block) { + return add_spaces([ "while", "(" + make(condition) + ")", make(block) ]); + }, + "do": function(condition, block) { + return add_spaces([ "do", make(block), "while", "(" + make(condition) + ")" ]) + ";"; + }, + "return": function(expr) { + var out = [ "return" ]; + if (expr != null) out.push(make(expr)); + return add_spaces(out) + ";"; + }, + "binary": function(operator, lvalue, rvalue) { + var left = make(lvalue), right = make(rvalue); + // XXX: I'm pretty sure other cases will bite here. + // we need to be smarter. + // adding parens all the time is the safest bet. + if (member(lvalue[0], [ "assign", "conditional", "seq" ]) || + lvalue[0] == "binary" && PRECEDENCE[operator] > PRECEDENCE[lvalue[1]]) { + left = "(" + left + ")"; + } + if (member(rvalue[0], [ "assign", "conditional", "seq" ]) || + rvalue[0] == "binary" && PRECEDENCE[operator] >= PRECEDENCE[rvalue[1]] && + !(rvalue[1] == operator && member(operator, [ "&&", "||", "*" ]))) { + right = "(" + right + ")"; + } + return add_spaces([ left, operator, right ]); + }, + "unary-prefix": function(operator, expr) { + var val = make(expr); + if (!(expr[0] == "num" || (expr[0] == "unary-prefix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) + val = "(" + val + ")"; + return operator + (jsp.is_alphanumeric_char(operator.charAt(0)) ? " " : "") + val; + }, + "unary-postfix": function(operator, expr) { + var val = make(expr); + if (!(expr[0] == "num" || (expr[0] == "unary-postfix" && !HOP(OPERATORS, operator + expr[1])) || !needs_parens(expr))) + val = "(" + val + ")"; + return val + operator; + }, + "sub": function(expr, subscript) { + var hash = make(expr); + if (needs_parens(expr)) + hash = "(" + hash + ")"; + return hash + "[" + make(subscript) + "]"; + }, + "object": function(props) { + if (props.length == 0) + return "{}"; + return "{" + newline + with_indent(function(){ + return MAP(props, function(p){ + if (p.length == 3) { + // getter/setter. The name is in p[0], the arg.list in p[1][2], the + // body in p[1][3] and type ("get" / "set") in p[2]. + return indent(make_function(p[0], p[1][2], p[1][3], p[2])); + } + var key = p[0], val = make(p[1]); + if (options.quote_keys) { + key = encode_string(key); + } else if ((typeof key == "number" || !beautify && +key + "" == key) + && parseFloat(key) >= 0) { + key = make_num(+key); + } else if (!is_identifier(key)) { + key = encode_string(key); + } + return indent(add_spaces(beautify && options.space_colon + ? [ key, ":", val ] + : [ key + ":", val ])); + }).join("," + newline); + }) + newline + indent("}"); + }, + "regexp": function(rx, mods) { + return "/" + rx + "/" + mods; + }, + "array": function(elements) { + if (elements.length == 0) return "[]"; + return add_spaces([ "[", add_commas(MAP(elements, function(el){ + if (!beautify && el[0] == "atom" && el[1] == "undefined") return ""; + return parenthesize(el, "seq"); + })), "]" ]); + }, + "stat": function(stmt) { + return make(stmt).replace(/;*\s*$/, ";"); + }, + "seq": function() { + return add_commas(MAP(slice(arguments), make)); + }, + "label": function(name, block) { + return add_spaces([ make_name(name), ":", make(block) ]); + }, + "with": function(expr, block) { + return add_spaces([ "with", "(" + make(expr) + ")", make(block) ]); + }, + "atom": function(name) { + return make_name(name); + } + }; + + // The squeezer replaces "block"-s that contain only a single + // statement with the statement itself; technically, the AST + // is correct, but this can create problems when we output an + // IF having an ELSE clause where the THEN clause ends in an + // IF *without* an ELSE block (then the outer ELSE would refer + // to the inner IF). This function checks for this case and + // adds the block brackets if needed. + function make_then(th) { + if (th[0] == "do") { + // https://github.com/mishoo/UglifyJS/issues/#issue/57 + // IE croaks with "syntax error" on code like this: + // if (foo) do ... while(cond); else ... + // we need block brackets around do/while + return make([ "block", [ th ]]); + } + var b = th; + while (true) { + var type = b[0]; + if (type == "if") { + if (!b[3]) + // no else, we must add the block + return make([ "block", [ th ]]); + b = b[3]; + } + else if (type == "while" || type == "do") b = b[2]; + else if (type == "for" || type == "for-in") b = b[4]; + else break; + } + return make(th); + }; + + function make_function(name, args, body, keyword) { + var out = keyword || "function"; + if (name) { + out += " " + make_name(name); + } + out += "(" + add_commas(MAP(args, make_name)) + ")"; + return add_spaces([ out, make_block(body) ]); + }; + + function make_block_statements(statements, noindent) { + for (var a = [], last = statements.length - 1, i = 0; i <= last; ++i) { + var stat = statements[i]; + var code = make(stat); + if (code != ";") { + if (!beautify && i == last) { + if ((stat[0] == "while" && empty(stat[2])) || + (member(stat[0], [ "for", "for-in"] ) && empty(stat[4])) || + (stat[0] == "if" && empty(stat[2]) && !stat[3]) || + (stat[0] == "if" && stat[3] && empty(stat[3]))) { + code = code.replace(/;*\s*$/, ";"); + } else { + code = code.replace(/;+\s*$/, ""); + } + } + a.push(code); + } + } + return noindent ? a : MAP(a, indent); + }; + + function make_switch_block(body) { + var n = body.length; + if (n == 0) return "{}"; + return "{" + newline + MAP(body, function(branch, i){ + var has_body = branch[1].length > 0, code = with_indent(function(){ + return indent(branch[0] + ? add_spaces([ "case", make(branch[0]) + ":" ]) + : "default:"); + }, 0.5) + (has_body ? newline + with_indent(function(){ + return make_block_statements(branch[1]).join(newline); + }) : ""); + if (!beautify && has_body && i < n - 1) + code += ";"; + return code; + }).join(newline) + newline + indent("}"); + }; + + function make_block(statements) { + if (!statements) return ";"; + if (statements.length == 0) return "{}"; + return "{" + newline + with_indent(function(){ + return make_block_statements(statements).join(newline); + }) + newline + indent("}"); + }; + + function make_1vardef(def) { + var name = def[0], val = def[1]; + if (val != null) + name = add_spaces([ make_name(name), "=", parenthesize(val, "seq") ]); + return name; + }; + + var $stack = []; + + function make(node) { + var type = node[0]; + var gen = generators[type]; + if (!gen) + throw new Error("Can't find generator for \"" + type + "\""); + $stack.push(node); + var ret = gen.apply(type, node.slice(1)); + $stack.pop(); + return ret; + }; + + return make(ast); + }; + + function split_lines(code, max_line_length) { + var splits = [ 0 ]; + jsp.parse(function(){ + var next_token = jsp.tokenizer(code); + var last_split = 0; + var prev_token; + function current_length(tok) { + return tok.pos - last_split; + }; + function split_here(tok) { + last_split = tok.pos; + splits.push(last_split); + }; + function custom(){ + var tok = next_token.apply(this, arguments); + out: { + if (prev_token) { + if (prev_token.type == "keyword") break out; + } + if (current_length(tok) > max_line_length) { + switch (tok.type) { + case "keyword": + case "atom": + case "name": + case "punc": + split_here(tok); + break out; + } + } + } + prev_token = tok; + return tok; + }; + custom.context = function() { + return next_token.context.apply(this, arguments); + }; + return custom; + }()); + return splits.map(function(pos, i){ + return code.substring(pos, splits[i + 1] || code.length); + }).join("\n"); + }; + + /* -----[ Utilities ]----- */ + + function repeat_string(str, i) { + if (i <= 0) return ""; + if (i == 1) return str; + var d = repeat_string(str, i >> 1); + d += d; + if (i & 1) d += str; + return d; + }; + + function defaults(args, defs) { + var ret = {}; + if (args === true) + args = {}; + for (var i in defs) if (HOP(defs, i)) { + ret[i] = (args && HOP(args, i)) ? args[i] : defs[i]; + } + return ret; + }; + + function is_identifier(name) { + return /^[a-z_$][a-z0-9_$]*$/i.test(name) + && name != "this" + && !HOP(jsp.KEYWORDS_ATOM, name) + && !HOP(jsp.RESERVED_WORDS, name) + && !HOP(jsp.KEYWORDS, name); + }; + + function HOP(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); + }; + + // some utilities + + var MAP; + + (function(){ + MAP = function(a, f, o) { + var ret = []; + for (var i = 0; i < a.length; ++i) { + var val = f.call(o, a[i], i); + if (val instanceof AtTop) ret.unshift(val.v); + else ret.push(val); + } + return ret; + }; + MAP.at_top = function(val) { return new AtTop(val) }; + function AtTop(val) { this.v = val }; + })(); + + /* -----[ Exports ]----- */ + + Uglify.ast_walker = ast_walker; + Uglify.ast_mangle = ast_mangle; + Uglify.ast_squeeze = ast_squeeze; + Uglify.gen_code = gen_code; + Uglify.ast_add_scope = ast_add_scope; + Uglify.set_logger = function(logger) { warn = logger }; + Uglify.make_string = make_string; + Uglify.split_lines = split_lines; + Uglify.MAP = MAP; + + // keep this last! + Uglify.ast_squeeze_more = (function() { + var slice = jsp.slice, + member = jsp.member, + PRECEDENCE = jsp.PRECEDENCE, + OPERATORS = jsp.OPERATORS; + + function ast_squeeze_more(ast) { + var w = pro.ast_walker(), walk = w.walk; + return w.with_walkers({ + "call": function(expr, args) { + if (expr[0] == "dot" && expr[2] == "toString" && args.length == 0) { + // foo.toString() ==> foo+"" + return [ "binary", "+", expr[1], [ "string", "" ]]; + } + } + }, function() { + return walk(ast); + }); + }; + }()); + +}()); + +Uglify.uglify = function (orig_code, options) { + options || (options = {}); + + var ast = Uglify.parse(orig_code, options.strict_semicolons); // parse code and get the initial AST + ast = Uglify.ast_mangle(ast, options.mangle_options); // get a new AST with mangled names + ast = Uglify.ast_squeeze(ast, options.squeeze_options); // get an AST with compression optimizations + var final_code = Uglify.gen_code(ast, options.gen_options); // compressed code here + return final_code; +} \ No newline at end of file diff --git a/dist/id3-minimized.js b/dist/id3-minimized.js deleted file mode 100644 index 847eb37..0000000 --- a/dist/id3-minimized.js +++ /dev/null @@ -1,28 +0,0 @@ -var q=null;function y(g,i,d){function f(b,h,e,a,d,f){var j=c();if(j){typeof f==="undefined"&&(f=!0);if(h)typeof j.onload!="undefined"?j.onload=function(){j.status=="200"||j.status=="206"?(j.fileSize=d||j.getResponseHeader("Content-Length"),h(j)):e&&e();j=q}:j.onreadystatechange=function(){if(j.readyState==4)j.status=="200"||j.status=="206"?(j.fileSize=d||j.getResponseHeader("Content-Length"),h(j)):e&&e(),j=q};j.open("GET",b,f);j.overrideMimeType&&j.overrideMimeType("text/plain; charset=x-user-defined");a&&j.setRequestHeader("Range", -"bytes="+a[0]+"-"+a[1]);j.setRequestHeader("If-Modified-Since","Sat, 1 Jan 1970 00:00:00 GMT");j.send(q)}else e&&e()}function c(){var b=q;window.XMLHttpRequest?b=new XMLHttpRequest:window.F&&(b=new ActiveXObject("Microsoft.XMLHTTP"));return b}function a(b,h){var e=c();if(e){if(h)typeof e.onload!="undefined"?e.onload=function(){e.status=="200"&&h(this);e=q}:e.onreadystatechange=function(){e.readyState==4&&(e.status=="200"&&h(this),e=q)};e.open("HEAD",b,!0);e.send(q)}}function b(b,h){var e,a;function c(b){var p= -~~(b[0]/e)-a,b=~~(b[1]/e)+1+a;p<0&&(p=0);b>=blockTotal&&(b=blockTotal-1);return[p,b]}function g(a,c){for(;n[a[0]];)if(a[0]++,a[0]>a[1]){c&&c();return}for(;n[a[1]];)if(a[1]--,a[0]>a[1]){c&&c();return}var k=[a[0]*e,(a[1]+1)*e-1];f(b,function(b){parseInt(b.getResponseHeader("Content-Length"),10)==h&&(a[0]=0,a[1]=blockTotal-1,k[0]=0,k[1]=h-1);for(var b={data:b.W||b.responseText,s:k[0]},p=a[0];p<=a[1];p++)n[p]=b;i+=k[1]-k[0]+1;c&&c()},d,k,j,!!c)}var j,i=0,l=new z("",0,h),n=[];e=e||2048;a=typeof a==="undefined"? -0:a;blockTotal=~~((h-1)/e)+1;for(var m in l)l.hasOwnProperty(m)&&typeof l[m]==="function"&&(this[m]=l[m]);this.a=function(b){var a;g(c([b,b]));a=n[~~(b/e)];if(typeof a.data=="string")return a.data.charCodeAt(b-a.s)&255;else if(typeof a.data=="unknown")return IEBinary_getByteAt(a.data,b-a.s)};this.N=function(){return i};this.f=function(b,a){g(c(b),a)}}(function(){a(g,function(a){a=parseInt(a.getResponseHeader("Content-Length"),10)||-1;i(new b(g,a))})})()} -function z(g,i,d){var f=g,c=i||0,a=0;this.P=function(){return f};if(typeof g=="string")a=d||f.length,this.a=function(b){return f.charCodeAt(b+c)&255};else if(typeof g=="unknown")a=d||IEBinary_getLength(f),this.a=function(b){return IEBinary_getByteAt(f,b+c)};this.n=function(b,a){for(var h=Array(a),e=0;e127?b-256:b};this.r=function(b,a){var h=a?(this.a(b)<< -8)+this.a(b+1):(this.a(b+1)<<8)+this.a(b);h<0&&(h+=65536);return h};this.S=function(b,a){var h=this.r(b,a);return h>32767?h-65536:h};this.h=function(b,a){var h=this.a(b),e=this.a(b+1),c=this.a(b+2),d=this.a(b+3),h=a?(((h<<8)+e<<8)+c<<8)+d:(((d<<8)+c<<8)+e<<8)+h;h<0&&(h+=4294967296);return h};this.R=function(b,a){var c=this.h(b,a);return c>2147483647?c-4294967296:c};this.q=function(b){var a=this.a(b),c=this.a(b+1),b=this.a(b+2),a=((a<<8)+c<<8)+b;a<0&&(a+=16777216);return a};this.c=function(b,a){for(var c= -[],e=b,d=0;e=224?a[g]=String.fromCharCode(i):(j=(b[d+f]<<8)+b[d+c],d+=2,a[g]=String.fromCharCode(i,j))}b= -new String(a.join(""));b.g=d;break;case "utf-8":e=0;d=Math.min(d||b.length,b.length);b[0]==239&&b[1]==187&&b[2]==191&&(e=3);f=[];for(c=0;e=194&&a<224?(g=b[e++],f[c]=String.fromCharCode(((a&31)<<6)+(g&63))):a>=224&&a<240?(g=b[e++],i=b[e++],f[c]=String.fromCharCode(((a&255)<<12)+((g&63)<<6)+(i&63))):a>=240&&a<245&&(g=b[e++],i=b[e++],j=b[e++],a=((a&7)<<18)+((g&63)<<12)+((i&63)<<6)+(j&63)-65536,f[c]=String.fromCharCode((a>>10)+55296, -(a&1023)+56320));b=new String(f.join(""));b.g=e;break;default:d=[];f=f||b.length;for(e=0;e\r\nFunction IEBinary_getByteAt(strBinary, iOffset)\r\n\tIEBinary_getByteAt = AscB(MidB(strBinary,iOffset+1,1))\r\nEnd Function\r\nFunction IEBinary_getLength(strBinary)\r\n\tIEBinary_getLength = LenB(strBinary)\r\nEnd Function\r\n<\/script>\r\n");(function(g){g.FileAPIReader=function(g){return function(d,f){var c=new FileReader;c.onload=function(a){f(new z(a.target.result))};c.readAsBinaryString(g)}}})(this);(function(g){g.k={i:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",z:function(g){for(var d="",f,c,a,b,p,h,e=0;e>2,f=(f&3)<<4|c>>4,p=(c&15)<<2|a>>6,h=a&63,isNaN(c)?p=h=64:isNaN(a)&&(h=64),d=d+Base64.i.charAt(b)+Base64.i.charAt(f)+Base64.i.charAt(p)+Base64.i.charAt(h);return d}};g.Base64=g.k;g.k.encodeBytes=g.k.z})(this);(function(g){var i=g.t={},d={},f=[0,7];i.C=function(c,a,b){b=b||{};(b.dataReader||y)(c,function(g){g.f(f,function(){var f=g.c(4,7)=="ftypM4A"?ID4:g.c(0,3)=="ID3"?ID3v2:ID3v1;f.o(g,function(){var e=b.tags,i=f.p(g,e),e=d[c]||{},k;for(k in i)i.hasOwnProperty(k)&&(e[k]=i[k]);d[c]=e;a&&a()})})})};i.A=function(c){if(!d[c])return q;var a={},b;for(b in d[c])d[c].hasOwnProperty(b)&&(a[b]=d[c][b]);return a};i.B=function(c,a){if(!d[c])return q;return d[c][a]};g.ID3=g.t;i.loadTags=i.C;i.getAllTags=i.A;i.getTag= -i.B})(this);(function(g){var i=g.u={},d=["Blues","Classic Rock","Country","Dance","Disco","Funk","Grunge","Hip-Hop","Jazz","Metal","New Age","Oldies","Other","Pop","R&B","Rap","Reggae","Rock","Techno","Industrial","Alternative","Ska","Death Metal","Pranks","Soundtrack","Euro-Techno","Ambient","Trip-Hop","Vocal","Jazz+Funk","Fusion","Trance","Classical","Instrumental","Acid","House","Game","Sound Clip","Gospel","Noise","AlternRock","Bass","Soul","Punk","Space","Meditative","Instrumental Pop","Instrumental Rock", -"Ethnic","Gothic","Darkwave","Techno-Industrial","Electronic","Pop-Folk","Eurodance","Dream","Southern Rock","Comedy","Cult","Gangsta","Top 40","Christian Rap","Pop/Funk","Jungle","Native American","Cabaret","New Wave","Psychadelic","Rave","Showtunes","Trailer","Lo-Fi","Tribal","Acid Punk","Acid Jazz","Polka","Retro","Musical","Rock & Roll","Hard Rock","Folk","Folk-Rock","National Folk","Swing","Fast Fusion","Bebob","Latin","Revival","Celtic","Bluegrass","Avantgarde","Gothic Rock","Progressive Rock", -"Psychedelic Rock","Symphonic Rock","Slow Rock","Big Band","Chorus","Easy Listening","Acoustic","Humour","Speech","Chanson","Opera","Chamber Music","Sonata","Symphony","Booty Bass","Primus","Porn Groove","Satire","Slow Jam","Club","Tango","Samba","Folklore","Ballad","Power Ballad","Rhythmic Soul","Freestyle","Duet","Punk Rock","Drum Solo","Acapella","Euro-House","Dance Hall"];i.o=function(d,c){var a=d.j();d.f([a-128-1,a],c)};i.p=function(f){var c=f.j()-128;if(f.c(c,3)=="TAG"){var a=f.c(c+3,30).replace(/\0/g, -""),b=f.c(c+33,30).replace(/\0/g,""),g=f.c(c+63,30).replace(/\0/g,""),h=f.c(c+93,4).replace(/\0/g,"");if(f.a(c+97+28)==0)var e=f.c(c+97,28).replace(/\0/g,""),i=f.a(c+97+29);else e="",i=0;f=f.a(c+97+30);return{version:"1.1",title:a,artist:b,album:g,year:h,comment:e,track:i,genre:f<255?d[f]:""}}else return{}};g.ID3v1=g.u})(this);(function(g){function i(a,b){var c=b.a(a),d=b.a(a+1),e=b.a(a+2);return b.a(a+3)&127|(e&127)<<7|(d&127)<<14|(c&127)<<21}var d=g.G={};d.b={};d.frames={BUF:"Recommended buffer size",CNT:"Play counter",COM:"Comments",CRA:"Audio encryption",CRM:"Encrypted meta frame",ETC:"Event timing codes",EQU:"Equalization",GEO:"General encapsulated object",IPL:"Involved people list",LNK:"Linked information",MCI:"Music CD Identifier",MLL:"MPEG location lookup table",PIC:"Attached picture",POP:"Popularimeter",REV:"Reverb", -RVA:"Relative volume adjustment",SLT:"Synchronized lyric/text",STC:"Synced tempo codes",TAL:"Album/Movie/Show title",TBP:"BPM (Beats Per Minute)",TCM:"Composer",TCO:"Content type",TCR:"Copyright message",TDA:"Date",TDY:"Playlist delay",TEN:"Encoded by",TFT:"File type",TIM:"Time",TKE:"Initial key",TLA:"Language(s)",TLE:"Length",TMT:"Media type",TOA:"Original artist(s)/performer(s)",TOF:"Original filename",TOL:"Original Lyricist(s)/text writer(s)",TOR:"Original release year",TOT:"Original album/Movie/Show title", -TP1:"Lead artist(s)/Lead performer(s)/Soloist(s)/Performing group",TP2:"Band/Orchestra/Accompaniment",TP3:"Conductor/Performer refinement",TP4:"Interpreted, remixed, or otherwise modified by",TPA:"Part of a set",TPB:"Publisher",TRC:"ISRC (International Standard Recording Code)",TRD:"Recording dates",TRK:"Track number/Position in set",TSI:"Size",TSS:"Software/hardware and settings used for encoding",TT1:"Content group description",TT2:"Title/Songname/Content description",TT3:"Subtitle/Description refinement", -TXT:"Lyricist/text writer",TXX:"User defined text information frame",TYE:"Year",UFI:"Unique file identifier",ULT:"Unsychronized lyric/text transcription",WAF:"Official audio file webpage",WAR:"Official artist/performer webpage",WAS:"Official audio source webpage",WCM:"Commercial information",WCP:"Copyright/Legal information",WPB:"Publishers official webpage",WXX:"User defined URL link frame",AENC:"Audio encryption",APIC:"Attached picture",COMM:"Comments",COMR:"Commercial frame",ENCR:"Encryption method registration", -EQUA:"Equalization",ETCO:"Event timing codes",GEOB:"General encapsulated object",GRID:"Group identification registration",IPLS:"Involved people list",LINK:"Linked information",MCDI:"Music CD identifier",MLLT:"MPEG location lookup table",OWNE:"Ownership frame",PRIV:"Private frame",PCNT:"Play counter",POPM:"Popularimeter",POSS:"Position synchronisation frame",RBUF:"Recommended buffer size",RVAD:"Relative volume adjustment",RVRB:"Reverb",SYLT:"Synchronized lyric/text",SYTC:"Synchronized tempo codes", -TALB:"Album/Movie/Show title",TBPM:"BPM (beats per minute)",TCOM:"Composer",TCON:"Content type",TCOP:"Copyright message",TDAT:"Date",TDLY:"Playlist delay",TENC:"Encoded by",TEXT:"Lyricist/Text writer",TFLT:"File type",TIME:"Time",TIT1:"Content group description",TIT2:"Title/songname/content description",TIT3:"Subtitle/Description refinement",TKEY:"Initial key",TLAN:"Language(s)",TLEN:"Length",TMED:"Media type",TOAL:"Original album/movie/show title",TOFN:"Original filename",TOLY:"Original lyricist(s)/text writer(s)", -TOPE:"Original artist(s)/performer(s)",TORY:"Original release year",TOWN:"File owner/licensee",TPE1:"Lead performer(s)/Soloist(s)",TPE2:"Band/orchestra/accompaniment",TPE3:"Conductor/performer refinement",TPE4:"Interpreted, remixed, or otherwise modified by",TPOS:"Part of a set",TPUB:"Publisher",TRCK:"Track number/Position in set",TRDA:"Recording dates",TRSN:"Internet radio station name",TRSO:"Internet radio station owner",TSIZ:"Size",TSRC:"ISRC (international standard recording code)",TSSE:"Software/Hardware and settings used for encoding", -TYER:"Year",TXXX:"User defined text information frame",UFID:"Unique file identifier",USER:"Terms of use",USLT:"Unsychronized lyric/text transcription",WCOM:"Commercial information",WCOP:"Copyright/Legal information",WOAF:"Official audio file webpage",WOAR:"Official artist/performer webpage",WOAS:"Official audio source webpage",WORS:"Official internet radio station homepage",WPAY:"Payment",WPUB:"Publishers official webpage",WXXX:"User defined URL link frame"};var f={title:["TIT2","TT2"],artist:["TPE1", -"TP1"],album:["TALB","TAL"],year:["TYER","TYE"],comment:["COMM","COM"],track:["TRCK","TRK"],genre:["TCON","TCO"],picture:["APIC","PIC"],lyrics:["USLT","ULT"]},c=["title","artist","album","track"];d.o=function(a,b){a.f([0,i(6,a)],b)};d.p=function(a,b){var g=0,h=a.a(g+3);if(h>4)return{version:">2.4"};var e=a.a(g+4),v=a.d(g+5,7),k=a.d(g+5,6),s=a.d(g+5,5),j=i(g+6,a);g+=10;if(k){var o=a.h(g,!0);g+=o+4}var h={version:"2."+h+"."+e,major:h,revision:e,flags:{unsynchronisation:v,extended_header:k,experimental_indicator:s}, -size:j},l;if(v)l={};else{j-=10;for(var v=a,e=b,k={},s=h.major,o=[],n=0,m;m=(e||c)[n];n++)o=o.concat(f[m]||[m]);for(e=o;g2&&(u={message:{Y:n.d(m+8,6),K:n.d(m+8,5),V:n.d(m+8,4)},m:{T:n.d(m+8+1,7),H:n.d(m+8+1,3),J:n.d(m+8+1,2),D:n.d(m+8+1,1),w:n.d(m+8+1,0)}}),m+=t,u&&u.m.w&&(i(m,n),m+=4,r-=4),!u||!u.m.D))l in -d.b?o=d.b[l]:l[0]=="T"&&(o=d.b["T*"]),o=o?o(m,r,n,u):void 0,o={id:l,size:r,description:l in d.frames?d.frames[l]:"Unknown",data:o},l in k?(k[l].id&&(k[l]=[k[l]]),k[l].push(o)):k[l]=o}l=k}for(var w in f)if(f.hasOwnProperty(w)){a:{r=f[w];typeof r=="string"&&(r=[r]);t=0;for(g=void 0;g=r[t];t++)if(g in l){a=l[g].data;break a}a=void 0}a&&(h[w]=a)}for(var x in l)l.hasOwnProperty(x)&&(h[x]=l[x]);return h};g.ID3v2=d})(this);(function(){function g(d){var f;switch(d){case 0:f="iso-8859-1";break;case 1:f="utf-16";break;case 2:f="utf-16be";break;case 3:f="utf-8"}return f}var i=["32x32 pixels 'file icon' (PNG only)","Other file icon","Cover (front)","Cover (back)","Leaflet page","Media (e.g. lable side of CD)","Lead artist/lead performer/soloist","Artist/performer","Conductor","Band/Orchestra","Composer","Lyricist/text writer","Recording Location","During recording","During performance","Movie/video screen capture","A bright coloured fish", -"Illustration","Band/artist logotype","Publisher/Studio logotype"];ID3v2.b.APIC=function(d,f,c,a,b){var b=b||"3",a=d,p=g(c.a(d));switch(b){case "2":var h=c.c(d+1,3);d+=4;break;case "3":case "4":h=c.e(d+1,f-(d-a),p),d+=1+h.g}b=c.a(d,1);b=i[b];p=c.e(d+1,f-(d-a),p);d+=1+p.g;return{format:h.toString(),type:b,description:p.toString(),data:c.n(d,a+f-d)}};ID3v2.b.COMM=function(d,f,c){var a=d,b=g(c.a(d)),i=c.c(d+1,3),h=c.e(d+4,f-4,b);d+=4+h.g;d=c.e(d,a+f-d,b);return{language:i,X:h.toString(),text:d.toString()}}; -ID3v2.b.COM=ID3v2.b.COMM;ID3v2.b.PIC=function(d,f,c,a){return ID3v2.b.APIC(d,f,c,a,"2")};ID3v2.b.PCNT=function(d,f,c){return c.O(d)};ID3v2.b.CNT=ID3v2.b.PCNT;ID3v2.b["T*"]=function(d,f,c){var a=g(c.a(d));return c.e(d+1,f-1,a).toString()};ID3v2.b.TCON=function(){return ID3v2.b["T*"].apply(this,arguments).replace(/^\(\d+\)/,"")};ID3v2.b.TCO=ID3v2.b.TCON;ID3v2.b.USLT=function(d,f,c){var a=d,b=g(c.a(d)),i=c.c(d+1,3),h=c.e(d+4,f-4,b);d+=4+h.g;d=c.e(d,a+f-d,b);return{language:i,I:h.toString(),U:d.toString()}}; -ID3v2.b.ULT=ID3v2.b.USLT})();(function(g){function i(c,a,b,d){var g=c.h(a,!0);if(g==0)d();else{var e=c.c(a+4,4);["moov","udta","meta","ilst"].indexOf(e)>-1?(e=="meta"&&(a+=4),c.f([a+8,a+8+8],function(){i(c,a+8,g-8,d)})):c.f([a+(e in f.l?0:g),a+g+8],function(){i(c,a+g,b,d)})}}function d(c,a,b,g,h){for(var h=h===void 0?"":h+" ",e=b;e-1){k=="meta"&&(e+=4);d(c,a,e+8,i-8,h);break}if(f.l[k]){var s=a.q(e+16+1),j=f.l[k],s=f.types[s];if(k== -"trkn")c[j[0]]=a.a(e+16+11),c.count=a.a(e+16+13);else{var k=e+16+4+4,o=i-16-4-4;switch(s){case "text":c[j[0]]=a.e(k,o,"UTF-8");break;case "uint8":c[j[0]]=a.r(k);break;case "jpeg":case "png":c[j[0]]={m:"image/"+s,data:a.n(k,o)}}}}e+=i}}var f=g.v={};f.types={0:"uint8",1:"text",13:"jpeg",14:"png",21:"uint8"};f.l={"\u00a9alb":["album"],"\u00a9art":["artist"],"\u00a9ART":["artist"],aART:["artist"],"\u00a9day":["year"],"\u00a9nam":["title"],"\u00a9gen":["genre"],trkn:["track"],"\u00a9wrt":["composer"], -"\u00a9too":["encoder"],cprt:["copyright"],covr:["picture"],"\u00a9grp":["grouping"],keyw:["keyword"],"\u00a9lyr":["lyrics"],"\u00a9gen":["genre"]};f.o=function(c,a){c.f([0,7],function(){i(c,0,c.j(),a)})};f.p=function(c){var a={};d(a,c,0,c.j());return a};g.ID4=g.v})(this); diff --git a/dist/id3.js b/dist/id3.js new file mode 100644 index 0000000..5bb0f83 --- /dev/null +++ b/dist/id3.js @@ -0,0 +1,1318 @@ +/***/ +/** + * Copyright (c) 2010, António Afonso . All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY António Afonso ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +var StringUtils = { + readUTF16String: function(bytes, bigEndian, maxBytes) { + var ix = 0; + var offset1 = 1, offset2 = 0; + maxBytes = Math.min(maxBytes||bytes.length, bytes.length); + + if( bytes[0] == 0xFE && bytes[1] == 0xFF ) { + bigEndian = true; + ix = 2; + } else if( bytes[0] == 0xFF && bytes[1] == 0xFE ) { + bigEndian = false; + ix = 2; + } + if( bigEndian ) { + offset1 = 0; + offset2 = 1; + } + + var arr = []; + for( var j = 0; ix < maxBytes; j++ ) { + var byte1 = bytes[ix+offset1]; + var byte2 = bytes[ix+offset2]; + var word1 = (byte1<<8)+byte2; + ix += 2; + if( word1 == 0x0000 ) { + break; + } else if( byte1 < 0xD8 || byte1 >= 0xE0 ) { + arr[j] = String.fromCharCode(word1); + } else { + var byte3 = bytes[ix+offset1]; + var byte4 = bytes[ix+offset2]; + var word2 = (byte3<<8)+byte4; + ix += 2; + arr[j] = String.fromCharCode(word1, word2); + } + } + var string = new String(arr.join("")); + string.bytesReadCount = ix; + return string; + }, + readUTF8String: function(bytes, maxBytes) { + var ix = 0; + maxBytes = Math.min(maxBytes||bytes.length, bytes.length); + + if( bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF ) { + ix = 3; + } + + var arr = []; + for( var j = 0; ix < maxBytes; j++ ) { + var byte1 = bytes[ix++]; + if( byte1 == 0x00 ) { + break; + } else if( byte1 < 0x80 ) { + arr[j] = String.fromCharCode(byte1); + } else if( byte1 >= 0xC2 && byte1 < 0xE0 ) { + var byte2 = bytes[ix++]; + arr[j] = String.fromCharCode(((byte1&0x1F)<<6) + (byte2&0x3F)); + } else if( byte1 >= 0xE0 && byte1 < 0xF0 ) { + var byte2 = bytes[ix++]; + var byte3 = bytes[ix++]; + arr[j] = String.fromCharCode(((byte1&0xFF)<<12) + ((byte2&0x3F)<<6) + (byte3&0x3F)); + } else if( byte1 >= 0xF0 && byte1 < 0xF5) { + var byte2 = bytes[ix++]; + var byte3 = bytes[ix++]; + var byte4 = bytes[ix++]; + var codepoint = ((byte1&0x07)<<18) + ((byte2&0x3F)<<12)+ ((byte3&0x3F)<<6) + (byte4&0x3F) - 0x10000; + arr[j] = String.fromCharCode( + (codepoint>>10) + 0xD800, + (codepoint&0x3FF) + 0xDC00 + ); + } + } + var string = new String(arr.join("")); + string.bytesReadCount = ix; + return string; + }, + readNullTerminatedString: function(bytes, maxBytes) { + var arr = []; + maxBytes = maxBytes || bytes.length; + for ( var i = 0; i < maxBytes; ) { + var byte1 = bytes[i++]; + if( byte1 == 0x00 ) break; + arr[i-1] = String.fromCharCode(byte1); + } + var string = new String(arr.join("")); + string.bytesReadCount = i; + return string; + }, + + readWin1251String: function(str) { + var charmap = unescape( + "%u0402%u0403%u201A%u0453%u201E%u2026%u2020%u2021%u20AC%u2030%u0409%u2039%u040A%u040C%u040B%u040F"+ + "%u0452%u2018%u2019%u201C%u201D%u2022%u2013%u2014%u0000%u2122%u0459%u203A%u045A%u045C%u045B%u045F"+ + "%u00A0%u040E%u045E%u0408%u00A4%u0490%u00A6%u00A7%u0401%u00A9%u0404%u00AB%u00AC%u00AD%u00AE%u0407"+ + "%u00B0%u00B1%u0406%u0456%u0491%u00B5%u00B6%u00B7%u0451%u2116%u0454%u00BB%u0458%u0405%u0455%u0457"); + var code2char = function(code) { + if(code >= 0xC0 && code <= 0xFF) return String.fromCharCode(code - 0xC0 + 0x0410) + if(code >= 0x80 && code <= 0xBF) return charmap.charAt(code - 0x80) + return String.fromCharCode(code) + }; + var res = ""; + for(var i = 0; i < str.length; i++) res = res + code2char(str.charCodeAt(i)) + console.log('Win1251 result:',res); + return res; + } +}; +/** + * Buffered Binary Ajax 0.2.1 + * Copyright (c) 2010 António Afonso, antonio.afonso gmail, http://www.aadsm.net/ + * MIT License [http://www.opensource.org/licenses/mit-license.php] + * + * Adapted from Binary Ajax 0.1.5 + */ + +/** + * @class Reads a remote file without having to download it all. + * + * Creates a new BufferedBinaryFile that will download chunks of the file pointed by the URL given only on a per need basis. + * + * @param {string} strUrl The URL with the location of the file to be read. + * @param {number} iLength The size of the file. + * @param {number} [blockSize=2048] The size of the chunk that will be downloaded when data is read. + * @param {number} [blockRadius=0] The number of chunks, immediately after and before the chunk needed, that will also be downloaded. + * + * @constructor + * @augments BinaryFile + */ +function BufferedBinaryFile(strUrl, iLength, blockSize, blockRadius) { + var undefined; + var downloadedBytesCount = 0; + var binaryFile = new BinaryFile("", 0, iLength); + var blocks = []; + + blockSize = blockSize || 1024*2; + blockRadius = (typeof blockRadius === "undefined") ? 0 : blockRadius; + blockTotal = ~~((iLength-1)/blockSize) + 1; + + function getBlockRangeForByteRange(range) { + var blockStart = ~~(range[0]/blockSize) - blockRadius; + var blockEnd = ~~(range[1]/blockSize)+1 + blockRadius; + + if( blockStart < 0 ) blockStart = 0; + if( blockEnd >= blockTotal ) blockEnd = blockTotal-1; + + return [blockStart, blockEnd]; + } + + // TODO: wondering if a "recently used block" could help things around + // here. + function getBlockAtOffset(offset) { + var blockRange = getBlockRangeForByteRange([offset, offset]); + waitForBlocks(blockRange); + return blocks[~~(offset/blockSize)]; + } + + /** + * @param {?function()} callback If a function is passed then this function will be asynchronous and the callback invoked when the blocks have been loaded, otherwise it blocks script execution until the request is completed. + */ + function waitForBlocks(blockRange, callback) { + // Filter out already downloaded blocks or return if found out that + // the entire block range has already been downloaded. + while( blocks[blockRange[0]] ) { + blockRange[0]++; + if( blockRange[0] > blockRange[1] ) return callback ? callback() : undefined; + } + while( blocks[blockRange[1]] ) { + blockRange[1]--; + if( blockRange[0] > blockRange[1] ) return callback ? callback() : undefined; + } + var range = [blockRange[0]*blockSize, (blockRange[1]+1)*blockSize-1]; + //console.log("Getting: " + range[0] + " to " + range[1]); + sendRequest( + strUrl, + function(http) { + var size = parseInt(http.getResponseHeader("Content-Length"), 10); + // Range header not supported + if( size == iLength ) { + blockRange[0] = 0; + blockRange[1] = blockTotal-1; + range[0] = 0; + range[1] = iLength-1; + } + var block = { + data: http.responseBody || http.responseText, + offset: range[0] + }; + + for( var i = blockRange[0]; i <= blockRange[1]; i++ ) { + blocks[i] = block; + } + downloadedBytesCount += range[1] - range[0] + 1; + if (callback) callback(); + }, + fncError, + range, + "bytes", + undefined, + !!callback + ); + } + + // Mixin all BinaryFile's methods. + // Not using prototype linking since the constructor needs to know + // the length of the file. + for( var key in binaryFile ) { + if( binaryFile.hasOwnProperty(key) && + typeof binaryFile[key] === "function") { + this[key] = binaryFile[key]; + } + } + /** + * @override + */ + this.getByteAt = function(iOffset) { + var block = getBlockAtOffset(iOffset); + if( typeof block.data == "string" ) { + return block.data.charCodeAt(iOffset - block.offset) & 0xFF; + } else if( typeof block.data == "unknown" ) { + return IEBinary_getByteAt(block.data, iOffset - block.offset); + } + }; + + /** + * Gets the number of total bytes that have been downloaded. + * + * @returns The number of total bytes that have been downloaded. + */ + this.getDownloadedBytesCount = function() { + return downloadedBytesCount; + }; + + /** + * Downloads the byte range given. Useful for preloading. + * + * @param {Array} range Two element array that denotes the first byte to be read on the first position and the last byte to be read on the last position. A range of [2, 5] will download bytes 2,3,4 and 5. + * @param {?function()} callback The function to invoke when the blocks have been downloaded, this makes this call asynchronous. + */ + this.loadRange = function(range, callback) { + var blockRange = getBlockRangeForByteRange(range); + waitForBlocks(blockRange, callback); + }; +} + + +/** + * @constructor + */ +function BinaryFile(strData, iDataOffset, iDataLength) { + var data = strData; + var dataOffset = iDataOffset || 0; + var dataLength = 0; + + this.getRawData = function() { + return data; + }; + + if (typeof strData == "string") { + dataLength = iDataLength || data.length; + + this.getByteAt = function(iOffset) { + return data.charCodeAt(iOffset + dataOffset) & 0xFF; + }; + } else if (typeof strData == "unknown") { + dataLength = iDataLength || IEBinary_getLength(data); + + this.getByteAt = function(iOffset) { + return IEBinary_getByteAt(data, iOffset + dataOffset); + }; + } + // @aadsm + this.getBytesAt = function(iOffset, iLength) { + var bytes = new Array(iLength); + for( var i = 0; i < iLength; i++ ) { + bytes[i] = this.getByteAt(iOffset+i); + } + return bytes; + }; + + this.getLength = function() { + return dataLength; + }; + + // @aadsm + this.isBitSetAt = function(iOffset, iBit) { + var iByte = this.getByteAt(iOffset); + return (iByte & (1 << iBit)) != 0; + }; + + this.getSByteAt = function(iOffset) { + var iByte = this.getByteAt(iOffset); + if (iByte > 127) + return iByte - 256; + else + return iByte; + }; + + this.getShortAt = function(iOffset, bBigEndian) { + var iShort = bBigEndian ? + (this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1) + : (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset); + if (iShort < 0) iShort += 65536; + return iShort; + }; + this.getSShortAt = function(iOffset, bBigEndian) { + var iUShort = this.getShortAt(iOffset, bBigEndian); + if (iUShort > 32767) + return iUShort - 65536; + else + return iUShort; + }; + this.getLongAt = function(iOffset, bBigEndian) { + var iByte1 = this.getByteAt(iOffset), + iByte2 = this.getByteAt(iOffset + 1), + iByte3 = this.getByteAt(iOffset + 2), + iByte4 = this.getByteAt(iOffset + 3); + + var iLong = bBigEndian ? + (((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4 + : (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1; + if (iLong < 0) iLong += 4294967296; + return iLong; + }; + this.getSLongAt = function(iOffset, bBigEndian) { + var iULong = this.getLongAt(iOffset, bBigEndian); + if (iULong > 2147483647) + return iULong - 4294967296; + else + return iULong; + }; + // @aadsm + this.getInteger24At = function(iOffset, bBigEndian) { + var iByte1 = this.getByteAt(iOffset), + iByte2 = this.getByteAt(iOffset + 1), + iByte3 = this.getByteAt(iOffset + 2); + + var iInteger = bBigEndian ? + ((((iByte1 << 8) + iByte2) << 8) + iByte3) + : ((((iByte3 << 8) + iByte2) << 8) + iByte1); + if (iInteger < 0) iInteger += 16777216; + return iInteger; + }; + this.getStringAt = function(iOffset, iLength) { + var aStr = []; + for (var i=iOffset,j=0;i0) || !(iLength>0)){ + return ''; + } + var bytes = this.getBytesAt(iOffset, iLength), + originalString = this.getStringAt(iOffset, iLength), + iCharset=iCharset || jschardet.detect(originalString).encoding, + sString; + console.log('Charset:',iCharset); + + switch( iCharset.toLowerCase() ) { + + case 'utf-16': + case 'utf-16le': + case 'utf-16be': + sString = StringUtils.readUTF16String(bytes, iCharset); + break; + + case 'utf-8': + sString = StringUtils.readUTF8String(bytes); + break; + case 'iso-8859-1': + var charsetDetection=jschardet.detect(originalString); + console.log('Detection:',charsetDetection); + if('TIS-620'===charsetDetection.encoding || + 'windows-1253'===charsetDetection.encoding || + 'windows-1251'===charsetDetection.encoding || + 'EUC-TV'===charsetDetection.encoding){ + sString = StringUtils.readWin1251String(originalString); + break; + } + case 'windows-1251': + sString = StringUtils.readWin1251String(originalString); + break; + case 'maccyrillic': + sString = StringUtils.readWin1251String(originalString); + break; + default: + sString = StringUtils.readNullTerminatedString(bytes); + break; + } + console.log('Result',sString); + return sString; + }; + + this.getCharAt = function(iOffset) { + return String.fromCharCode(this.getByteAt(iOffset)); + }; + this.toBase64 = function() { + return window.btoa(data); + }; + this.fromBase64 = function(strBase64) { + data = window.atob(strBase64); + }; + + this.loadRange = function(range, callback) { + callback(); + }; +} +/** + * Copyright (c) 2011 Anton Podviaznikov, podviaznikov@gmail.com + * MIT License [http://www.opensource.org/licenses/mit-license.php] + * + */ + (function(ns) { + ns["FileAPIReader"] = function(binaryData) { + return function(url, fncCallback, fncError) { + fncCallback(new BinaryFile(binaryData)); + } + }; +})(this); + +// Modified version of http://www.webtoolkit.info/javascript-base64.html +(function(ns) { + ns.Base64 = { + // private property + _keyStr : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", + + // public method for encoding + encodeBytes : function (input) { + var output = ""; + var chr1, chr2, chr3, enc1, enc2, enc3, enc4; + var i = 0; + + while (i < input.length) { + + chr1 = input[i++]; + chr2 = input[i++]; + chr3 = input[i++]; + + enc1 = chr1 >> 2; + enc2 = ((chr1 & 3) << 4) | (chr2 >> 4); + enc3 = ((chr2 & 15) << 2) | (chr3 >> 6); + enc4 = chr3 & 63; + + if (isNaN(chr2)) { + enc3 = enc4 = 64; + } else if (isNaN(chr3)) { + enc4 = 64; + } + + output = output + + Base64._keyStr.charAt(enc1) + Base64._keyStr.charAt(enc2) + + Base64._keyStr.charAt(enc3) + Base64._keyStr.charAt(enc4); + + } + + return output; + } + }; + + // Export functions for closure compiler + ns["Base64"] = ns.Base64; + ns.Base64["encodeBytes"] = ns.Base64.encodeBytes; +})(this); +/* + * JavaScript ID3 Tag Reader 0.1.2 + * Copyright (c) 2008 Jacob Seidelin, cupboy@gmail.com, http://blog.nihilogic.dk/ + * MIT License [http://www.opensource.org/licenses/mit-license.php] + * + * Extended by António Afonso (antonio.afonso@opera.com), Opera Software ASA + * Modified by António Afonso + */ + +(function(ns) { + var ID3 = ns.ID3 = {}; + + var _files = {}; + // location of the format identifier + var _formatIDRange = [0, 7]; + + /** + * Finds out the tag format of this data and returns the appropriate + * reader. + */ + function getTagReader(data) { + // FIXME: improve this detection according to the spec + return data.getStringAt(4, 7) == "ftypM4A" ? ID4 : + (data.getStringAt(0, 3) == "ID3" ? ID3v2 : ID3v1); + } + + function readTags(reader, data, url, tags) { + var tagsFound = reader.readTagsFromData(data, tags); + var tags = _files[url] || {}; + for( var tag in tagsFound ) if( tagsFound.hasOwnProperty(tag) ) { + tags[tag] = tagsFound[tag]; + } + _files[url] = tags; + } + + /** + * @param {string} url The location of the sound file to read. + * @param {function()} cb The callback function to be invoked when all tags have been read. + * @param {{tags: Array., dataReader: function(string, function(BinaryReader))}} options The set of options that can specify the tags to be read and the dataReader to use in order to read the file located at url. + */ + ID3.loadTags = function(url, cb, options) { + options = options || {}; + var dataReader = options["dataReader"]; + + dataReader(url, function(data) { + // preload the format identifier + data.loadRange(_formatIDRange, function() { + var reader = getTagReader(data); + reader.loadData(data, function() { + readTags(reader, data, url, options["tags"]); + if( cb ) cb(); + }); + }); + }); + }; + + ID3.getAllTags = function(url) { + if (!_files[url]) return null; + + var tags = {}; + for (var a in _files[url]) { + if (_files[url].hasOwnProperty(a)) + tags[a] = _files[url][a]; + } + return tags; + }; + + ID3.getTag = function(url, tag) { + if (!_files[url]) return null; + + return _files[url][tag]; + }; + + // Export functions for closure compiler + ns["ID3"] = ns.ID3; + ID3["loadTags"] = ID3.loadTags; + ID3["getAllTags"] = ID3.getAllTags; + ID3["getTag"] = ID3.getTag; +})(this); +/* + * JavaScript ID3 Tag Reader 0.1.2 + * Copyright (c) 2008 Jacob Seidelin, cupboy@gmail.com, http://blog.nihilogic.dk/ + * MIT License [http://www.opensource.org/licenses/mit-license.php] + * + * Extended by António Afonso (antonio.afonso@opera.com), Opera Software ASA + * Modified by António Afonso (antonio.afonso gmail.com) + */ + +(function(ns) { + var ID3v1 = ns.ID3v1 = {}; + var genres = [ + "Blues","Classic Rock","Country","Dance","Disco","Funk","Grunge", + "Hip-Hop","Jazz","Metal","New Age","Oldies","Other","Pop","R&B", + "Rap","Reggae","Rock","Techno","Industrial","Alternative","Ska", + "Death Metal","Pranks","Soundtrack","Euro-Techno","Ambient", + "Trip-Hop","Vocal","Jazz+Funk","Fusion","Trance","Classical", + "Instrumental","Acid","House","Game","Sound Clip","Gospel", + "Noise","AlternRock","Bass","Soul","Punk","Space","Meditative", + "Instrumental Pop","Instrumental Rock","Ethnic","Gothic", + "Darkwave","Techno-Industrial","Electronic","Pop-Folk", + "Eurodance","Dream","Southern Rock","Comedy","Cult","Gangsta", + "Top 40","Christian Rap","Pop/Funk","Jungle","Native American", + "Cabaret","New Wave","Psychadelic","Rave","Showtunes","Trailer", + "Lo-Fi","Tribal","Acid Punk","Acid Jazz","Polka","Retro", + "Musical","Rock & Roll","Hard Rock","Folk","Folk-Rock", + "National Folk","Swing","Fast Fusion","Bebob","Latin","Revival", + "Celtic","Bluegrass","Avantgarde","Gothic Rock","Progressive Rock", + "Psychedelic Rock","Symphonic Rock","Slow Rock","Big Band", + "Chorus","Easy Listening","Acoustic","Humour","Speech","Chanson", + "Opera","Chamber Music","Sonata","Symphony","Booty Bass","Primus", + "Porn Groove","Satire","Slow Jam","Club","Tango","Samba", + "Folklore","Ballad","Power Ballad","Rhythmic Soul","Freestyle", + "Duet","Punk Rock","Drum Solo","Acapella","Euro-House","Dance Hall" + ]; + + ID3v1.loadData = function(data, callback) { + var length = data.getLength(); + data.loadRange([length-128-1, length], callback); + } + + ID3v1.readTagsFromData = function(data) { + var offset = data.getLength() - 128; + var header = data.getStringAt(offset, 3); + if (header == "TAG") { + var title = data.getStringWithCharsetAt(offset + 3, 30).replace(/\0/g, ""); + var artist = data.getStringWithCharsetAt(offset + 33, 30).replace(/\0/g, ""); + var album = data.getStringWithCharsetAt(offset + 63, 30).replace(/\0/g, ""); + var year = data.getStringAt(offset + 93, 4).replace(/\0/g, ""); + + var trackFlag = data.getByteAt(offset + 97 + 28); + if (trackFlag == 0) { + var comment = data.getStringAt(offset + 97, 28).replace(/\0/g, ""); + var track = data.getByteAt(offset + 97 + 29); + } else { + var comment = ""; + var track = 0; + } + + var genreIdx = data.getByteAt(offset + 97 + 30); + if (genreIdx < 255) { + var genre = genres[genreIdx]; + } else { + var genre = ""; + } + + return { + "version" : '1.1', + "title" : title, + "artist" : artist, + "album" : album, + "year" : year, + "comment" : comment, + "track" : track, + "genre" : genre + } + } else { + return {}; + } + }; + + // Export functions for closure compiler + ns["ID3v1"] = ns.ID3v1; +})(this); +/* + * Copyright (c) 2009 Opera Software ASA, António Afonso (antonio.afonso@opera.com) + * Modified by António Afonso + */ + +(function(ns) { + var ID3v2 = ns.ID3v2 = {}; + + ID3v2.readFrameData = {}; + ID3v2.frames = { + // v2.2 + "BUF" : "Recommended buffer size", + "CNT" : "Play counter", + "COM" : "Comments", + "CRA" : "Audio encryption", + "CRM" : "Encrypted meta frame", + "ETC" : "Event timing codes", + "EQU" : "Equalization", + "GEO" : "General encapsulated object", + "IPL" : "Involved people list", + "LNK" : "Linked information", + "MCI" : "Music CD Identifier", + "MLL" : "MPEG location lookup table", + "PIC" : "Attached picture", + "POP" : "Popularimeter", + "REV" : "Reverb", + "RVA" : "Relative volume adjustment", + "SLT" : "Synchronized lyric/text", + "STC" : "Synced tempo codes", + "TAL" : "Album/Movie/Show title", + "TBP" : "BPM (Beats Per Minute)", + "TCM" : "Composer", + "TCO" : "Content type", + "TCR" : "Copyright message", + "TDA" : "Date", + "TDY" : "Playlist delay", + "TEN" : "Encoded by", + "TFT" : "File type", + "TIM" : "Time", + "TKE" : "Initial key", + "TLA" : "Language(s)", + "TLE" : "Length", + "TMT" : "Media type", + "TOA" : "Original artist(s)/performer(s)", + "TOF" : "Original filename", + "TOL" : "Original Lyricist(s)/text writer(s)", + "TOR" : "Original release year", + "TOT" : "Original album/Movie/Show title", + "TP1" : "Lead artist(s)/Lead performer(s)/Soloist(s)/Performing group", + "TP2" : "Band/Orchestra/Accompaniment", + "TP3" : "Conductor/Performer refinement", + "TP4" : "Interpreted, remixed, or otherwise modified by", + "TPA" : "Part of a set", + "TPB" : "Publisher", + "TRC" : "ISRC (International Standard Recording Code)", + "TRD" : "Recording dates", + "TRK" : "Track number/Position in set", + "TSI" : "Size", + "TSS" : "Software/hardware and settings used for encoding", + "TT1" : "Content group description", + "TT2" : "Title/Songname/Content description", + "TT3" : "Subtitle/Description refinement", + "TXT" : "Lyricist/text writer", + "TXX" : "User defined text information frame", + "TYE" : "Year", + "UFI" : "Unique file identifier", + "ULT" : "Unsychronized lyric/text transcription", + "WAF" : "Official audio file webpage", + "WAR" : "Official artist/performer webpage", + "WAS" : "Official audio source webpage", + "WCM" : "Commercial information", + "WCP" : "Copyright/Legal information", + "WPB" : "Publishers official webpage", + "WXX" : "User defined URL link frame", + // v2.3 + "AENC" : "Audio encryption", + "APIC" : "Attached picture", + "COMM" : "Comments", + "COMR" : "Commercial frame", + "ENCR" : "Encryption method registration", + "EQUA" : "Equalization", + "ETCO" : "Event timing codes", + "GEOB" : "General encapsulated object", + "GRID" : "Group identification registration", + "IPLS" : "Involved people list", + "LINK" : "Linked information", + "MCDI" : "Music CD identifier", + "MLLT" : "MPEG location lookup table", + "OWNE" : "Ownership frame", + "PRIV" : "Private frame", + "PCNT" : "Play counter", + "POPM" : "Popularimeter", + "POSS" : "Position synchronisation frame", + "RBUF" : "Recommended buffer size", + "RVAD" : "Relative volume adjustment", + "RVRB" : "Reverb", + "SYLT" : "Synchronized lyric/text", + "SYTC" : "Synchronized tempo codes", + "TALB" : "Album/Movie/Show title", + "TBPM" : "BPM (beats per minute)", + "TCOM" : "Composer", + "TCON" : "Content type", + "TCOP" : "Copyright message", + "TDAT" : "Date", + "TDLY" : "Playlist delay", + "TENC" : "Encoded by", + "TEXT" : "Lyricist/Text writer", + "TFLT" : "File type", + "TIME" : "Time", + "TIT1" : "Content group description", + "TIT2" : "Title/songname/content description", + "TIT3" : "Subtitle/Description refinement", + "TKEY" : "Initial key", + "TLAN" : "Language(s)", + "TLEN" : "Length", + "TMED" : "Media type", + "TOAL" : "Original album/movie/show title", + "TOFN" : "Original filename", + "TOLY" : "Original lyricist(s)/text writer(s)", + "TOPE" : "Original artist(s)/performer(s)", + "TORY" : "Original release year", + "TOWN" : "File owner/licensee", + "TPE1" : "Lead performer(s)/Soloist(s)", + "TPE2" : "Band/orchestra/accompaniment", + "TPE3" : "Conductor/performer refinement", + "TPE4" : "Interpreted, remixed, or otherwise modified by", + "TPOS" : "Part of a set", + "TPUB" : "Publisher", + "TRCK" : "Track number/Position in set", + "TRDA" : "Recording dates", + "TRSN" : "Internet radio station name", + "TRSO" : "Internet radio station owner", + "TSIZ" : "Size", + "TSRC" : "ISRC (international standard recording code)", + "TSSE" : "Software/Hardware and settings used for encoding", + "TYER" : "Year", + "TXXX" : "User defined text information frame", + "UFID" : "Unique file identifier", + "USER" : "Terms of use", + "USLT" : "Unsychronized lyric/text transcription", + "WCOM" : "Commercial information", + "WCOP" : "Copyright/Legal information", + "WOAF" : "Official audio file webpage", + "WOAR" : "Official artist/performer webpage", + "WOAS" : "Official audio source webpage", + "WORS" : "Official internet radio station homepage", + "WPAY" : "Payment", + "WPUB" : "Publishers official webpage", + "WXXX" : "User defined URL link frame" + }; + + var _shortcuts = { + "title" : ["TIT2", "TT2"], + "artist" : ["TPE1", "TP1"], + "album" : ["TALB", "TAL"], + "year" : ["TYER", "TYE"], + "comment" : ["COMM", "COM"], + "track" : ["TRCK", "TRK"], + "genre" : ["TCON", "TCO"], + "picture" : ["APIC", "PIC"], + "lyrics" : ["USLT", "ULT"] + }; + var _defaultShortcuts = ["title", "artist", "album", "track"]; + + function getTagsFromShortcuts(shortcuts) { + var tags = []; + for( var i = 0, shortcut; shortcut = shortcuts[i]; i++ ) { + tags = tags.concat(_shortcuts[shortcut]||[shortcut]); + } + return tags; + } + + // The ID3v2 tag/frame size is encoded with four bytes where the most significant bit (bit 7) is set to zero in every byte, making a total of 28 bits. The zeroed bits are ignored, so a 257 bytes long tag is represented as $00 00 02 01. + function readSynchsafeInteger32At(offset, data) { + var size1 = data.getByteAt(offset); + var size2 = data.getByteAt(offset+1); + var size3 = data.getByteAt(offset+2); + var size4 = data.getByteAt(offset+3); + // 0x7f = 0b01111111 + var size = size4 & 0x7f + | ((size3 & 0x7f) << 7) + | ((size2 & 0x7f) << 14) + | ((size1 & 0x7f) << 21); + + return size; + } + + function readFrameFlags(data, offset) + { + var flags = + { + message: + { + tag_alter_preservation : data.isBitSetAt( offset, 6), + file_alter_preservation : data.isBitSetAt( offset, 5), + read_only : data.isBitSetAt( offset, 4) + }, + format: + { + grouping_identity : data.isBitSetAt( offset+1, 7), + compression : data.isBitSetAt( offset+1, 3), + encription : data.isBitSetAt( offset+1, 2), + unsynchronisation : data.isBitSetAt( offset+1, 1), + data_length_indicator : data.isBitSetAt( offset+1, 0) + } + }; + + return flags; + } + + /** All the frames consists of a frame header followed by one or more fields containing the actual information. + * The frame ID made out of the characters capital A-Z and 0-9. Identifiers beginning with "X", "Y" and "Z" are for experimental use and free for everyone to use, without the need to set the experimental bit in the tag header. Have in mind that someone else might have used the same identifier as you. All other identifiers are either used or reserved for future use. + * The frame ID is followed by a size descriptor, making a total header size of ten bytes in every frame. The size is calculated as frame size excluding frame header (frame size - 10). + */ + function readFrames(offset, end, data, id3header, tags) + { + var frames = {}; + var frameDataSize; + var major = id3header["major"]; + + tags = getTagsFromShortcuts(tags || _defaultShortcuts); + + while( offset < end ) { + var readFrameFunc = null; + var frameData = data; + var frameDataOffset = offset; + var flags = null; + + switch( major ) { + case 2: + var frameID = frameData.getStringAt(frameDataOffset, 3); + var frameSize = frameData.getInteger24At(frameDataOffset+3, true); + var frameHeaderSize = 6; + break; + + case 3: + var frameID = frameData.getStringAt(frameDataOffset, 4); + var frameSize = frameData.getLongAt(frameDataOffset+4, true); + var frameHeaderSize = 10; + break; + + case 4: + var frameID = frameData.getStringAt(frameDataOffset, 4); + var frameSize = readSynchsafeInteger32At(frameDataOffset+4, frameData); + var frameHeaderSize = 10; + break; + } + // if last frame GTFO + if( frameID == "" ) { break; } + + // advance data offset to the next frame data + offset += frameHeaderSize + frameSize; + // skip unwanted tags + if( tags.indexOf( frameID ) < 0 ) { continue; } + + // read frame message and format flags + if( major > 2 ) + { + flags = readFrameFlags(frameData, frameDataOffset+8); + } + + frameDataOffset += frameHeaderSize; + + // the first 4 bytes are the real data size + // (after unsynchronisation && encryption) + if( flags && flags.format.data_length_indicator ) + { + frameDataSize = readSynchsafeInteger32At(frameDataOffset, frameData); + frameDataOffset += 4; + frameSize -= 4; + } + + // TODO: support unsynchronisation + if( flags && flags.format.unsynchronisation ) + { + //frameData = removeUnsynchronisation(frameData, frameSize); + continue; + } + + // find frame parsing function + if( frameID in ID3v2.readFrameData ) { + readFrameFunc = ID3v2.readFrameData[frameID]; + } else if( frameID[0] == "T" ) { + readFrameFunc = ID3v2.readFrameData["T*"]; + } + + var parsedData = readFrameFunc ? readFrameFunc(frameDataOffset, frameSize, frameData, flags) : undefined; + var desc = frameID in ID3v2.frames ? ID3v2.frames[frameID] : 'Unknown'; + + var frame = { + id : frameID, + size : frameSize, + description : desc, + data : parsedData + }; + + if( frameID in frames ) { + if( frames[frameID].id ) { + frames[frameID] = [frames[frameID]]; + } + frames[frameID].push(frame); + } else { + frames[frameID] = frame; + } + } + + return frames; + } + + //function removeUnsynchronisation(data, size) + //{ + // return data; + //} + + function getFrameData( frames, ids ) { + if( typeof ids == 'string' ) { ids = [ids]; } + + for( var i = 0, id; id = ids[i]; i++ ) { + if( id in frames ) { return frames[id].data; } + } + } + + ID3v2.loadData = function(data, callback) { + data.loadRange([0, readSynchsafeInteger32At(6, data)], callback); + }; + + // http://www.id3.org/id3v2.3.0 + ID3v2.readTagsFromData = function(data, tags) { + var offset = 0; + var major = data.getByteAt(offset+3); + if( major > 4 ) { return {version: '>2.4'}; } + var revision = data.getByteAt(offset+4); + var unsynch = data.isBitSetAt(offset+5, 7); + var xheader = data.isBitSetAt(offset+5, 6); + var xindicator = data.isBitSetAt(offset+5, 5); + var size = readSynchsafeInteger32At(offset+6, data); + offset += 10; + + if( xheader ) { + var xheadersize = data.getLongAt(offset, true); + // The 'Extended header size', currently 6 or 10 bytes, excludes itself. + offset += xheadersize + 4; + } + + var id3 = { + "version" : '2.' + major + '.' + revision, + "major" : major, + "revision" : revision, + "flags" : { + "unsynchronisation" : unsynch, + "extended_header" : xheader, + "experimental_indicator" : xindicator + }, + "size" : size + }; + var frames = unsynch ? {} : readFrames(offset, size-10, data, id3, tags); + // create shortcuts for most common data + for( var name in _shortcuts ) if(_shortcuts.hasOwnProperty(name)) { + var data = getFrameData( frames, _shortcuts[name] ); + if( data ) id3[name] = data; + } + + for( var frame in frames ) { + if( frames.hasOwnProperty(frame) ) { + id3[frame] = frames[frame]; + } + } + + return id3; + }; + + // Export functions for closure compiler + ns["ID3v2"] = ID3v2; +})(this); +/* + * Copyright (c) 2009 Opera Software ASA, António Afonso (antonio.afonso@opera.com) + * Modified by António Afonso + */ +(function() { + var pictureType = [ + "32x32 pixels 'file icon' (PNG only)", + "Other file icon", + "Cover (front)", + "Cover (back)", + "Leaflet page", + "Media (e.g. lable side of CD)", + "Lead artist/lead performer/soloist", + "Artist/performer", + "Conductor", + "Band/Orchestra", + "Composer", + "Lyricist/text writer", + "Recording Location", + "During recording", + "During performance", + "Movie/video screen capture", + "A bright coloured fish", + "Illustration", + "Band/artist logotype", + "Publisher/Studio logotype" + ]; + + function getTextEncoding( bite ) { + var charset; + switch( bite ) + { + case 0x00: + charset = 'iso-8859-1'; + break; + + case 0x01: + charset = 'utf-16'; + break; + + case 0x02: + charset = 'utf-16be'; + break; + + case 0x03: + charset = 'utf-8'; + break; + } + + return charset; + } + + function getTime( duration ) + { + var duration = duration/1000, + seconds = Math.floor( duration ) % 60, + minutes = Math.floor( duration/60 ) % 60, + hours = Math.floor( duration/3600 ); + + return { + seconds : seconds, + minutes : minutes, + hours : hours + }; + } + + function formatTime( time ) + { + var seconds = time.seconds < 10 ? '0'+time.seconds : time.seconds; + var minutes = (time.hours > 0 && time.minutes < 10) ? '0'+time.minutes : time.minutes; + + return (time.hours>0?time.hours+':':'') + minutes + ':' + seconds; + } + + ID3v2.readFrameData['APIC'] = function readPictureFrame(offset, length, data, flags, v) { + v = v || '3'; + return { + "format" : '', + "type" : '', + "description" : '', + "data" : '' + }; + }; + + ID3v2.readFrameData['COMM'] = function readCommentsFrame(offset, length, data) { + var start = offset; + var charset = getTextEncoding( data.getByteAt(offset) ); + var language = data.getStringAt( offset+1, 3 ); + var shortdesc = data.getStringWithCharsetAt(offset+4, length-4, charset); + + offset += 4 + shortdesc.bytesReadCount; + var text = data.getStringWithCharsetAt( offset, (start+length) - offset, charset ); + + return { + language : language, + short_description : shortdesc.toString(), + text : text.toString() + }; + }; + + ID3v2.readFrameData['COM'] = ID3v2.readFrameData['COMM']; + + ID3v2.readFrameData['PIC'] = function(offset, length, data, flags) { + return ID3v2.readFrameData['APIC'](offset, length, data, flags, '2'); + }; + + ID3v2.readFrameData['PCNT'] = function readCounterFrame(offset, length, data) { + // FIXME: implement the rest of the spec + return data.getInteger32At(offset); + }; + + ID3v2.readFrameData['CNT'] = ID3v2.readFrameData['PCNT']; + + ID3v2.readFrameData['T*'] = function readTextFrame(offset, length, data) { + var charset = getTextEncoding( data.getByteAt(offset) ); + + return data.getStringWithCharsetAt(offset+1, length-1, charset).toString(); + }; + + ID3v2.readFrameData['TCON'] = function readGenreFrame(offset, length, data) { + var text = ID3v2.readFrameData['T*'].apply( this, arguments ); + return text.replace(/^\(\d+\)/, ''); + }; + + ID3v2.readFrameData['TCO'] = ID3v2.readFrameData['TCON']; + + //ID3v2.readFrameData['TLEN'] = function readLengthFrame(offset, length, data) { + // var text = ID3v2.readFrameData['T*'].apply( this, arguments ); + // + // return { + // text : text, + // parsed : formatTime( getTime(parseInt(text)) ) + // }; + //}; + + ID3v2.readFrameData['USLT'] = function readLyricsFrame(offset, length, data) { + var start = offset; + var charset = getTextEncoding( data.getByteAt(offset) ); + var language = data.getStringAt( offset+1, 3 ); + var descriptor = data.getStringWithCharsetAt( offset+4, length-4, charset ); + + offset += 4 + descriptor.bytesReadCount; + var lyrics = data.getStringWithCharsetAt( offset, (start+length) - offset, charset ); + + return { + language : language, + descriptor : descriptor.toString(), + lyrics : lyrics.toString() + }; + }; + + ID3v2.readFrameData['ULT'] = ID3v2.readFrameData['USLT']; +})(); +/* + * Support for iTunes-style m4a tags + * See: + * http://atomicparsley.sourceforge.net/mpeg-4files.html + * http://developer.apple.com/mac/library/documentation/QuickTime/QTFF/Metadata/Metadata.html + * Authored by Joshua Kifer + * MIT License [http://www.opensource.org/licenses/mit-license.php] + */ + +(function(ns) { + var ID4 = ns.ID4 = {}; + + ID4.types = { + '0' : 'uint8', + '1' : 'text', + '13' : 'jpeg', + '14' : 'png', + '21' : 'uint8' + }; + ID4.atom = { + '©alb': ['album'], + '©art': ['artist'], + '©ART': ['artist'], + 'aART': ['artist'], + '©day': ['year'], + '©nam': ['title'], + '©gen': ['genre'], + 'trkn': ['track'], + '©wrt': ['composer'], + '©too': ['encoder'], + 'cprt': ['copyright'], + 'covr': ['picture'], + '©grp': ['grouping'], + 'keyw': ['keyword'], + '©lyr': ['lyrics'], + '©gen': ['genre'] + }; + + ID4.loadData = function(data, callback) { + // load the header of the first block + data.loadRange([0, 7], function () { + loadAtom(data, 0, data.getLength(), callback); + }); + }; + + /** + * Make sure that the [offset, offset+7] bytes (the block header) are + * already loaded before calling this function. + */ + function loadAtom(data, offset, length, callback) { + // 8 is the size of the atomSize and atomName fields. + // When reading the current block we always read 8 more bytes in order + // to also read the header of the next block. + var atomSize = data.getLongAt(offset, true); + if (atomSize == 0) return callback(); + var atomName = data.getStringAt(offset + 4, 4); + + // Container atoms + if (['moov', 'udta', 'meta', 'ilst'].indexOf(atomName) > -1) + { + if (atomName == 'meta') offset += 4; // next_item_id (uint32) + data.loadRange([offset+8, offset+8 + 8], function() { + loadAtom(data, offset + 8, atomSize - 8, callback); + }); + } else { + // Value atoms + var readAtom = atomName in ID4.atom; + data.loadRange([offset+(readAtom?0:atomSize), offset+atomSize + 8], function() { + loadAtom(data, offset+atomSize, length, callback); + }); + } + }; + + ID4.readTagsFromData = function(data) { + var tag = {}; + readAtom(tag, data, 0, data.getLength()); + return tag; + }; + + function readAtom(tag, data, offset, length, indent) + { + indent = indent === undefined ? "" : indent + " "; + var seek = offset; + while (seek < offset + length) + { + var atomSize = data.getLongAt(seek, true); + if (atomSize == 0) return; + var atomName = data.getStringAt(seek + 4, 4); + // Container atoms + if (['moov', 'udta', 'meta', 'ilst'].indexOf(atomName) > -1) + { + if (atomName == 'meta') seek += 4; // next_item_id (uint32) + readAtom(tag, data, seek + 8, atomSize - 8, indent); + return; + } + // Value atoms + if (ID4.atom[atomName]) + { + var klass = data.getInteger24At(seek + 16 + 1, true); + var atom = ID4.atom[atomName]; + var type = ID4.types[klass]; + if (atomName == 'trkn') + { + tag[atom[0]] = data.getByteAt(seek + 16 + 11); + tag['count'] = data.getByteAt(seek + 16 + 13); + } + else + { + // 16: name + size + "data" + size (4 bytes each) + // 4: atom version (1 byte) + atom flags (3 bytes) + // 4: NULL (usually locale indicator) + var dataStart = seek + 16 + 4 + 4; + var dataEnd = atomSize - 16 - 4 - 4; + switch( type ) { + case 'text': + tag[atom[0]] = data.getStringWithCharsetAt(dataStart, dataEnd, "UTF-8"); + break; + + case 'uint8': + tag[atom[0]] = data.getShortAt(dataStart); + break; + + case 'jpeg': + case 'png': + tag[atom[0]] = { + format : "image/" + type, + data : data.getBytesAt(dataStart, dataEnd) + }; + break; + } + } + } + seek += atomSize; + } + } + + // Export functions for closure compiler + ns["ID4"] = ns.ID4; +})(this); diff --git a/dist/id3.min.js b/dist/id3.min.js new file mode 100644 index 0000000..42527db --- /dev/null +++ b/dist/id3.min.js @@ -0,0 +1,31 @@ +function v(d){function b(a){if(a>=192&&a<=255)return String.fromCharCode(a-192+1040);if(a>=128&&a<=191)return e.charAt(a-128);return String.fromCharCode(a)}for(var e=unescape("%u0402%u0403%u201A%u0453%u201E%u2026%u2020%u2021%u20AC%u2030%u0409%u2039%u040A%u040C%u040B%u040F%u0452%u2018%u2019%u201C%u201D%u2022%u2013%u2014%u0000%u2122%u0459%u203A%u045A%u045C%u045B%u045F%u00A0%u040E%u045E%u0408%u00A4%u0490%u00A6%u00A7%u0401%u00A9%u0404%u00AB%u00AC%u00AD%u00AE%u0407%u00B0%u00B1%u0406%u0456%u0491%u00B5%u00B6%u00B7%u0451%u2116%u0454%u00BB%u0458%u0405%u0455%u0457"), +a="",g=0;g127?a-256:a};this.r=function(a,g){var c=g?(this.a(a)<<8)+this.a(a+ +1):(this.a(a+1)<<8)+this.a(a);c<0&&(c+=65536);return c};this.Q=function(a,g){var c=this.r(a,g);return c>32767?c-65536:c};this.g=function(a,g){var c=this.a(a),f=this.a(a+1),b=this.a(a+2),e=this.a(a+3),c=g?(((c<<8)+f<<8)+b<<8)+e:(((e<<8)+b<<8)+f<<8)+c;c<0&&(c+=4294967296);return c};this.P=function(a,g){var c=this.g(a,g);return c>2147483647?c-4294967296:c};this.q=function(a){var g=this.a(a),c=this.a(a+1),a=this.a(a+2),g=((g<<8)+c<<8)+a;g<0&&(g+=16777216);return g};this.c=function(a,g){for(var c=[],f= +a,b=0;f0)||!(g>0))return"";var f=this.p(a,g),a=this.c(a,g),c=c||jschardet.w(a).encoding;console.log("Charset:",c);switch(c.toLowerCase()){case "utf-16":case "utf-16le":case "utf-16be":var a=c,b,e=0,h=1,c=0;b=Math.min(b||f.length,f.length);f[0]==254&&f[1]==255?(a=!0,e=2):f[0]==255&&f[1]==254&&(a=!1,e=2);a&&(h=0,c=1);a=[];for(g=0;e=224? +a[g]=String.fromCharCode(j):(d=(f[e+h]<<8)+f[e+c],e+=2,a[g]=String.fromCharCode(j,d))}f=new String(a.join(""));f.i=e;break;case "utf-8":b=0;e=Math.min(e||f.length,f.length);f[0]==239&&f[1]==187&&f[2]==191&&(b=3);h=[];for(c=0;b=194&&a<224?(g=f[b++],h[c]=String.fromCharCode(((a&31)<<6)+(g&63))):a>=224&&a<240?(g=f[b++],j=f[b++],h[c]=String.fromCharCode(((a&255)<<12)+((g&63)<<6)+(j&63))):a>=240&&a<245&&(g=f[b++],j=f[b++],d=f[b++], +a=((a&7)<<18)+((g&63)<<12)+((j&63)<<6)+(d&63)-65536,h[c]=String.fromCharCode((a>>10)+55296,(a&1023)+56320));f=new String(h.join(""));f.i=b;break;case "iso-8859-1":if(f=jschardet.w(a),console.log("Detection:",f),"TIS-620"===f.encoding||"windows-1253"===f.encoding||"windows-1251"===f.encoding||"EUC-TV"===f.encoding){f=v(a);break}case "windows-1251":f=v(a);break;case "maccyrillic":f=v(a);break;default:e=[];h=h||f.length;for(b=0;b>2,a=(a&3)<<4|g>>4,d=(g&15)<<2|c>>6,i=c&63,isNaN(g)?d=i=64:isNaN(c)&&(i=64),e=e+Base64.h.charAt(f)+Base64.h.charAt(a)+Base64.h.charAt(d)+Base64.h.charAt(i);return e}};d.Base64=d.j;d.j.encodeBytes=d.j.z})(this); +(function(d){var b=d.s={},e={};b.C=function(a,g,c){c=c||{};(0,c.dataReader)(a,function(b){b.f(0,function(){var d=b.c(4,7)=="ftypM4A"?ID4:b.c(0,3)=="ID3"?ID3v2:ID3v1;d.m(b,function(){var i=c.tags,h=d.n(b,i),i=e[a]||{},o;for(o in h)h.hasOwnProperty(o)&&(i[o]=h[o]);e[a]=i;g&&g()})})})};b.A=function(a){if(!e[a])return null;var b={},c;for(c in e[a])e[a].hasOwnProperty(c)&&(b[c]=e[a][c]);return b};b.B=function(a,b){if(!e[a])return null;return e[a][b]};d.ID3=d.s;b.loadTags=b.C;b.getAllTags=b.A;b.getTag= +b.B})(this); +(function(d){var b=d.t={},e=["Blues","Classic Rock","Country","Dance","Disco","Funk","Grunge","Hip-Hop","Jazz","Metal","New Age","Oldies","Other","Pop","R&B","Rap","Reggae","Rock","Techno","Industrial","Alternative","Ska","Death Metal","Pranks","Soundtrack","Euro-Techno","Ambient","Trip-Hop","Vocal","Jazz+Funk","Fusion","Trance","Classical","Instrumental","Acid","House","Game","Sound Clip","Gospel","Noise","AlternRock","Bass","Soul","Punk","Space","Meditative","Instrumental Pop","Instrumental Rock","Ethnic", +"Gothic","Darkwave","Techno-Industrial","Electronic","Pop-Folk","Eurodance","Dream","Southern Rock","Comedy","Cult","Gangsta","Top 40","Christian Rap","Pop/Funk","Jungle","Native American","Cabaret","New Wave","Psychadelic","Rave","Showtunes","Trailer","Lo-Fi","Tribal","Acid Punk","Acid Jazz","Polka","Retro","Musical","Rock & Roll","Hard Rock","Folk","Folk-Rock","National Folk","Swing","Fast Fusion","Bebob","Latin","Revival","Celtic","Bluegrass","Avantgarde","Gothic Rock","Progressive Rock","Psychedelic Rock", +"Symphonic Rock","Slow Rock","Big Band","Chorus","Easy Listening","Acoustic","Humour","Speech","Chanson","Opera","Chamber Music","Sonata","Symphony","Booty Bass","Primus","Porn Groove","Satire","Slow Jam","Club","Tango","Samba","Folklore","Ballad","Power Ballad","Rhythmic Soul","Freestyle","Duet","Punk Rock","Drum Solo","Acapella","Euro-House","Dance Hall"];b.m=function(a,b){a.f(0,b)};b.n=function(a){var b=a.l()-128;if(a.c(b,3)=="TAG"){var c=a.e(b+3,30).replace(/\0/g,""),f=a.e(b+33,30).replace(/\0/g, +""),d=a.e(b+63,30).replace(/\0/g,""),i=a.c(b+93,4).replace(/\0/g,"");if(a.a(b+97+28)==0)var h=a.c(b+97,28).replace(/\0/g,""),o=a.a(b+97+29);else h="",o=0;a=a.a(b+97+30);return{version:"1.1",title:c,artist:f,album:d,year:i,comment:h,track:o,genre:a<255?e[a]:""}}else return{}};d.ID3v1=d.t})(this); +(function(d){function b(a,b){var g=b.a(a),e=b.a(a+1),d=b.a(a+2);return b.a(a+3)&127|(d&127)<<7|(e&127)<<14|(g&127)<<21}var e=d.F={};e.b={};e.frames={BUF:"Recommended buffer size",CNT:"Play counter",COM:"Comments",CRA:"Audio encryption",CRM:"Encrypted meta frame",ETC:"Event timing codes",EQU:"Equalization",GEO:"General encapsulated object",IPL:"Involved people list",LNK:"Linked information",MCI:"Music CD Identifier",MLL:"MPEG location lookup table",PIC:"Attached picture",POP:"Popularimeter",REV:"Reverb", +RVA:"Relative volume adjustment",SLT:"Synchronized lyric/text",STC:"Synced tempo codes",TAL:"Album/Movie/Show title",TBP:"BPM (Beats Per Minute)",TCM:"Composer",TCO:"Content type",TCR:"Copyright message",TDA:"Date",TDY:"Playlist delay",TEN:"Encoded by",TFT:"File type",TIM:"Time",TKE:"Initial key",TLA:"Language(s)",TLE:"Length",TMT:"Media type",TOA:"Original artist(s)/performer(s)",TOF:"Original filename",TOL:"Original Lyricist(s)/text writer(s)",TOR:"Original release year",TOT:"Original album/Movie/Show title", +TP1:"Lead artist(s)/Lead performer(s)/Soloist(s)/Performing group",TP2:"Band/Orchestra/Accompaniment",TP3:"Conductor/Performer refinement",TP4:"Interpreted, remixed, or otherwise modified by",TPA:"Part of a set",TPB:"Publisher",TRC:"ISRC (International Standard Recording Code)",TRD:"Recording dates",TRK:"Track number/Position in set",TSI:"Size",TSS:"Software/hardware and settings used for encoding",TT1:"Content group description",TT2:"Title/Songname/Content description",TT3:"Subtitle/Description refinement", +TXT:"Lyricist/text writer",TXX:"User defined text information frame",TYE:"Year",UFI:"Unique file identifier",ULT:"Unsychronized lyric/text transcription",WAF:"Official audio file webpage",WAR:"Official artist/performer webpage",WAS:"Official audio source webpage",WCM:"Commercial information",WCP:"Copyright/Legal information",WPB:"Publishers official webpage",WXX:"User defined URL link frame",AENC:"Audio encryption",APIC:"Attached picture",COMM:"Comments",COMR:"Commercial frame",ENCR:"Encryption method registration", +EQUA:"Equalization",ETCO:"Event timing codes",GEOB:"General encapsulated object",GRID:"Group identification registration",IPLS:"Involved people list",LINK:"Linked information",MCDI:"Music CD identifier",MLLT:"MPEG location lookup table",OWNE:"Ownership frame",PRIV:"Private frame",PCNT:"Play counter",POPM:"Popularimeter",POSS:"Position synchronisation frame",RBUF:"Recommended buffer size",RVAD:"Relative volume adjustment",RVRB:"Reverb",SYLT:"Synchronized lyric/text",SYTC:"Synchronized tempo codes", +TALB:"Album/Movie/Show title",TBPM:"BPM (beats per minute)",TCOM:"Composer",TCON:"Content type",TCOP:"Copyright message",TDAT:"Date",TDLY:"Playlist delay",TENC:"Encoded by",TEXT:"Lyricist/Text writer",TFLT:"File type",TIME:"Time",TIT1:"Content group description",TIT2:"Title/songname/content description",TIT3:"Subtitle/Description refinement",TKEY:"Initial key",TLAN:"Language(s)",TLEN:"Length",TMED:"Media type",TOAL:"Original album/movie/show title",TOFN:"Original filename",TOLY:"Original lyricist(s)/text writer(s)", +TOPE:"Original artist(s)/performer(s)",TORY:"Original release year",TOWN:"File owner/licensee",TPE1:"Lead performer(s)/Soloist(s)",TPE2:"Band/orchestra/accompaniment",TPE3:"Conductor/performer refinement",TPE4:"Interpreted, remixed, or otherwise modified by",TPOS:"Part of a set",TPUB:"Publisher",TRCK:"Track number/Position in set",TRDA:"Recording dates",TRSN:"Internet radio station name",TRSO:"Internet radio station owner",TSIZ:"Size",TSRC:"ISRC (international standard recording code)",TSSE:"Software/Hardware and settings used for encoding", +TYER:"Year",TXXX:"User defined text information frame",UFID:"Unique file identifier",USER:"Terms of use",USLT:"Unsychronized lyric/text transcription",WCOM:"Commercial information",WCOP:"Copyright/Legal information",WOAF:"Official audio file webpage",WOAR:"Official artist/performer webpage",WOAS:"Official audio source webpage",WORS:"Official internet radio station homepage",WPAY:"Payment",WPUB:"Publishers official webpage",WXXX:"User defined URL link frame"};var a={title:["TIT2","TT2"],artist:["TPE1", +"TP1"],album:["TALB","TAL"],year:["TYER","TYE"],comment:["COMM","COM"],track:["TRCK","TRK"],genre:["TCON","TCO"],picture:["APIC","PIC"],lyrics:["USLT","ULT"]},g=["title","artist","album","track"];e.m=function(a,g){a.f([0,b(6,a)],g)};e.n=function(c,f){var d=0,i=c.a(d+3);if(i>4)return{version:">2.4"};var h=c.a(d+4),o=c.d(d+5,7),j=c.d(d+5,6),q=c.d(d+5,5),r=b(d+6,c);d+=10;if(j){var n=c.g(d,!0);d+=n+4}var i={version:"2."+i+"."+h,major:i,revision:h,flags:{unsynchronisation:o,extended_header:j,experimental_indicator:q}, +size:r},k;if(o)k={};else{r-=10;for(var o=c,h=f,j={},q=i.major,n=[],m=0,l;l=(h||g)[m];m++)n=n.concat(a[l]||[l]);for(h=n;d2&&(u={message:{V:m.d(l+8,6),J:m.d(l+8,5),T:m.d(l+8,4)},k:{R:m.d(l+8+1,7),G:m.d(l+8+1,3),I:m.d(l+8+1,2),D:m.d(l+8+1,1),v:m.d(l+8+1,0)}}),l+=t,u&&u.k.v&&(b(l,m),l+=4,p-=4),!u|| +!u.k.D))k in e.b?n=e.b[k]:k[0]=="T"&&(n=e.b["T*"]),n=n?n(l,p,m,u):void 0,n={id:k,size:p,description:k in e.frames?e.frames[k]:"Unknown",data:n},k in j?(j[k].id&&(j[k]=[j[k]]),j[k].push(n)):j[k]=n}k=j}for(var w in a)if(a.hasOwnProperty(w)){a:{p=a[w];typeof p=="string"&&(p=[p]);t=0;for(d=void 0;d=p[t];t++)if(d in k){c=k[d].data;break a}c=void 0}c&&(i[w]=c)}for(var x in k)k.hasOwnProperty(x)&&(i[x]=k[x]);return i};d.ID3v2=e})(this); +(function(){function d(b){var e;switch(b){case 0:e="iso-8859-1";break;case 1:e="utf-16";break;case 2:e="utf-16be";break;case 3:e="utf-8"}return e}ID3v2.b.APIC=function(){return{format:"",type:"",description:"",data:""}};ID3v2.b.COMM=function(b,e,a){var g=b,c=d(a.a(b)),f=a.c(b+1,3),s=a.e(b+4,e-4,c);b+=4+s.i;b=a.e(b,g+e-b,c);return{language:f,U:s.toString(),text:b.toString()}};ID3v2.b.COM=ID3v2.b.COMM;ID3v2.b.PIC=function(b,e,a,g){return ID3v2.b.APIC(b,e,a,g,"2")};ID3v2.b.PCNT=function(b,e,a){return a.M(b)}; +ID3v2.b.CNT=ID3v2.b.PCNT;ID3v2.b["T*"]=function(b,e,a){var g=d(a.a(b));return a.e(b+1,e-1,g).toString()};ID3v2.b.TCON=function(){return ID3v2.b["T*"].apply(this,arguments).replace(/^\(\d+\)/,"")};ID3v2.b.TCO=ID3v2.b.TCON;ID3v2.b.USLT=function(b,e,a){var g=b,c=d(a.a(b)),f=a.c(b+1,3),s=a.e(b+4,e-4,c);b+=4+s.i;b=a.e(b,g+e-b,c);return{language:f,H:s.toString(),S:b.toString()}};ID3v2.b.ULT=ID3v2.b.USLT})(); +(function(d){function b(a,c,e,d){var i=a.g(c,!0);if(i==0)d();else{var h=a.c(c+4,4);["moov","udta","meta","ilst"].indexOf(h)>-1?(h=="meta"&&(c+=4),a.f(0,function(){b(a,c+8,i-8,d)})):a.f(0,function(){b(a,c+i,e,d)})}}function e(b,c,d,s,i){for(var i=i===void 0?"":i+" ",h=d;h-1){j=="meta"&&(h+=4);e(b,c,h+8,o-8,i);break}if(a.o[j]){var q=c.q(h+16+1),r=a.o[j],q=a.types[q];if(j=="trkn")b[r[0]]=c.a(h+16+11),b.count= +c.a(h+16+13);else{var j=h+16+4+4,n=o-16-4-4;switch(q){case "text":b[r[0]]=c.e(j,n,"UTF-8");break;case "uint8":b[r[0]]=c.r(j);break;case "jpeg":case "png":b[r[0]]={k:"image/"+q,data:c.p(j,n)}}}}h+=o}}var a=d.u={};a.types={"0":"uint8","1":"text","13":"jpeg","14":"png","21":"uint8"};a.o={"\u00a9alb":["album"],"\u00a9art":["artist"],"\u00a9ART":["artist"],aART:["artist"],"\u00a9day":["year"],"\u00a9nam":["title"],"\u00a9gen":["genre"],trkn:["track"],"\u00a9wrt":["composer"],"\u00a9too":["encoder"],cprt:["copyright"], +covr:["picture"],"\u00a9grp":["grouping"],keyw:["keyword"],"\u00a9lyr":["lyrics"],"\u00a9gen":["genre"]};a.m=function(a,c){a.f(0,function(){b(a,0,a.l(),c)})};a.n=function(a){var b={};e(b,a,0,a.l());return b};d.ID4=d.u})(this); diff --git a/id3reader.js.iml b/id3reader.js.iml new file mode 100644 index 0000000..ef582b1 --- /dev/null +++ b/id3reader.js.iml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/make-minimize.sh b/make-minimize.sh deleted file mode 100755 index 0c24b7c..0000000 --- a/make-minimize.sh +++ /dev/null @@ -1,16 +0,0 @@ -CLOSURE_COMPILER=/usr/local/closure-compiler/compiler.jar - -java -jar "$CLOSURE_COMPILER" \ - --compilation_level ADVANCED_OPTIMIZATIONS \ - --js src/stringutils.js \ - --js src/bufferedbinaryajax.js \ - --js src/filereader.js \ - --js src/base64.js \ - --js src/id3.js \ - --js src/id3v1.js \ - --js src/id3v2.js \ - --js src/id3v2frames.js \ - --js src/id4.js \ -> dist/id3-minimized.js - -#--formatting PRETTY_PRINT \ \ No newline at end of file diff --git a/src/binaryajax.js b/src/binaryajax.js deleted file mode 100755 index 696f97b..0000000 --- a/src/binaryajax.js +++ /dev/null @@ -1,286 +0,0 @@ - -/* - * Binary Ajax 0.1.5 - * Copyright (c) 2008 Jacob Seidelin, cupboy@gmail.com, http://blog.nihilogic.dk/ - * MIT License [http://www.opensource.org/licenses/mit-license.php] - * - * Extended by António Afonso - */ -var BinaryFile = function(strData, iDataOffset, iDataLength) { - var data = strData; - var dataOffset = iDataOffset || 0; - var dataLength = 0; - - this.getRawData = function() { - return data; - } - - if (typeof strData == "string") { - dataLength = iDataLength || data.length; - - this.getByteAt = function(iOffset) { - return data.charCodeAt(iOffset + dataOffset) & 0xFF; - } - } else if (typeof strData == "unknown") { - dataLength = iDataLength || IEBinary_getLength(data); - - this.getByteAt = function(iOffset) { - return IEBinary_getByteAt(data, iOffset + dataOffset); - } - } - // @aadsm - this.getBytesAt = function(iOffset, iLength) { - var bytes = new Array(iLength); - for( var i = 0; i < iLength; i++ ) { - bytes[i] = this.getByteAt(iOffset+i); - } - return bytes; - } - - this.getLength = function() { - return dataLength; - } - - // @aadsm - this.isBitSetAt = function(iOffset, iBit) { - var iByte = this.getByteAt(iOffset); - return (iByte & (1 << iBit)) != 0; - } - - this.getSByteAt = function(iOffset) { - var iByte = this.getByteAt(iOffset); - if (iByte > 127) - return iByte - 256; - else - return iByte; - } - - this.getShortAt = function(iOffset, bBigEndian) { - var iShort = bBigEndian ? - (this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1) - : (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset) - if (iShort < 0) iShort += 65536; - return iShort; - } - this.getSShortAt = function(iOffset, bBigEndian) { - var iUShort = this.getShortAt(iOffset, bBigEndian); - if (iUShort > 32767) - return iUShort - 65536; - else - return iUShort; - } - this.getLongAt = function(iOffset, bBigEndian) { - var iByte1 = this.getByteAt(iOffset), - iByte2 = this.getByteAt(iOffset + 1), - iByte3 = this.getByteAt(iOffset + 2), - iByte4 = this.getByteAt(iOffset + 3); - - var iLong = bBigEndian ? - (((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4 - : (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1; - if (iLong < 0) iLong += 4294967296; - return iLong; - } - this.getSLongAt = function(iOffset, bBigEndian) { - var iULong = this.getLongAt(iOffset, bBigEndian); - if (iULong > 2147483647) - return iULong - 4294967296; - else - return iULong; - } - // @aadsm - this.getInteger24At = function(iOffset, bBigEndian) { - var iByte1 = this.getByteAt(iOffset), - iByte2 = this.getByteAt(iOffset + 1), - iByte3 = this.getByteAt(iOffset + 2); - - var iInteger = bBigEndian ? - ((((iByte1 << 8) + iByte2) << 8) + iByte3) - : ((((iByte3 << 8) + iByte2) << 8) + iByte1); - if (iInteger < 0) iInteger += 16777216; - return iInteger; - } - this.getStringAt = function(iOffset, iLength) { - var aStr = []; - for (var i=iOffset,j=0;i= 0 ) { - sendRequest(strURL, fncCallback, fncError, [iStart, iEnd], (strAcceptRanges == "bytes"), iLength); - } else { - sendRequest(strURL, fncCallback, fncError); - } - } - ); - - } else { - sendRequest(strURL, fncCallback, fncError); - } - } - -}()); - - -document.write( - "\r\n" -); diff --git a/src/binaryfile.js b/src/binaryfile.js new file mode 100644 index 0000000..8374fc3 --- /dev/null +++ b/src/binaryfile.js @@ -0,0 +1,302 @@ +/** + * Buffered Binary Ajax 0.2.1 + * Copyright (c) 2010 António Afonso, antonio.afonso gmail, http://www.aadsm.net/ + * MIT License [http://www.opensource.org/licenses/mit-license.php] + * + * Adapted from Binary Ajax 0.1.5 + */ + +/** + * @class Reads a remote file without having to download it all. + * + * Creates a new BufferedBinaryFile that will download chunks of the file pointed by the URL given only on a per need basis. + * + * @param {string} strUrl The URL with the location of the file to be read. + * @param {number} iLength The size of the file. + * @param {number} [blockSize=2048] The size of the chunk that will be downloaded when data is read. + * @param {number} [blockRadius=0] The number of chunks, immediately after and before the chunk needed, that will also be downloaded. + * + * @constructor + * @augments BinaryFile + */ +function BufferedBinaryFile(strUrl, iLength, blockSize, blockRadius) { + var undefined; + var downloadedBytesCount = 0; + var binaryFile = new BinaryFile("", 0, iLength); + var blocks = []; + + blockSize = blockSize || 1024*2; + blockRadius = (typeof blockRadius === "undefined") ? 0 : blockRadius; + blockTotal = ~~((iLength-1)/blockSize) + 1; + + function getBlockRangeForByteRange(range) { + var blockStart = ~~(range[0]/blockSize) - blockRadius; + var blockEnd = ~~(range[1]/blockSize)+1 + blockRadius; + + if( blockStart < 0 ) blockStart = 0; + if( blockEnd >= blockTotal ) blockEnd = blockTotal-1; + + return [blockStart, blockEnd]; + } + + // TODO: wondering if a "recently used block" could help things around + // here. + function getBlockAtOffset(offset) { + var blockRange = getBlockRangeForByteRange([offset, offset]); + waitForBlocks(blockRange); + return blocks[~~(offset/blockSize)]; + } + + /** + * @param {?function()} callback If a function is passed then this function will be asynchronous and the callback invoked when the blocks have been loaded, otherwise it blocks script execution until the request is completed. + */ + function waitForBlocks(blockRange, callback) { + // Filter out already downloaded blocks or return if found out that + // the entire block range has already been downloaded. + while( blocks[blockRange[0]] ) { + blockRange[0]++; + if( blockRange[0] > blockRange[1] ) return callback ? callback() : undefined; + } + while( blocks[blockRange[1]] ) { + blockRange[1]--; + if( blockRange[0] > blockRange[1] ) return callback ? callback() : undefined; + } + var range = [blockRange[0]*blockSize, (blockRange[1]+1)*blockSize-1]; + //console.log("Getting: " + range[0] + " to " + range[1]); + sendRequest( + strUrl, + function(http) { + var size = parseInt(http.getResponseHeader("Content-Length"), 10); + // Range header not supported + if( size == iLength ) { + blockRange[0] = 0; + blockRange[1] = blockTotal-1; + range[0] = 0; + range[1] = iLength-1; + } + var block = { + data: http.responseBody || http.responseText, + offset: range[0] + }; + + for( var i = blockRange[0]; i <= blockRange[1]; i++ ) { + blocks[i] = block; + } + downloadedBytesCount += range[1] - range[0] + 1; + if (callback) callback(); + }, + fncError, + range, + "bytes", + undefined, + !!callback + ); + } + + // Mixin all BinaryFile's methods. + // Not using prototype linking since the constructor needs to know + // the length of the file. + for( var key in binaryFile ) { + if( binaryFile.hasOwnProperty(key) && + typeof binaryFile[key] === "function") { + this[key] = binaryFile[key]; + } + } + /** + * @override + */ + this.getByteAt = function(iOffset) { + var block = getBlockAtOffset(iOffset); + if( typeof block.data == "string" ) { + return block.data.charCodeAt(iOffset - block.offset) & 0xFF; + } else if( typeof block.data == "unknown" ) { + return IEBinary_getByteAt(block.data, iOffset - block.offset); + } + }; + + /** + * Gets the number of total bytes that have been downloaded. + * + * @returns The number of total bytes that have been downloaded. + */ + this.getDownloadedBytesCount = function() { + return downloadedBytesCount; + }; + + /** + * Downloads the byte range given. Useful for preloading. + * + * @param {Array} range Two element array that denotes the first byte to be read on the first position and the last byte to be read on the last position. A range of [2, 5] will download bytes 2,3,4 and 5. + * @param {?function()} callback The function to invoke when the blocks have been downloaded, this makes this call asynchronous. + */ + this.loadRange = function(range, callback) { + var blockRange = getBlockRangeForByteRange(range); + waitForBlocks(blockRange, callback); + }; +} + + +/** + * @constructor + */ +function BinaryFile(strData, iDataOffset, iDataLength) { + var data = strData; + var dataOffset = iDataOffset || 0; + var dataLength = 0; + + this.getRawData = function() { + return data; + }; + + if (typeof strData == "string") { + dataLength = iDataLength || data.length; + + this.getByteAt = function(iOffset) { + return data.charCodeAt(iOffset + dataOffset) & 0xFF; + }; + } else if (typeof strData == "unknown") { + dataLength = iDataLength || IEBinary_getLength(data); + + this.getByteAt = function(iOffset) { + return IEBinary_getByteAt(data, iOffset + dataOffset); + }; + } + // @aadsm + this.getBytesAt = function(iOffset, iLength) { + var bytes = new Array(iLength); + for( var i = 0; i < iLength; i++ ) { + bytes[i] = this.getByteAt(iOffset+i); + } + return bytes; + }; + + this.getLength = function() { + return dataLength; + }; + + // @aadsm + this.isBitSetAt = function(iOffset, iBit) { + var iByte = this.getByteAt(iOffset); + return (iByte & (1 << iBit)) != 0; + }; + + this.getSByteAt = function(iOffset) { + var iByte = this.getByteAt(iOffset); + if (iByte > 127) + return iByte - 256; + else + return iByte; + }; + + this.getShortAt = function(iOffset, bBigEndian) { + var iShort = bBigEndian ? + (this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1) + : (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset); + if (iShort < 0) iShort += 65536; + return iShort; + }; + this.getSShortAt = function(iOffset, bBigEndian) { + var iUShort = this.getShortAt(iOffset, bBigEndian); + if (iUShort > 32767) + return iUShort - 65536; + else + return iUShort; + }; + this.getLongAt = function(iOffset, bBigEndian) { + var iByte1 = this.getByteAt(iOffset), + iByte2 = this.getByteAt(iOffset + 1), + iByte3 = this.getByteAt(iOffset + 2), + iByte4 = this.getByteAt(iOffset + 3); + + var iLong = bBigEndian ? + (((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4 + : (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1; + if (iLong < 0) iLong += 4294967296; + return iLong; + }; + this.getSLongAt = function(iOffset, bBigEndian) { + var iULong = this.getLongAt(iOffset, bBigEndian); + if (iULong > 2147483647) + return iULong - 4294967296; + else + return iULong; + }; + // @aadsm + this.getInteger24At = function(iOffset, bBigEndian) { + var iByte1 = this.getByteAt(iOffset), + iByte2 = this.getByteAt(iOffset + 1), + iByte3 = this.getByteAt(iOffset + 2); + + var iInteger = bBigEndian ? + ((((iByte1 << 8) + iByte2) << 8) + iByte3) + : ((((iByte3 << 8) + iByte2) << 8) + iByte1); + if (iInteger < 0) iInteger += 16777216; + return iInteger; + }; + this.getStringAt = function(iOffset, iLength) { + var aStr = []; + for (var i=iOffset,j=0;i0) || !(iLength>0)){ + return ''; + } + var bytes = this.getBytesAt(iOffset, iLength), + originalString = this.getStringAt(iOffset, iLength), + iCharset=iCharset || jschardet.detect(originalString).encoding, + sString; + console.log('Charset:',iCharset); + + switch( iCharset.toLowerCase() ) { + + case 'utf-16': + case 'utf-16le': + case 'utf-16be': + sString = StringUtils.readUTF16String(bytes, iCharset); + break; + + case 'utf-8': + sString = StringUtils.readUTF8String(bytes); + break; + case 'iso-8859-1': + var charsetDetection=jschardet.detect(originalString); + console.log('Detection:',charsetDetection); + if('TIS-620'===charsetDetection.encoding || + 'windows-1253'===charsetDetection.encoding || + 'windows-1251'===charsetDetection.encoding || + 'EUC-TV'===charsetDetection.encoding){ + sString = StringUtils.readWin1251String(originalString); + break; + } + case 'windows-1251': + sString = StringUtils.readWin1251String(originalString); + break; + case 'maccyrillic': + sString = StringUtils.readWin1251String(originalString); + break; + default: + sString = StringUtils.readNullTerminatedString(bytes); + break; + } + console.log('Result',sString); + return sString; + }; + + this.getCharAt = function(iOffset) { + return String.fromCharCode(this.getByteAt(iOffset)); + }; + this.toBase64 = function() { + return window.btoa(data); + }; + this.fromBase64 = function(strBase64) { + data = window.atob(strBase64); + }; + + this.loadRange = function(range, callback) { + callback(); + }; +} \ No newline at end of file diff --git a/src/bufferedbinaryajax.js b/src/bufferedbinaryajax.js deleted file mode 100644 index 7c29f6c..0000000 --- a/src/bufferedbinaryajax.js +++ /dev/null @@ -1,408 +0,0 @@ -/** - * Buffered Binary Ajax 0.2.1 - * Copyright (c) 2010 António Afonso, antonio.afonso gmail, http://www.aadsm.net/ - * MIT License [http://www.opensource.org/licenses/mit-license.php] - * - * Adapted from Binary Ajax 0.1.5 - */ - -/** - * This function prepares a BufferedBinaryFile object for reading the file pointed by the URL given. - * - * @param {String} strUrl The URL with the location of the file to be read. - * @param {function(BufferedBinaryFile)} fncCallback The function that will be invoked when the BufferedBinaryFile is ready to be used. - * @param {function()} fncError The function that will be invoked when an error occrus, for instance, the file pointed by the URL is doesn't exist. - */ -var BufferedBinaryAjax = function(strUrl, fncCallback, fncError) { - function sendRequest(strURL, fncCallback, fncError, aRange, bAcceptRanges, iFileSize, bAsync) { - var oHTTP = createRequest(); - if (oHTTP) { - var iDataOffset = 0; - if (aRange && !bAcceptRanges) { - iDataOffset = aRange[0]; - } - var iDataLen = 0; - if (aRange) { - iDataLen = aRange[1]-aRange[0]+1; - } - if( typeof bAsync === "undefined" ) bAsync = true; - - if (fncCallback) { - if (typeof(oHTTP.onload) != "undefined") { - oHTTP.onload = function() { - - if (oHTTP.status == "200" || oHTTP.status == "206") { - oHTTP.fileSize = iFileSize || oHTTP.getResponseHeader("Content-Length"); - fncCallback(oHTTP); - } else { - if (fncError) fncError(); - } - oHTTP = null; - }; - } else { - oHTTP.onreadystatechange = function() { - if (oHTTP.readyState == 4) { - if (oHTTP.status == "200" || oHTTP.status == "206") { - oHTTP.fileSize = iFileSize || oHTTP.getResponseHeader("Content-Length"); - fncCallback(oHTTP); - } else { - if (fncError) fncError(); - } - oHTTP = null; - } - }; - } - } - oHTTP.open("GET", strURL, bAsync); - - if (oHTTP.overrideMimeType) oHTTP.overrideMimeType('text/plain; charset=x-user-defined'); - - if (aRange && bAcceptRanges) { - oHTTP.setRequestHeader("Range", "bytes=" + aRange[0] + "-" + aRange[1]); - } - - oHTTP.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 1970 00:00:00 GMT"); - - oHTTP.send(null); - } else { - if (fncError) fncError(); - } - } - function createRequest() { - var oHTTP = null; - if (window.XMLHttpRequest) { - oHTTP = new XMLHttpRequest(); - } else if (window.ActiveXObject) { - oHTTP = new ActiveXObject("Microsoft.XMLHTTP"); - } - return oHTTP; - } - - function getHead(strURL, fncCallback, fncError) { - var oHTTP = createRequest(); - if (oHTTP) { - if (fncCallback) { - if (typeof(oHTTP.onload) != "undefined") { - oHTTP.onload = function() { - if (oHTTP.status == "200") { - fncCallback(this); - } else { - if (fncError) fncError(); - } - oHTTP = null; - }; - } else { - oHTTP.onreadystatechange = function() { - if (oHTTP.readyState == 4) { - if (oHTTP.status == "200") { - fncCallback(this); - } else { - if (fncError) fncError(); - } - oHTTP = null; - } - }; - } - } - oHTTP.open("HEAD", strURL, true); - oHTTP.send(null); - } else { - if (fncError) fncError(); - } - } - - /** - * @class Reads a remote file without having to download it all. - * - * Creates a new BufferedBinaryFile that will download chunks of the file pointed by the URL given only on a per need basis. - * - * @param {string} strUrl The URL with the location of the file to be read. - * @param {number} iLength The size of the file. - * @param {number} [blockSize=2048] The size of the chunk that will be downloaded when data is read. - * @param {number} [blockRadius=0] The number of chunks, immediately after and before the chunk needed, that will also be downloaded. - * - * @constructor - * @augments BinaryFile - */ - function BufferedBinaryFile(strUrl, iLength, blockSize, blockRadius) { - var undefined; - var downloadedBytesCount = 0; - var binaryFile = new BinaryFile("", 0, iLength); - var blocks = []; - - blockSize = blockSize || 1024*2; - blockRadius = (typeof blockRadius === "undefined") ? 0 : blockRadius; - blockTotal = ~~((iLength-1)/blockSize) + 1; - - function getBlockRangeForByteRange(range) { - var blockStart = ~~(range[0]/blockSize) - blockRadius; - var blockEnd = ~~(range[1]/blockSize)+1 + blockRadius; - - if( blockStart < 0 ) blockStart = 0; - if( blockEnd >= blockTotal ) blockEnd = blockTotal-1; - - return [blockStart, blockEnd]; - } - - // TODO: wondering if a "recently used block" could help things around - // here. - function getBlockAtOffset(offset) { - var blockRange = getBlockRangeForByteRange([offset, offset]); - waitForBlocks(blockRange); - return blocks[~~(offset/blockSize)]; - } - - /** - * @param {?function()} callback If a function is passed then this function will be asynchronous and the callback invoked when the blocks have been loaded, otherwise it blocks script execution until the request is completed. - */ - function waitForBlocks(blockRange, callback) { - // Filter out already downloaded blocks or return if found out that - // the entire block range has already been downloaded. - while( blocks[blockRange[0]] ) { - blockRange[0]++; - if( blockRange[0] > blockRange[1] ) return callback ? callback() : undefined; - } - while( blocks[blockRange[1]] ) { - blockRange[1]--; - if( blockRange[0] > blockRange[1] ) return callback ? callback() : undefined; - } - var range = [blockRange[0]*blockSize, (blockRange[1]+1)*blockSize-1]; - //console.log("Getting: " + range[0] + " to " + range[1]); - sendRequest( - strUrl, - function(http) { - var size = parseInt(http.getResponseHeader("Content-Length"), 10); - // Range header not supported - if( size == iLength ) { - blockRange[0] = 0; - blockRange[1] = blockTotal-1; - range[0] = 0; - range[1] = iLength-1; - } - var block = { - data: http.responseBody || http.responseText, - offset: range[0] - }; - - for( var i = blockRange[0]; i <= blockRange[1]; i++ ) { - blocks[i] = block; - } - downloadedBytesCount += range[1] - range[0] + 1; - if (callback) callback(); - }, - fncError, - range, - "bytes", - undefined, - !!callback - ); - } - - // Mixin all BinaryFile's methods. - // Not using prototype linking since the constructor needs to know - // the length of the file. - for( var key in binaryFile ) { - if( binaryFile.hasOwnProperty(key) && - typeof binaryFile[key] === "function") { - this[key] = binaryFile[key]; - } - } - /** - * @override - */ - this.getByteAt = function(iOffset) { - var block = getBlockAtOffset(iOffset); - if( typeof block.data == "string" ) { - return block.data.charCodeAt(iOffset - block.offset) & 0xFF; - } else if( typeof block.data == "unknown" ) { - return IEBinary_getByteAt(block.data, iOffset - block.offset); - } - }; - - /** - * Gets the number of total bytes that have been downloaded. - * - * @returns The number of total bytes that have been downloaded. - */ - this.getDownloadedBytesCount = function() { - return downloadedBytesCount; - }; - - /** - * Downloads the byte range given. Useful for preloading. - * - * @param {Array} range Two element array that denotes the first byte to be read on the first position and the last byte to be read on the last position. A range of [2, 5] will download bytes 2,3,4 and 5. - * @param {?function()} callback The function to invoke when the blocks have been downloaded, this makes this call asynchronous. - */ - this.loadRange = function(range, callback) { - var blockRange = getBlockRangeForByteRange(range); - waitForBlocks(blockRange, callback); - }; - } - - function init() { - getHead( - strUrl, - function(oHTTP) { - var iLength = parseInt(oHTTP.getResponseHeader("Content-Length"),10) || -1; - fncCallback(new BufferedBinaryFile(strUrl, iLength)); - } - ); - } - - init(); -}; - -/** - * @constructor - */ -function BinaryFile(strData, iDataOffset, iDataLength) { - var data = strData; - var dataOffset = iDataOffset || 0; - var dataLength = 0; - - this.getRawData = function() { - return data; - }; - - if (typeof strData == "string") { - dataLength = iDataLength || data.length; - - this.getByteAt = function(iOffset) { - return data.charCodeAt(iOffset + dataOffset) & 0xFF; - }; - } else if (typeof strData == "unknown") { - dataLength = iDataLength || IEBinary_getLength(data); - - this.getByteAt = function(iOffset) { - return IEBinary_getByteAt(data, iOffset + dataOffset); - }; - } - // @aadsm - this.getBytesAt = function(iOffset, iLength) { - var bytes = new Array(iLength); - for( var i = 0; i < iLength; i++ ) { - bytes[i] = this.getByteAt(iOffset+i); - } - return bytes; - }; - - this.getLength = function() { - return dataLength; - }; - - // @aadsm - this.isBitSetAt = function(iOffset, iBit) { - var iByte = this.getByteAt(iOffset); - return (iByte & (1 << iBit)) != 0; - }; - - this.getSByteAt = function(iOffset) { - var iByte = this.getByteAt(iOffset); - if (iByte > 127) - return iByte - 256; - else - return iByte; - }; - - this.getShortAt = function(iOffset, bBigEndian) { - var iShort = bBigEndian ? - (this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1) - : (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset); - if (iShort < 0) iShort += 65536; - return iShort; - }; - this.getSShortAt = function(iOffset, bBigEndian) { - var iUShort = this.getShortAt(iOffset, bBigEndian); - if (iUShort > 32767) - return iUShort - 65536; - else - return iUShort; - }; - this.getLongAt = function(iOffset, bBigEndian) { - var iByte1 = this.getByteAt(iOffset), - iByte2 = this.getByteAt(iOffset + 1), - iByte3 = this.getByteAt(iOffset + 2), - iByte4 = this.getByteAt(iOffset + 3); - - var iLong = bBigEndian ? - (((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4 - : (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1; - if (iLong < 0) iLong += 4294967296; - return iLong; - }; - this.getSLongAt = function(iOffset, bBigEndian) { - var iULong = this.getLongAt(iOffset, bBigEndian); - if (iULong > 2147483647) - return iULong - 4294967296; - else - return iULong; - }; - // @aadsm - this.getInteger24At = function(iOffset, bBigEndian) { - var iByte1 = this.getByteAt(iOffset), - iByte2 = this.getByteAt(iOffset + 1), - iByte3 = this.getByteAt(iOffset + 2); - - var iInteger = bBigEndian ? - ((((iByte1 << 8) + iByte2) << 8) + iByte3) - : ((((iByte3 << 8) + iByte2) << 8) + iByte1); - if (iInteger < 0) iInteger += 16777216; - return iInteger; - }; - this.getStringAt = function(iOffset, iLength) { - var aStr = []; - for (var i=iOffset,j=0;i\r\n" - + "Function IEBinary_getByteAt(strBinary, iOffset)\r\n" - + " IEBinary_getByteAt = AscB(MidB(strBinary,iOffset+1,1))\r\n" - + "End Function\r\n" - + "Function IEBinary_getLength(strBinary)\r\n" - + " IEBinary_getLength = LenB(strBinary)\r\n" - + "End Function\r\n" - + "\r\n" -); diff --git a/src/filereader.js b/src/filereader.js index 587b2a6..19f5759 100755 --- a/src/filereader.js +++ b/src/filereader.js @@ -1,19 +1,12 @@ /** - * Copyright (c) 2010 António Afonso, antonio.afonso gmail, http://www.aadsm.net/ + * Copyright (c) 2011 Anton Podviaznikov, podviaznikov@gmail.com * MIT License [http://www.opensource.org/licenses/mit-license.php] * */ - -(function(ns) { - ns["FileAPIReader"] = function(file) { + (function(ns) { + ns["FileAPIReader"] = function(binaryData) { return function(url, fncCallback, fncError) { - var reader = new FileReader(); - - reader.onload = function(event) { - var result = event.target.result; - fncCallback(new BinaryFile(result)); - }; - reader.readAsBinaryString(file); + fncCallback(new BinaryFile(binaryData)); } }; -})(this); \ No newline at end of file +})(this); diff --git a/src/id3.js b/src/id3.js index 2f1c6d5..d8d713d 100755 --- a/src/id3.js +++ b/src/id3.js @@ -26,7 +26,6 @@ function readTags(reader, data, url, tags) { var tagsFound = reader.readTagsFromData(data, tags); - //console.log("Downloaded data: " + data.getDownloadedBytesCount() + "bytes"); var tags = _files[url] || {}; for( var tag in tagsFound ) if( tagsFound.hasOwnProperty(tag) ) { tags[tag] = tagsFound[tag]; @@ -41,7 +40,7 @@ */ ID3.loadTags = function(url, cb, options) { options = options || {}; - var dataReader = options["dataReader"] || BufferedBinaryAjax; + var dataReader = options["dataReader"]; dataReader(url, function(data) { // preload the format identifier diff --git a/src/id3v1.js b/src/id3v1.js index e282589..9b81c19 100644 --- a/src/id3v1.js +++ b/src/id3v1.js @@ -43,9 +43,9 @@ var offset = data.getLength() - 128; var header = data.getStringAt(offset, 3); if (header == "TAG") { - var title = data.getStringAt(offset + 3, 30).replace(/\0/g, ""); - var artist = data.getStringAt(offset + 33, 30).replace(/\0/g, ""); - var album = data.getStringAt(offset + 63, 30).replace(/\0/g, ""); + var title = data.getStringWithCharsetAt(offset + 3, 30).replace(/\0/g, ""); + var artist = data.getStringWithCharsetAt(offset + 33, 30).replace(/\0/g, ""); + var album = data.getStringWithCharsetAt(offset + 63, 30).replace(/\0/g, ""); var year = data.getStringAt(offset + 93, 4).replace(/\0/g, ""); var trackFlag = data.getByteAt(offset + 97 + 28); diff --git a/src/id3v2frames.js b/src/id3v2frames.js index 665931d..5c0738b 100644 --- a/src/id3v2frames.js +++ b/src/id3v2frames.js @@ -74,32 +74,11 @@ ID3v2.readFrameData['APIC'] = function readPictureFrame(offset, length, data, flags, v) { v = v || '3'; - - var start = offset; - var charset = getTextEncoding( data.getByteAt(offset) ); - switch( v ) { - case '2': - var format = data.getStringAt(offset+1, 3); - offset += 4; - break; - - case '3': - case '4': - var format = data.getStringWithCharsetAt(offset+1, length - (offset-start), charset); - offset += 1 + format.bytesReadCount; - break; - } - var bite = data.getByteAt(offset, 1); - var type = pictureType[bite]; - var desc = data.getStringWithCharsetAt(offset+1, length - (offset-start), charset); - - offset += 1 + desc.bytesReadCount; - return { - "format" : format.toString(), - "type" : type, - "description" : desc.toString(), - "data" : data.getBytesAt(offset, (start+length) - offset) + "format" : '', + "type" : '', + "description" : '', + "data" : '' }; }; diff --git a/src/stringutils.js b/src/stringutils.js index 10cf041..ea93ee8 100644 --- a/src/stringutils.js +++ b/src/stringutils.js @@ -109,5 +109,22 @@ var StringUtils = { var string = new String(arr.join("")); string.bytesReadCount = i; return string; + }, + + readWin1251String: function(str) { + var charmap = unescape( + "%u0402%u0403%u201A%u0453%u201E%u2026%u2020%u2021%u20AC%u2030%u0409%u2039%u040A%u040C%u040B%u040F"+ + "%u0452%u2018%u2019%u201C%u201D%u2022%u2013%u2014%u0000%u2122%u0459%u203A%u045A%u045C%u045B%u045F"+ + "%u00A0%u040E%u045E%u0408%u00A4%u0490%u00A6%u00A7%u0401%u00A9%u0404%u00AB%u00AC%u00AD%u00AE%u0407"+ + "%u00B0%u00B1%u0406%u0456%u0491%u00B5%u00B6%u00B7%u0451%u2116%u0454%u00BB%u0458%u0405%u0455%u0457"); + var code2char = function(code) { + if(code >= 0xC0 && code <= 0xFF) return String.fromCharCode(code - 0xC0 + 0x0410) + if(code >= 0x80 && code <= 0xBF) return charmap.charAt(code - 0x80) + return String.fromCharCode(code) + }; + var res = ""; + for(var i = 0; i < str.length; i++) res = res + code2char(str.charCodeAt(i)) + console.log('Win1251 result:',res); + return res; } }; \ No newline at end of file