@utrecht/web-component-library-stencil 1.0.0-alpha.162 → 1.0.0-alpha.166

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

@@ -1,408 +0,0 @@
-const { Readable } = require('stream');
-const {
-    normalizeReplacer,
-    normalizeSpace,
-    replaceValue,
-    getTypeAsync,
-    type: {
-        PRIMITIVE,
-        OBJECT,
-        ARRAY,
-        PROMISE,
-        STRING_STREAM,
-        OBJECT_STREAM
-    }
-} = require('./utils');
-const noop = () => {};
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-
-// TODO: Remove when drop support for Node.js 10
-// Node.js 10 has no well-formed JSON.stringify()
-// https://github.com/tc39/proposal-well-formed-stringify
-// Adopted code from https://bugs.chromium.org/p/v8/issues/detail?id=7782#c12
-const wellformedStringStringify = JSON.stringify('\ud800') === '"\\ud800"'
-    ? JSON.stringify
-    : s => JSON.stringify(s).replace(
-        /\p{Surrogate}/gu,
-        m => `\\u${m.charCodeAt(0).toString(16)}`
-    );
-
-function push() {
-    this.push(this._stack.value);
-    this.popStack();
-}
-
-function pushPrimitive(value) {
-    switch (typeof value) {
-        case 'string':
-            this.push(this.encodeString(value));
-            break;
-
-        case 'number':
-            this.push(Number.isFinite(value) ? this.encodeNumber(value) : 'null');
-            break;
-
-        case 'boolean':
-            this.push(value ? 'true' : 'false');
-            break;
-
-        case 'undefined':
-        case 'object': // typeof null === 'object'
-            this.push('null');
-            break;
-
-        default:
-            this.destroy(new TypeError(`Do not know how to serialize a ${value.constructor && value.constructor.name || typeof value}`));
-    }
-}
-
-function processObjectEntry(key) {
-    const current = this._stack;
-
-    if (!current.first) {
-        current.first = true;
-    } else {
-        this.push(',');
-    }
-
-    if (this.space) {
-        this.push(`\n${this.space.repeat(this._depth)}${this.encodeString(key)}: `);
-    } else {
-        this.push(this.encodeString(key) + ':');
-    }
-}
-
-function processObject() {
-    const current = this._stack;
-
-    // when no keys left, remove obj from stack
-    if (current.index === current.keys.length) {
-        if (this.space && current.first) {
-            this.push(`\n${this.space.repeat(this._depth - 1)}}`);
-        } else {
-            this.push('}');
-        }
-
-        this.popStack();
-        return;
-    }
-
-    const key = current.keys[current.index];
-
-    this.processValue(current.value, key, current.value[key], processObjectEntry);
-    current.index++;
-}
-
-function processArrayItem(index) {
-    if (index !== 0) {
-        this.push(',');
-    }
-
-    if (this.space) {
-        this.push(`\n${this.space.repeat(this._depth)}`);
-    }
-}
-
-function processArray() {
-    const current = this._stack;
-
-    if (current.index === current.value.length) {
-        if (this.space && current.index > 0) {
-            this.push(`\n${this.space.repeat(this._depth - 1)}]`);
-        } else {
-            this.push(']');
-        }
-
-        this.popStack();
-        return;
-    }
-
-    this.processValue(current.value, current.index, current.value[current.index], processArrayItem);
-    current.index++;
-}
-
-function createStreamReader(fn) {
-    return function() {
-        const current = this._stack;
-        const data = current.value.read(this._readSize);
-
-        if (data !== null) {
-            current.first = false;
-            fn.call(this, data, current);
-        } else {
-            if ((current.first && !current.value._readableState.reading) || current.ended) {
-                this.popStack();
-            } else {
-                current.first = true;
-                current.awaiting = true;
-            }
-        }
-    };
-}
-
-const processReadableObject = createStreamReader(function(data, current) {
-    this.processValue(current.value, current.index, data, processArrayItem);
-    current.index++;
-});
-
-const processReadableString = createStreamReader(function(data) {
-    this.push(data);
-});
-
-class JsonStringifyStream extends Readable {
-    constructor(value, replacer, space) {
-        super({
-            autoDestroy: true
-        });
-
-        this.getKeys = Object.keys;
-        this.replacer = normalizeReplacer(replacer);
-
-        if (Array.isArray(this.replacer)) {
-            const allowlist = this.replacer;
-
-            this.getKeys = (value) => allowlist.filter(key => hasOwnProperty.call(value, key));
-            this.replacer = null;
-        }
-
-        this.space = normalizeSpace(space);
-        this._depth = 0;
-
-        this.error = null;
-        this._processing = false;
-        this._ended = false;
-
-        this._readSize = 0;
-        this._buffer = '';
-
-        this._stack = null;
-        this._visited = new WeakSet();
-
-        this.pushStack({
-            handler: () => {
-                this.popStack();
-                this.processValue({ '': value }, '', value, noop);
-            }
-        });
-    }
-
-    encodeString(value) {
-        if (/[^\x20-\uD799]|[\x22\x5c]/.test(value)) {
-            return wellformedStringStringify(value);
-        }
-
-        return '"' + value + '"';
-    }
-
-    encodeNumber(value) {
-        return value;
-    }
-
-    processValue(holder, key, value, callback) {
-        value = replaceValue(holder, key, value, this.replacer);
-
-        let type = getTypeAsync(value);
-
-        switch (type) {
-            case PRIMITIVE:
-                if (callback !== processObjectEntry || value !== undefined) {
-                    callback.call(this, key);
-                    pushPrimitive.call(this, value);
-                }
-                break;
-
-            case OBJECT:
-                callback.call(this, key);
-
-                // check for circular structure
-                if (this._visited.has(value)) {
-                    return this.destroy(new TypeError('Converting circular structure to JSON'));
-                }
-
-                this._visited.add(value);
-                this._depth++;
-                this.push('{');
-                this.pushStack({
-                    handler: processObject,
-                    value,
-                    index: 0,
-                    first: false,
-                    keys: this.getKeys(value)
-                });
-                break;
-
-            case ARRAY:
-                callback.call(this, key);
-
-                // check for circular structure
-                if (this._visited.has(value)) {
-                    return this.destroy(new TypeError('Converting circular structure to JSON'));
-                }
-
-                this._visited.add(value);
-
-                this.push('[');
-                this.pushStack({
-                    handler: processArray,
-                    value,
-                    index: 0
-                });
-                this._depth++;
-                break;
-
-            case PROMISE:
-                this.pushStack({
-                    handler: noop,
-                    awaiting: true
-                });
-
-                Promise.resolve(value)
-                    .then(resolved => {
-                        this.popStack();
-                        this.processValue(holder, key, resolved, callback);
-                        this.processStack();
-                    })
-                    .catch(error => {
-                        this.destroy(error);
-                    });
-                break;
-
-            case STRING_STREAM:
-            case OBJECT_STREAM:
-                callback.call(this, key);
-
-                // TODO: Remove when drop support for Node.js 10
-                // Used `_readableState.endEmitted` as fallback, since Node.js 10 has no `readableEnded` getter
-                if (value.readableEnded || value._readableState.endEmitted) {
-                    return this.destroy(new Error('Readable Stream has ended before it was serialized. All stream data have been lost'));
-                }
-
-                if (value.readableFlowing) {
-                    return this.destroy(new Error('Readable Stream is in flowing mode, data may have been lost. Trying to pause stream.'));
-                }
-
-                if (type === OBJECT_STREAM) {
-                    this.push('[');
-                    this.pushStack({
-                        handler: push,
-                        value: this.space ? '\n' + this.space.repeat(this._depth) + ']' : ']'
-                    });
-                    this._depth++;
-                }
-
-                const self = this.pushStack({
-                    handler: type === OBJECT_STREAM ? processReadableObject : processReadableString,
-                    value,
-                    index: 0,
-                    first: false,
-                    ended: false,
-                    awaiting: !value.readable || value.readableLength === 0
-                });
-                const continueProcessing = () => {
-                    if (self.awaiting) {
-                        self.awaiting = false;
-                        this.processStack();
-                    }
-                };
-
-                value.once('error', error => this.destroy(error));
-                value.once('end', () => {
-                    self.ended = true;
-                    continueProcessing();
-                });
-                value.on('readable', continueProcessing);
-                break;
-        }
-    }
-
-    pushStack(node) {
-        node.prev = this._stack;
-        return this._stack = node;
-    }
-
-    popStack() {
-        const { handler, value } = this._stack;
-
-        if (handler === processObject || handler === processArray || handler === processReadableObject) {
-            this._visited.delete(value);
-            this._depth--;
-        }
-
-        this._stack = this._stack.prev;
-    }
-
-    processStack() {
-        if (this._processing || this._ended) {
-            return;
-        }
-
-        try {
-            this._processing = true;
-
-            while (this._stack !== null && !this._stack.awaiting) {
-                this._stack.handler.call(this);
-
-                if (!this._processing) {
-                    return;
-                }
-            }
-
-            this._processing = false;
-        } catch (error) {
-            this.destroy(error);
-            return;
-        }
-
-        if (this._stack === null && !this._ended) {
-            this._finish();
-            this.push(null);
-        }
-    }
-
-    push(data) {
-        if (data !== null) {
-            this._buffer += data;
-
-            // check buffer overflow
-            if (this._buffer.length < this._readSize) {
-                return;
-            }
-
-            // flush buffer
-            data = this._buffer;
-            this._buffer = '';
-            this._processing = false;
-        }
-
-        super.push(data);
-    }
-
-    _read(size) {
-        // start processing
-        this._readSize = size || this.readableHighWaterMark;
-        this.processStack();
-    }
-
-    _finish() {
-        this._ended = true;
-        this._processing = false;
-        this._stack = null;
-        this._visited = null;
-
-        if (this._buffer && this._buffer.length) {
-            super.push(this._buffer); // flush buffer
-        }
-
-        this._buffer = '';
-    }
-
-    _destroy(error, cb) {
-        this.error = this.error || error;
-        this._finish();
-        cb(error);
-    }
-}
-
-module.exports = function createJsonStringifyStream(value, replacer, space) {
-    return new JsonStringifyStream(value, replacer, space);
-};

package/dist/collection/node_modules/@discoveryjs/json-ext/src/text-decoder-browser.js

@@ -1 +0,0 @@
-module.exports = TextDecoder;

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

@@ -1 +0,0 @@
-module.exports = require('util').TextDecoder;

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

@@ -1,149 +0,0 @@
-const PrimitiveType = 1;
-const ObjectType = 2;
-const ArrayType = 3;
-const PromiseType = 4;
-const ReadableStringType = 5;
-const ReadableObjectType = 6;
-// https://tc39.es/ecma262/#table-json-single-character-escapes
-const escapableCharCodeSubstitution = { // JSON Single Character Escape Sequences
-    0x08: '\\b',
-    0x09: '\\t',
-    0x0a: '\\n',
-    0x0c: '\\f',
-    0x0d: '\\r',
-    0x22: '\\\"',
-    0x5c: '\\\\'
-};
-
-function isLeadingSurrogate(code) {
-    return code >= 0xD800 && code <= 0xDBFF;
-}
-
-function isTrailingSurrogate(code) {
-    return code >= 0xDC00 && code <= 0xDFFF;
-}
-
-function isReadableStream(value) {
-    return (
-        typeof value.pipe === 'function' &&
-        typeof value._read === 'function' &&
-        typeof value._readableState === 'object' && value._readableState !== null
-    );
-}
-
-function replaceValue(holder, key, value, replacer) {
-    if (value && typeof value.toJSON === 'function') {
-        value = value.toJSON();
-    }
-
-    if (replacer !== null) {
-        value = replacer.call(holder, String(key), value);
-    }
-
-    switch (typeof value) {
-        case 'function':
-        case 'symbol':
-            value = undefined;
-            break;
-
-        case 'object':
-            if (value !== null) {
-                const cls = value.constructor;
-                if (cls === String || cls === Number || cls === Boolean) {
-                    value = value.valueOf();
-                }
-            }
-            break;
-    }
-
-    return value;
-}
-
-function getTypeNative(value) {
-    if (value === null || typeof value !== 'object') {
-        return PrimitiveType;
-    }
-
-    if (Array.isArray(value)) {
-        return ArrayType;
-    }
-
-    return ObjectType;
-}
-
-function getTypeAsync(value) {
-    if (value === null || typeof value !== 'object') {
-        return PrimitiveType;
-    }
-
-    if (typeof value.then === 'function') {
-        return PromiseType;
-    }
-
-    if (isReadableStream(value)) {
-        return value._readableState.objectMode ? ReadableObjectType : ReadableStringType;
-    }
-
-    if (Array.isArray(value)) {
-        return ArrayType;
-    }
-
-    return ObjectType;
-}
-
-function normalizeReplacer(replacer) {
-    if (typeof replacer === 'function') {
-        return replacer;
-    }
-
-    if (Array.isArray(replacer)) {
-        const allowlist = new Set(replacer
-            .map(item => {
-                const cls = item && item.constructor;
-                return cls === String || cls === Number ? String(item) : null;
-            })
-            .filter(item => typeof item === 'string')
-        );
-
-        return [...allowlist];
-    }
-
-    return null;
-}
-
-function normalizeSpace(space) {
-    if (typeof space === 'number') {
-        if (!Number.isFinite(space) || space < 1) {
-            return false;
-        }
-
-        return ' '.repeat(Math.min(space, 10));
-    }
-
-    if (typeof space === 'string') {
-        return space.slice(0, 10) || false;
-    }
-
-    return false;
-}
-
-module.exports = {
-    escapableCharCodeSubstitution,
-    isLeadingSurrogate,
-    isTrailingSurrogate,
-    type: {
-        PRIMITIVE: PrimitiveType,
-        PROMISE: PromiseType,
-        ARRAY: ArrayType,
-        OBJECT: ObjectType,
-        STRING_STREAM: ReadableStringType,
-        OBJECT_STREAM: ReadableObjectType
-    },
-
-    isReadableStream,
-    replaceValue,
-    getTypeNative,
-    getTypeAsync,
-    normalizeReplacer,
-    normalizeSpace
-};