PageSourceSearch

https://www.foxit.com/assets/js/foxit-common.js?v=10090605-79

js foxit.com collected 2026-10-10 00:13:42 UTC 16,810 bytes, 595 lines download raw bytes

1var foxitApp = {
2   REGION_INFO: '',
3   DATA_FOR_TRACK: '',
4   init: function (params) {
5      this.REGION_INFO = params.REGION_INFO || '';
6      this.DATA_FOR_TRACK = params.DATA_FOR_TRACK || '';
7   },
8   getParamUri: () => {
9      return atob(foxitApp.PARAM_URI)
10   },
11};
12let dataFilter = {
13   number: {
14      sum: function (...nums) {
15         let sum = 0;
16         for (let i = 0, len = nums.length; i < len; i++) {
17            sum += nums[i]
18         }
19         if (sum) {
20            sum += 0.0000001
21         }
22         return sum
23      },
24      fixedSum: function (len, ...nums) {
25         let sum = 0;
26         for (let i = 0, len = nums.length; i < len; i++) {
27            sum += nums[i]
28         }
29         return this.fixed(sum + 0.0000001, len)
30      },
31      round: function (num, d = 2) {
32         return Math.round((parseFloat(num) + Number.EPSILON) * Math.pow(10, d)) / Math.pow(10, d)
33      },
34      checkPostInt: function (value) {
35         return /(^[1-9]\d*$)/.test(value)
36      },
37      checkNatural: function (value) {
38         return /^0$|(^[1-9]\d*$)/.test(value)
39      },
40      fixed: function (val, len, round) {
41         len = isNaN(len) ? 2 : len;
42         round = !dataFilter.isEmpty(round);
43         val = Number.parseFloat(val);
44         if (typeof val === 'string') {
45            val = parseFloat(val)
46         }
47         if (round) {
48            return Number(val + 1 / Math.pow(10, len + 4)).toFixed(len)
49         } else {
50            return (parseInt(this.numMulti(val, Math.pow(10, len))) / Math.pow(10, len)).toFixed(len)
51         }
52      },
53      fixedAdd: function (a, b, len) {
54         len = isNaN(len) ? 2 : len;
55         return ((this.numMulti(parseFloat(a), Math.pow(10, len)) + this.numMulti(parseFloat(b), Math.pow(10, len))) / Math.pow(10, len)).toFixed(len)
56      },
57      numSub: function (num1, num2) {
58         let r1, r2, m, n;
59         try {
60            r1 = num1.toString().split('.')[1].length
61         } catch (e) {
62            r1 = 0
63         }
64         try {
65            r2 = num2.toString().split('.')[1].length
66         } catch (e) {
67            r2 = 0
68         }
69         m = Math.pow(10, Math.max(r1, r2));
70         n = (r1 >= r2) ? r1 : r2;
71         return parseFloat(((num1 * m - num2 * m) / m).toFixed(n))
72      },
73      numMulti: function (num1, num2) {
74         let baseNum = 0;
75         try {
76            baseNum += num1.toString().split(".")[1].length
77         } catch (e) { }
78         try {
79            baseNum += num2.toString().split(".")[1].length
80         } catch (e) { }
81         return Number(num1.toString().replace(".", "")) * Number(num2.toString().replace(".", "")) / Math.pow(10, baseNum)
82      },
83      numMultiArr: function (num, numArr, round = !0) {
84         let total = 0;
85         num = parseFloat(num);
86         for (let i = 0; i < numArr.length; i++) {
87            total += parseFloat(dataFilter.number.fixed(num * parseFloat(numArr[i]), 2, !0))
88         }
89         return total
90      },
91      numDivide: function (num1, num2) {
92         let baseNum = 0;
93         try {
94            baseNum += num1.toString().split(".")[1].length
95         } catch (e) { }
96         try {
97            baseNum += num2.toString().split(".")[1].length
98         } catch (e) { }
99         return dataFilter.number.fixed((num1 / num2) + 0.0000001, 2)
100      },
101      fmtMoney: function (s, n, c, cs, g, lang) {
102         lang = lang || 'en-us';
103         n = n > 0 && n <= 20 ? n : 2;
104         s = parseFloat((s + '').replace(/[^\d\.-]/g, '')).toFixed(n) + '';
105         let configForUSD = {
106            'en-us': {
107               p: 'b',
108               t: ',',
109               c: '.',
110               g: '',
111               code: '$'
112            },
113            'ru-ru': {
114               p: 'b',
115               t: '',
116               c: ',',
117               g: '',
118               code: '$'
119            },
120            'es-la': {
121               p: 'b',
122               t: '',
123               c: ',',
124               g: ' ',
125               code: '$'
126            },
127            'pt-br': {
128               p: 'b',
129               t: '.',
130               c: ',',
131               g: ' ',
132               code: '$'
133            },
134            'fr-fr': {
135               p: 'a',
136               t: ' ',
137               c: ',',
138               g: ' ',
139               code: '$'
140            },
141            'de-de': {
142               p: 'a',
143               t: '.',
144               c: ',',
145               g: ' ',
146               code: '$'
147            },
148            'nl-nl': {
149               p: 'b',
150               t: '',
151               c: ',',
152               g: ' ',
153               code: '$'
154            },
155            'pt-pt': {
156               p: 'a',
157               t: '.',
158               c: ',',
159               g: ' ',
160               code: '$'
161            },
162            'it-it': {
163               p: 'b',
164               t: '.',
165               c: ',',
166               g: ' ',
167               code: '$'
168            },
169            'pl-pl': {
170               p: 'a',
171               t: '',
172               c: ',',
173               g: ' ',
174               code: '$'
175            },
176         };
177         let configForEUR = {
178            'en-us': {
179               p: 'b',
180               t: ',',
181               c: '.',
182               g: '',
183               code: '€'
184            },
185            'ru-ru': {
186               p: 'b',
187               t: '',
188               c: ',',
189               g: '',
190               code: '€'
191            },
192            'es-la': {
193               p: 'b',
194               t: '',
195               c: ',',
196               g: '',
197               code: '€'
198            },
199            'pt-br': {
200               p: 'b',
201               t: '.',
202               c: ',',
203               g: '',
204               code: '€'
205            },
206            'fr-fr': {
207               p: 'a',
208               t: ' ',
209               c: ',',
210               g: '',
211               code: '€'
212            },
213            'de-de': {
214               p: 'a',
215               t: '.',
216               c: ',',
217               g: '',
218               code: '€'
219            },
220            'nl-nl': {
221               p: 'b',
222               t: '',
223               c: ',',
224               g: ' ',
225               code: '€'
226            },
227            'pt-pt': {
228               p: 'a',
229               t: '.',
230               c: ',',
231               g: ' ',
232               code: '€'
233            },
234            'it-it': {
235               p: 'a',
236               t: '.',
237               c: ',',
238               g: '',
239               code: '€'
240            },
241            'pl-pl': {
242               p: 'a',
243               t: '',
244               c: ',',
245               g: ' ',
246               code: '€'
247            },
248         };
249         let configForCommon = {
250            'en-us': {
251               p: 'b',
252               t: ',',
253               c: '.',
254               g: '',
255               code: cs
256            },
257            'ru-ru': {
258               p: 'b',
259               t: '',
260               c: ',',
261               g: '',
262               code: cs
263            },
264            'es-la': {
265               p: 'b',
266               t: '',
267               c: ',',
268               g: ' ',
269               code: cs
270            },
271            'pt-br': {
272               p: 'b',
273               t: '.',
274               c: ',',
275               g: ' ',
276               code: cs
277            },
278            'fr-fr': {
279               p: 'b',
280               t: ' ',
281               c: ',',
282               g: ' ',
283               code: cs
284            },
285            'de-de': {
286               p: 'b',
287               t: '.',
288               c: ',',
289               g: ' ',
290               code: cs
291            },
292            'nl-nl': {
293               p: 'b',
294               t: '',
295               c: ',',
296               g: ' ',
297               code: cs
298            },
299            'pt-pt': {
300               p: 'b',
301               t: '.',
302               c: ',',
303               g: ' ',
304               code: cs
305            },
306            'it-it': {
307               p: 'b',
308               t: '.',
309               c: ',',
310               g: ' ',
311               code: cs
312            },
313            'pl-pl': {
314               p: 'b',
315               t: '',
316               c: ',',
317               g: ' ',
318               code: cs
319            },
320         };
321         let config = {};
322         if (c === 'usd' || c === 'USD') {
323            config = configForUSD
324         } else if (c === 'eur' || c === 'EUR') {
325            config = configForEUR
326         } else {
327            config = configForCommon
328         }
329         let l = s.split('.')[0].split('').reverse();
330         let r = s.split('.')[1];
331         let t = '';
332         for (let i = 0; i < l.length; i++) {
333            t += l[i] + ((i + 1) % 3 === 0 && (i + 1) !== l.length ? config[lang].t : '')
334         }
335         if (config[lang].p === 'b') {
336            return config[lang].code + config[lang].g + t.split('').reverse().join('') + config[lang].c + r
337         } else {
338            return t.split('').reverse().join('') + config[lang].c + r + config[lang].g + config[lang].code
339         }
340      },
341      reverseFmtMoney: function (s) {
342         return parseFloat(s.replace(/[^\d\.-]/g, ''))
343      },
344   },
345   string: {
346      checkAaNumSpChars: function (value, spChars = '') {
347         let regObj;
348         if (spChars === '') {
349            regObj = new RegExp("^[A-Za-z0-9]+$")
350         } else {
351            regObj = new RegExp("^[A-Za-z0-9" + spChars + "]+$")
352         }
353         return regObj.test(value)
354      },
355      isEmail: function (val) {
356         let reEmail = /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/;
357         return reEmail.test(val)
358      },
359      trim: function (val) {
360         if (val === "") {
361            return val
362         } else {
363            return val.replace(/^\s+|\s+$/g, "")
364         }
365      },
366      isHttp: function (val) {
367         let reg = /^(https?:\/\/)([0-9a-z.]+)(:[0-9]+)?([/0-9a-z.]+)?(\?[0-9a-z&=]+)?(#[0-9-a-z]+)?/i;
368         return reg.test(val)
369      },
370      httpBuildQuery: function (obj) {
371         let str = '',
372            k = '',
373            val = '';
374         for (let e in obj) {
375            if (str === '') {
376               if (e === 'meta_data') {
377                  for (let ee in obj[e]) {
378                     if (str === '') {
379                        str += 'meta_data[' + ee + ']=' + obj[e][ee]
380                     } else {
381                        str += '&meta_data[' + ee + ']=' + obj[e][ee]
382                     }
383                  }
384               } else {
385                  str += e + '=' + obj[e]
386               }
387            } else {
388               if (e === 'meta_data') {
389                  for (let ee in obj[e]) {
390                     str += '&meta_data[' + ee + ']=' + obj[e][ee]
391                  }
392               } else {
393                  str += '&' + e + '=' + obj[e]
394               }
395            }
396         }
397         return str
398      },
399      basename: function (url) {
400         let idx = url.lastIndexOf('/')
401         idx = idx > -1 ? idx : url.lastIndexOf('\\')
402         if (idx < 0) {
403            return url
404         }
405         return url.substring(idx + 1)
406      },
407      sanitize: str => {
408         let div = document.createElement('div');
409         div.textContent = str;
410         return div.innerHTML
411      }
412   },
413   length: function (val) {
414      if (val instanceof Array) {
415         return val.length
416      } else if (typeof val === 'object') {
417         return Object.getOwnPropertyNames(val).length
418      }
419   },
420   object: {
421      isNull: function (val) {
422         return JSON.stringify(val) === "{}"
423      },
424      isObject: function (val) {
425         return (typeof val) === 'object'
426      },
427      length: function (val) {
428         return Object.getOwnPropertyNames(val).length
429      },
430      objectKeys: function (obj, keyName = 'key') {
431         let list = [];
432         for (let i = 0; i < obj.length; i++) {
433            list.push(obj[i][keyName])
434         }
435         return list
436      },
437      keys: function (obj) {
438         return Object.keys(obj)
439      },
440      copy: function (obj, type = 'json') {
441         let newObj = null;
442         switch (type) {
443            case 'json':
444               newObj = JSON.parse(JSON.stringify(obj));
445               break;
446            default:
447               newObj = obj
448         }
449         return newObj
450      },
451      isEqual: function (objA, objB) {
452         return JSON.stringify(objA) === JSON.stringify(objB)
453      },
454      checkNested: function (obj) {
455         if (this.isObject(obj) === !1) {
456            return !1
457         }
458         var args = Array.prototype.slice.call(arguments, 1);
459         for (var i = 0; i < args.length; i++) {
460            if (!obj || !obj.hasOwnProperty(args[i])) {
461               return !1
462            }
463            obj = obj[args[i]]
464         }
465         return !0
466      }
467   },
468   isUndef: function (val) {
469      return (typeof val) === 'undefined'
470   },
471   isNull: function (val) {
472      return (val === '' || (typeof val) === 'undefined' || val === null)
473   },
474   isEmpty: function (val) {
475      return val === '' || (typeof val) === 'undefined' || val === null || JSON.stringify(val) === '{}' || JSON.stringify(val) === '[]' || val === !1
476   },
477   ____isObjectAttrEmpty: function (val) { },
478   hello: function () {
479      alert('world')
480   },
481   array: {
482      inArray: function (needle, haystack) {
483         for (let i = 0; i < haystack.length; i++) {
484            if (haystack[i] === needle) {
485               return !0
486            }
487         }
488         return !1
489      },
490      arrayKeys: function (array) {
491         if (dataFilter.isEmpty(array)) {
492            return []
493         } else {
494            return Object.keys(array)
495         }
496      },
497      filter: function (array) {
498         return array.filter(function (e) {
499            return e != null
500         })
501      },
502      arrayWalk: function (array, func) {
503         if (typeof func !== 'function') {
504            return array
505         }
506         let originalArr = array.concat();
507         array.forEach(function (e, i) {
508            array[i] = func(originalArr, i, e)
509         });
510         return array
511      },
512      getItem: function (arr, k, d) {
513         d = d === 'undefined' ? '' : d;
514         if (dataFilter.object.checkNested(arr, k)) {
515            return arr[k]
516         } else {
517            return d
518         }
519      },
520      sortBy: function (key, list, type) {
521         let temp = null;
522         let flag = !1;
523         type = type || 'up';
524         if (type === 'up') {
525            for (let i = 1; i < list.length; i++) {
526               for (let k = 0; k < list.length - i; k++) {
527                  if (list[k][key] > list[k + 1][key]) {
528                     temp = list[k + 1];
529                     list[k + 1] = list[k];
530                     list[k] = temp;
531                     flag = !0
532                  }
533               }
534            }
535         } else {
536            for (let i = 1; i < list.length; i++) {
537               for (let k = 0; k < list.length - i; k++) {
538                  if (list[k][key] < list[k + 1][key]) {
539                     temp = list[k + 1];
540                     list[k + 1] = list[k];
541                     list[k] = temp;
542                     flag = !0
543                  }
544               }
545            }
546         }
547         return Object.assign([], list)
548      },
549      array_column: function (arr, cn) {
550         return arr.map(function (value, index) {
551            return value[cn]
552         })
553      },
554      array_sum: function (arr) {
555         return arr.reduce((partialSum, a) => partialSum + a, 0)
556      }
557   },
558   json: {
559      safeParse: function (val) {
560         val = val.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
561         return JSON.parse(val)
562      },
563   },
564   explode: function (d, s) {
565      return s.split(d)
566   },
567   isSSL: function () {
568      return 'https:' === document.location.protocol
569   },
570   rsaEncrypt: function (text) {
571      let encryptObj = new JSEncrypt();
572      encryptObj.setPublicKey(metaDataJs.rsaEncryptPk);
573      return encryptObj.encrypt(text)
574   },
575   encFormDataStr: function (slt, fields) {
576      let dataArr = slt.serializeArray();
577      let str = '';
578      Object.keys(dataArr).forEach(function (k) {
579         if (dataFilter.array.inArray(dataArr[k].name, fields)) {
580            if (str) {
581               str += '&' + dataArr[k].name + '=' + encodeURIComponent(dataFilter.rsaEncrypt(dataArr[k].value))
582            } else {
583               str += dataArr[k].name + '=' + encodeURIComponent(dataFilter.rsaEncrypt(dataArr[k].value))
584            }
585         } else {
586            if (str) {
587               str += '&' + dataArr[k].name + '=' + dataArr[k].value
588            } else {
589               str += dataArr[k].name + '=' + dataArr[k].value
590            }
591         }
592      });
593      return str
594   }
595};

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.