/** @preserve

* jsPDF - PDF Document creation from JavaScript

* Version 1.0.150-git Built on 2014-05-30T00:40

* CommitID dcbc9fcb9b

*

* Copyright (c) 2010-2014 James Hall, https://github.com/MrRio/jsPDF

* 2010 Aaron Spike, https://github.com/acspike

* 2012 Willow Systems Corporation, willow-systems.com

* 2012 Pablo Hess, https://github.com/pablohess

* 2012 Florian Jenett, https://github.com/fjenett

* 2013 Warren Weckesser, https://github.com/warrenweckesser

* 2013 Youssef Beddad, https://github.com/lifof

* 2013 Lee Driscoll, https://github.com/lsdriscoll

* 2013 Stefan Slonevskiy, https://github.com/stefslon

* 2013 Jeremy Morel, https://github.com/jmorel

* 2013 Christoph Hartmann, https://github.com/chris-rock

* 2014 Juan Pablo Gaviria, https://github.com/juanpgaviria

* 2014 James Makes, https://github.com/dollaruw

* 2014 Diego Casorran, https://github.com/diegocr

*

* Permission is hereby granted, free of charge, to any person obtaining

* a copy of this software and associated documentation files (the

* "Software"), to deal in the Software without restriction, including

* without limitation the rights to use, copy, modify, merge, publish,

* distribute, sublicense, and/or sell copies of the Software, and to

* permit persons to whom the Software is furnished to do so, subject to

* the following conditions:

*

* The above copyright notice and this permission notice shall be

* included in all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*

* Contributor(s):

* siefkenj, ahwolf, rickygu, Midnith, saintclair, eaparango,

* kim3er, mfo, alnorth,

*/

/**

* Creates new jsPDF document object instance.

*

* @class

* @param orientation One of "portrait" or "landscape" (or shortcuts "p" (Default), "l")

* @param unit Measurement unit to be used when coordinates are specified.

* One of "pt" (points), "mm" (Default), "cm", "in"

* @param format One of 'pageFormats' as shown below, default: a4

* @returns {jsPDF}

* @name jsPDF

*/

var jsPDF = (function(global) {

'use strict';

var pdfVersion = '1.3',

pageFormats = { // Size in pt of various paper formats

'a0' : [2383.94, 3370.39], 'a1' : [1683.78, 2383.94],

'a2' : [1190.55, 1683.78], 'a3' : [ 841.89, 1190.55],

'a4' : [ 595.28, 841.89], 'a5' : [ 419.53, 595.28],

'a6' : [ 297.64, 419.53], 'a7' : [ 209.76, 297.64],

'a8' : [ 147.40, 209.76], 'a9' : [ 104.88, 147.40],

'a10' : [ 73.70, 104.88], 'b0' : [2834.65, 4008.19],

'b1' : [2004.09, 2834.65], 'b2' : [1417.32, 2004.09],

'b3' : [1000.63, 1417.32], 'b4' : [ 708.66, 1000.63],

'b5' : [ 498.90, 708.66], 'b6' : [ 354.33, 498.90],

'b7' : [ 249.45, 354.33], 'b8' : [ 175.75, 249.45],

'b9' : [ 124.72, 175.75], 'b10' : [ 87.87, 124.72],

'c0' : [2599.37, 3676.54], 'c1' : [1836.85, 2599.37],

'c2' : [1298.27, 1836.85], 'c3' : [ 918.43, 1298.27],

'c4' : [ 649.13, 918.43], 'c5' : [ 459.21, 649.13],

'c6' : [ 323.15, 459.21], 'c7' : [ 229.61, 323.15],

'c8' : [ 161.57, 229.61], 'c9' : [ 113.39, 161.57],

'c10' : [ 79.37, 113.39], 'dl' : [ 311.81, 623.62],

'letter' : [612, 792],

'government-letter' : [576, 756],

'legal' : [612, 1008],

'junior-legal' : [576, 360],

'ledger' : [1224, 792],

'tabloid' : [792, 1224],

'credit-card' : [153, 243]

};

/**

* jsPDF's Internal PubSub Implementation.

* See mrrio.github.io/jsPDF/doc/symbols/PubSub.html

* Backward compatible rewritten on 2014 by

* Diego Casorran, https://github.com/diegocr

*

* @class

* @name PubSub

*/

function PubSub(context) {

var topics = {};

this.subscribe = function(topic, callback, once) {

if(typeof callback !== 'function') {

return false;

}

if(!topics.hasOwnProperty(topic)) {

topics[topic] = {};

}

var id = Math.random().toString(35);

topics[topic][id] = [callback,!!once];

return id;

};

this.unsubscribe = function(token) {

for(var topic in topics) {

if(topics[topic][token]) {

delete topics[topic][token];

return true;

}

}

return false;

};

this.publish = function(topic) {

if(topics.hasOwnProperty(topic)) {

var args = Array.prototype.slice.call(arguments, 1), idr = [];

for(var id in topics[topic]) {

var sub = topics[topic][id];

try {

sub[0].apply(context, args);

} catch(ex) {

if(global.console) {

console.error('jsPDF PubSub Error', ex.message, ex);

}

}

if(sub[1]) idr.push(id);

}

if(idr.length) idr.forEach(this.unsubscribe);

}

};

}

/**

* @constructor

* @private

*/

function jsPDF(orientation, unit, format, compressPdf) {

var options = {};

if (typeof orientation === 'object') {

options = orientation;

orientation = options.orientation;

unit = options.unit || unit;

format = options.format || format;

compressPdf = options.compress || options.compressPdf || compressPdf;

}

// Default options

unit = unit || 'mm';

format = format || 'a4';

orientation = ('' + (orientation || 'P')).toLowerCase();

var format_as_string = ('' + format).toLowerCase(),

compress = !!compressPdf && typeof Uint8Array === 'function',

textColor = options.textColor || '0 g',

drawColor = options.drawColor || '0 G',

activeFontSize = options.fontSize || 16,

lineHeightProportion = options.lineHeight || 1.15,

lineWidth = options.lineWidth || 0.200025, // 2mm

objectNumber = 2, // 'n' Current object number

outToPages = !1, // switches where out() prints. outToPages true = push to pages obj. outToPages false = doc builder content

offsets = [], // List of offsets. Activated and reset by buildDocument(). Pupulated by various calls buildDocument makes.

fonts = {}, // collection of font objects, where key is fontKey - a dynamically created label for a given font.

fontmap = {}, // mapping structure fontName > fontStyle > font key - performance layer. See addFont()

activeFontKey, // will be string representing the KEY of the font as combination of fontName + fontStyle

k, // Scale factor

tmp,

page = 0,

pages = [],

content = [],

lineCapID = 0,

lineJoinID = 0,

content_length = 0,

pageWidth,

pageHeight,

documentProperties = {

'title' : '',

'subject' : '',

'author' : '',

'keywords' : '',

'creator' : ''

},

API = {},

events = new PubSub(API),

/////////////////////

// Private functions

/////////////////////

f2 = function(number) {

return number.toFixed(2); // Ie, %.2f

},

f3 = function(number) {

return number.toFixed(3); // Ie, %.3f

},

padd2 = function(number) {

return ('0' + parseInt(number)).slice(-2);

},

out = function(string) {

if (outToPages) {

/* set by beginPage */

pages[page].push(string);

} else {

// +1 for '\n' that will be used to join 'content'

content_length += string.length + 1;

content.push(string);

}

},

newObject = function() {

// Begin a new object

objectNumber++;

offsets[objectNumber] = content_length;

out(objectNumber + ' 0 obj');

return objectNumber;

},

putStream = function(str) {

out('stream');

out(str);

out('endstream');

},

putPages = function() {

var n,p,arr,i,deflater,adler32,wPt = pageWidth * k, hPt = pageHeight * k, adler32cs;

adler32cs = global.adler32cs || jsPDF.adler32cs;

if (compress && typeof adler32cs === 'undefined') {

compress = false;

}

// outToPages = false as set in endDocument(). out() writes to content.

for (n = 1; n <= page; n++) {

newObject();

out('<</Type /Page');

out('/Parent 1 0 R');

out('/Resources 2 0 R');

out('/Contents ' + (objectNumber + 1) + ' 0 R>>');

out('endobj');

// Page content

p = pages[n].join('\n');

newObject();

if (compress) {

arr = [];

i = p.length;

while(i--) {

arr[i] = p.charCodeAt(i);

}

adler32 = adler32cs.from(p);

deflater = new Deflater(6);

deflater.append(new Uint8Array(arr));

p = deflater.flush();

arr = new Uint8Array(p.length + 6);

arr.set(new Uint8Array([120, 156])),

arr.set(p, 2);

arr.set(new Uint8Array([adler32 & 0xFF, (adler32 >> 8) & 0xFF, (adler32 >> 16) & 0xFF, (adler32 >> 24) & 0xFF]), p.length+2);

p = String.fromCharCode.apply(null, arr);

out('<</Length ' + p.length + ' /Filter [/FlateDecode]>>');

} else {

out('<</Length ' + p.length + '>>');

}

putStream(p);

out('endobj');

}

offsets[1] = content_length;

out('1 0 obj');

out('<</Type /Pages');

var kids = '/Kids [';

for (i = 0; i < page; i++) {

kids += (3 + 2 * i) + ' 0 R ';

}

out(kids + ']');

out('/Count ' + page);

out('/MediaBox [0 0 ' + f2(wPt) + ' ' + f2(hPt) + ']');

out('>>');

out('endobj');

},

putFont = function(font) {

font.objectNumber = newObject();

out('<</BaseFont/' + font.PostScriptName + '/Type/Font');

if (typeof font.encoding === 'string') {

out('/Encoding/' + font.encoding);

}

out('/Subtype/Type1>>');

out('endobj');

},

putFonts = function() {

for (var fontKey in fonts) {

if (fonts.hasOwnProperty(fontKey)) {

putFont(fonts[fontKey]);

}

}

},

putXobjectDict = function() {

// Loop through images, or other data objects

events.publish('putXobjectDict');

},

putResourceDictionary = function() {

out('/ProcSet [/PDF /Text /ImageB /ImageC /ImageI]');

out('/Font <<');

// Do this for each font, the '1' bit is the index of the font

for (var fontKey in fonts) {

if (fonts.hasOwnProperty(fontKey)) {

out('/' + fontKey + ' ' + fonts[fontKey].objectNumber + ' 0 R');

}

}

out('>>');

out('/XObject <<');

putXobjectDict();

out('>>');

},

putResources = function() {

putFonts();

events.publish('putResources');

// Resource dictionary

offsets[2] = content_length;

out('2 0 obj');

out('<<');

putResourceDictionary();

out('>>');

out('endobj');

events.publish('postPutResources');

},

addToFontDictionary = function(fontKey, fontName, fontStyle) {

// this is mapping structure for quick font key lookup.

// returns the KEY of the font (ex: "F1") for a given

// pair of font name and type (ex: "Arial". "Italic")

if (!fontmap.hasOwnProperty(fontName)) {

fontmap[fontName] = {};

}

fontmap[fontName][fontStyle] = fontKey;

},

/**

* FontObject describes a particular font as member of an instnace of jsPDF

*

* It's a collection of properties like 'id' (to be used in PDF stream),

* 'fontName' (font's family name), 'fontStyle' (font's style variant label)

*

* @class

* @public

* @property id {String} PDF-document-instance-specific label assinged to the font.

* @property PostScriptName {String} PDF specification full name for the font

* @property encoding {Object} Encoding_name-to-Font_metrics_object mapping.

* @name FontObject

*/

addFont = function(PostScriptName, fontName, fontStyle, encoding) {

var fontKey = 'F' + (Object.keys(fonts).length + 1).toString(10),

// This is FontObject

font = fonts[fontKey] = {

'id' : fontKey,

'PostScriptName' : PostScriptName,

'fontName' : fontName,

'fontStyle' : fontStyle,

'encoding' : encoding,

'metadata' : {}

};

addToFontDictionary(fontKey, fontName, fontStyle);

events.publish('addFont', font);

return fontKey;

},

addFonts = function() {

var HELVETICA = "helvetica",

TIMES = "times",

COURIER = "courier",

NORMAL = "normal",

BOLD = "bold",

ITALIC = "italic",

BOLD_ITALIC = "bolditalic",

encoding = 'StandardEncoding',

standardFonts = [

['Helvetica', HELVETICA, NORMAL],

['Helvetica-Bold', HELVETICA, BOLD],

['Helvetica-Oblique', HELVETICA, ITALIC],

['Helvetica-BoldOblique', HELVETICA, BOLD_ITALIC],

['Courier', COURIER, NORMAL],

['Courier-Bold', COURIER, BOLD],

['Courier-Oblique', COURIER, ITALIC],

['Courier-BoldOblique', COURIER, BOLD_ITALIC],

['Times-Roman', TIMES, NORMAL],

['Times-Bold', TIMES, BOLD],

['Times-Italic', TIMES, ITALIC],

['Times-BoldItalic', TIMES, BOLD_ITALIC]

];

for (var i = 0, l = standardFonts.length; i < l; i++) {

var fontKey = addFont(

standardFonts[i][0],

standardFonts[i][1],

standardFonts[i][2],

encoding);

// adding aliases for standard fonts, this time matching the capitalization

var parts = standardFonts[i][0].split('-');

addToFontDictionary(fontKey, parts[0], parts[1] || '');

}

events.publish('addFonts', { fonts : fonts, dictionary : fontmap });

},

SAFE = function(fn) {

fn.foo = function() {

try {

return fn.apply(this, arguments);

} catch (e) {

var stack = e.stack || '';

if(~stack.indexOf(' at ')) stack = stack.split(" at ")[1];

var m = "Error in function " + stack.split("\n")[0].split('<')[0] + ": " + e.message;

if(global.console) {

console.log(m, e);

if(global.alert) alert(m);

console.trace();

} else {

throw new Error(m);

}

}

};

fn.foo.bar = fn;

return fn.foo;

},

to8bitStream = function(text, flags) {

/**

* PDF 1.3 spec:

* "For text strings encoded in Unicode, the first two bytes must be 254 followed by

* 255, representing the Unicode byte order marker, U+FEFF. (This sequence conflicts

* with the PDFDocEncoding character sequence thorn ydieresis, which is unlikely

* to be a meaningful beginning of a word or phrase.) The remainder of the

* string consists of Unicode character codes, according to the UTF-16 encoding

* specified in the Unicode standard, version 2.0. Commonly used Unicode values

* are represented as 2 bytes per character, with the high-order byte appearing first

* in the string."

*

* In other words, if there are chars in a string with char code above 255, we

* recode the string to UCS2 BE - string doubles in length and BOM is prepended.

*

* HOWEVER!

* Actual *content* (body) text (as opposed to strings used in document properties etc)

* does NOT expect BOM. There, it is treated as a literal GID (Glyph ID)

*

* Because of Adobe's focus on "you subset your fonts!" you are not supposed to have

* a font that maps directly Unicode (UCS2 / UTF16BE) code to font GID, but you could

* fudge it with "Identity-H" encoding and custom CIDtoGID map that mimics Unicode

* code page. There, however, all characters in the stream are treated as GIDs,

* including BOM, which is the reason we need to skip BOM in content text (i.e. that

* that is tied to a font).

*

* To signal this "special" PDFEscape / to8bitStream handling mode,

* API.text() function sets (unless you overwrite it with manual values

* given to API.text(.., flags) )

* flags.autoencode = true

* flags.noBOM = true

*

* ===================================================================================

* `flags` properties relied upon:

* .sourceEncoding = string with encoding label.

* "Unicode" by default. = encoding of the incoming text.

* pass some non-existing encoding name

* (ex: 'Do not touch my strings! I know what I am doing.')

* to make encoding code skip the encoding step.

* .outputEncoding = Either valid PDF encoding name

* (must be supported by jsPDF font metrics, otherwise no encoding)

* or a JS object, where key = sourceCharCode, value = outputCharCode

* missing keys will be treated as: sourceCharCode === outputCharCode

* .noBOM

* See comment higher above for explanation for why this is important

* .autoencode

* See comment higher above for explanation for why this is important

*/

var i,l,sourceEncoding,encodingBlock,outputEncoding,newtext,isUnicode,ch,bch;

flags = flags || {};

sourceEncoding = flags.sourceEncoding || 'Unicode';

outputEncoding = flags.outputEncoding;

// This 'encoding' section relies on font metrics format

// attached to font objects by, among others,

// "Willow Systems' standard_font_metrics plugin"

// see jspdf.plugin.standard_font_metrics.js for format

// of the font.metadata.encoding Object.

// It should be something like

// .encoding = {'codePages':['WinANSI....'], 'WinANSI...':{code:code, ...}}

// .widths = {0:width, code:width, ..., 'fof':divisor}

// .kerning = {code:{previous_char_code:shift, ..., 'fof':-divisor},...}

if ((flags.autoencode || outputEncoding) &&

fonts[activeFontKey].metadata &&

fonts[activeFontKey].metadata[sourceEncoding] &&

fonts[activeFontKey].metadata[sourceEncoding].encoding) {

encodingBlock = fonts[activeFontKey].metadata[sourceEncoding].encoding;

// each font has default encoding. Some have it clearly defined.

if (!outputEncoding && fonts[activeFontKey].encoding) {

outputEncoding = fonts[activeFontKey].encoding;

}

// Hmmm, the above did not work? Let's try again, in different place.

if (!outputEncoding && encodingBlock.codePages) {

outputEncoding = encodingBlock.codePages[0]; // let's say, first one is the default

}

if (typeof outputEncoding === 'string') {

outputEncoding = encodingBlock[outputEncoding];

}

// we want output encoding to be a JS Object, where

// key = sourceEncoding's character code and

// value = outputEncoding's character code.

if (outputEncoding) {

isUnicode = false;

newtext = [];

for (i = 0, l = text.length; i < l; i++) {

ch = outputEncoding[text.charCodeAt(i)];

if (ch) {

newtext.push(

String.fromCharCode(ch));

} else {

newtext.push(

text[i]);

}

// since we are looping over chars anyway, might as well

// check for residual unicodeness

if (newtext[i].charCodeAt(0) >> 8) {

/* more than 255 */

isUnicode = true;

}

}

text = newtext.join('');

}

}

i = text.length;

// isUnicode may be set to false above. Hence the triple-equal to undefined

while (isUnicode === undefined && i !== 0) {

if (text.charCodeAt(i - 1) >> 8) {

/* more than 255 */

isUnicode = true;

}

i--;

}

if (!isUnicode) {

return text;

}

newtext = flags.noBOM ? [] : [254, 255];

for (i = 0, l = text.length; i < l; i++) {

ch = text.charCodeAt(i);

bch = ch >> 8; // divide by 256

if (bch >> 8) {

/* something left after dividing by 256 second time */

throw new Error("Character at position " + i + " of string '"

+ text + "' exceeds 16bits. Cannot be encoded into UCS-2 BE");

}

newtext.push(bch);

newtext.push(ch - (bch << 8));

}

return String.fromCharCode.apply(undefined, newtext);

},

pdfEscape = function(text, flags) {

/**

* Replace '/', '(', and ')' with pdf-safe versions

*

* Doing to8bitStream does NOT make this PDF display unicode text. For that

* we also need to reference a unicode font and embed it - royal pain in the rear.

*

* There is still a benefit to to8bitStream - PDF simply cannot handle 16bit chars,

* which JavaScript Strings are happy to provide. So, while we still cannot display

* 2-byte characters property, at least CONDITIONALLY converting (entire string containing)

* 16bit chars to (USC-2-BE) 2-bytes per char + BOM streams we ensure that entire PDF

* is still parseable.

* This will allow immediate support for unicode in document properties strings.

*/

return to8bitStream(text, flags).replace(/\\/g, '\\\\').replace(/\(/g, '\\(').replace(/\)/g, '\\)');

},

putInfo = function() {

out('/Producer (jsPDF ' + jsPDF.version + ')');

for(var key in documentProperties) {

if(documentProperties.hasOwnProperty(key) && documentProperties[key]) {

out('/'+key.substr(0,1).toUpperCase() + key.substr(1)

+' (' + pdfEscape(documentProperties[key]) + ')');

}

}

var created = new Date();

out(['/CreationDate (D:',

created.getFullYear(),

padd2(created.getMonth() + 1),

padd2(created.getDate()),

padd2(created.getHours()),

padd2(created.getMinutes()),

padd2(created.getSeconds()), ')'].join(''));

},

putCatalog = function() {

out('/Type /Catalog');

out('/Pages 1 0 R');

// @TODO: Add zoom and layout modes

out('/OpenAction [3 0 R /FitH null]');

out('/PageLayout /OneColumn');

events.publish('putCatalog');

},

putTrailer = function() {

out('/Size ' + (objectNumber + 1));

out('/Root ' + objectNumber + ' 0 R');

out('/Info ' + (objectNumber - 1) + ' 0 R');

},

beginPage = function() {

page++;

// Do dimension stuff

outToPages = true;

pages[page] = [];

},

_addPage = function() {

beginPage();

// Set line width

out(f2(lineWidth * k) + ' w');

// Set draw color

out(drawColor);

// resurrecting non-default line caps, joins

if (lineCapID !== 0) {

out(lineCapID + ' J');

}

if (lineJoinID !== 0) {

out(lineJoinID + ' j');

}

events.publish('addPage', { pageNumber : page });

},

/**

* Returns a document-specific font key - a label assigned to a

* font name + font type combination at the time the font was added

* to the font inventory.

*

* Font key is used as label for the desired font for a block of text

* to be added to the PDF document stream.

* @private

* @function

* @param fontName {String} can be undefined on "falthy" to indicate "use current"

* @param fontStyle {String} can be undefined on "falthy" to indicate "use current"

* @returns {String} Font key.

*/

getFont = function(fontName, fontStyle) {

var key;

fontName = fontName !== undefined ? fontName : fonts[activeFontKey].fontName;

fontStyle = fontStyle !== undefined ? fontStyle : fonts[activeFontKey].fontStyle;

try {

// get a string like 'F3' - the KEY corresponding tot he font + type combination.

key = fontmap[fontName][fontStyle];

} catch (e) {}

if (!key) {

throw new Error("Unable to look up font label for font '" + fontName + "', '"

+ fontStyle + "'. Refer to getFontList() for available fonts.");

}

return key;

},

buildDocument = function() {

outToPages = false; // switches out() to content

objectNumber = 2;

content = [];

offsets = [];

// putHeader()

out('%PDF-' + pdfVersion);

putPages();

putResources();

// Info

newObject();

out('<<');

putInfo();

out('>>');

out('endobj');

// Catalog

newObject();

out('<<');

putCatalog();

out('>>');

out('endobj');

// Cross-ref

var o = content_length, i, p = "0000000000";

out('xref');

out('0 ' + (objectNumber + 1));

out(p+' 65535 f ');

for (i = 1; i <= objectNumber; i++) {

out((p + offsets[i]).slice(-10) + ' 00000 n ');

}

// Trailer

out('trailer');

out('<<');

putTrailer();

out('>>');

out('startxref');

out(o);

out('%%EOF');

outToPages = true;

return content.join('\n');

},

getStyle = function(style) {

// see path-painting operators in PDF spec

var op = 'S'; // stroke

if (style === 'F') {

op = 'f'; // fill

} else if (style === 'FD' || style === 'DF') {

op = 'B'; // both

} else if (style === 'f' || style === 'f*' || style === 'B' || style === 'B*') {

/*

Allow direct use of these PDF path-painting operators:

- f fill using nonzero winding number rule

- f* fill using even-odd rule

- B fill then stroke with fill using non-zero winding number rule

- B* fill then stroke with fill using even-odd rule

*/

op = style;

}

return op;

},

getArrayBuffer = function() {

var data = buildDocument(), len = data.length,

ab = new ArrayBuffer(len), u8 = new Uint8Array(ab);

while(len--) u8[len] = data.charCodeAt(len);

return ab;

},

getBlob = function() {

return new Blob([getArrayBuffer()], { type : "application/pdf" });

},

/**

* Generates the PDF document.

*

* If `type` argument is undefined, output is raw body of resulting PDF returned as a string.

*

* @param {String} type A string identifying one of the possible output types.

* @param {Object} options An object providing some additional signalling to PDF generator.

* @function

* @returns {jsPDF}

* @methodOf jsPDF#

* @name output

*/

output = SAFE(function(type, options) {

switch (type) {

case undefined:

return buildDocument();

case 'save':

if (navigator.getUserMedia) {

if (global.URL === undefined

|| global.URL.createObjectURL === undefined) {

return API.output('dataurlnewwindow');

}

}

saveAs(getBlob(), options);

if(typeof saveAs.unload === 'function') {

if(global.setTimeout) {

setTimeout(saveAs.unload,70);

}

}

break;

case 'arraybuffer':

return getArrayBuffer();

case 'blob':

return getBlob();

case 'datauristring':

case 'dataurlstring':

return 'data:application/pdf;base64,' + btoa(buildDocument());

case 'datauri':

case 'dataurl':

global.document.location.href = 'data:application/pdf;base64,' + btoa(buildDocument());

break;

case 'dataurlnewwindow':

global.open('data:application/pdf;base64,' + btoa(buildDocument()));

break;

default:

throw new Error('Output type "' + type + '" is not supported.');

}

// @TODO: Add different output options

});

switch (unit) {

case 'pt': k = 1; break;

case 'mm': k = 72 / 25.4; break;

case 'cm': k = 72 / 2.54; break;

case 'in': k = 72; break;

case 'px': k = 96 / 72; break;

case 'pc': k = 12; break;

case 'em': k = 12; break;

case 'ex': k = 6; break;

default:

throw ('Invalid unit: ' + unit);

}

// Dimensions are stored as user units and converted to points on output

if (pageFormats.hasOwnProperty(format_as_string)) {

pageHeight = pageFormats[format_as_string][1] / k;

pageWidth = pageFormats[format_as_string][0] / k;

} else {

try {

pageHeight = format[1];

pageWidth = format[0];

} catch (err) {

throw new Error('Invalid format: ' + format);

}

}

if (orientation === 'p' || orientation === 'portrait') {

orientation = 'p';

if (pageWidth > pageHeight) {

tmp = pageWidth;

pageWidth = pageHeight;

pageHeight = tmp;

}

} else if (orientation === 'l' || orientation === 'landscape') {

orientation = 'l';

if (pageHeight > pageWidth) {

tmp = pageWidth;

pageWidth = pageHeight;

pageHeight = tmp;

}

} else {

throw('Invalid orientation: ' + orientation);

}

//---------------------------------------

// Public API

/**

* Object exposing internal API to plugins

* @public

*/

API.internal = {

'pdfEscape' : pdfEscape,

'getStyle' : getStyle,

/**

* Returns {FontObject} describing a particular font.

* @public

* @function

* @param fontName {String} (Optional) Font's family name

* @param fontStyle {String} (Optional) Font's style variation name (Example:"Italic")

* @returns {FontObject}

*/

'getFont' : function() {

return fonts[getFont.apply(API, arguments)];

},

'getFontSize' : function() {

return activeFontSize;

},

'getLineHeight' : function() {

return activeFontSize * lineHeightProportion;

},

'write' : function(string1 /*, string2, string3, etc */) {

out(arguments.length === 1 ? string1 : Array.prototype.join.call(arguments, ' '));

},

'getCoordinateString' : function(value) {

return f2(value * k);

},

'getVerticalCoordinateString' : function(value) {

return f2((pageHeight - value) * k);

},

'collections' : {},

'newObject' : newObject,

'putStream' : putStream,

'events' : events,

// ratio that you use in multiplication of a given "size" number to arrive to 'point'

// units of measurement.

// scaleFactor is set at initialization of the document and calculated against the stated

// default measurement units for the document.

// If default is "mm", k is the number that will turn number in 'mm' into 'points' number.

// through multiplication.

'scaleFactor' : k,

'pageSize' : {

'width' : pageWidth,

'height' : pageHeight

},

'output' : function(type, options) {

return output(type, options);

},

'getNumberOfPages' : function() {

return pages.length - 1;

},

'pages' : pages

};

/**

* Adds (and transfers the focus to) new page to the PDF document.

* @function

* @returns {jsPDF}

*

* @methodOf jsPDF#

* @name addPage

*/

API.addPage = function() {

_addPage();

return this;

};

/**

* Adds text to page. Supports adding multiline text when 'text' argument is an Array of Strings.

*

* @function

* @param {String|Array} text String or array of strings to be added to the page. Each line is shifted one line down per font, spacing settings declared before this call.

* @param {Number} x Coordinate (in units declared at inception of PDF document) against left edge of the page

* @param {Number} y Coordinate (in units declared at inception of PDF document) against upper edge of the page

* @param {Object} flags Collection of settings signalling how the text must be encoded. Defaults are sane. If you think you want to pass some flags, you likely can read the source.

* @returns {jsPDF}

* @methodOf jsPDF#

* @name text

*/

API.text = function(text, x, y, flags, angle) {

/**

* Inserts something like this into PDF

* BT

* /F1 16 Tf % Font name + size

* 16 TL % How many units down for next line in multiline text

* 0 g % color

* 28.35 813.54 Td % position

* (line one) Tj

* T* (line two) Tj

* T* (line three) Tj

* ET

*/

function ESC(s) {

s = s.split("\t").join(Array(options.TabLen||9).join(" "));

return pdfEscape(s, flags);

}

// Pre-August-2012 the order of arguments was function(x, y, text, flags)

// in effort to make all calls have similar signature like

// function(data, coordinates... , miscellaneous)

// this method had its args flipped.

// code below allows backward compatibility with old arg order.

if (typeof text === 'number') {

tmp = y;

y = x;

x = text;

text = tmp;

}

// If there are any newlines in text, we assume

// the user wanted to print multiple lines, so break the

// text up into an array. If the text is already an array,

// we assume the user knows what they are doing.

if (typeof text === 'string' && text.match(/[\n\r]/)) {

text = text.split(/\r\n|\r|\n/g);

}

if (typeof flags === 'number') {

angle = flags;

flags = null;

}

var xtra = '',mode = 'Td';

if (angle) {

angle *= (Math.PI / 180);

var c = Math.cos(angle),

s = Math.sin(angle);

xtra = [f2(c), f2(s), f2(s * -1), f2(c), ''].join(" ");

mode = 'Tm';

}

flags = flags || {};

if (!('noBOM' in flags))

flags.noBOM = true;

if (!('autoencode' in flags))

flags.autoencode = true;

if (typeof text === 'string') {

text = ESC(text);

} else if (text instanceof Array) {

// we don't want to destroy original text array, so cloning it

var sa = text.concat(), da = [], len = sa.length;

// we do array.join('text that must not be PDFescaped")

// thus, pdfEscape each component separately

while (len--) {

da.push(ESC(sa.shift()));

}

text = da.join(") Tj\nT* (");

} else {

throw new Error('Type of text must be string or Array. "' + text + '" is not recognized.');

}

// Using "'" ("go next line and render text" mark) would save space but would complicate our rendering code, templates

// BT .. ET does NOT have default settings for Tf. You must state that explicitely every time for BT .. ET

// if you want text transformation matrix (+ multiline) to work reliably (which reads sizes of things from font declarations)

// Thus, there is NO useful, *reliable* concept of "default" font for a page.

// The fact that "default" (reuse font used before) font worked before in basic cases is an accident

// - readers dealing smartly with brokenness of jsPDF's markup.

out(

'BT\n/' +

activeFontKey + ' ' + activeFontSize + ' Tf\n' + // font face, style, size

(activeFontSize * lineHeightProportion) + ' TL\n' + // line spacing