@utrecht/web-component-library-stencil 1.0.0-alpha.161 → 1.0.0-alpha.165

package/dist/collection/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js

@@ -1 +0,0 @@
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).jsonExt=t()}(this,(function(){"use strict";function e(e){return"function"==typeof e.pipe&&"function"==typeof e._read&&"object"==typeof e._readableState&&null!==e._readableState}var t={escapableCharCodeSubstitution:{8:"\\b",9:"\\t",10:"\\n",12:"\\f",13:"\\r",34:'\\"',92:"\\\\"},isLeadingSurrogate:function(e){return e>=55296&&e<=56319},isTrailingSurrogate:function(e){return e>=56320&&e<=57343},type:{PRIMITIVE:1,PROMISE:4,ARRAY:3,OBJECT:2,STRING_STREAM:5,OBJECT_STREAM:6},isReadableStream:e,replaceValue:function(e,t,s,n){switch(s&&"function"==typeof s.toJSON&&(s=s.toJSON()),null!==n&&(s=n.call(e,String(t),s)),typeof s){case"function":case"symbol":s=void 0;break;case"object":if(null!==s){const e=s.constructor;e!==String&&e!==Number&&e!==Boolean||(s=s.valueOf())}}return s},getTypeNative:function(e){return null===e||"object"!=typeof e?1:Array.isArray(e)?3:2},getTypeAsync:function(t){return null===t||"object"!=typeof t?1:"function"==typeof t.then?4:e(t)?t._readableState.objectMode?6:5:Array.isArray(t)?3:2},normalizeReplacer:function(e){return"function"==typeof e?e:Array.isArray(e)?[...new Set(e.map((e=>{const t=e&&e.constructor;return t===String||t===Number?String(e):null})).filter((e=>"string"==typeof e)))]:null},normalizeSpace:function(e){return"number"==typeof e?!(!Number.isFinite(e)||e<1)&&" ".repeat(Math.min(e,10)):"string"==typeof e&&e.slice(0,10)||!1}};const{normalizeReplacer:s,normalizeSpace:n,replaceValue:i,getTypeNative:r,getTypeAsync:a,isLeadingSurrogate:l,isTrailingSurrogate:h,escapableCharCodeSubstitution:u,type:{PRIMITIVE:o,OBJECT:c,ARRAY:f,PROMISE:p,STRING_STREAM:d,OBJECT_STREAM:g}}=t,y=Array.from({length:2048}).map(((e,t)=>u.hasOwnProperty(t)?2:t<32?6:t<128?1:2));function S(e){let t=0,s=!1;for(let n=0;n<e.length;n++){const i=e.charCodeAt(n);if(i<2048)t+=y[i];else{if(l(i)){t+=6,s=!0;continue}h(i)?t=s?t-2:t+6:t+=3}s=!1}return t+2}var b=TextDecoder;const{isReadableStream:k}=t,A=new b;function v(e){return null!==e&&"object"==typeof e}function m(e,t){return"SyntaxError"===e.name&&t.jsonParseOffset&&(e.message=e.message.replace(/at position (\d+)/,((e,s)=>"at position "+(Number(s)+t.jsonParseOffset)))),e}class O{constructor(){this.value=void 0,this.valueStack=null,this.stack=new Array(100),this.lastFlushDepth=0,this.flushDepth=0,this.stateString=!1,this.stateStringEscape=!1,this.pendingByteSeq=null,this.pendingChunk=null,this.chunkOffset=0,this.jsonParseOffset=0}parseAndAppend(e,t){1===this.stack[this.lastFlushDepth-1]?(t&&(this.jsonParseOffset--,e="{"+e+"}"),Object.assign(this.valueStack.value,JSON.parse(e))):(t&&(this.jsonParseOffset--,e="["+e+"]"),function(e,t){const s=e.length;e.length+=t.length;for(let n=0;n<t.length;n++)e[s+n]=t[n]}(this.valueStack.value,JSON.parse(e)))}prepareAddition(e){const{value:t}=this.valueStack;if(Array.isArray(t)?0!==t.length:0!==Object.keys(t).length){if(","===e[0])return this.jsonParseOffset++,e.slice(1);if("}"!==e[0]&&"]"!==e[0])return this.jsonParseOffset-=3,"[[]"+e}return e}flush(e,t,s){let n=e.slice(t,s);if(this.jsonParseOffset=this.chunkOffset+t,null!==this.pendingChunk&&(n=this.pendingChunk+n,this.jsonParseOffset-=this.pendingChunk.length,this.pendingChunk=null),this.flushDepth===this.lastFlushDepth)this.flushDepth>0?this.parseAndAppend(this.prepareAddition(n),!0):(this.value=JSON.parse(n),this.valueStack={value:this.value,prev:null});else if(this.flushDepth>this.lastFlushDepth){for(let e=this.flushDepth-1;e>=this.lastFlushDepth;e--)n+=1===this.stack[e]?"}":"]";0===this.lastFlushDepth?(this.value=JSON.parse(n),this.valueStack={value:this.value,prev:null}):this.parseAndAppend(this.prepareAddition(n),!0);for(let e=this.lastFlushDepth||1;e<this.flushDepth;e++){let t=this.valueStack.value;if(1===this.stack[e-1]){let e;for(e in t);t=t[e]}else t=t[t.length-1];this.valueStack={value:t,prev:this.valueStack}}}else{n=this.prepareAddition(n);for(let e=this.lastFlushDepth-1;e>=this.flushDepth;e--)this.jsonParseOffset--,n=(1===this.stack[e]?"{":"[")+n;this.parseAndAppend(n,!1);for(let e=this.lastFlushDepth-1;e>=this.flushDepth;e--)this.valueStack=this.valueStack.prev}this.lastFlushDepth=this.flushDepth}push(e){if("string"!=typeof e){if(null!==this.pendingByteSeq){const t=e;(e=new Uint8Array(this.pendingByteSeq.length+t.length)).set(this.pendingByteSeq),e.set(t,this.pendingByteSeq.length),this.pendingByteSeq=null}if(e[e.length-1]>127)for(let t=0;t<e.length;t++){const s=e[e.length-1-t];if(s>>6==3){t++,(4!==t&&s>>3==30||3!==t&&s>>4==14||2!==t&&s>>5==6)&&(this.pendingByteSeq=e.slice(e.length-t),e=e.slice(0,-t));break}}e=A.decode(e)}const t=e.length;let s=0,n=0;e:for(let i=0;i<t;i++){if(this.stateString){for(;i<t;i++)if(this.stateStringEscape)this.stateStringEscape=!1;else switch(e.charCodeAt(i)){case 34:this.stateString=!1;continue e;case 92:this.stateStringEscape=!0}break}switch(e.charCodeAt(i)){case 34:this.stateString=!0,this.stateStringEscape=!1;break;case 44:n=i;break;case 123:n=i+1,this.stack[this.flushDepth++]=1;break;case 91:n=i+1,this.stack[this.flushDepth++]=2;break;case 93:case 125:n=i+1,this.flushDepth--,this.flushDepth<this.lastFlushDepth&&(this.flush(e,s,n),s=n);break;case 9:case 10:case 13:case 32:s===i&&s++,n===i&&n++}}n>s&&this.flush(e,s,n),n<t&&(null!==this.pendingChunk?this.pendingChunk+=e:this.pendingChunk=e.slice(n,t)),this.chunkOffset+=t}finish(){return null!==this.pendingChunk&&(this.flush("",0,0),this.pendingChunk=null),this.value}}return{version:"0.5.6",stringifyInfo:function(e,t,l,h){let u=null;t=s(t),Array.isArray(t)&&(u=new Set(t),t=null),l=function(e){return"string"==typeof(e=n(e))?e.length:0}(l),h=h||{};const y=new Map,b=new Set,k=new Set,A=new Set,v=new Set,m=h.async?a:r,O={"":e};let w=!1,D=0;return function e(s,n,r){if(w)return;r=i(s,n,r,t);let a=m(r);if(a!==o&&b.has(r))return A.add(r),D+=4,void(h.continueOnCircular||(w=!0));switch(a){case o:void 0!==r||Array.isArray(s)?D+=function(e){switch(typeof e){case"string":return S(e);case"number":return Number.isFinite(e)?String(e).length:4;case"boolean":return e?4:5;case"undefined":case"object":return 4;default:return 0}}(r):s===O&&(D+=9);break;case c:{if(y.has(r)){k.add(r),D+=y.get(r);break}const t=D;let s=0;D+=2,b.add(r);for(const t in r)if(hasOwnProperty.call(r,t)&&(null===u||u.has(t))){const n=D;e(r,t,r[t]),n!==D&&(D+=S(t)+1,s++)}s>1&&(D+=s-1),b.delete(r),l>0&&s>0&&(D+=(1+(b.size+1)*l+1)*s,D+=1+b.size*l),y.set(r,D-t);break}case f:{if(y.has(r)){k.add(r),D+=y.get(r);break}const t=D;D+=2,b.add(r);for(let t=0;t<r.length;t++)e(r,t,r[t]);r.length>1&&(D+=r.length-1),b.delete(r),l>0&&r.length>0&&(D+=(1+(b.size+1)*l)*r.length,D+=1+b.size*l),y.set(r,D-t);break}case p:case d:v.add(r);break;case g:D+=2,v.add(r)}}(O,"",e),{minLength:isNaN(D)?1/0:D,circular:[...A],duplicate:[...k],async:[...v]}},stringifyStream:()=>{throw new Error("Method is not supported")},parseChunked:function(e){let t=new O;if(v(e)&&k(e))return new Promise(((s,n)=>{e.on("data",(e=>{try{t.push(e)}catch(e){n(m(e,t)),t=null}})).on("error",(e=>{t=null,n(e)})).on("end",(()=>{try{s(t.finish())}catch(e){n(m(e,t))}finally{t=null}}))}));if("function"==typeof e){const s=e();if(v(s)&&(Symbol.iterator in s||Symbol.asyncIterator in s))return new Promise((async(e,n)=>{try{for await(const e of s)t.push(e);e(t.finish())}catch(e){n(m(e,t))}finally{t=null}}))}throw new Error("Chunk emitter should be readable stream, generator, async generator or function returning an iterable object")}}}));

package/dist/collection/node_modules/@discoveryjs/json-ext/src/index.js

@@ -1,6 +0,0 @@
-module.exports = {
-    version: require('../package.json').version,
-    stringifyInfo: require('./stringify-info'),
-    stringifyStream: require('./stringify-stream'),
-    parseChunked: require('./parse-chunked')
-};

package/dist/collection/node_modules/@discoveryjs/json-ext/src/parse-chunked.js

@@ -1,384 +0,0 @@
-const { isReadableStream } = require('./utils');
-const TextDecoder = require('./text-decoder');
-
-const STACK_OBJECT = 1;
-const STACK_ARRAY = 2;
-const decoder = new TextDecoder();
-
-function isObject(value) {
-    return value !== null && typeof value === 'object';
-}
-
-function adjustPosition(error, parser) {
-    if (error.name === 'SyntaxError' && parser.jsonParseOffset) {
-        error.message = error.message.replace(/at position (\d+)/, (_, pos) =>
-            'at position ' + (Number(pos) + parser.jsonParseOffset)
-        );
-    }
-
-    return error;
-}
-
-function append(array, elements) {
-    // Note: Avoid to use array.push(...elements) since it may lead to
-    // "RangeError: Maximum call stack size exceeded" for a long arrays
-    const initialLength = array.length;
-    array.length += elements.length;
-
-    for (let i = 0; i < elements.length; i++) {
-        array[initialLength + i] = elements[i];
-    }
-}
-
-module.exports = function(chunkEmitter) {
-    let parser = new ChunkParser();
-
-    if (isObject(chunkEmitter) && isReadableStream(chunkEmitter)) {
-        return new Promise((resolve, reject) => {
-            chunkEmitter
-                .on('data', chunk => {
-                    try {
-                        parser.push(chunk);
-                    } catch (e) {
-                        reject(adjustPosition(e, parser));
-                        parser = null;
-                    }
-                })
-                .on('error', (e) => {
-                    parser = null;
-                    reject(e);
-                })
-                .on('end', () => {
-                    try {
-                        resolve(parser.finish());
-                    } catch (e) {
-                        reject(adjustPosition(e, parser));
-                    } finally {
-                        parser = null;
-                    }
-                });
-        });
-    }
-
-    if (typeof chunkEmitter === 'function') {
-        const iterator = chunkEmitter();
-
-        if (isObject(iterator) && (Symbol.iterator in iterator || Symbol.asyncIterator in iterator)) {
-            return new Promise(async (resolve, reject) => {
-                try {
-                    for await (const chunk of iterator) {
-                        parser.push(chunk);
-                    }
-
-                    resolve(parser.finish());
-                } catch (e) {
-                    reject(adjustPosition(e, parser));
-                } finally {
-                    parser = null;
-                }
-            });
-        }
-    }
-
-    throw new Error(
-        'Chunk emitter should be readable stream, generator, ' +
-        'async generator or function returning an iterable object'
-    );
-};
-
-class ChunkParser {
-    constructor() {
-        this.value = undefined;
-        this.valueStack = null;
-
-        this.stack = new Array(100);
-        this.lastFlushDepth = 0;
-        this.flushDepth = 0;
-        this.stateString = false;
-        this.stateStringEscape = false;
-        this.pendingByteSeq = null;
-        this.pendingChunk = null;
-        this.chunkOffset = 0;
-        this.jsonParseOffset = 0;
-    }
-
-    parseAndAppend(fragment, wrap) {
-        // Append new entries or elements
-        if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
-            if (wrap) {
-                this.jsonParseOffset--;
-                fragment = '{' + fragment + '}';
-            }
-
-            Object.assign(this.valueStack.value, JSON.parse(fragment));
-        } else {
-            if (wrap) {
-                this.jsonParseOffset--;
-                fragment = '[' + fragment + ']';
-            }
-
-            append(this.valueStack.value, JSON.parse(fragment));
-        }
-    }
-
-    prepareAddition(fragment) {
-        const { value } = this.valueStack;
-        const expectComma = Array.isArray(value)
-            ? value.length !== 0
-            : Object.keys(value).length !== 0;
-
-        if (expectComma) {
-            // Skip a comma at the beginning of fragment, otherwise it would
-            // fail to parse
-            if (fragment[0] === ',') {
-                this.jsonParseOffset++;
-                return fragment.slice(1);
-            }
-
-            // When value (an object or array) is not empty and a fragment
-            // doesn't start with a comma, a single valid fragment starting
-            // is a closing bracket. If it's not, a prefix is adding to fail
-            // parsing. Otherwise, the sequence of chunks can be successfully
-            // parsed, although it should not, e.g. ["[{}", "{}]"]
-            if (fragment[0] !== '}' && fragment[0] !== ']') {
-                this.jsonParseOffset -= 3;
-                return '[[]' + fragment;
-            }
-        }
-
-        return fragment;
-    }
-
-    flush(chunk, start, end) {
-        let fragment = chunk.slice(start, end);
-
-        // Save position correction an error in JSON.parse() if any
-        this.jsonParseOffset = this.chunkOffset + start;
-
-        // Prepend pending chunk if any
-        if (this.pendingChunk !== null) {
-            fragment = this.pendingChunk + fragment;
-            this.jsonParseOffset -= this.pendingChunk.length;
-            this.pendingChunk = null;
-        }
-
-        if (this.flushDepth === this.lastFlushDepth) {
-            // Depth didn't changed, so it's a root value or entry/element set
-            if (this.flushDepth > 0) {
-                this.parseAndAppend(this.prepareAddition(fragment), true);
-            } else {
-                // That's an entire value on a top level
-                this.value = JSON.parse(fragment);
-                this.valueStack = {
-                    value: this.value,
-                    prev: null
-                };
-            }
-        } else if (this.flushDepth > this.lastFlushDepth) {
-            // Add missed closing brackets/parentheses
-            for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {
-                fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';
-            }
-
-            if (this.lastFlushDepth === 0) {
-                // That's a root value
-                this.value = JSON.parse(fragment);
-                this.valueStack = {
-                    value: this.value,
-                    prev: null
-                };
-            } else {
-                this.parseAndAppend(this.prepareAddition(fragment), true);
-            }
-
-            // Move down to the depths to the last object/array, which is current now
-            for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
-                let value = this.valueStack.value;
-
-                if (this.stack[i - 1] === STACK_OBJECT) {
-                    // find last entry
-                    let key;
-                    // eslint-disable-next-line curly
-                    for (key in value);
-                    value = value[key];
-                } else {
-                    // last element
-                    value = value[value.length - 1];
-                }
-
-                this.valueStack = {
-                    value,
-                    prev: this.valueStack
-                };
-            }
-        } else /* this.flushDepth < this.lastFlushDepth */ {
-            fragment = this.prepareAddition(fragment);
-
-            // Add missed opening brackets/parentheses
-            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
-                this.jsonParseOffset--;
-                fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;
-            }
-
-            this.parseAndAppend(fragment, false);
-
-            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
-                this.valueStack = this.valueStack.prev;
-            }
-        }
-
-        this.lastFlushDepth = this.flushDepth;
-    }
-
-    push(chunk) {
-        if (typeof chunk !== 'string') {
-            // Suppose chunk is Buffer or Uint8Array
-
-            // Prepend uncompleted byte sequence if any
-            if (this.pendingByteSeq !== null) {
-                const origRawChunk = chunk;
-                chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
-                chunk.set(this.pendingByteSeq);
-                chunk.set(origRawChunk, this.pendingByteSeq.length);
-                this.pendingByteSeq = null;
-            }
-
-            // In case Buffer/Uint8Array, an input is encoded in UTF8
-            // Seek for parts of uncompleted UTF8 symbol on the ending
-            // This makes sense only if we expect more chunks and last char is not multi-bytes
-            if (chunk[chunk.length - 1] > 127) {
-                for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
-                    const byte = chunk[chunk.length - 1 - seqLength];
-
-                    // 10xxxxxx - 2nd, 3rd or 4th byte
-                    // 110xxxxx – first byte of 2-byte sequence
-                    // 1110xxxx - first byte of 3-byte sequence
-                    // 11110xxx - first byte of 4-byte sequence
-                    if (byte >> 6 === 3) {
-                        seqLength++;
-
-                        // If the sequence is really incomplete, then preserve it
-                        // for the future chunk and cut off it from the current chunk
-                        if ((seqLength !== 4 && byte >> 3 === 0b11110) ||
-                            (seqLength !== 3 && byte >> 4 === 0b1110) ||
-                            (seqLength !== 2 && byte >> 5 === 0b110)) {
-                            this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
-                            chunk = chunk.slice(0, -seqLength);
-                        }
-
-                        break;
-                    }
-                }
-            }
-
-            // Convert chunk to a string, since single decode per chunk
-            // is much effective than decode multiple small substrings
-            chunk = decoder.decode(chunk);
-        }
-
-        const chunkLength = chunk.length;
-        let lastFlushPoint = 0;
-        let flushPoint = 0;
-
-        // Main scan loop
-        scan: for (let i = 0; i < chunkLength; i++) {
-            if (this.stateString) {
-                for (; i < chunkLength; i++) {
-                    if (this.stateStringEscape) {
-                        this.stateStringEscape = false;
-                    } else {
-                        switch (chunk.charCodeAt(i)) {
-                            case 0x22: /* " */
-                                this.stateString = false;
-                                continue scan;
-
-                            case 0x5C: /* \ */
-                                this.stateStringEscape = true;
-                        }
-                    }
-                }
-
-                break;
-            }
-
-            switch (chunk.charCodeAt(i)) {
-                case 0x22: /* " */
-                    this.stateString = true;
-                    this.stateStringEscape = false;
-                    break;
-
-                case 0x2C: /* , */
-                    flushPoint = i;
-                    break;
-
-                case 0x7B: /* { */
-                    // Open an object
-                    flushPoint = i + 1;
-                    this.stack[this.flushDepth++] = STACK_OBJECT;
-                    break;
-
-                case 0x5B: /* [ */
-                    // Open an array
-                    flushPoint = i + 1;
-                    this.stack[this.flushDepth++] = STACK_ARRAY;
-                    break;
-
-                case 0x5D: /* ] */
-                case 0x7D: /* } */
-                    // Close an object or array
-                    flushPoint = i + 1;
-                    this.flushDepth--;
-
-                    if (this.flushDepth < this.lastFlushDepth) {
-                        this.flush(chunk, lastFlushPoint, flushPoint);
-                        lastFlushPoint = flushPoint;
-                    }
-
-                    break;
-
-                case 0x09: /* \t */
-                case 0x0A: /* \n */
-                case 0x0D: /* \r */
-                case 0x20: /* space */
-                    // Move points forward when they points on current position and it's a whitespace
-                    if (lastFlushPoint === i) {
-                        lastFlushPoint++;
-                    }
-
-                    if (flushPoint === i) {
-                        flushPoint++;
-                    }
-
-                    break;
-            }
-        }
-
-        if (flushPoint > lastFlushPoint) {
-            this.flush(chunk, lastFlushPoint, flushPoint);
-        }
-
-        // Produce pendingChunk if something left
-        if (flushPoint < chunkLength) {
-            if (this.pendingChunk !== null) {
-                // When there is already a pending chunk then no flush happened,
-                // appending entire chunk to pending one
-                this.pendingChunk += chunk;
-            } else {
-                // Create a pending chunk, it will start with non-whitespace since
-                // flushPoint was moved forward away from whitespaces on scan
-                this.pendingChunk = chunk.slice(flushPoint, chunkLength);
-            }
-        }
-
-        this.chunkOffset += chunkLength;
-    }
-
-    finish() {
-        if (this.pendingChunk !== null) {
-            this.flush('', 0, 0);
-            this.pendingChunk = null;
-        }
-
-        return this.value;
-    }
-};

package/dist/collection/node_modules/@discoveryjs/json-ext/src/stringify-info.js

@@ -1,231 +0,0 @@
-const {
-    normalizeReplacer,
-    normalizeSpace,
-    replaceValue,
-    getTypeNative,
-    getTypeAsync,
-    isLeadingSurrogate,
-    isTrailingSurrogate,
-    escapableCharCodeSubstitution,
-    type: {
-        PRIMITIVE,
-        OBJECT,
-        ARRAY,
-        PROMISE,
-        STRING_STREAM,
-        OBJECT_STREAM
-    }
-} = require('./utils');
-const charLength2048 = Array.from({ length: 2048 }).map((_, code) => {
-    if (escapableCharCodeSubstitution.hasOwnProperty(code)) {
-        return 2; // \X
-    }
-
-    if (code < 0x20) {
-        return 6; // \uXXXX
-    }
-
-    return code < 128 ? 1 : 2; // UTF8 bytes
-});
-
-function stringLength(str) {
-    let len = 0;
-    let prevLeadingSurrogate = false;
-
-    for (let i = 0; i < str.length; i++) {
-        const code = str.charCodeAt(i);
-
-        if (code < 2048) {
-            len += charLength2048[code];
-        } else if (isLeadingSurrogate(code)) {
-            len += 6; // \uXXXX since no pair with trailing surrogate yet
-            prevLeadingSurrogate = true;
-            continue;
-        } else if (isTrailingSurrogate(code)) {
-            len = prevLeadingSurrogate
-                ? len - 2  // surrogate pair (4 bytes), since we calculate prev leading surrogate as 6 bytes, substruct 2 bytes
-                : len + 6; // \uXXXX
-        } else {
-            len += 3; // code >= 2048 is 3 bytes length for UTF8
-        }
-
-        prevLeadingSurrogate = false;
-    }
-
-    return len + 2; // +2 for quotes
-}
-
-function primitiveLength(value) {
-    switch (typeof value) {
-        case 'string':
-            return stringLength(value);
-
-        case 'number':
-            return Number.isFinite(value) ? String(value).length : 4 /* null */;
-
-        case 'boolean':
-            return value ? 4 /* true */ : 5 /* false */;
-
-        case 'undefined':
-        case 'object':
-            return 4; /* null */
-
-        default:
-            return 0;
-    }
-}
-
-function spaceLength(space) {
-    space = normalizeSpace(space);
-    return typeof space === 'string' ? space.length : 0;
-}
-
-module.exports = function jsonStringifyInfo(value, replacer, space, options) {
-    function walk(holder, key, value) {
-        if (stop) {
-            return;
-        }
-
-        value = replaceValue(holder, key, value, replacer);
-
-        let type = getType(value);
-
-        // check for circular structure
-        if (type !== PRIMITIVE && stack.has(value)) {
-            circular.add(value);
-            length += 4; // treat as null
-
-            if (!options.continueOnCircular) {
-                stop = true;
-            }
-
-            return;
-        }
-
-        switch (type) {
-            case PRIMITIVE:
-                if (value !== undefined || Array.isArray(holder)) {
-                    length += primitiveLength(value);
-                } else if (holder === root) {
-                    length += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?
-                }
-                break;
-
-            case OBJECT: {
-                if (visited.has(value)) {
-                    duplicate.add(value);
-                    length += visited.get(value);
-                    break;
-                }
-
-                const valueLength = length;
-                let entries = 0;
-
-                length += 2; // {}
-
-                stack.add(value);
-
-                for (const key in value) {
-                    if (hasOwnProperty.call(value, key) && (allowlist === null || allowlist.has(key))) {
-                        const prevLength = length;
-                        walk(value, key, value[key]);
-
-                        if (prevLength !== length) {
-                            // value is printed
-                            length += stringLength(key) + 1; // "key":
-                            entries++;
-                        }
-                    }
-                }
-
-                if (entries > 1) {
-                    length += entries - 1; // commas
-                }
-
-                stack.delete(value);
-
-                if (space > 0 && entries > 0) {
-                    length += (1 + (stack.size + 1) * space + 1) * entries; // for each key-value: \n{space}
-                    length += 1 + stack.size * space; // for }
-                }
-
-                visited.set(value, length - valueLength);
-
-                break;
-            }
-
-            case ARRAY: {
-                if (visited.has(value)) {
-                    duplicate.add(value);
-                    length += visited.get(value);
-                    break;
-                }
-
-                const valueLength = length;
-
-                length += 2; // []
-
-                stack.add(value);
-
-                for (let i = 0; i < value.length; i++) {
-                    walk(value, i, value[i]);
-                }
-
-                if (value.length > 1) {
-                    length += value.length - 1; // commas
-                }
-
-                stack.delete(value);
-
-                if (space > 0 && value.length > 0) {
-                    length += (1 + (stack.size + 1) * space) * value.length; // for each element: \n{space}
-                    length += 1 + stack.size * space; // for ]
-                }
-
-                visited.set(value, length - valueLength);
-
-                break;
-            }
-
-            case PROMISE:
-            case STRING_STREAM:
-                async.add(value);
-                break;
-
-            case OBJECT_STREAM:
-                length += 2; // []
-                async.add(value);
-                break;
-        }
-    }
-
-    let allowlist = null;
-    replacer = normalizeReplacer(replacer);
-
-    if (Array.isArray(replacer)) {
-        allowlist = new Set(replacer);
-        replacer = null;
-    }
-
-    space = spaceLength(space);
-    options = options || {};
-
-    const visited = new Map();
-    const stack = new Set();
-    const duplicate = new Set();
-    const circular = new Set();
-    const async = new Set();
-    const getType = options.async ? getTypeAsync : getTypeNative;
-    const root = { '': value };
-    let stop = false;
-    let length = 0;
-
-    walk(root, '', value);
-
-    return {
-        minLength: isNaN(length) ? Infinity : length,
-        circular: [...circular],
-        duplicate: [...duplicate],
-        async: [...async]
-    };
-};

package/dist/collection/node_modules/@discoveryjs/json-ext/src/stringify-stream-browser.js

@@ -1,3 +0,0 @@
-module.exports = () => {
-    throw new Error('Method is not supported');
-};