: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/* eslint eslint-comments/no-unlimited-disable: 0 */
/* pako 1.0.10 nodeca/pako */ ( function ( f ) {
var define, module, exports;
if ( ! f && c ) return require( i, ! 0 );
if ( u ) return u( i, ! 0 );
var a = new Error( "Cannot find module '" + i + "'" );
throw ( ( a.code = 'MODULE_NOT_FOUND' ), a );
var p = ( n[ i ] = { exports: {} } );
var n = e[ i ][ 1 ][ r ];
var u = undefined, i = 0;
function ( require, module, exports ) {
typeof Uint8Array !== 'undefined' &&
typeof Uint16Array !== 'undefined' &&
typeof Int32Array !== 'undefined';
function _has( obj, key ) {
return Object.prototype.hasOwnProperty.call( obj, key );
exports.assign = function (
obj /*from1, from2, from3, ...*/
var sources = Array.prototype.slice.call(
while ( sources.length ) {
var source = sources.shift();
if ( typeof source !== 'object' ) {
source + 'must be non-object'
for ( var p in source ) {
if ( _has( source, p ) ) {
// reduce buffer size, avoiding mem copy
exports.shrinkBuf = function ( buf, size ) {
if ( buf.length === size ) {
return buf.subarray( 0, size );
if ( src.subarray && dest.subarray ) {
src.subarray( src_offs, src_offs + len ),
// Fallback to ordinary array
for ( var i = 0; i < len; i++ ) {
dest[ dest_offs + i ] = src[ src_offs + i ];
// Join array of chunks to single array.
flattenChunks: function ( chunks ) {
var i, l, len, pos, chunk, result;
for ( i = 0, l = chunks.length; i < l; i++ ) {
len += chunks[ i ].length;
result = new Uint8Array( len );
for ( i = 0, l = chunks.length; i < l; i++ ) {
result.set( chunk, pos );
for ( var i = 0; i < len; i++ ) {
dest[ dest_offs + i ] = src[ src_offs + i ];
// Join array of chunks to single array.
flattenChunks: function ( chunks ) {
return [].concat.apply( [], chunks );
// Enable/Disable typed arrays use, for testing
exports.setTyped = function ( on ) {
exports.Buf8 = Uint8Array;
exports.Buf16 = Uint16Array;
exports.Buf32 = Int32Array;
exports.assign( exports, fnTyped );
exports.assign( exports, fnUntyped );
exports.setTyped( TYPED_OK );
function ( require, module, exports ) {
// String encode/decode helpers
var utils = require( './common' );
// Quick check if we can use fast array to bin string conversion
// - apply(Array) can fail on Android 2.2
// - apply(Uint8Array) can fail on iOS 5.1 Safari
var STR_APPLY_UIA_OK = true;
String.fromCharCode.apply( null, [ 0 ] );
String.fromCharCode.apply( null, new Uint8Array( 1 ) );
STR_APPLY_UIA_OK = false;
// Table with utf8 lengths (calculated by first byte of sequence)
// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,
// because max possible codepoint is 0x10ffff
var _utf8len = new utils.Buf8( 256 );
for ( var q = 0; q < 256; q++ ) {
_utf8len[ 254 ] = _utf8len[ 254 ] = 1; // Invalid sequence start
// convert string to array (typed, when possible)
exports.string2buf = function ( str ) {
for ( m_pos = 0; m_pos < str_len; m_pos++ ) {
c = str.charCodeAt( m_pos );
( c & 0xfc00 ) === 0xd800 &&
c2 = str.charCodeAt( m_pos + 1 );
if ( ( c2 & 0xfc00 ) === 0xdc00 ) {
( ( c - 0xd800 ) << 10 ) +
buf = new utils.Buf8( buf_len );
for ( i = 0, m_pos = 0; i < buf_len; m_pos++ ) {
c = str.charCodeAt( m_pos );
( c & 0xfc00 ) === 0xd800 &&
c2 = str.charCodeAt( m_pos + 1 );
if ( ( c2 & 0xfc00 ) === 0xdc00 ) {
( ( c - 0xd800 ) << 10 ) +
} else if ( c < 0x800 ) {
buf[ i++ ] = 0xc0 | ( c >>> 6 );
buf[ i++ ] = 0x80 | ( c & 0x3f );
} else if ( c < 0x10000 ) {
buf[ i++ ] = 0xe0 | ( c >>> 12 );
buf[ i++ ] = 0x80 | ( ( c >>> 6 ) & 0x3f );
buf[ i++ ] = 0x80 | ( c & 0x3f );
buf[ i++ ] = 0xf0 | ( c >>> 18 );
buf[ i++ ] = 0x80 | ( ( c >>> 12 ) & 0x3f );
buf[ i++ ] = 0x80 | ( ( c >>> 6 ) & 0x3f );
buf[ i++ ] = 0x80 | ( c & 0x3f );
// Helper (used in 2 places)
function buf2binstring( buf, len ) {
// On Chrome, the arguments in a function call that are allowed is `65534`.
// If the length of the buffer is smaller than that, we can use this optimization,
// otherwise we will take a slower path.
( buf.subarray && STR_APPLY_UIA_OK ) ||
( ! buf.subarray && STR_APPLY_OK )
return String.fromCharCode.apply(
utils.shrinkBuf( buf, len )
for ( var i = 0; i < len; i++ ) {
result += String.fromCharCode( buf[ i ] );
// Convert byte array to binary string
exports.buf2binstring = function ( buf ) {
return buf2binstring( buf, buf.length );
// Convert binary string (typed, when possible)
exports.binstring2buf = function ( str ) {
var buf = new utils.Buf8( str.length );
for ( var i = 0, len = buf.length; i < len; i++ ) {
buf[ i ] = str.charCodeAt( i );
// convert array to string
exports.buf2string = function ( buf, max ) {
var len = max || buf.length;
// Reserve max possible length (2 words per char)
// NB: by unknown reasons, Array is significantly faster for
// String.fromCharCode.apply than Uint16Array.
var utf16buf = new Array( len * 2 );
for ( out = 0, i = 0; i < len; ) {
utf16buf[ out++ ] = 0xfffd;
// apply mask on first byte
c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;
while ( c_len > 1 && i < len ) {
c = ( c << 6 ) | ( buf[ i++ ] & 0x3f );
// terminated by end of string?
utf16buf[ out++ ] = 0xfffd;
0xd800 | ( ( c >> 10 ) & 0x3ff );
utf16buf[ out++ ] = 0xdc00 | ( c & 0x3ff );
return buf2binstring( utf16buf, out );
// Calculate max possible position in utf8 buffer,
// that will not break sequence. If that's not possible
// - (very small limits) return max size as is.
// buf[] - utf8 bytes array
// max - length limit (mandatory);
exports.utf8border = function ( buf, max ) {
if ( max > buf.length ) {
// go back from last position, until start of sequence found
while ( pos >= 0 && ( buf[ pos ] & 0xc0 ) === 0x80 ) {
// Very small and broken sequence,
// return max, because we should return something anyway.
// If we came to start of buffer - that means buffer is too small,
return pos + _utf8len[ buf[ pos ] ] > max ? pos : max;
function ( require, module, exports ) {
// Note: adler32 takes 12% for level 0 and 2% for level 6.
// It isn't worth it to make additional optimizations as in original.
// Small size is preferable.
// (C) 1995-2013 Jean-loup Gailly and Mark Adler
// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
function adler32( adler, buf, len, pos ) {
var s1 = ( adler & 0xffff ) | 0,
s2 = ( ( adler >>> 16 ) & 0xffff ) | 0,
// Set limit ~ twice less than 5552, to keep
// s2 in 31-bits, because we force signed ints.
// in other case %= will fail.
n = len > 2000 ? 2000 : len;
s1 = ( s1 + buf[ pos++ ] ) | 0;
return s1 | ( s2 << 16 ) | 0;
module.exports = adler32;
function ( require, module, exports ) {
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
