mongodb-livedata-server 0.1.3 → 0.1.4

package/dist/meteor/ejson/ejson.js

@@ -1,569 +1,568 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clone = exports.equals = exports.isBinary = exports.parse = exports.stringify = exports.fromJSONValue = exports._adjustTypesFromJSONValue = exports.toJSONValue = exports._adjustTypesToJSONValue = exports._getConverters = exports._getTypes = exports._isCustomType = exports.addType = void 0;
-const utils_1 = require("./utils");
-const stringify_1 = __importDefault(require("./stringify"));
-// Custom type interface definition
-/**
- * @class CustomType
- * @instanceName customType
- * @memberOf EJSON
- * @summary The interface that a class must satisfy to be able to become an
- * EJSON custom type via EJSON.addType.
- */
-/**
- * @function typeName
- * @memberOf EJSON.CustomType
- * @summary Return the tag used to identify this type.  This must match the
- *          tag used to register this type with
- *          [`EJSON.addType`](#ejson_add_type).
- * @locus Anywhere
- * @instance
- */
-/**
- * @function toJSONValue
- * @memberOf EJSON.CustomType
- * @summary Serialize this instance into a JSON-compatible value.
- * @locus Anywhere
- * @instance
- */
-/**
- * @function clone
- * @memberOf EJSON.CustomType
- * @summary Return a value `r` such that `this.equals(r)` is true, and
- *          modifications to `r` do not affect `this` and vice versa.
- * @locus Anywhere
- * @instance
- */
-/**
- * @function equals
- * @memberOf EJSON.CustomType
- * @summary Return `true` if `other` has a value equal to `this`; `false`
- *          otherwise.
- * @locus Anywhere
- * @param {Object} other Another object to compare this to.
- * @instance
- */
-const customTypes = new Map();
-// Add a custom type, using a method of your choice to get to and
-// from a basic JSON-able representation.  The factory argument
-// is a function of JSON-able --> your object
-// The type you add must have:
-// - A toJSONValue() method, so that Meteor can serialize it
-// - a typeName() method, to show how to look it up in our type table.
-// It is okay if these methods are monkey-patched on.
-// EJSON.clone will use toJSONValue and the given factory to produce
-// a clone, but you may specify a method clone() that will be
-// used instead.
-// Similarly, EJSON.equals will use toJSONValue to make comparisons,
-// but you may provide a method equals() instead.
-/**
- * @summary Add a custom datatype to EJSON.
- * @locus Anywhere
- * @param {String} name A tag for your custom type; must be unique among
- *                      custom data types defined in your project, and must
- *                      match the result of your type's `typeName` method.
- * @param {Function} factory A function that deserializes a JSON-compatible
- *                           value into an instance of your type.  This should
- *                           match the serialization performed by your
- *                           type's `toJSONValue` method.
- */
-function addType(name, factory) {
-    if (customTypes.has(name)) {
-        throw new Error(`Type ${name} already present`);
-    }
-    customTypes.set(name, factory);
-}
-exports.addType = addType;
-;
-const builtinConverters = [
-    {
-        matchJSONValue(obj) {
-            return (0, utils_1.hasOwn)(obj, '$date') && (0, utils_1.lengthOf)(obj) === 1;
-        },
-        matchObject(obj) {
-            return obj instanceof Date;
-        },
-        toJSONValue(obj) {
-            return { $date: obj.getTime() };
-        },
-        fromJSONValue(obj) {
-            return new Date(obj.$date);
-        },
-    },
-    {
-        matchJSONValue(obj) {
-            return (0, utils_1.hasOwn)(obj, '$regexp')
-                && (0, utils_1.hasOwn)(obj, '$flags')
-                && (0, utils_1.lengthOf)(obj) === 2;
-        },
-        matchObject(obj) {
-            return obj instanceof RegExp;
-        },
-        toJSONValue(regexp) {
-            return {
-                $regexp: regexp.source,
-                $flags: regexp.flags
-            };
-        },
-        fromJSONValue(obj) {
-            // Replaces duplicate / invalid flags.
-            return new RegExp(obj.$regexp, obj.$flags
-                // Cut off flags at 50 chars to avoid abusing RegExp for DOS.
-                .slice(0, 50)
-                .replace(/[^gimuy]/g, '')
-                .replace(/(.)(?=.*\1)/g, ''));
-        },
-    },
-    {
-        // which we match.)
-        matchJSONValue(obj) {
-            return (0, utils_1.hasOwn)(obj, '$InfNaN') && (0, utils_1.lengthOf)(obj) === 1;
-        },
-        matchObject: utils_1.isInfOrNaN,
-        toJSONValue(obj) {
-            let sign;
-            if (Number.isNaN(obj)) {
-                sign = 0;
-            }
-            else if (obj === Infinity) {
-                sign = 1;
-            }
-            else {
-                sign = -1;
-            }
-            return { $InfNaN: sign };
-        },
-        fromJSONValue(obj) {
-            return obj.$InfNaN / 0;
-        },
-    },
-    {
-        matchJSONValue(obj) {
-            return (0, utils_1.hasOwn)(obj, '$binary') && (0, utils_1.lengthOf)(obj) === 1;
-        },
-        matchObject(obj) {
-            return typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array
-                || (obj && (0, utils_1.hasOwn)(obj, '$Uint8ArrayPolyfill'));
-        },
-        toJSONValue(obj) {
-            return { $binary: Buffer.from(obj).toString("base64") };
-        },
-        fromJSONValue(obj) {
-            return Buffer.from(obj.$binary, "base64").toString();
-        },
-    },
-    {
-        matchJSONValue(obj) {
-            return (0, utils_1.hasOwn)(obj, '$escape') && (0, utils_1.lengthOf)(obj) === 1;
-        },
-        matchObject(obj) {
-            let match = false;
-            if (obj) {
-                const keyCount = (0, utils_1.lengthOf)(obj);
-                if (keyCount === 1 || keyCount === 2) {
-                    match =
-                        builtinConverters.some(converter => converter.matchJSONValue(obj));
-                }
-            }
-            return match;
-        },
-        toJSONValue(obj) {
-            const newObj = {};
-            (0, utils_1.keysOf)(obj).forEach(key => {
-                newObj[key] = toJSONValue(obj[key]);
-            });
-            return { $escape: newObj };
-        },
-        fromJSONValue(obj) {
-            const newObj = {};
-            (0, utils_1.keysOf)(obj.$escape).forEach(key => {
-                newObj[key] = fromJSONValue(obj.$escape[key]);
-            });
-            return newObj;
-        },
-    },
-    {
-        matchJSONValue(obj) {
-            return (0, utils_1.hasOwn)(obj, '$type')
-                && (0, utils_1.hasOwn)(obj, '$value') && (0, utils_1.lengthOf)(obj) === 2;
-        },
-        matchObject(obj) {
-            return _isCustomType(obj);
-        },
-        toJSONValue(obj) {
-            const jsonValue = obj.toJSONValue();
-            return { $type: obj.typeName(), $value: jsonValue };
-        },
-        fromJSONValue(obj) {
-            const typeName = obj.$type;
-            if (!customTypes.has(typeName)) {
-                throw new Error(`Custom EJSON type ${typeName} is not defined`);
-            }
-            const converter = customTypes.get(typeName);
-            return converter(obj.$value);
-        },
-    },
-];
-function _isCustomType(obj) {
-    return obj &&
-        (0, utils_1.isFunction)(obj.toJSONValue) &&
-        (0, utils_1.isFunction)(obj.typeName) &&
-        customTypes.has(obj.typeName());
-}
-exports._isCustomType = _isCustomType;
-function _getTypes(isOriginal = false) { return (isOriginal ? customTypes : (0, utils_1.convertMapToObject)(customTypes)); }
-exports._getTypes = _getTypes;
-function _getConverters() { return builtinConverters; }
-exports._getConverters = _getConverters;
-// Either return the JSON-compatible version of the argument, or undefined (if
-// the item isn't itself replaceable, but maybe some fields in it are)
-const toJSONValueHelper = item => {
-    for (let i = 0; i < builtinConverters.length; i++) {
-        const converter = builtinConverters[i];
-        if (converter.matchObject(item)) {
-            return converter.toJSONValue(item);
-        }
-    }
-    return undefined;
-};
-// for both arrays and objects, in-place modification.
-function _adjustTypesToJSONValue(obj) {
-    // Is it an atom that we need to adjust?
-    if (obj === null) {
-        return null;
-    }
-    const maybeChanged = toJSONValueHelper(obj);
-    if (maybeChanged !== undefined) {
-        return maybeChanged;
-    }
-    // Other atoms are unchanged.
-    if (!(0, utils_1.isObject)(obj)) {
-        return obj;
-    }
-    // Iterate over array or object structure.
-    (0, utils_1.keysOf)(obj).forEach(key => {
-        const value = obj[key];
-        if (!(0, utils_1.isObject)(value) && value !== undefined &&
-            !(0, utils_1.isInfOrNaN)(value)) {
-            return; // continue
-        }
-        const changed = toJSONValueHelper(value);
-        if (changed) {
-            obj[key] = changed;
-            return; // on to the next key
-        }
-        // if we get here, value is an object but not adjustable
-        // at this level.  recurse.
-        _adjustTypesToJSONValue(value);
-    });
-    return obj;
-}
-exports._adjustTypesToJSONValue = _adjustTypesToJSONValue;
-;
-/**
- * @summary Serialize an EJSON-compatible value into its plain JSON
- *          representation.
- * @locus Anywhere
- * @param {EJSON} val A value to serialize to plain JSON.
- */
-function toJSONValue(item) {
-    const changed = toJSONValueHelper(item);
-    if (changed !== undefined) {
-        return changed;
-    }
-    let newItem = item;
-    if ((0, utils_1.isObject)(item)) {
-        newItem = clone(item);
-        _adjustTypesToJSONValue(newItem);
-    }
-    return newItem;
-}
-exports.toJSONValue = toJSONValue;
-;
-// Either return the argument changed to have the non-json
-// rep of itself (the Object version) or the argument itself.
-// DOES NOT RECURSE.  For actually getting the fully-changed value, use
-// EJSON.fromJSONValue
-const fromJSONValueHelper = value => {
-    if ((0, utils_1.isObject)(value) && value !== null) {
-        const keys = (0, utils_1.keysOf)(value);
-        if (keys.length <= 2
-            && keys.every(k => typeof k === 'string' && k.substr(0, 1) === '$')) {
-            for (let i = 0; i < builtinConverters.length; i++) {
-                const converter = builtinConverters[i];
-                if (converter.matchJSONValue(value)) {
-                    return converter.fromJSONValue(value);
-                }
-            }
-        }
-    }
-    return value;
-};
-// for both arrays and objects. Tries its best to just
-// use the object you hand it, but may return something
-// different if the object you hand it itself needs changing.
-function _adjustTypesFromJSONValue(obj) {
-    if (obj === null) {
-        return null;
-    }
-    const maybeChanged = fromJSONValueHelper(obj);
-    if (maybeChanged !== obj) {
-        return maybeChanged;
-    }
-    // Other atoms are unchanged.
-    if (!(0, utils_1.isObject)(obj)) {
-        return obj;
-    }
-    (0, utils_1.keysOf)(obj).forEach(key => {
-        const value = obj[key];
-        if ((0, utils_1.isObject)(value)) {
-            const changed = fromJSONValueHelper(value);
-            if (value !== changed) {
-                obj[key] = changed;
-                return;
-            }
-            // if we get here, value is an object but not adjustable
-            // at this level.  recurse.
-            _adjustTypesFromJSONValue(value);
-        }
-    });
-    return obj;
-}
-exports._adjustTypesFromJSONValue = _adjustTypesFromJSONValue;
-;
-/**
- * @summary Deserialize an EJSON value from its plain JSON representation.
- * @locus Anywhere
- * @param {JSONCompatible} val A value to deserialize into EJSON.
- */
-function fromJSONValue(item) {
-    let changed = fromJSONValueHelper(item);
-    if (changed === item && (0, utils_1.isObject)(item)) {
-        changed = clone(item);
-        _adjustTypesFromJSONValue(changed);
-    }
-    return changed;
-}
-exports.fromJSONValue = fromJSONValue;
-;
-/**
- * @summary Serialize a value to a string. For EJSON values, the serialization
- *          fully represents the value. For non-EJSON values, serializes the
- *          same way as `JSON.stringify`.
- * @locus Anywhere
- * @param {EJSON} val A value to stringify.
- * @param {Object} [options]
- * @param {Boolean | Integer | String} options.indent Indents objects and
- * arrays for easy readability.  When `true`, indents by 2 spaces; when an
- * integer, indents by that number of spaces; and when a string, uses the
- * string as the indentation pattern.
- * @param {Boolean} options.canonical When `true`, stringifies keys in an
- *                                    object in sorted order.
- */
-function stringify(val, opts) {
-    return (0, utils_1.handleError)((item, options) => {
-        let serialized;
-        const json = toJSONValue(item);
-        if (options && (options.canonical || options.indent)) {
-            serialized = (0, stringify_1.default)(json, options);
-        }
-        else {
-            serialized = JSON.stringify(json);
-        }
-        return serialized;
-    }, val, opts);
-}
-exports.stringify = stringify;
-/**
- * @summary Parse a string into an EJSON value. Throws an error if the string
- *          is not valid EJSON.
- * @locus Anywhere
- * @param {String} str A string to parse into an EJSON value.
- */
-function parse(item) {
-    if (typeof item !== 'string') {
-        throw new Error('EJSON.parse argument should be a string');
-    }
-    return fromJSONValue(JSON.parse(item));
-}
-exports.parse = parse;
-;
-/**
- * @summary Returns true if `x` is a buffer of binary data, as returned from
- *          [`EJSON.newBinary`](#ejson_new_binary).
- * @param {Object} x The variable to check.
- * @locus Anywhere
- */
-function isBinary(obj) {
-    return !!((typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array) ||
-        (obj && obj.$Uint8ArrayPolyfill));
-}
-exports.isBinary = isBinary;
-;
-/**
- * @summary Return true if `a` and `b` are equal to each other.  Return false
- *          otherwise.  Uses the `equals` method on `a` if present, otherwise
- *          performs a deep comparison.
- * @locus Anywhere
- * @param {EJSON} a
- * @param {EJSON} b
- * @param {Object} [options]
- * @param {Boolean} options.keyOrderSensitive Compare in key sensitive order,
- * if supported by the JavaScript implementation.  For example, `{a: 1, b: 2}`
- * is equal to `{b: 2, a: 1}` only when `keyOrderSensitive` is `false`.  The
- * default is `false`.
- */
-function equals(a, b, options) {
-    let i;
-    const keyOrderSensitive = !!(options && options.keyOrderSensitive);
-    if (a === b) {
-        return true;
-    }
-    // This differs from the IEEE spec for NaN equality, b/c we don't want
-    // anything ever with a NaN to be poisoned from becoming equal to anything.
-    if (Number.isNaN(a) && Number.isNaN(b)) {
-        return true;
-    }
-    // if either one is falsy, they'd have to be === to be equal
-    if (!a || !b) {
-        return false;
-    }
-    if (!((0, utils_1.isObject)(a) && (0, utils_1.isObject)(b))) {
-        return false;
-    }
-    if (a instanceof Date && b instanceof Date) {
-        return a.valueOf() === b.valueOf();
-    }
-    if (isBinary(a) && isBinary(b)) {
-        if (a.length !== b.length) {
-            return false;
-        }
-        for (i = 0; i < a.length; i++) {
-            if (a[i] !== b[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if ((0, utils_1.isFunction)(a.equals)) {
-        return a.equals(b, options);
-    }
-    if ((0, utils_1.isFunction)(b.equals)) {
-        return b.equals(a, options);
-    }
-    // Array.isArray works across iframes while instanceof won't
-    const aIsArray = Array.isArray(a);
-    const bIsArray = Array.isArray(b);
-    // if not both or none are array they are not equal
-    if (aIsArray !== bIsArray) {
-        return false;
-    }
-    if (aIsArray && bIsArray) {
-        if (a.length !== b.length) {
-            return false;
-        }
-        for (i = 0; i < a.length; i++) {
-            if (!equals(a[i], b[i], options)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    // fallback for custom types that don't implement their own equals
-    switch (+_isCustomType(a) + +_isCustomType(b)) {
-        case 1: return false;
-        case 2: return equals(toJSONValue(a), toJSONValue(b));
-        default: // Do nothing
-    }
-    // fall back to structural equality of objects
-    let ret;
-    const aKeys = (0, utils_1.keysOf)(a);
-    const bKeys = (0, utils_1.keysOf)(b);
-    if (keyOrderSensitive) {
-        i = 0;
-        ret = aKeys.every(key => {
-            if (i >= bKeys.length) {
-                return false;
-            }
-            if (key !== bKeys[i]) {
-                return false;
-            }
-            if (!equals(a[key], b[bKeys[i]], options)) {
-                return false;
-            }
-            i++;
-            return true;
-        });
-    }
-    else {
-        i = 0;
-        ret = aKeys.every(key => {
-            if (!(0, utils_1.hasOwn)(b, key)) {
-                return false;
-            }
-            if (!equals(a[key], b[key], options)) {
-                return false;
-            }
-            i++;
-            return true;
-        });
-    }
-    return ret && i === bKeys.length;
-}
-exports.equals = equals;
-;
-/**
- * @summary Return a deep copy of `val`.
- * @locus Anywhere
- * @param {EJSON} val A value to copy.
- */
-function clone(v) {
-    let ret;
-    if (!(0, utils_1.isObject)(v)) {
-        return v;
-    }
-    if (v === null) {
-        return null; // null has typeof "object"
-    }
-    if (v instanceof Date) {
-        return new Date(v.getTime());
-    }
-    // RegExps are not really EJSON elements (eg we don't define a serialization
-    // for them), but they're immutable anyway, so we can support them in clone.
-    if (v instanceof RegExp) {
-        return v;
-    }
-    if (isBinary(v)) {
-        ret = new Uint8Array(v.length);
-        for (let i = 0; i < v.length; i++) {
-            ret[i] = v[i];
-        }
-        return ret;
-    }
-    if (Array.isArray(v)) {
-        return v.map(clone);
-    }
-    if ((0, utils_1.isArguments)(v)) {
-        return Array.from(v).map(clone);
-    }
-    // handle general user-defined typed Objects if they have a clone method
-    if ("clone" in v && (0, utils_1.isFunction)(v.clone)) {
-        return v.clone();
-    }
-    // handle other custom types
-    if (_isCustomType(v)) {
-        return fromJSONValue(clone(toJSONValue(v)));
-    }
-    // handle other objects
-    ret = {};
-    (0, utils_1.keysOf)(v).forEach((key) => {
-        ret[key] = clone(v[key]);
-    });
-    return ret;
-}
-exports.clone = clone;
-;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addType = addType;
+exports._isCustomType = _isCustomType;
+exports._getTypes = _getTypes;
+exports._getConverters = _getConverters;
+exports._adjustTypesToJSONValue = _adjustTypesToJSONValue;
+exports.toJSONValue = toJSONValue;
+exports._adjustTypesFromJSONValue = _adjustTypesFromJSONValue;
+exports.fromJSONValue = fromJSONValue;
+exports.stringify = stringify;
+exports.parse = parse;
+exports.isBinary = isBinary;
+exports.equals = equals;
+exports.clone = clone;
+const utils_1 = require("./utils");
+const stringify_1 = __importDefault(require("./stringify"));
+// Custom type interface definition
+/**
+ * @class CustomType
+ * @instanceName customType
+ * @memberOf EJSON
+ * @summary The interface that a class must satisfy to be able to become an
+ * EJSON custom type via EJSON.addType.
+ */
+/**
+ * @function typeName
+ * @memberOf EJSON.CustomType
+ * @summary Return the tag used to identify this type.  This must match the
+ *          tag used to register this type with
+ *          [`EJSON.addType`](#ejson_add_type).
+ * @locus Anywhere
+ * @instance
+ */
+/**
+ * @function toJSONValue
+ * @memberOf EJSON.CustomType
+ * @summary Serialize this instance into a JSON-compatible value.
+ * @locus Anywhere
+ * @instance
+ */
+/**
+ * @function clone
+ * @memberOf EJSON.CustomType
+ * @summary Return a value `r` such that `this.equals(r)` is true, and
+ *          modifications to `r` do not affect `this` and vice versa.
+ * @locus Anywhere
+ * @instance
+ */
+/**
+ * @function equals
+ * @memberOf EJSON.CustomType
+ * @summary Return `true` if `other` has a value equal to `this`; `false`
+ *          otherwise.
+ * @locus Anywhere
+ * @param {Object} other Another object to compare this to.
+ * @instance
+ */
+const customTypes = new Map();
+// Add a custom type, using a method of your choice to get to and
+// from a basic JSON-able representation.  The factory argument
+// is a function of JSON-able --> your object
+// The type you add must have:
+// - A toJSONValue() method, so that Meteor can serialize it
+// - a typeName() method, to show how to look it up in our type table.
+// It is okay if these methods are monkey-patched on.
+// EJSON.clone will use toJSONValue and the given factory to produce
+// a clone, but you may specify a method clone() that will be
+// used instead.
+// Similarly, EJSON.equals will use toJSONValue to make comparisons,
+// but you may provide a method equals() instead.
+/**
+ * @summary Add a custom datatype to EJSON.
+ * @locus Anywhere
+ * @param {String} name A tag for your custom type; must be unique among
+ *                      custom data types defined in your project, and must
+ *                      match the result of your type's `typeName` method.
+ * @param {Function} factory A function that deserializes a JSON-compatible
+ *                           value into an instance of your type.  This should
+ *                           match the serialization performed by your
+ *                           type's `toJSONValue` method.
+ */
+function addType(name, factory) {
+    if (customTypes.has(name)) {
+        throw new Error(`Type ${name} already present`);
+    }
+    customTypes.set(name, factory);
+}
+;
+const builtinConverters = [
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$date') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject(obj) {
+            return obj instanceof Date;
+        },
+        toJSONValue(obj) {
+            return { $date: obj.getTime() };
+        },
+        fromJSONValue(obj) {
+            return new Date(obj.$date);
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$regexp')
+                && (0, utils_1.hasOwn)(obj, '$flags')
+                && (0, utils_1.lengthOf)(obj) === 2;
+        },
+        matchObject(obj) {
+            return obj instanceof RegExp;
+        },
+        toJSONValue(regexp) {
+            return {
+                $regexp: regexp.source,
+                $flags: regexp.flags
+            };
+        },
+        fromJSONValue(obj) {
+            // Replaces duplicate / invalid flags.
+            return new RegExp(obj.$regexp, obj.$flags
+                // Cut off flags at 50 chars to avoid abusing RegExp for DOS.
+                .slice(0, 50)
+                .replace(/[^gimuy]/g, '')
+                .replace(/(.)(?=.*\1)/g, ''));
+        },
+    },
+    {
+        // which we match.)
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$InfNaN') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject: utils_1.isInfOrNaN,
+        toJSONValue(obj) {
+            let sign;
+            if (Number.isNaN(obj)) {
+                sign = 0;
+            }
+            else if (obj === Infinity) {
+                sign = 1;
+            }
+            else {
+                sign = -1;
+            }
+            return { $InfNaN: sign };
+        },
+        fromJSONValue(obj) {
+            return obj.$InfNaN / 0;
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$binary') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject(obj) {
+            return typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array
+                || (obj && (0, utils_1.hasOwn)(obj, '$Uint8ArrayPolyfill'));
+        },
+        toJSONValue(obj) {
+            return { $binary: Buffer.from(obj).toString("base64") };
+        },
+        fromJSONValue(obj) {
+            return Buffer.from(obj.$binary, "base64").toString();
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$escape') && (0, utils_1.lengthOf)(obj) === 1;
+        },
+        matchObject(obj) {
+            let match = false;
+            if (obj) {
+                const keyCount = (0, utils_1.lengthOf)(obj);
+                if (keyCount === 1 || keyCount === 2) {
+                    match =
+                        builtinConverters.some(converter => converter.matchJSONValue(obj));
+                }
+            }
+            return match;
+        },
+        toJSONValue(obj) {
+            const newObj = {};
+            (0, utils_1.keysOf)(obj).forEach(key => {
+                newObj[key] = toJSONValue(obj[key]);
+            });
+            return { $escape: newObj };
+        },
+        fromJSONValue(obj) {
+            const newObj = {};
+            (0, utils_1.keysOf)(obj.$escape).forEach(key => {
+                newObj[key] = fromJSONValue(obj.$escape[key]);
+            });
+            return newObj;
+        },
+    },
+    {
+        matchJSONValue(obj) {
+            return (0, utils_1.hasOwn)(obj, '$type')
+                && (0, utils_1.hasOwn)(obj, '$value') && (0, utils_1.lengthOf)(obj) === 2;
+        },
+        matchObject(obj) {
+            return _isCustomType(obj);
+        },
+        toJSONValue(obj) {
+            const jsonValue = obj.toJSONValue();
+            return { $type: obj.typeName(), $value: jsonValue };
+        },
+        fromJSONValue(obj) {
+            const typeName = obj.$type;
+            if (!customTypes.has(typeName)) {
+                throw new Error(`Custom EJSON type ${typeName} is not defined`);
+            }
+            const converter = customTypes.get(typeName);
+            return converter(obj.$value);
+        },
+    },
+];
+function _isCustomType(obj) {
+    return obj &&
+        (0, utils_1.isFunction)(obj.toJSONValue) &&
+        (0, utils_1.isFunction)(obj.typeName) &&
+        customTypes.has(obj.typeName());
+}
+function _getTypes(isOriginal = false) { return (isOriginal ? customTypes : (0, utils_1.convertMapToObject)(customTypes)); }
+function _getConverters() { return builtinConverters; }
+// Either return the JSON-compatible version of the argument, or undefined (if
+// the item isn't itself replaceable, but maybe some fields in it are)
+const toJSONValueHelper = item => {
+    for (let i = 0; i < builtinConverters.length; i++) {
+        const converter = builtinConverters[i];
+        if (converter.matchObject(item)) {
+            return converter.toJSONValue(item);
+        }
+    }
+    return undefined;
+};
+// for both arrays and objects, in-place modification.
+function _adjustTypesToJSONValue(obj) {
+    // Is it an atom that we need to adjust?
+    if (obj === null) {
+        return null;
+    }
+    const maybeChanged = toJSONValueHelper(obj);
+    if (maybeChanged !== undefined) {
+        return maybeChanged;
+    }
+    // Other atoms are unchanged.
+    if (!(0, utils_1.isObject)(obj)) {
+        return obj;
+    }
+    // Iterate over array or object structure.
+    (0, utils_1.keysOf)(obj).forEach(key => {
+        const value = obj[key];
+        if (!(0, utils_1.isObject)(value) && value !== undefined &&
+            !(0, utils_1.isInfOrNaN)(value)) {
+            return; // continue
+        }
+        const changed = toJSONValueHelper(value);
+        if (changed) {
+            obj[key] = changed;
+            return; // on to the next key
+        }
+        // if we get here, value is an object but not adjustable
+        // at this level.  recurse.
+        _adjustTypesToJSONValue(value);
+    });
+    return obj;
+}
+;
+/**
+ * @summary Serialize an EJSON-compatible value into its plain JSON
+ *          representation.
+ * @locus Anywhere
+ * @param {EJSON} val A value to serialize to plain JSON.
+ */
+function toJSONValue(item) {
+    const changed = toJSONValueHelper(item);
+    if (changed !== undefined) {
+        return changed;
+    }
+    let newItem = item;
+    if ((0, utils_1.isObject)(item)) {
+        newItem = clone(item);
+        _adjustTypesToJSONValue(newItem);
+    }
+    return newItem;
+}
+;
+// Either return the argument changed to have the non-json
+// rep of itself (the Object version) or the argument itself.
+// DOES NOT RECURSE.  For actually getting the fully-changed value, use
+// EJSON.fromJSONValue
+const fromJSONValueHelper = value => {
+    if ((0, utils_1.isObject)(value) && value !== null) {
+        const keys = (0, utils_1.keysOf)(value);
+        if (keys.length <= 2
+            && keys.every(k => typeof k === 'string' && k.substr(0, 1) === '$')) {
+            for (let i = 0; i < builtinConverters.length; i++) {
+                const converter = builtinConverters[i];
+                if (converter.matchJSONValue(value)) {
+                    return converter.fromJSONValue(value);
+                }
+            }
+        }
+    }
+    return value;
+};
+// for both arrays and objects. Tries its best to just
+// use the object you hand it, but may return something
+// different if the object you hand it itself needs changing.
+function _adjustTypesFromJSONValue(obj) {
+    if (obj === null) {
+        return null;
+    }
+    const maybeChanged = fromJSONValueHelper(obj);
+    if (maybeChanged !== obj) {
+        return maybeChanged;
+    }
+    // Other atoms are unchanged.
+    if (!(0, utils_1.isObject)(obj)) {
+        return obj;
+    }
+    (0, utils_1.keysOf)(obj).forEach(key => {
+        const value = obj[key];
+        if ((0, utils_1.isObject)(value)) {
+            const changed = fromJSONValueHelper(value);
+            if (value !== changed) {
+                obj[key] = changed;
+                return;
+            }
+            // if we get here, value is an object but not adjustable
+            // at this level.  recurse.
+            _adjustTypesFromJSONValue(value);
+        }
+    });
+    return obj;
+}
+;
+/**
+ * @summary Deserialize an EJSON value from its plain JSON representation.
+ * @locus Anywhere
+ * @param {JSONCompatible} val A value to deserialize into EJSON.
+ */
+function fromJSONValue(item) {
+    let changed = fromJSONValueHelper(item);
+    if (changed === item && (0, utils_1.isObject)(item)) {
+        changed = clone(item);
+        _adjustTypesFromJSONValue(changed);
+    }
+    return changed;
+}
+;
+/**
+ * @summary Serialize a value to a string. For EJSON values, the serialization
+ *          fully represents the value. For non-EJSON values, serializes the
+ *          same way as `JSON.stringify`.
+ * @locus Anywhere
+ * @param {EJSON} val A value to stringify.
+ * @param {Object} [options]
+ * @param {Boolean | Integer | String} options.indent Indents objects and
+ * arrays for easy readability.  When `true`, indents by 2 spaces; when an
+ * integer, indents by that number of spaces; and when a string, uses the
+ * string as the indentation pattern.
+ * @param {Boolean} options.canonical When `true`, stringifies keys in an
+ *                                    object in sorted order.
+ */
+function stringify(val, opts) {
+    return (0, utils_1.handleError)((item, options) => {
+        let serialized;
+        const json = toJSONValue(item);
+        if (options && (options.canonical || options.indent)) {
+            serialized = (0, stringify_1.default)(json, options);
+        }
+        else {
+            serialized = JSON.stringify(json);
+        }
+        return serialized;
+    }, val, opts);
+}
+/**
+ * @summary Parse a string into an EJSON value. Throws an error if the string
+ *          is not valid EJSON.
+ * @locus Anywhere
+ * @param {String} str A string to parse into an EJSON value.
+ */
+function parse(item) {
+    if (typeof item !== 'string') {
+        throw new Error('EJSON.parse argument should be a string');
+    }
+    return fromJSONValue(JSON.parse(item));
+}
+;
+/**
+ * @summary Returns true if `x` is a buffer of binary data, as returned from
+ *          [`EJSON.newBinary`](#ejson_new_binary).
+ * @param {Object} x The variable to check.
+ * @locus Anywhere
+ */
+function isBinary(obj) {
+    return !!((typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array) ||
+        (obj && obj.$Uint8ArrayPolyfill));
+}
+;
+/**
+ * @summary Return true if `a` and `b` are equal to each other.  Return false
+ *          otherwise.  Uses the `equals` method on `a` if present, otherwise
+ *          performs a deep comparison.
+ * @locus Anywhere
+ * @param {EJSON} a
+ * @param {EJSON} b
+ * @param {Object} [options]
+ * @param {Boolean} options.keyOrderSensitive Compare in key sensitive order,
+ * if supported by the JavaScript implementation.  For example, `{a: 1, b: 2}`
+ * is equal to `{b: 2, a: 1}` only when `keyOrderSensitive` is `false`.  The
+ * default is `false`.
+ */
+function equals(a, b, options) {
+    let i;
+    const keyOrderSensitive = !!(options && options.keyOrderSensitive);
+    if (a === b) {
+        return true;
+    }
+    // This differs from the IEEE spec for NaN equality, b/c we don't want
+    // anything ever with a NaN to be poisoned from becoming equal to anything.
+    if (Number.isNaN(a) && Number.isNaN(b)) {
+        return true;
+    }
+    // if either one is falsy, they'd have to be === to be equal
+    if (!a || !b) {
+        return false;
+    }
+    if (!((0, utils_1.isObject)(a) && (0, utils_1.isObject)(b))) {
+        return false;
+    }
+    if (a instanceof Date && b instanceof Date) {
+        return a.valueOf() === b.valueOf();
+    }
+    if (isBinary(a) && isBinary(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if ((0, utils_1.isFunction)(a.equals)) {
+        return a.equals(b, options);
+    }
+    if ((0, utils_1.isFunction)(b.equals)) {
+        return b.equals(a, options);
+    }
+    // Array.isArray works across iframes while instanceof won't
+    const aIsArray = Array.isArray(a);
+    const bIsArray = Array.isArray(b);
+    // if not both or none are array they are not equal
+    if (aIsArray !== bIsArray) {
+        return false;
+    }
+    if (aIsArray && bIsArray) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (i = 0; i < a.length; i++) {
+            if (!equals(a[i], b[i], options)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // fallback for custom types that don't implement their own equals
+    switch (+_isCustomType(a) + +_isCustomType(b)) {
+        case 1: return false;
+        case 2: return equals(toJSONValue(a), toJSONValue(b));
+        default: // Do nothing
+    }
+    // fall back to structural equality of objects
+    let ret;
+    const aKeys = (0, utils_1.keysOf)(a);
+    const bKeys = (0, utils_1.keysOf)(b);
+    if (keyOrderSensitive) {
+        i = 0;
+        ret = aKeys.every(key => {
+            if (i >= bKeys.length) {
+                return false;
+            }
+            if (key !== bKeys[i]) {
+                return false;
+            }
+            if (!equals(a[key], b[bKeys[i]], options)) {
+                return false;
+            }
+            i++;
+            return true;
+        });
+    }
+    else {
+        i = 0;
+        ret = aKeys.every(key => {
+            if (!(0, utils_1.hasOwn)(b, key)) {
+                return false;
+            }
+            if (!equals(a[key], b[key], options)) {
+                return false;
+            }
+            i++;
+            return true;
+        });
+    }
+    return ret && i === bKeys.length;
+}
+;
+/**
+ * @summary Return a deep copy of `val`.
+ * @locus Anywhere
+ * @param {EJSON} val A value to copy.
+ */
+function clone(v) {
+    let ret;
+    if (!(0, utils_1.isObject)(v)) {
+        return v;
+    }
+    if (v === null) {
+        return null; // null has typeof "object"
+    }
+    if (v instanceof Date) {
+        return new Date(v.getTime());
+    }
+    // RegExps are not really EJSON elements (eg we don't define a serialization
+    // for them), but they're immutable anyway, so we can support them in clone.
+    if (v instanceof RegExp) {
+        return v;
+    }
+    if (isBinary(v)) {
+        ret = new Uint8Array(v.length);
+        for (let i = 0; i < v.length; i++) {
+            ret[i] = v[i];
+        }
+        return ret;
+    }
+    if (Array.isArray(v)) {
+        return v.map(clone);
+    }
+    if ((0, utils_1.isArguments)(v)) {
+        return Array.from(v).map(clone);
+    }
+    // handle general user-defined typed Objects if they have a clone method
+    if ("clone" in v && (0, utils_1.isFunction)(v.clone)) {
+        return v.clone();
+    }
+    // handle other custom types
+    if (_isCustomType(v)) {
+        return fromJSONValue(clone(toJSONValue(v)));
+    }
+    // handle other objects
+    ret = {};
+    (0, utils_1.keysOf)(v).forEach((key) => {
+        ret[key] = clone(v[key]);
+    });
+    return ret;
+}
+;