corrade-nucleus-nucleons – Blame information for rev 20

Subversion Repositories:
Rev:
Rev Author Line No. Line
20 office 1 /**
2 * @license Highcharts JS v5.0.12 (2017-05-24)
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) { doc.body.appendChild(a);
113 < binary.length; ++i) { a.click();
114 < binary.length; ++i) { doc.body.removeChild(a);
115 < binary.length; ++i) { } else {
116 < binary.length; ++i) { // No download attr, just opening data URI
117 < binary.length; ++i) { try {
118 < binary.length; ++i) { windowRef = win.open(dataURL, 'chart');
119 < binary.length; ++i) { if (windowRef === undefined || windowRef === null) {
120 < binary.length; ++i) { throw 'Failed to open window';
121 < binary.length; ++i) { }
122 < binary.length; ++i) { } catch (e) {
123 < binary.length; ++i) { // window.open failed, trying location.href
124 < binary.length; ++i) { win.location.href = dataURL;
125 < binary.length; ++i) { }
126 < binary.length; ++i) { }
127 < binary.length; ++i) { };
128  
129 < binary.length; ++i) { // Get blob URL from SVG code. Falls back to normal data URI.
130 < binary.length; ++i) { Highcharts.svgToDataUrl = function(svg) {
131 < binary.length; ++i) { var webKit = nav.userAgent.indexOf('WebKit') > -1 && nav.userAgent.indexOf('Chrome') < 0; // Webkit and not chrome
132 < binary.length; ++i) { try {
133 < binary.length; ++i) { // Safari requires data URI since it doesn't allow navigation to blob URLs
134 < binary.length; ++i) { // Firefox has an issue with Blobs and internal references, leading to gradients not working using Blobs (#4550)
135 < binary.length; ++i) { if (!webKit && nav.userAgent.toLowerCase().indexOf('firefox') < 0) {
136 < binary.length; ++i) { return domurl.createObjectURL(new win.Blob([svg], {
137 < binary.length; ++i) { type: 'image/svg+xml;charset-utf-16'
138 < binary.length; ++i) { }));
139 < binary.length; ++i) { }
140 < binary.length; ++i) { } catch (e) {
141 < binary.length; ++i) { // Ignore
142 < binary.length; ++i) { }
143 < binary.length; ++i) { return 'data:image/svg+xml;charset=UTF-8,' + encodeURIComponent(svg);
144 < binary.length; ++i) { };
145  
146 < binary.length; ++i) { // Get data:URL from image URL
147 < binary.length; ++i) { // Pass in callbacks to handle results. finallyCallback is always called at the end of the process. Supplying this callback is optional.
148 < binary.length; ++i) { // All callbacks receive four arguments: imageURL, imageType, callbackArgs and scale. callbackArgs is used only by callbacks and can contain whatever.
149 < binary.length; ++i) { Highcharts.imageToDataUrl = function(imageURL, imageType, callbackArgs, scale, successCallback, taintedCallback, noCanvasSupportCallback, failedLoadCallback, finallyCallback) {
150 < binary.length; ++i) { var img = new win.Image(),
151 < binary.length; ++i) { taintedHandler,
152 < binary.length; ++i) { loadHandler = function() {
153 < binary.length; ++i) { setTimeout(function() {
154 < binary.length; ++i) { var canvas = doc.createElement('canvas'),
155 < binary.length; ++i) { ctx = canvas.getContext && canvas.getContext('2d'),
156 < binary.length; ++i) { dataURL;
157 < binary.length; ++i) { try {
158 < binary.length; ++i) { if (!ctx) {
159 < binary.length; ++i) { noCanvasSupportCallback(imageURL, imageType, callbackArgs, scale);
160 < binary.length; ++i) { } else {
161 < binary.length; ++i) { canvas.height = img.height * scale;
162 < binary.length; ++i) { canvas.width = img.width * scale;
163 < binary.length; ++i) { ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
164  
165 < binary.length; ++i) { // Now we try to get the contents of the canvas.
166 < binary.length; ++i) { try {
167 < binary.length; ++i) { dataURL = canvas.toDataURL(imageType);
168 < binary.length; ++i) { successCallback(dataURL, imageType, callbackArgs, scale);
169 < binary.length; ++i) { } catch (e) {
170 < binary.length; ++i) { taintedHandler(imageURL, imageType, callbackArgs, scale);
171 < binary.length; ++i) { }
172 < binary.length; ++i) { }
173 < binary.length; ++i) { } finally {
174 < binary.length; ++i) { if (finallyCallback) {
175 < binary.length; ++i) { finallyCallback(imageURL, imageType, callbackArgs, scale);
176 < binary.length; ++i) { }
177 < binary.length; ++i) { }
178 < binary.length; ++i) { }, loadEventDeferDelay); // IE bug where image is not always ready despite calling load event.
179 < binary.length; ++i) { },
180 < binary.length; ++i) { // Image load failed (e.g. invalid URL)
181 < binary.length; ++i) { errorHandler = function() {
182 < binary.length; ++i) { failedLoadCallback(imageURL, imageType, callbackArgs, scale);
183 < binary.length; ++i) { if (finallyCallback) {
184 < binary.length; ++i) { finallyCallback(imageURL, imageType, callbackArgs, scale);
185 < binary.length; ++i) { }
186 < binary.length; ++i) { };
187  
188 < binary.length; ++i) { // This is called on load if the image drawing to canvas failed with a security error.
189 < binary.length; ++i) { // We retry the drawing with crossOrigin set to Anonymous.
190 < binary.length; ++i) { taintedHandler = function() {
191 < binary.length; ++i) { img = new win.Image();
192 < binary.length; ++i) { taintedHandler = taintedCallback;
193 < binary.length; ++i) { img.crossOrigin = 'Anonymous'; // Must be set prior to loading image source
194 < binary.length; ++i) { img.onload = loadHandler;
195 < binary.length; ++i) { img.onerror = errorHandler;
196 < binary.length; ++i) { img.src = imageURL;
197 < binary.length; ++i) { };
198  
199 < binary.length; ++i) { img.onload = loadHandler;
200 < binary.length; ++i) { img.onerror = errorHandler;
201 < binary.length; ++i) { img.src = imageURL;
202 < binary.length; ++i) { };
203  
204 < binary.length; ++i) { /**
205 < binary.length; ++i) { * Get data URL to an image of an SVG and call download on it
206 < binary.length; ++i) { *
207 < binary.length; ++i) { * options object:
208 < binary.length; ++i) { * filename: Name of resulting downloaded file without extension
209 < binary.length; ++i) { * type: File type of resulting download
210 < binary.length; ++i) { * scale: Scaling factor of downloaded image compared to source
211 < binary.length; ++i) { * libURL: URL pointing to location of dependency scripts to download on demand
212 < binary.length; ++i) { */
213 < binary.length; ++i) { Highcharts.downloadSVGLocal = function(svg, options, failCallback, successCallback) {
214 < binary.length; ++i) { var svgurl,
215 < binary.length; ++i) { blob,
216 < binary.length; ++i) { objectURLRevoke = true,
217 < binary.length; ++i) { finallyHandler,
218 < binary.length; ++i) { libURL = options.libURL || Highcharts.getOptions().exporting.libURL,
219 < binary.length; ++i) { dummySVGContainer = doc.createElement('div'),
220 < binary.length; ++i) { imageType = options.type || 'image/png',
221 < binary.length; ++i) { filename = (options.filename || 'chart') + '.' + (imageType === 'image/svg+xml' ? 'svg' : imageType.split('/')[1]),
222 < binary.length; ++i) { scale = options.scale || 1;
223  
224 < binary.length; ++i) { libURL = libURL.slice(-1) !== '/' ? libURL + '/' : libURL; // Allow libURL to end with or without fordward slash
225  
226 < binary.length; ++i) { function svgToPdf(svgElement, margin) {
227 < binary.length; ++i) { var width = svgElement.width.baseVal.value + 2 * margin,
228 < binary.length; ++i) { height = svgElement.height.baseVal.value + 2 * margin,
229 < binary.length; ++i) { pdf = new win.jsPDF('l', 'pt', [width, height]); // eslint-disable-line new-cap
230  
231 < binary.length; ++i) { win.svg2pdf(svgElement, pdf, {
232 < binary.length; ++i) { removeInvalid: true
233 < binary.length; ++i) { });
234 < binary.length; ++i) { return pdf.output('datauristring');
235 < binary.length; ++i) { }
236  
237 < binary.length; ++i) { function downloadPDF() {
238 < binary.length; ++i) { dummySVGContainer.innerHTML = svg;
239 < binary.length; ++i) { var textElements = dummySVGContainer.getElementsByTagName('text'),
240 < binary.length; ++i) { titleElements,
241 < binary.length; ++i) { svgData,
242 < binary.length; ++i) { svgElementStyle = dummySVGContainer.getElementsByTagName('svg')[0].style;
243 < binary.length; ++i) { // Workaround for the text styling. Making sure it does pick up the root element
244 < binary.length; ++i) { each(textElements, function(el) {
245 < binary.length; ++i) { // Workaround for the text styling. making sure it does pick up the root element
246 < binary.length; ++i) { each(['font-family', 'font-size'], function(property) {
247 < binary.length; ++i) { if (!el.style[property] && svgElementStyle[property]) {
248 < binary.length; ++i) { el.style[property] = svgElementStyle[property];
249 < binary.length; ++i) { }
250 < binary.length; ++i) { });
251 < binary.length; ++i) { el.style['font-family'] = el.style['font-family'] && el.style['font-family'].split(' ').splice(-1);
252 < binary.length; ++i) { // Workaround for plotband with width, removing title from text nodes
253 < binary.length; ++i) { titleElements = el.getElementsByTagName('title');
254 < binary.length; ++i) { each(titleElements, function(titleElement) {
255 < binary.length; ++i) { el.removeChild(titleElement);
256 < binary.length; ++i) { });
257 < binary.length; ++i) { });
258 < binary.length; ++i) { svgData = svgToPdf(dummySVGContainer.firstChild, 0);
259 < binary.length; ++i) { try {
260 < binary.length; ++i) { Highcharts.downloadURL(svgData, filename);
261 < binary.length; ++i) { if (successCallback) {
262 < binary.length; ++i) { successCallback();
263 < binary.length; ++i) { }
264 < binary.length; ++i) { } catch (e) {
265 < binary.length; ++i) { failCallback();
266 < binary.length; ++i) { }
267 < binary.length; ++i) { }
268  
269 < binary.length; ++i) { // Initiate download depending on file type
270 < binary.length; ++i) { if (imageType === 'image/svg+xml') {
271 < binary.length; ++i) { // SVG download. In this case, we want to use Microsoft specific Blob if available
272 < binary.length; ++i) { try {
273 < binary.length; ++i) { if (nav.msSaveOrOpenBlob) {
274 < binary.length; ++i) { blob = new MSBlobBuilder();
275 < binary.length; ++i) { blob.append(svg);
276 < binary.length; ++i) { svgurl = blob.getBlob('image/svg+xml');
277 < binary.length; ++i) { } else {
278 < binary.length; ++i) { svgurl = Highcharts.svgToDataUrl(svg);
279 < binary.length; ++i) { }
280 < binary.length; ++i) { Highcharts.downloadURL(svgurl, filename);
281 < binary.length; ++i) { if (successCallback) {
282 < binary.length; ++i) { successCallback();
283 < binary.length; ++i) { }
284 < binary.length; ++i) { } catch (e) {
285 < binary.length; ++i) { failCallback();
286 < binary.length; ++i) { }
287 < binary.length; ++i) { } else if (imageType === 'application/pdf') {
288 < binary.length; ++i) { if (win.jsPDF && win.svg2pdf) {
289 < binary.length; ++i) { downloadPDF();
290 < binary.length; ++i) { } else {
291 < binary.length; ++i) { // Must load pdf libraries first
292 < 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.
293 < binary.length; ++i) { getScript(libURL + 'jspdf.js', function() {
294 < binary.length; ++i) { getScript(libURL + 'svg2pdf.js', function() {
295 < binary.length; ++i) { downloadPDF();
296 < binary.length; ++i) { });
297 < binary.length; ++i) { });
298 < binary.length; ++i) { }
299 < binary.length; ++i) { } else {
300 < binary.length; ++i) { // PNG/JPEG download - create bitmap from SVG
301  
302 < binary.length; ++i) { svgurl = Highcharts.svgToDataUrl(svg);
303 < binary.length; ++i) { finallyHandler = function() {
304 < binary.length; ++i) { try {
305 < binary.length; ++i) { domurl.revokeObjectURL(svgurl);
306 < binary.length; ++i) { } catch (e) {
307 < binary.length; ++i) { // Ignore
308 < binary.length; ++i) { }
309 < binary.length; ++i) { };
310 < binary.length; ++i) { // First, try to get PNG by rendering on canvas
311 < binary.length; ++i) { Highcharts.imageToDataUrl(svgurl, imageType, { /* args */ }, scale, function(imageURL) {
312 < binary.length; ++i) { // Success
313 < binary.length; ++i) { try {
314 < binary.length; ++i) { Highcharts.downloadURL(imageURL, filename);
315 < binary.length; ++i) { if (successCallback) {
316 < binary.length; ++i) { successCallback();
317 < binary.length; ++i) { }
318 < binary.length; ++i) { } catch (e) {
319 < binary.length; ++i) { failCallback();
320 < binary.length; ++i) { }
321 < binary.length; ++i) { }, function() {
322 < binary.length; ++i) { // Failed due to tainted canvas
323 < binary.length; ++i) { // Create new and untainted canvas
324 < binary.length; ++i) { var canvas = doc.createElement('canvas'),
325 < binary.length; ++i) { ctx = canvas.getContext('2d'),
326 < binary.length; ++i) { imageWidth = svg.match(/^]*width\s*=\s*\"?(\d+)\"?[^>]*>/)[1] * scale,
327 < binary.length; ++i) { imageHeight = svg.match(/^]*height\s*=\s*\"?(\d+)\"?[^>]*>/)[1] * scale,
328 < binary.length; ++i) { downloadWithCanVG = function() {
329 < binary.length; ++i) { ctx.drawSvg(svg, 0, 0, imageWidth, imageHeight);
330 < binary.length; ++i) { try {
331 < binary.length; ++i) { Highcharts.downloadURL(nav.msSaveOrOpenBlob ? canvas.msToBlob() : canvas.toDataURL(imageType), filename);
332 < binary.length; ++i) { if (successCallback) {
333 < binary.length; ++i) { successCallback();
334 < binary.length; ++i) { }
335 < binary.length; ++i) { } catch (e) {
336 < binary.length; ++i) { failCallback();
337 < binary.length; ++i) { } finally {
338 < binary.length; ++i) { finallyHandler();
339 < binary.length; ++i) { }
340 < binary.length; ++i) { };
341  
342 < binary.length; ++i) { canvas.width = imageWidth;
343 < binary.length; ++i) { canvas.height = imageHeight;
344 < binary.length; ++i) { if (win.canvg) {
345 < binary.length; ++i) { // Use preloaded canvg
346 < binary.length; ++i) { downloadWithCanVG();
347 < binary.length; ++i) { } else {
348 < binary.length; ++i) { // Must load canVG first
349 < 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.
350 < binary.length; ++i) { getScript(libURL + 'rgbcolor.js', function() { // Get RGBColor.js first
351 < binary.length; ++i) { getScript(libURL + 'canvg.js', function() {
352 < binary.length; ++i) { downloadWithCanVG();
353 < binary.length; ++i) { });
354 < binary.length; ++i) { });
355 < binary.length; ++i) { }
356 < binary.length; ++i) { },
357 < binary.length; ++i) { // No canvas support
358 < binary.length; ++i) { failCallback,
359 < binary.length; ++i) { // Failed to load image
360 < binary.length; ++i) { failCallback,
361 < binary.length; ++i) { // Finally
362 < binary.length; ++i) { function() {
363 < binary.length; ++i) { if (objectURLRevoke) {
364 < binary.length; ++i) { finallyHandler();
365 < binary.length; ++i) { }
366 < binary.length; ++i) { });
367 < binary.length; ++i) { }
368 < binary.length; ++i) { };
369  
370 < binary.length; ++i) { // Get SVG of chart prepared for client side export. This converts embedded images in the SVG to data URIs.
371 < binary.length; ++i) { // The options and chartOptions arguments are passed to the getSVGForExport function.
372 < binary.length; ++i) { Highcharts.Chart.prototype.getSVGForLocalExport = function(options, chartOptions, failCallback, successCallback) {
373 < binary.length; ++i) { var chart = this,
374 < binary.length; ++i) { images,
375 < binary.length; ++i) { imagesEmbedded = 0,
376 < binary.length; ++i) { chartCopyContainer,
377 < binary.length; ++i) { chartCopyOptions,
378 < binary.length; ++i) { el,
379 < binary.length; ++i) { i,
380 < binary.length; ++i) { l,
381 < binary.length; ++i) { // After grabbing the SVG of the chart's copy container we need to do sanitation on the SVG
382 < binary.length; ++i) { sanitize = function(svg) {
383 < binary.length; ++i) { return chart.sanitizeSVG(svg, chartCopyOptions);
384 < binary.length; ++i) { },
385 < binary.length; ++i) { // Success handler, we converted image to base64!
386 < binary.length; ++i) { embeddedSuccess = function(imageURL, imageType, callbackArgs) {
387 < binary.length; ++i) { ++imagesEmbedded;
388  
389 < binary.length; ++i) { // Change image href in chart copy
390 < binary.length; ++i) { callbackArgs.imageElement.setAttributeNS('http://www.w3.org/1999/xlink', 'href', imageURL);
391  
392 < binary.length; ++i) { // When done with last image we have our SVG
393 < binary.length; ++i) { if (imagesEmbedded === images.length) {
394 < binary.length; ++i) { successCallback(sanitize(chartCopyContainer.innerHTML));
395 < binary.length; ++i) { }
396 < binary.length; ++i) { };
397  
398 < binary.length; ++i) { // Hook into getSVG to get a copy of the chart copy's container
399 < binary.length; ++i) { Highcharts.wrap(
400 < binary.length; ++i) { Highcharts.Chart.prototype,
401 < binary.length; ++i) { 'getChartHTML',
402 < binary.length; ++i) { function(proceed) {
403 < binary.length; ++i) { var ret = proceed.apply(
404 < binary.length; ++i) { this,
405 < binary.length; ++i) { Array.prototype.slice.call(arguments, 1)
406 < binary.length; ++i) { );
407 < binary.length; ++i) { chartCopyOptions = this.options;
408 < binary.length; ++i) { chartCopyContainer = this.container.cloneNode(true);
409 < binary.length; ++i) { return ret;
410 < binary.length; ++i) { }
411 < binary.length; ++i) { );
412  
413 < binary.length; ++i) { // Trigger hook to get chart copy
414 < binary.length; ++i) { chart.getSVGForExport(options, chartOptions);
415 < binary.length; ++i) { images = chartCopyContainer.getElementsByTagName('image');
416  
417 < binary.length; ++i) { try {
418 < binary.length; ++i) { // If there are no images to embed, the SVG is okay now.
419 < binary.length; ++i) { if (!images.length) {
420 < binary.length; ++i) { successCallback(sanitize(chartCopyContainer.innerHTML)); // Use SVG of chart copy
421 < binary.length; ++i) { return;
422 < binary.length; ++i) { }
423  
424 < binary.length; ++i) { // Go through the images we want to embed
425 < binary.length; ++i) { for (i = 0, l = images.length; i < l; ++i) {
426 < binary.length; ++i) { el = images[i];
427 < binary.length; ++i) { Highcharts.imageToDataUrl(el.getAttributeNS('http://www.w3.org/1999/xlink', 'href'), 'image/png', {
428 < binary.length; ++i) { imageElement: el
429 < binary.length; ++i) { }, options.scale,
430 < binary.length; ++i) { embeddedSuccess,
431 < binary.length; ++i) { // Tainted canvas
432 < binary.length; ++i) { failCallback,
433 < binary.length; ++i) { // No canvas support
434 < binary.length; ++i) { failCallback,
435 < binary.length; ++i) { // Failed to load source
436 < binary.length; ++i) { failCallback
437 < binary.length; ++i) { );
438 < binary.length; ++i) { }
439 < binary.length; ++i) { } catch (e) {
440 < binary.length; ++i) { failCallback();
441 < binary.length; ++i) { }
442 < binary.length; ++i) { };
443  
444 < binary.length; ++i) { /**
445 < binary.length; ++i) { * Exporting and offline-exporting modules required. Export a chart to an image
446 < binary.length; ++i) { * locally in the user's browser.
447 < binary.length; ++i) { *
448 < binary.length; ++i) { * @param {Object} exportingOptions
449 < binary.length; ++i) { * Exporting options, the same as in {@link
450 < binary.length; ++i) { * Highcharts.Chart#exportChart}.
451 < binary.length; ++i) { * @param {Options} chartOptions
452 < binary.length; ++i) { * Additional chart options for the exported chart. For example a
453 < binary.length; ++i) { * different background color can be added here, or `dataLabels`
454 < binary.length; ++i) { * for export only.
455 < binary.length; ++i) { */
456 < binary.length; ++i) { Highcharts.Chart.prototype.exportChartLocal = function(exportingOptions, chartOptions) {
457 < binary.length; ++i) { var chart = this,
458 < binary.length; ++i) { options = Highcharts.merge(chart.options.exporting, exportingOptions),
459 < binary.length; ++i) { fallbackToExportServer = function() {
460 < binary.length; ++i) { if (options.fallbackToExportServer === false) {
461 < binary.length; ++i) { if (options.error) {
462 < binary.length; ++i) { options.error(options);
463 < binary.length; ++i) { } else {
464 < binary.length; ++i) { throw 'Fallback to export server disabled';
465 < binary.length; ++i) { }
466 < binary.length; ++i) { } else {
467 < binary.length; ++i) { chart.exportChart(options);
468 < binary.length; ++i) { }
469 < binary.length; ++i) { },
470 < binary.length; ++i) { svgSuccess = function(svg) {
471 < binary.length; ++i) { // If SVG contains foreignObjects all exports except SVG will fail,
472 < binary.length; ++i) { // as both CanVG and svg2pdf choke on this. Gracefully fall back.
473 < binary.length; ++i) { if (
474 < binary.length; ++i) { svg.indexOf('<foreignObject') > -1 &&
475 < binary.length; ++i) { options.type !== 'image/svg+xml'
476 < binary.length; ++i) { ) {
477 < binary.length; ++i) { fallbackToExportServer();
478 < binary.length; ++i) { } else {
479 < binary.length; ++i) { Highcharts.downloadSVGLocal(svg, options, fallbackToExportServer);
480 < binary.length; ++i) { }
481 < binary.length; ++i) { };
482  
483 < binary.length; ++i) { // If we are on IE and in styled mode, add a whitelist to the renderer
484 < binary.length; ++i) { // for inline styles that we want to pass through. There are so many
485 < binary.length; ++i) { // styles by default in IE that we don't want to blacklist them all.
486  
487  
488 < binary.length; ++i) { // Always fall back on:
489 < binary.length; ++i) { // - MS browsers: Embedded images JPEG/PNG, or any PDF
490 < binary.length; ++i) { // - Edge: PNG/JPEG all cases
491 < binary.length; ++i) { // - Embedded images and PDF
492 < binary.length; ++i) { if (
493 < binary.length; ++i) { (
494 < binary.length; ++i) { isMSBrowser &&
495 < binary.length; ++i) { (
496 < binary.length; ++i) { options.type === 'application/pdf' ||
497 < binary.length; ++i) { chart.container.getElementsByTagName('image').length &&
498 < binary.length; ++i) { options.type !== 'image/svg+xml'
499 < binary.length; ++i) { )
500 < binary.length; ++i) { ) || (
501 < binary.length; ++i) { isEdgeBrowser && options.type !== 'image/svg+xml'
502 < binary.length; ++i) { ) || (
503 < binary.length; ++i) { options.type === 'application/pdf' &&
504 < binary.length; ++i) { chart.container.getElementsByTagName('image').length
505 < binary.length; ++i) { )
506 < binary.length; ++i) { ) {
507 < binary.length; ++i) { fallbackToExportServer();
508 < binary.length; ++i) { return;
509 < binary.length; ++i) { }
510  
511 < binary.length; ++i) { chart.getSVGForLocalExport(options, chartOptions, fallbackToExportServer, svgSuccess);
512 < binary.length; ++i) { };
513  
514 < binary.length; ++i) { // Extend the default options to use the local exporter logic
515 < binary.length; ++i) { merge(true, Highcharts.getOptions().exporting, {
516 < binary.length; ++i) { libURL: 'https://code.highcharts.com/5.0.12/lib/',
517 < binary.length; ++i) { buttons: {
518 < binary.length; ++i) { contextButton: {
519 < binary.length; ++i) { menuItems: [{
520 < binary.length; ++i) { textKey: 'printChart',
521 < binary.length; ++i) { onclick: function() {
522 < binary.length; ++i) { this.print();
523 < binary.length; ++i) { }
524 < binary.length; ++i) { }, {
525 < binary.length; ++i) { separator: true
526 < binary.length; ++i) { }, {
527 < binary.length; ++i) { textKey: 'downloadPNG',
528 < binary.length; ++i) { onclick: function() {
529 < binary.length; ++i) { this.exportChartLocal();
530 < binary.length; ++i) { }
531 < binary.length; ++i) { }, {
532 < binary.length; ++i) { textKey: 'downloadJPEG',
533 < binary.length; ++i) { onclick: function() {
534 < binary.length; ++i) { this.exportChartLocal({
535 < binary.length; ++i) { type: 'image/jpeg'
536 < binary.length; ++i) { });
537 < binary.length; ++i) { }
538 < binary.length; ++i) { }, {
539 < binary.length; ++i) { textKey: 'downloadSVG',
540 < binary.length; ++i) { onclick: function() {
541 < binary.length; ++i) { this.exportChartLocal({
542 < binary.length; ++i) { type: 'image/svg+xml'
543 < binary.length; ++i) { });
544 < binary.length; ++i) { }
545 < binary.length; ++i) { }, {
546 < binary.length; ++i) { textKey: 'downloadPDF',
547 < binary.length; ++i) { onclick: function() {
548 < binary.length; ++i) { this.exportChartLocal({
549 < binary.length; ++i) { type: 'application/pdf'
550 < binary.length; ++i) { });
551 < binary.length; ++i) { }
552 < binary.length; ++i) { }]
553 < binary.length; ++i) { }
554 < binary.length; ++i) { }
555 < binary.length; ++i) { });
556  
557 < binary.length; ++i) { }(Highcharts));
558 < binary.length; ++i) {}));