xhs-mp-pack 1.1.0-beta.0

package/dist/serialization/middlewares/ObjectMiddleware.js

@@ -0,0 +1,602 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const ArraySerializer_1 = __importDefault(require("../serializers/ArraySerializer"));
+const DateObjectSerializer_1 = __importDefault(require("../serializers/DateObjectSerializer"));
+const ErrorObjectSerializer_1 = __importDefault(require("../serializers/ErrorObjectSerializer"));
+const MapObjectSerializer_1 = __importDefault(require("../serializers/MapObjectSerializer"));
+const NullPrototypeObjectSerializer_1 = __importDefault(require("../serializers/NullPrototypeObjectSerializer"));
+const PlainObjectSerializer_1 = __importDefault(require("../serializers/PlainObjectSerializer"));
+const RegExpObjectSerializer_1 = __importDefault(require("../serializers/RegExpObjectSerializer"));
+const SerializerMiddleware_1 = __importDefault(require("../SerializerMiddleware"));
+const SetObjectSerializer_1 = __importDefault(require("../serializers/SetObjectSerializer"));
+/*
+
+Format:
+
+File -> Section*
+Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
+
+ObjectSection -> ESCAPE (
+    number:relativeOffset (number > 0) |
+    string:request (string|null):export
+) Section:value* ESCAPE ESCAPE_END_OBJECT
+ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
+EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
+EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
+OtherSection -> any (except ESCAPE)
+
+Why using null as escape value?
+Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
+Technically any value can be used.
+
+*/
+const setSetSize = (set, size) => {
+    let i = 0;
+    for (const item of set) {
+        if (i++ >= size) {
+            set.delete(item);
+        }
+    }
+};
+const setMapSize = (map, size) => {
+    let i = 0;
+    for (const item of map.keys()) {
+        if (i++ >= size) {
+            map.delete(item);
+        }
+    }
+};
+const toHash = (buffer, hashFunction) => {
+    const hash = (0, createHash_1.default)(hashFunction);
+    hash.update(buffer);
+    return hash.digest('latin1');
+};
+const ESCAPE = null;
+const ESCAPE_ESCAPE_VALUE = null;
+const ESCAPE_END_OBJECT = true;
+const ESCAPE_UNDEFINED = false;
+const CURRENT_VERSION = 2;
+const serializers = new Map();
+const serializerInversed = new Map();
+const loadedRequests = new Set();
+const NOT_SERIALIZABLE = {};
+const jsTypes = new Map();
+jsTypes.set(Object, new PlainObjectSerializer_1.default());
+jsTypes.set(Array, new ArraySerializer_1.default());
+jsTypes.set(null, new NullPrototypeObjectSerializer_1.default());
+jsTypes.set(Map, new MapObjectSerializer_1.default());
+jsTypes.set(Set, new SetObjectSerializer_1.default());
+jsTypes.set(Date, new DateObjectSerializer_1.default());
+jsTypes.set(RegExp, new RegExpObjectSerializer_1.default());
+jsTypes.set(Error, new ErrorObjectSerializer_1.default(Error));
+jsTypes.set(EvalError, new ErrorObjectSerializer_1.default(EvalError));
+jsTypes.set(RangeError, new ErrorObjectSerializer_1.default(RangeError));
+jsTypes.set(ReferenceError, new ErrorObjectSerializer_1.default(ReferenceError));
+jsTypes.set(SyntaxError, new ErrorObjectSerializer_1.default(SyntaxError));
+jsTypes.set(TypeError, new ErrorObjectSerializer_1.default(TypeError));
+// If in a sandboxed environment (e. g. jest), this escapes the sandbox and registers
+// real Object and Array types to. These types may occur in the wild too, e. g. when
+// using Structured Clone in postMessage.
+if (exports.constructor !== Object) {
+    const Obj = exports.constructor;
+    const Fn = Obj.constructor;
+    for (const [type, config] of Array.from(jsTypes)) {
+        if (type) {
+            const Type = new Fn(`return ${type.name};`)();
+            jsTypes.set(Type, config);
+        }
+    }
+}
+{
+    let i = 1;
+    for (const [type, serializer] of jsTypes) {
+        serializers.set(type, {
+            request: '',
+            name: i++,
+            serializer,
+        });
+    }
+}
+for (const { request, name, serializer } of serializers.values()) {
+    serializerInversed.set(`${request}/${name}`, serializer);
+}
+const loaders = new Map();
+class ObjectMiddleware extends SerializerMiddleware_1.default {
+    constructor(extendContext, hashFunction = 'md4') {
+        super();
+        this.extendContext = extendContext;
+        this._hashFunction = hashFunction;
+    }
+    static registerLoader(regExp, loader) {
+        loaders.set(regExp, loader);
+    }
+    static register(Constructor, request, name, serializer) {
+        const key = `${request}/${name}`;
+        if (serializers.has(Constructor)) {
+            throw new Error(`ObjectMiddleware.register: serializer for ${Constructor.name} is already registered`);
+        }
+        if (serializerInversed.has(key)) {
+            throw new Error(`ObjectMiddleware.register: serializer for ${key} is already registered`);
+        }
+        serializers.set(Constructor, {
+            request,
+            name,
+            serializer,
+        });
+        serializerInversed.set(key, serializer);
+    }
+    static registerNotSerializable(Constructor) {
+        if (serializers.has(Constructor)) {
+            throw new Error(`ObjectMiddleware.registerNotSerializable: serializer for ${Constructor.name} is already registered`);
+        }
+        serializers.set(Constructor, NOT_SERIALIZABLE);
+    }
+    static getSerializerFor(object) {
+        const proto = Object.getPrototypeOf(object);
+        let c;
+        if (proto === null) {
+            // Object created with Object.create(null)
+            c = null;
+        }
+        else {
+            c = proto.constructor;
+            if (!c) {
+                throw new Error('Serialization of objects with prototype without valid constructor property not possible');
+            }
+        }
+        const config = serializers.get(c);
+        if (!config)
+            throw new Error(`No serializer registered for ${c.name}`);
+        if (config === NOT_SERIALIZABLE)
+            throw NOT_SERIALIZABLE;
+        return config;
+    }
+    static getDeserializerFor(request, name) {
+        const key = `${request}/${name}`;
+        const serializer = serializerInversed.get(key);
+        if (serializer === undefined) {
+            throw new Error(`No deserializer registered for ${key}`);
+        }
+        return serializer;
+    }
+    static _getDeserializerForWithoutError(request, name) {
+        const key = `${request}/${name}`;
+        const serializer = serializerInversed.get(key);
+        return serializer;
+    }
+    serialize(data, context) {
+        let result = [CURRENT_VERSION];
+        let currentPos = 0;
+        let referenceable = new Map();
+        const addReferenceable = item => {
+            referenceable.set(item, currentPos++);
+        };
+        let bufferDedupeMap = new Map();
+        const dedupeBuffer = buf => {
+            const len = buf.length;
+            const entry = bufferDedupeMap.get(len);
+            if (entry === undefined) {
+                bufferDedupeMap.set(len, buf);
+                return buf;
+            }
+            if (Buffer.isBuffer(entry)) {
+                if (len < 32) {
+                    if (buf.equals(entry)) {
+                        return entry;
+                    }
+                    bufferDedupeMap.set(len, [entry, buf]);
+                    return buf;
+                }
+                const hash = toHash(entry, this._hashFunction);
+                const newMap = new Map();
+                newMap.set(hash, entry);
+                bufferDedupeMap.set(len, newMap);
+                const hashBuf = toHash(buf, this._hashFunction);
+                if (hash === hashBuf) {
+                    return entry;
+                }
+                return buf;
+            }
+            if (Array.isArray(entry)) {
+                if (entry.length < 16) {
+                    for (const item of entry) {
+                        if (buf.equals(item)) {
+                            return item;
+                        }
+                    }
+                    entry.push(buf);
+                    return buf;
+                }
+                const newMap = new Map();
+                const hash = toHash(buf, this._hashFunction);
+                let found;
+                for (const item of entry) {
+                    const itemHash = toHash(item, this._hashFunction);
+                    newMap.set(itemHash, item);
+                    if (found === undefined && itemHash === hash)
+                        found = item;
+                }
+                bufferDedupeMap.set(len, newMap);
+                if (found === undefined) {
+                    newMap.set(hash, buf);
+                    return buf;
+                }
+                return found;
+            }
+            const hash = toHash(buf, this._hashFunction);
+            const item = entry.get(hash);
+            if (item !== undefined) {
+                return item;
+            }
+            entry.set(hash, buf);
+            return buf;
+        };
+        let currentPosTypeLookup = 0;
+        let objectTypeLookup = new Map();
+        const cycleStack = new Set();
+        const stackToString = item => {
+            const arr = Array.from(cycleStack);
+            arr.push(item);
+            return arr
+                .map((item) => {
+                if (typeof item === 'string') {
+                    if (item.length > 100) {
+                        return `String ${JSON.stringify(item.slice(0, 100)).slice(0, -1)}..."`;
+                    }
+                    return `String ${JSON.stringify(item)}`;
+                }
+                try {
+                    const { request, name } = ObjectMiddleware.getSerializerFor(item);
+                    if (request) {
+                        return `${request}${name ? `.${name}` : ''}`;
+                    }
+                }
+                catch (e) {
+                    // ignore -> fallback
+                }
+                if (typeof item === 'object' && item !== null) {
+                    if (item.constructor) {
+                        if (item.constructor === Object)
+                            return `Object { ${Object.keys(item).join(', ')} }`;
+                        if (item.constructor === Map)
+                            return `Map { ${item.size} items }`;
+                        if (item.constructor === Array)
+                            return `Array { ${item.length} items }`;
+                        if (item.constructor === Set)
+                            return `Set { ${item.size} items }`;
+                        if (item.constructor === RegExp)
+                            return item.toString();
+                        return `${item.constructor.name}`;
+                    }
+                    return `Object [null prototype] { ${Object.keys(item).join(', ')} }`;
+                }
+                if (typeof item === 'bigint') {
+                    return `BigInt ${item}n`;
+                }
+                try {
+                    return `${item}`;
+                }
+                catch (e) {
+                    return `(${e.message})`;
+                }
+            })
+                .join(' -> ');
+        };
+        let hasDebugInfoAttached;
+        let ctx = Object.assign({ write(value, key) {
+                try {
+                    process(value);
+                }
+                catch (e) {
+                    if (e !== NOT_SERIALIZABLE) {
+                        if (hasDebugInfoAttached === undefined)
+                            hasDebugInfoAttached = new WeakSet();
+                        if (!hasDebugInfoAttached.has(e)) {
+                            e.message += `\nwhile serializing ${stackToString(value)}`;
+                            hasDebugInfoAttached.add(e);
+                        }
+                    }
+                    throw e;
+                }
+            },
+            setCircularReference(ref) {
+                addReferenceable(ref);
+            },
+            snapshot() {
+                return {
+                    length: result.length,
+                    cycleStackSize: cycleStack.size,
+                    referenceableSize: referenceable.size,
+                    currentPos,
+                    objectTypeLookupSize: objectTypeLookup.size,
+                    currentPosTypeLookup,
+                };
+            },
+            rollback(snapshot) {
+                result.length = snapshot.length;
+                setSetSize(cycleStack, snapshot.cycleStackSize);
+                setMapSize(referenceable, snapshot.referenceableSize);
+                currentPos = snapshot.currentPos;
+                setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
+                currentPosTypeLookup = snapshot.currentPosTypeLookup;
+            } }, context);
+        this.extendContext(ctx);
+        const process = item => {
+            if (Buffer.isBuffer(item)) {
+                // check if we can emit a reference
+                const ref = referenceable.get(item);
+                if (ref !== undefined) {
+                    result.push(ESCAPE, ref - currentPos);
+                    return;
+                }
+                const alreadyUsedBuffer = dedupeBuffer(item);
+                if (alreadyUsedBuffer !== item) {
+                    const ref = referenceable.get(alreadyUsedBuffer);
+                    if (ref !== undefined) {
+                        referenceable.set(item, ref);
+                        result.push(ESCAPE, ref - currentPos);
+                        return;
+                    }
+                    item = alreadyUsedBuffer;
+                }
+                addReferenceable(item);
+                result.push(item);
+            }
+            else if (item === ESCAPE) {
+                result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
+            }
+            else if (typeof item === 'object'
+            // We don't have to check for null as ESCAPE is null and this has been checked before
+            ) {
+                // check if we can emit a reference
+                const ref = referenceable.get(item);
+                if (ref !== undefined) {
+                    result.push(ESCAPE, ref - currentPos);
+                    return;
+                }
+                if (cycleStack.has(item)) {
+                    throw new Error(`This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize.`);
+                }
+                const { request, name, serializer } = ObjectMiddleware.getSerializerFor(item);
+                const key = `${request}/${name}`;
+                const lastIndex = objectTypeLookup.get(key);
+                if (lastIndex === undefined) {
+                    objectTypeLookup.set(key, currentPosTypeLookup++);
+                    result.push(ESCAPE, request, name);
+                }
+                else {
+                    result.push(ESCAPE, currentPosTypeLookup - lastIndex);
+                }
+                cycleStack.add(item);
+                try {
+                    serializer.serialize(item, ctx);
+                }
+                finally {
+                    cycleStack.delete(item);
+                }
+                result.push(ESCAPE, ESCAPE_END_OBJECT);
+                addReferenceable(item);
+            }
+            else if (typeof item === 'string') {
+                if (item.length > 1) {
+                    // short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
+                    // check if we can emit a reference
+                    const ref = referenceable.get(item);
+                    if (ref !== undefined) {
+                        result.push(ESCAPE, ref - currentPos);
+                        return;
+                    }
+                    addReferenceable(item);
+                }
+                if (item.length > 102400 && context.logger) {
+                    context.logger.warn(`Serializing big strings (${Math.round(item.length / 1024)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`);
+                }
+                result.push(item);
+            }
+            else if (typeof item === 'function') {
+                if (!SerializerMiddleware_1.default.isLazy(item))
+                    throw new Error(`Unexpected function ${item}`);
+                const serializedData = SerializerMiddleware_1.default.getLazySerializedValue(item);
+                if (serializedData !== undefined) {
+                    if (typeof serializedData === 'function') {
+                        result.push(serializedData);
+                    }
+                    else {
+                        throw new Error('Not implemented');
+                    }
+                }
+                else if (SerializerMiddleware_1.default.isLazy(item, this)) {
+                    throw new Error('Not implemented');
+                }
+                else {
+                    const data = SerializerMiddleware_1.default.serializeLazy(item, data => this.serialize([data], context));
+                    SerializerMiddleware_1.default.setLazySerializedValue(item, data);
+                    result.push(data);
+                }
+            }
+            else if (item === undefined) {
+                result.push(ESCAPE, ESCAPE_UNDEFINED);
+            }
+            else {
+                result.push(item);
+            }
+        };
+        try {
+            for (const item of data) {
+                process(item);
+            }
+            return result;
+        }
+        catch (e) {
+            if (e === NOT_SERIALIZABLE)
+                return null;
+            throw e;
+        }
+        finally {
+            // Get rid of these references to avoid leaking memory
+            // This happens because the optimized code v8 generates
+            // is optimized for our "ctx.write" method so it will reference
+            // it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
+            data = undefined;
+            result = undefined;
+            referenceable = undefined;
+            bufferDedupeMap = undefined;
+            objectTypeLookup = undefined;
+            ctx = undefined;
+        }
+    }
+    deserialize(data, context) {
+        let currentDataPos = 0;
+        const read = () => {
+            if (currentDataPos >= data.length)
+                throw new Error('Unexpected end of stream');
+            return data[currentDataPos++];
+        };
+        if (read() !== CURRENT_VERSION)
+            throw new Error('Version mismatch, serializer changed');
+        let currentPos = 0;
+        let referenceable = [];
+        const addReferenceable = item => {
+            referenceable.push(item);
+            currentPos++;
+        };
+        let currentPosTypeLookup = 0;
+        let objectTypeLookup = [];
+        let result = [];
+        let ctx = Object.assign({ read() {
+                return decodeValue();
+            },
+            setCircularReference(ref) {
+                addReferenceable(ref);
+            } }, context);
+        this.extendContext(ctx);
+        const decodeValue = () => {
+            const item = read();
+            if (item === ESCAPE) {
+                const nextItem = read();
+                if (nextItem === ESCAPE_ESCAPE_VALUE) {
+                    return ESCAPE;
+                }
+                if (nextItem === ESCAPE_UNDEFINED) {
+                    return undefined;
+                }
+                if (nextItem === ESCAPE_END_OBJECT) {
+                    throw new Error(`Unexpected end of object at position ${currentDataPos - 1}`);
+                }
+                else {
+                    const request = nextItem;
+                    let serializer;
+                    if (typeof request === 'number') {
+                        if (request < 0) {
+                            // relative reference
+                            return referenceable[currentPos + request];
+                        }
+                        serializer = objectTypeLookup[currentPosTypeLookup - request];
+                    }
+                    else {
+                        if (typeof request !== 'string') {
+                            throw new Error(`Unexpected type (${typeof request}) of request ` +
+                                `at position ${currentDataPos - 1}`);
+                        }
+                        const name = read();
+                        serializer = ObjectMiddleware._getDeserializerForWithoutError(request, name);
+                        if (serializer === undefined) {
+                            if (request && !loadedRequests.has(request)) {
+                                let loaded = false;
+                                for (const [regExp, loader] of loaders) {
+                                    if (regExp.test(request)) {
+                                        if (loader(request)) {
+                                            loaded = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (!loaded) {
+                                    require(request);
+                                }
+                                loadedRequests.add(request);
+                            }
+                            serializer = ObjectMiddleware.getDeserializerFor(request, name);
+                        }
+                        objectTypeLookup.push(serializer);
+                        currentPosTypeLookup++;
+                    }
+                    try {
+                        const item = serializer.deserialize(ctx);
+                        const end1 = read();
+                        if (end1 !== ESCAPE) {
+                            throw new Error('Expected end of object');
+                        }
+                        const end2 = read();
+                        if (end2 !== ESCAPE_END_OBJECT) {
+                            throw new Error('Expected end of object');
+                        }
+                        addReferenceable(item);
+                        return item;
+                    }
+                    catch (err) {
+                        // As this is only for error handling, we omit creating a Map for
+                        // faster access to this information, as this would affect performance
+                        // in the good case
+                        let serializerEntry;
+                        for (const entry of serializers) {
+                            if (entry[1].serializer === serializer) {
+                                serializerEntry = entry;
+                                break;
+                            }
+                        }
+                        const name = !serializerEntry
+                            ? 'unknown'
+                            : !serializerEntry[1].request
+                                ? serializerEntry[0].name
+                                : serializerEntry[1].name
+                                    ? `${serializerEntry[1].request} ${serializerEntry[1].name}`
+                                    : serializerEntry[1].request;
+                        err.message += `\n(during deserialization of ${name})`;
+                        throw err;
+                    }
+                }
+            }
+            else if (typeof item === 'string') {
+                if (item.length > 1) {
+                    addReferenceable(item);
+                }
+                return item;
+            }
+            else if (Buffer.isBuffer(item)) {
+                addReferenceable(item);
+                return item;
+            }
+            else if (typeof item === 'function') {
+                return SerializerMiddleware_1.default.deserializeLazy(item, data => this.deserialize(data, context)[0]);
+            }
+            else {
+                return item;
+            }
+        };
+        try {
+            while (currentDataPos < data.length) {
+                result.push(decodeValue());
+            }
+            return result;
+        }
+        finally {
+            // Get rid of these references to avoid leaking memory
+            // This happens because the optimized code v8 generates
+            // is optimized for our "ctx.read" method so it will reference
+            // it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
+            result = undefined;
+            referenceable = undefined;
+            data = undefined;
+            objectTypeLookup = undefined;
+            ctx = undefined;
+        }
+    }
+}
+// @ts-ignore
+ObjectMiddleware.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
+exports.default = ObjectMiddleware;

package/dist/serialization/middlewares/SingleItemMiddleware.d.ts

@@ -0,0 +1,6 @@
+import SerializerMiddleware from '../SerializerMiddleware';
+declare class SingleItemMiddleware extends SerializerMiddleware {
+    serialize(data: any, context: any): any[];
+    deserialize(data: any, context: any): any;
+}
+export default SingleItemMiddleware;

package/dist/serialization/middlewares/SingleItemMiddleware.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SerializerMiddleware_1 = __importDefault(require("../SerializerMiddleware"));
+class SingleItemMiddleware extends SerializerMiddleware_1.default {
+    serialize(data, context) {
+        return [data];
+    }
+    deserialize(data, context) {
+        return data[0];
+    }
+}
+exports.default = SingleItemMiddleware;

package/dist/serialization/registerExternalSerializer.d.ts

@@ -0,0 +1 @@
+export {};