corrade-nucleus-nucleons – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /**
2 * @license Highcharts JS v5.0.10 (2017-03-31)
3 * Client side exporting module
4 *
5 * (c) 2015 Torstein Honsi / Oystein Moseng
6 *
7 * License: www.highcharts.com/license
8 */
9 'use strict';
10 (function(factory) {
11 if (typeof module === 'object' && module.exports) {
12 module.exports = factory;
13 } else {
14 factory(Highcharts);
15 }
16 }(function(Highcharts) {
17 (function(Highcharts) {
18 /**
19 * Client side exporting module
20 *
21 * (c) 2015 Torstein Honsi / Oystein Moseng
22 *
23 * License: www.highcharts.com/license
24 */
25  
26 /*global MSBlobBuilder */
27  
28 var merge = Highcharts.merge,
29 win = Highcharts.win,
30 nav = win.navigator,
31 doc = win.document,
32 each = Highcharts.each,
33 domurl = win.URL || win.webkitURL || win,
34 isMSBrowser = /Edge\/|Trident\/|MSIE /.test(nav.userAgent),
35 isEdgeBrowser = /Edge\/\d+/.test(nav.userAgent),
36 loadEventDeferDelay = isMSBrowser ? 150 : 0; // Milliseconds to defer image load event handlers to offset IE bug
37  
38 // Dummy object so we can reuse our canvas-tools.js without errors
39 Highcharts.CanVGRenderer = {};
40  
41  
42 /**
43 * Downloads a script and executes a callback when done.
44 * @param {String} scriptLocation
45 * @param {Function} callback
46 */
47 function getScript(scriptLocation, callback) {
48 var head = doc.getElementsByTagName('head')[0],
49 script = doc.createElement('script');
50  
51 script.type = 'text/javascript';
52 script.src = scriptLocation;
53 script.onload = callback;
54 script.onerror = function() {
55 console.error('Error loading script', scriptLocation); // eslint-disable-line no-console
56 };
57  
58 head.appendChild(script);
59 }
60  
61 // Convert dataURL to Blob if supported, otherwise returns undefined
62 Highcharts.dataURLtoBlob = function(dataURL) {
63 if (
64 win.atob &&
65 win.ArrayBuffer &&
66 win.Uint8Array &&
67 win.Blob &&
68 domurl.createObjectURL
69 ) {
70 // Try to convert data URL to Blob
71 var parts = dataURL.match(/data:([^;]*)(;base64)?,([0-9A-Za-z+/]+)/),
72 binStr = win.atob(parts[3]), // Assume base64 encoding
73 buf = new win.ArrayBuffer(binStr.length),
74 binary = new win.Uint8Array(buf),
75 blob;
76  
77 for (var i = 0; i < binary.length; ++i) {
78 < binary.length; ++i) { binary[i] = binStr.charCodeAt(i);
79 < binary.length; ++i) { }
80  
81 < binary.length; ++i) { blob = new win.Blob([binary], {
82 < binary.length; ++i) { 'type': parts[1]
83 < binary.length; ++i) { });
84 < binary.length; ++i) { return domurl.createObjectURL(blob);
85 < binary.length; ++i) { }
86 < binary.length; ++i) { };
87  
88 < binary.length; ++i) { // Download contents by dataURL/blob
89 < binary.length; ++i) { Highcharts.downloadURL = function(dataURL, filename) {
90 < binary.length; ++i) { var a = doc.createElement('a'),
91 < binary.length; ++i) { windowRef;
92  
93 < binary.length; ++i) { // IE specific blob implementation
94 < binary.length; ++i) { if (nav.msSaveOrOpenBlob) {
95 < binary.length; ++i) { nav.msSaveOrOpenBlob(dataURL, filename);
96 < binary.length; ++i) { return;
97 < binary.length; ++i) { }
98  
99 < binary.length; ++i) { // Some browsers have limitations for data URL lengths. Try to convert to
100 < binary.length; ++i) { // Blob or fall back.
101 < binary.length; ++i) { if (dataURL.length > 2000000) {
102 < binary.length; ++i) { dataURL = Highcharts.dataURLtoBlob(dataURL);
103 < binary.length; ++i) { if (!dataURL) {
104 < binary.length; ++i) { throw 'Data URL length limit reached';
105 < binary.length; ++i) { }
106 < binary.length; ++i) { }
107  
108 < binary.length; ++i) { // Try HTML5 download attr if supported
109 < binary.length; ++i) { if (a.download !== undefined) {
110 < binary.length; ++i) { a.href = dataURL;
111 < binary.length; ++i) { a.download = filename; // HTML5 download attribute
112 < binary.length; ++i) { a.target = '_blank';
113 < binary.length; ++i) { doc.body.appendChild(a);
114 < binary.length; ++i) { a.click();
115 < binary.length; ++i) { doc.body.removeChild(a);
116 < binary.length; ++i) { } else {
117 < binary.length; ++i) { // No download attr, just opening data URI
118 < binary.length; ++i) { try {
119 < binary.length; ++i) { windowRef = win.open(dataURL, 'chart');
120 < binary.length; ++i) { if (windowRef === undefined || windowRef === null) {
121 < binary.length; ++i) { throw 'Failed to open window';
122 < binary.length; ++i) { }
123 < binary.length; ++i) { } catch (e) {
124 < binary.length; ++i) { // window.open failed, trying location.href
125 < binary.length; ++i) { win.location.href = dataURL;
126 < binary.length; ++i) { }
127 < binary.length; ++i) { }
128 < binary.length; ++i) { };
129  
130 < binary.length; ++i) { // Get blob URL from SVG code. Falls back to normal data URI.
131 < binary.length; ++i) { Highcharts.svgToDataUrl = function(svg) {
132 < binary.length; ++i) { var webKit = nav.userAgent.indexOf('WebKit') > -1 && nav.userAgent.indexOf('Chrome') < 0; // Webkit and not chrome
133 < binary.length; ++i) { try {
134 < binary.length; ++i) { // Safari requires data URI since it doesn't allow navigation to blob URLs
135 < binary.length; ++i) { // Firefox has an issue with Blobs and internal references, leading to gradients not working using Blobs (#4550)
136 < binary.length; ++i) { if (!webKit && nav.userAgent.toLowerCase().indexOf('firefox') < 0) {
137 < binary.length; ++i) { return domurl.createObjectURL(new win.Blob([svg], {
138 < binary.length; ++i) { type: 'image/svg+xml;charset-utf-16'
139 < binary.length; ++i) { }));
140 < binary.length; ++i) { }
141 < binary.length; ++i) { } catch (e) {
142 < binary.length; ++i) { // Ignore
143 < binary.length; ++i) { }
144 < binary.length; ++i) { return 'data:image/svg+xml;charset=UTF-8,' + encodeURIComponent(svg);
145 < binary.length; ++i) { };
146  
147 < binary.length; ++i) { // Get data:URL from image URL
148 < binary.length; ++i) { // Pass in callbacks to handle results. finallyCallback is always called at the end of the process. Supplying this callback is optional.
149 < binary.length; ++i) { // All callbacks receive four arguments: imageURL, imageType, callbackArgs and scale. callbackArgs is used only by callbacks and can contain whatever.
150 < binary.length; ++i) { Highcharts.imageToDataUrl = function(imageURL, imageType, callbackArgs, scale, successCallback, taintedCallback, noCanvasSupportCallback, failedLoadCallback, finallyCallback) {
151 < binary.length; ++i) { var img = new win.Image(),
152 < binary.length; ++i) { taintedHandler,
153 < binary.length; ++i) { loadHandler = function() {
154 < binary.length; ++i) { setTimeout(function() {
155 < binary.length; ++i) { var canvas = doc.createElement('canvas'),
156 < binary.length; ++i) { ctx = canvas.getContext && canvas.getContext('2d'),
157 < binary.length; ++i) { dataURL;
158 < binary.length; ++i) { try {
159 < binary.length; ++i) { if (!ctx) {
160 < binary.length; ++i) { noCanvasSupportCallback(imageURL, imageType, callbackArgs, scale);
161 < binary.length; ++i) { } else {
162 < binary.length; ++i) { canvas.height = img.height * scale;
163 < binary.length; ++i) { canvas.width = img.width * scale;
164 < binary.length; ++i) { ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
165  
166 < binary.length; ++i) { // Now we try to get the contents of the canvas.
167 < binary.length; ++i) { try {
168 < binary.length; ++i) { dataURL = canvas.toDataURL(imageType);
169 < binary.length; ++i) { successCallback(dataURL, imageType, callbackArgs, scale);
170 < binary.length; ++i) { } catch (e) {
171 < binary.length; ++i) { taintedHandler(imageURL, imageType, callbackArgs, scale);
172 < binary.length; ++i) { }
173 < binary.length; ++i) { }
174 < binary.length; ++i) { } finally {
175 < binary.length; ++i) { if (finallyCallback) {
176 < binary.length; ++i) { finallyCallback(imageURL, imageType, callbackArgs, scale);
177 < binary.length; ++i) { }
178 < binary.length; ++i) { }
179 < binary.length; ++i) { }, loadEventDeferDelay); // IE bug where image is not always ready despite calling load event.
180 < binary.length; ++i) { },
181 < binary.length; ++i) { // Image load failed (e.g. invalid URL)
182 < binary.length; ++i) { errorHandler = function() {
183 < binary.length; ++i) { failedLoadCallback(imageURL, imageType, callbackArgs, scale);
184 < binary.length; ++i) { if (finallyCallback) {
185 < binary.length; ++i) { finallyCallback(imageURL, imageType, callbackArgs, scale);
186 < binary.length; ++i) { }
187 < binary.length; ++i) { };
188  
189 < binary.length; ++i) { // This is called on load if the image drawing to canvas failed with a security error.
190 < binary.length; ++i) { // We retry the drawing with crossOrigin set to Anonymous.
191 < binary.length; ++i) { taintedHandler = function() {
192 < binary.length; ++i) { img = new win.Image();
193 < binary.length; ++i) { taintedHandler = taintedCallback;
194 < binary.length; ++i) { img.crossOrigin = 'Anonymous'; // Must be set prior to loading image source
195 < binary.length; ++i) { img.onload = loadHandler;
196 < binary.length; ++i) { img.onerror = errorHandler;
197 < binary.length; ++i) { img.src = imageURL;
198 < binary.length; ++i) { };
199  
200 < binary.length; ++i) { img.onload = loadHandler;
201 < binary.length; ++i) { img.onerror = errorHandler;
202 < binary.length; ++i) { img.src = imageURL;
203 < binary.length; ++i) { };
204  
205 < binary.length; ++i) { /**
206 < binary.length; ++i) { * Get data URL to an image of an SVG and call download on it
207 < binary.length; ++i) { *
208 < binary.length; ++i) { * options object:
209 < binary.length; ++i) { * filename: Name of resulting downloaded file without extension
210 < binary.length; ++i) { * type: File type of resulting download
211 < binary.length; ++i) { * scale: Scaling factor of downloaded image compared to source
212 < binary.length; ++i) { * libURL: URL pointing to location of dependency scripts to download on demand
213 < binary.length; ++i) { */
214 < binary.length; ++i) { Highcharts.downloadSVGLocal = function(svg, options, failCallback, successCallback) {
215 < binary.length; ++i) { var svgurl,
216 < binary.length; ++i) { blob,
217 < binary.length; ++i) { objectURLRevoke = true,
218 < binary.length; ++i) { finallyHandler,
219 < binary.length; ++i) { libURL = options.libURL || Highcharts.getOptions().exporting.libURL,
220 < binary.length; ++i) { dummySVGContainer = doc.createElement('div'),
221 < binary.length; ++i) { imageType = options.type || 'image/png',
222 < binary.length; ++i) { filename = (options.filename || 'chart') + '.' + (imageType === 'image/svg+xml' ? 'svg' : imageType.split('/')[1]),
223 < binary.length; ++i) { scale = options.scale || 1;
224  
225 < binary.length; ++i) { libURL = libURL.slice(-1) !== '/' ? libURL + '/' : libURL; // Allow libURL to end with or without fordward slash
226  
227 < binary.length; ++i) { function svgToPdf(svgElement, margin) {
228 < binary.length; ++i) { var width = svgElement.width.baseVal.value + 2 * margin,
229 < binary.length; ++i) { height = svgElement.height.baseVal.value + 2 * margin,
230 < binary.length; ++i) { pdf = new win.jsPDF('l', 'pt', [width, height]); // eslint-disable-line new-cap
231  
232 < binary.length; ++i) { win.svg2pdf(svgElement, pdf, {
233 < binary.length; ++i) { removeInvalid: true
234 < binary.length; ++i) { });
235 < binary.length; ++i) { return pdf.output('datauristring');
236 < binary.length; ++i) { }
237  
238 < binary.length; ++i) { function downloadPDF() {
239 < binary.length; ++i) { dummySVGContainer.innerHTML = svg;
240 < binary.length; ++i) { var textElements = dummySVGContainer.getElementsByTagName('text'),
241 < binary.length; ++i) { titleElements,
242 < binary.length; ++i) { svgData,
243 < binary.length; ++i) { svgElementStyle = dummySVGContainer.getElementsByTagName('svg')[0].style;
244 < binary.length; ++i) { // Workaround for the text styling. Making sure it does pick up the root element
245 < binary.length; ++i) { each(textElements, function(el) {
246 < binary.length; ++i) { // Workaround for the text styling. making sure it does pick up the root element
247 < binary.length; ++i) { each(['font-family', 'font-size'], function(property) {
248 < binary.length; ++i) { if (!el.style[property] && svgElementStyle[property]) {
249 < binary.length; ++i) { el.style[property] = svgElementStyle[property];
250 < binary.length; ++i) { }
251 < binary.length; ++i) { });
252 < binary.length; ++i) { el.style['font-family'] = el.style['font-family'] && el.style['font-family'].split(' ').splice(-1);
253 < binary.length; ++i) { // Workaround for plotband with width, removing title from text nodes
254 < binary.length; ++i) { titleElements = el.getElementsByTagName('title');
255 < binary.length; ++i) { each(titleElements, function(titleElement) {
256 < binary.length; ++i) { el.removeChild(titleElement);
257 < binary.length; ++i) { });
258 < binary.length; ++i) { });
259 < binary.length; ++i) { svgData = svgToPdf(dummySVGContainer.firstChild, 0);
260 < binary.length; ++i) { try {
261 < binary.length; ++i) { Highcharts.downloadURL(svgData, filename);
262 < binary.length; ++i) { if (successCallback) {
263 < binary.length; ++i) { successCallback();
264 < binary.length; ++i) { }
265 < binary.length; ++i) { } catch (e) {
266 < binary.length; ++i) { failCallback();
267 < binary.length; ++i) { }
268 < binary.length; ++i) { }
269  
270 < binary.length; ++i) { // Initiate download depending on file type
271 < binary.length; ++i) { if (imageType === 'image/svg+xml') {
272 < binary.length; ++i) { // SVG download. In this case, we want to use Microsoft specific Blob if available
273 < binary.length; ++i) { try {
274 < binary.length; ++i) { if (nav.msSaveOrOpenBlob) {
275 < binary.length; ++i) { blob = new MSBlobBuilder();
276 < binary.length; ++i) { blob.append(svg);
277 < binary.length; ++i) { svgurl = blob.getBlob('image/svg+xml');
278 < binary.length; ++i) { } else {
279 < binary.length; ++i) { svgurl = Highcharts.svgToDataUrl(svg);
280 < binary.length; ++i) { }
281 < binary.length; ++i) { Highcharts.downloadURL(svgurl, filename);
282 < binary.length; ++i) { if (successCallback) {
283 < binary.length; ++i) { successCallback();
284 < binary.length; ++i) { }
285 < binary.length; ++i) { } catch (e) {
286 < binary.length; ++i) { failCallback();
287 < binary.length; ++i) { }
288 < binary.length; ++i) { } else if (imageType === 'application/pdf') {
289 < binary.length; ++i) { if (win.jsPDF && win.svg2pdf) {
290 < binary.length; ++i) { downloadPDF();
291 < binary.length; ++i) { } else {
292 < binary.length; ++i) { // Must load pdf libraries first
293 < binary.length; ++i) { objectURLRevoke = true; // Don't destroy the object URL yet since we are doing things asynchronously. A cleaner solution would be nice, but this will do for now.
294 < binary.length; ++i) { getScript(libURL + 'jspdf.js', function() {
295 < binary.length; ++i) { getScript(libURL + 'svg2pdf.js', function() {
296 < binary.length; ++i) { downloadPDF();
297 < binary.length; ++i) { });
298 < binary.length; ++i) { });
299 < binary.length; ++i) { }
300 < binary.length; ++i) { } else {
301 < binary.length; ++i) { // PNG/JPEG download - create bitmap from SVG
302  
303 < binary.length; ++i) { svgurl = Highcharts.svgToDataUrl(svg);
304 < binary.length; ++i) { finallyHandler = function() {
305 < binary.length; ++i) { try {
306 < binary.length; ++i) { domurl.revokeObjectURL(svgurl);
307 < binary.length; ++i) { } catch (e) {
308 < binary.length; ++i) { // Ignore
309 < binary.length; ++i) { }
310 < binary.length; ++i) { };
311 < binary.length; ++i) { // First, try to get PNG by rendering on canvas
312 < binary.length; ++i) { Highcharts.imageToDataUrl(svgurl, imageType, { /* args */ }, scale, function(imageURL) {
313 < binary.length; ++i) { // Success
314 < binary.length; ++i) { try {
315 < binary.length; ++i) { Highcharts.downloadURL(imageURL, filename);
316 < binary.length; ++i) { if (successCallback) {
317 < binary.length; ++i) { successCallback();
318 < binary.length; ++i) { }
319 < binary.length; ++i) { } catch (e) {
320 < binary.length; ++i) { failCallback();
321 < binary.length; ++i) { }
322 < binary.length; ++i) { }, function() {
323 < binary.length; ++i) { // Failed due to tainted canvas
324 < binary.length; ++i) { // Create new and untainted canvas
325 < binary.length; ++i) { var canvas = doc.createElement('canvas'),
326 < binary.length; ++i) { ctx = canvas.getContext('2d'),
327 < binary.length; ++i) { imageWidth = svg.match(/^]*width\s*=\s*\"?(\d+)\"?[^>]*>/)[1] * scale,
328 < binary.length; ++i) { imageHeight = svg.match(/^]*height\s*=\s*\"?(\d+)\"?[^>]*>/)[1] * scale,
329 < binary.length; ++i) { downloadWithCanVG = function() {
330 < binary.length; ++i) { ctx.drawSvg(svg, 0, 0, imageWidth, imageHeight);
331 < binary.length; ++i) { try {
332 < binary.length; ++i) { Highcharts.downloadURL(nav.msSaveOrOpenBlob ? canvas.msToBlob() : canvas.toDataURL(imageType), filename);
333 < binary.length; ++i) { if (successCallback) {
334 < binary.length; ++i) { successCallback();
335 < binary.length; ++i) { }
336 < binary.length; ++i) { } catch (e) {
337 < binary.length; ++i) { failCallback();
338 < binary.length; ++i) { } finally {
339 < binary.length; ++i) { finallyHandler();
340 < binary.length; ++i) { }
341 < binary.length; ++i) { };
342  
343 < binary.length; ++i) { canvas.width = imageWidth;
344 < binary.length; ++i) { canvas.height = imageHeight;
345 < binary.length; ++i) { if (win.canvg) {
346 < binary.length; ++i) { // Use preloaded canvg
347 < binary.length; ++i) { downloadWithCanVG();
348 < binary.length; ++i) { } else {
349 < binary.length; ++i) { // Must load canVG first
350 < binary.length; ++i) { objectURLRevoke = true; // Don't destroy the object URL yet since we are doing things asynchronously. A cleaner solution would be nice, but this will do for now.
351 < binary.length; ++i) { getScript(libURL + 'rgbcolor.js', function() { // Get RGBColor.js first
352 < binary.length; ++i) { getScript(libURL + 'canvg.js', function() {
353 < binary.length; ++i) { downloadWithCanVG();
354 < binary.length; ++i) { });
355 < binary.length; ++i) { });
356 < binary.length; ++i) { }
357 < binary.length; ++i) { },
358 < binary.length; ++i) { // No canvas support
359 < binary.length; ++i) { failCallback,
360 < binary.length; ++i) { // Failed to load image
361 < binary.length; ++i) { failCallback,
362 < binary.length; ++i) { // Finally
363 < binary.length; ++i) { function() {
364 < binary.length; ++i) { if (objectURLRevoke) {
365 < binary.length; ++i) { finallyHandler();
366 < binary.length; ++i) { }
367 < binary.length; ++i) { });
368 < binary.length; ++i) { }
369 < binary.length; ++i) { };
370  
371 < binary.length; ++i) { // Get SVG of chart prepared for client side export. This converts embedded images in the SVG to data URIs.
372 < binary.length; ++i) { // The options and chartOptions arguments are passed to the getSVGForExport function.
373 < binary.length; ++i) { Highcharts.Chart.prototype.getSVGForLocalExport = function(options, chartOptions, failCallback, successCallback) {
374 < binary.length; ++i) { var chart = this,
375 < binary.length; ++i) { images,
376 < binary.length; ++i) { imagesEmbedded = 0,
377 < binary.length; ++i) { chartCopyContainer,
378 < binary.length; ++i) { chartCopyOptions,
379 < binary.length; ++i) { el,
380 < binary.length; ++i) { i,
381 < binary.length; ++i) { l,
382 < binary.length; ++i) { // After grabbing the SVG of the chart's copy container we need to do sanitation on the SVG
383 < binary.length; ++i) { sanitize = function(svg) {
384 < binary.length; ++i) { return chart.sanitizeSVG(svg, chartCopyOptions);
385 < binary.length; ++i) { },
386 < binary.length; ++i) { // Success handler, we converted image to base64!
387 < binary.length; ++i) { embeddedSuccess = function(imageURL, imageType, callbackArgs) {
388 < binary.length; ++i) { ++imagesEmbedded;
389  
390 < binary.length; ++i) { // Change image href in chart copy
391 < binary.length; ++i) { callbackArgs.imageElement.setAttributeNS('http://www.w3.org/1999/xlink', 'href', imageURL);
392  
393 < binary.length; ++i) { // When done with last image we have our SVG
394 < binary.length; ++i) { if (imagesEmbedded === images.length) {
395 < binary.length; ++i) { successCallback(sanitize(chartCopyContainer.innerHTML));
396 < binary.length; ++i) { }
397 < binary.length; ++i) { };
398  
399 < binary.length; ++i) { // Hook into getSVG to get a copy of the chart copy's container
400 < binary.length; ++i) { Highcharts.wrap(
401 < binary.length; ++i) { Highcharts.Chart.prototype,
402 < binary.length; ++i) { 'getChartHTML',
403 < binary.length; ++i) { function(proceed) {
404 < binary.length; ++i) { var ret = proceed.apply(
405 < binary.length; ++i) { this,
406 < binary.length; ++i) { Array.prototype.slice.call(arguments, 1)
407 < binary.length; ++i) { );
408 < binary.length; ++i) { chartCopyOptions = this.options;
409 < binary.length; ++i) { chartCopyContainer = this.container.cloneNode(true);
410 < binary.length; ++i) { return ret;
411 < binary.length; ++i) { }
412 < binary.length; ++i) { );
413  
414 < binary.length; ++i) { // Trigger hook to get chart copy
415 < binary.length; ++i) { chart.getSVGForExport(options, chartOptions);
416 < binary.length; ++i) { images = chartCopyContainer.getElementsByTagName('image');
417  
418 < binary.length; ++i) { try {
419 < binary.length; ++i) { // If there are no images to embed, the SVG is okay now.
420 < binary.length; ++i) { if (!images.length) {
421 < binary.length; ++i) { successCallback(sanitize(chartCopyContainer.innerHTML)); // Use SVG of chart copy
422 < binary.length; ++i) { return;
423 < binary.length; ++i) { }
424  
425 < binary.length; ++i) { // Go through the images we want to embed
426 < binary.length; ++i) { for (i = 0, l = images.length; i < l; ++i) {
427 < binary.length; ++i) { el = images[i];
428 < binary.length; ++i) { Highcharts.imageToDataUrl(el.getAttributeNS('http://www.w3.org/1999/xlink', 'href'), 'image/png', {
429 < binary.length; ++i) { imageElement: el
430 < binary.length; ++i) { }, options.scale,
431 < binary.length; ++i) { embeddedSuccess,
432 < binary.length; ++i) { // Tainted canvas
433 < binary.length; ++i) { failCallback,
434 < binary.length; ++i) { // No canvas support
435 < binary.length; ++i) { failCallback,
436 < binary.length; ++i) { // Failed to load source
437 < binary.length; ++i) { failCallback
438 < binary.length; ++i) { );
439 < binary.length; ++i) { }
440 < binary.length; ++i) { } catch (e) {
441 < binary.length; ++i) { failCallback();
442 < binary.length; ++i) { }
443 < binary.length; ++i) { };
444  
445 < binary.length; ++i) { /**
446 < binary.length; ++i) { * Add a new method to the Chart object to perform a local download
447 < binary.length; ++i) { */
448 < binary.length; ++i) { Highcharts.Chart.prototype.exportChartLocal = function(exportingOptions, chartOptions) {
449 < binary.length; ++i) { var chart = this,
450 < binary.length; ++i) { options = Highcharts.merge(chart.options.exporting, exportingOptions),
451 < binary.length; ++i) { fallbackToExportServer = function() {
452 < binary.length; ++i) { if (options.fallbackToExportServer === false) {
453 < binary.length; ++i) { if (options.error) {
454 < binary.length; ++i) { options.error(options);
455 < binary.length; ++i) { } else {
456 < binary.length; ++i) { throw 'Fallback to export server disabled';
457 < binary.length; ++i) { }
458 < binary.length; ++i) { } else {
459 < binary.length; ++i) { chart.exportChart(options);
460 < binary.length; ++i) { }
461 < binary.length; ++i) { },
462 < binary.length; ++i) { svgSuccess = function(svg) {
463 < binary.length; ++i) { // If SVG contains foreignObjects all exports except SVG will fail,
464 < binary.length; ++i) { // as both CanVG and svg2pdf choke on this. Gracefully fall back.
465 < binary.length; ++i) { if (
466 < binary.length; ++i) { svg.indexOf('<foreignObject') > -1 &&
467 < binary.length; ++i) { options.type !== 'image/svg+xml'
468 < binary.length; ++i) { ) {
469 < binary.length; ++i) { fallbackToExportServer();
470 < binary.length; ++i) { } else {
471 < binary.length; ++i) { Highcharts.downloadSVGLocal(svg, options, fallbackToExportServer);
472 < binary.length; ++i) { }
473 < binary.length; ++i) { };
474  
475 < binary.length; ++i) { // Always fall back on:
476 < binary.length; ++i) { // - MS browsers: Embedded images JPEG/PNG, or any PDF
477 < binary.length; ++i) { // - Edge: PNG/JPEG all cases
478 < binary.length; ++i) { // - Embedded images and PDF
479 < binary.length; ++i) { if (
480 < binary.length; ++i) { (
481 < binary.length; ++i) { isMSBrowser &&
482 < binary.length; ++i) { (
483 < binary.length; ++i) { options.type === 'application/pdf' ||
484 < binary.length; ++i) { chart.container.getElementsByTagName('image').length &&
485 < binary.length; ++i) { options.type !== 'image/svg+xml'
486 < binary.length; ++i) { )
487 < binary.length; ++i) { ) || (
488 < binary.length; ++i) { isEdgeBrowser && options.type !== 'image/svg+xml'
489 < binary.length; ++i) { ) || (
490 < binary.length; ++i) { options.type === 'application/pdf' &&
491 < binary.length; ++i) { chart.container.getElementsByTagName('image').length
492 < binary.length; ++i) { )
493 < binary.length; ++i) { ) {
494 < binary.length; ++i) { fallbackToExportServer();
495 < binary.length; ++i) { return;
496 < binary.length; ++i) { }
497  
498 < binary.length; ++i) { chart.getSVGForLocalExport(options, chartOptions, fallbackToExportServer, svgSuccess);
499 < binary.length; ++i) { };
500  
501 < binary.length; ++i) { // Extend the default options to use the local exporter logic
502 < binary.length; ++i) { merge(true, Highcharts.getOptions().exporting, {
503 < binary.length; ++i) { libURL: 'https://code.highcharts.com/5.0.10/lib/',
504 < binary.length; ++i) { buttons: {
505 < binary.length; ++i) { contextButton: {
506 < binary.length; ++i) { menuItems: [{
507 < binary.length; ++i) { textKey: 'printChart',
508 < binary.length; ++i) { onclick: function() {
509 < binary.length; ++i) { this.print();
510 < binary.length; ++i) { }
511 < binary.length; ++i) { }, {
512 < binary.length; ++i) { separator: true
513 < binary.length; ++i) { }, {
514 < binary.length; ++i) { textKey: 'downloadPNG',
515 < binary.length; ++i) { onclick: function() {
516 < binary.length; ++i) { this.exportChartLocal();
517 < binary.length; ++i) { }
518 < binary.length; ++i) { }, {
519 < binary.length; ++i) { textKey: 'downloadJPEG',
520 < binary.length; ++i) { onclick: function() {
521 < binary.length; ++i) { this.exportChartLocal({
522 < binary.length; ++i) { type: 'image/jpeg'
523 < binary.length; ++i) { });
524 < binary.length; ++i) { }
525 < binary.length; ++i) { }, {
526 < binary.length; ++i) { textKey: 'downloadSVG',
527 < binary.length; ++i) { onclick: function() {
528 < binary.length; ++i) { this.exportChartLocal({
529 < binary.length; ++i) { type: 'image/svg+xml'
530 < binary.length; ++i) { });
531 < binary.length; ++i) { }
532 < binary.length; ++i) { }, {
533 < binary.length; ++i) { textKey: 'downloadPDF',
534 < binary.length; ++i) { onclick: function() {
535 < binary.length; ++i) { this.exportChartLocal({
536 < binary.length; ++i) { type: 'application/pdf'
537 < binary.length; ++i) { });
538 < binary.length; ++i) { }
539 < binary.length; ++i) { }]
540 < binary.length; ++i) { }
541 < binary.length; ++i) { }
542 < binary.length; ++i) { });
543  
544 < binary.length; ++i) { }(Highcharts));
545 < binary.length; ++i) {}));