/**
     * A utility for safely converting an object a `DataEntity`.
     * This will detect if passed an already converted input and return it.
     *
     * NOTE: `DataEntity.make` is different from using `new DataEntity`
     * because it attaching it doesn't shallow cloning the object
     * onto the `DataEntity` instance, this is significatly faster and so it
     * is recommended to use this in production.
    */
    static make(input: DataInput, metadata?: object): DataEntity {
        if (input == null) return new DataEntity({});
        if (DataEntity.isDataEntity(input)) return input;
        if (!isPlainObject(input)) {
            throw new Error(`Invalid data source, must be an object, got "${kindOf(input)}"`);
        }

        Object.defineProperties(input, {
            getMetadata: {
                value(key?: string) {
                    return getMetadata(this, key);
                },
                enumerable: false,
                writable: false
            },
            setMetadata: {
                value(key: string, value: any) {
                    return setMetadata(this, key, value);
                },
                enumerable: false,
                writable: false
            },
            toBuffer: {
                value(opConfig: EncodingConfig = {}) {
                    return toBuffer(this, opConfig);
                },
                enumerable: false,
                writable: false
            }
        });

        const entity = input as DataEntity;
        _metadata.set(entity, Object.assign({ createdAt: Date.now() }, metadata));
        return entity as DataEntity;
    }

export function parseJSON<T = object>(buf: Buffer|string): T {
    if (!Buffer.isBuffer(buf) && !isString(buf)) {
        throw new TypeError(`Failure to serialize non-buffer, got "${kindOf(buf)}"`);
    }

    try {
        // @ts-ignore because it does work with buffers
        return JSON.parse(buf);
    } catch (err) {
        throw new Error(`Failure to parse buffer, ${toString(err)}`);
    }
}

    constructor(data: object, metadata?: object) {
        _metadata.set(this, fastAssign({ createdAt: Date.now() }, metadata));

        if (data == null) return;

        if (DataEntity.isDataEntity(data)) return data;

        if (!isPlainObject(data)) {
            throw new Error(`Invalid data source, must be an object, got "${kindOf(data)}"`);
        }

        fastAssign(this, data);
    }

function sampleFunction() {
    kindOf(arguments);
    // => 'arguments'
}