@opra/common 0.33.13 → 1.0.0-alpha.10

package/cjs/filter/filter-rules.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterRules = void 0;
+const index_js_1 = require("../exception/index.js");
+const index_js_2 = require("../filter/index.js");
+const index_js_3 = require("../helpers/index.js");
+const index_js_4 = require("../i18n/index.js");
+class FilterRules {
+    constructor(rules, options) {
+        this._rules = new index_js_3.ResponsiveMap();
+        Object.defineProperty(this, '_rules', {
+            value: new index_js_3.ResponsiveMap(null, { caseSensitive: options?.caseSensitive }),
+            enumerable: false,
+        });
+        if (rules) {
+            for (const [k, v] of Object.entries(rules)) {
+                this.set(k, v);
+            }
+        }
+    }
+    set(fieldName, options) {
+        const operators = typeof options?.operators === 'string'
+            ? options.operators.split(/\s*[,| ]\s*/)
+            : options?.operators;
+        this._rules.set(fieldName, (0, index_js_3.omitUndefined)({
+            ...options,
+            operators,
+        }));
+    }
+    normalizeFilter(filter, dataType) {
+        if (!filter)
+            return;
+        const ast = typeof filter === 'string' ? index_js_2.OpraFilter.parse(filter) : filter;
+        if (ast instanceof index_js_2.OpraFilter.ComparisonExpression) {
+            this.normalizeFilter(ast.left, dataType);
+            if (!(ast.left instanceof index_js_2.OpraFilter.QualifiedIdentifier && ast.left.field)) {
+                throw new TypeError(`Invalid filter query. Left side should be a data field.`);
+            }
+            // Check if filtering accepted for given field
+            // const findManyOp = this.getOperation('findMany');
+            const rule = this._rules.get(ast.left.value);
+            if (!rule) {
+                throw new index_js_1.OpraException({
+                    message: (0, index_js_4.translate)('error:UNACCEPTED_FILTER_FIELD', { field: ast.left.value }),
+                    code: 'UNACCEPTED_FILTER_FIELD',
+                    details: {
+                        field: ast.left.value,
+                    },
+                });
+            }
+            // Check if filtering endpoint accepted for given field
+            if (rule.operators && !rule.operators.includes(ast.op)) {
+                throw new index_js_1.OpraException({
+                    message: (0, index_js_4.translate)('error:UNACCEPTED_FILTER_OPERATION', { field: ast.left.value }),
+                    code: 'UNACCEPTED_FILTER_OPERATION',
+                    details: {
+                        field: ast.left.value,
+                        operator: ast.op,
+                    },
+                });
+            }
+            this.normalizeFilter(ast.right, dataType);
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.LogicalExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.ArithmeticExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item.expression, dataType));
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.ArrayExpression) {
+            ast.items.forEach(item => this.normalizeFilter(item, dataType));
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.ParenthesizedExpression) {
+            this.normalizeFilter(ast.expression, dataType);
+            return ast;
+        }
+        if (ast instanceof index_js_2.OpraFilter.QualifiedIdentifier && dataType) {
+            ast.value = dataType.normalizeFieldPath(ast.value);
+            ast.field = dataType.getField(ast.value);
+            ast.dataType = ast.field.type;
+        }
+        return ast;
+    }
+    toJSON() {
+        return this._rules.toObject();
+    }
+    [Symbol.iterator]() {
+        return this._rules.entries();
+    }
+}
+exports.FilterRules = FilterRules;

package/cjs/filter/filter-tree-visitor.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterTreeVisitor = void 0;
-const tslib_1 = require("tslib");
-const antlr4_1 = tslib_1.__importDefault(require("@browsery/antlr4"));
+const antlr4_1 = require("@browsery/antlr4");
 const OpraFilterParser_js_1 = require("./antlr/OpraFilterParser.js");
 const index_js_1 = require("./ast/index.js");
 const external_constant_js_1 = require("./ast/terms/external-constant.js");
 const utils_js_1 = require("./utils.js");
-// Fix: antlr4 d.ts files are invalid
-const ParseTreeVisitor = antlr4_1.default.tree.ParseTreeVisitor;
-class FilterTreeVisitor extends ParseTreeVisitor {
+class FilterTreeVisitor extends antlr4_1.ParseTreeVisitor {
     constructor(options) {
         super();
         this._timeZone = options?.timeZone;
@@ -41,7 +38,7 @@ class FilterTreeVisitor extends ParseTreeVisitor {
         return new index_js_1.ComparisonExpression({
             op: ctx.comparisonOperator().getText(),
             left: this.visit(ctx.comparisonLeft()),
-            right: this.visit(ctx.comparisonRight())
+            right: this.visit(ctx.comparisonRight()),
         });
     }
     visitLogicalExpression(ctx) {
@@ -59,7 +56,7 @@ class FilterTreeVisitor extends ParseTreeVisitor {
         wrapChildren(ctx.expression_list(), ctx.logicalOperator().getText());
         return new index_js_1.LogicalExpression({
             op: ctx.logicalOperator().getText(),
-            items
+            items,
         });
     }
     visitQualifiedIdentifier(ctx) {

package/cjs/filter/opra-filter.ns.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./ast/index.js"), exports);
-tslib_1.__exportStar(require("./parse.js"), exports);
 tslib_1.__exportStar(require("./build.js"), exports);
-tslib_1.__exportStar(require("./opra-error-listener.js"), exports);
 tslib_1.__exportStar(require("./filter-tree-visitor.js"), exports);
+tslib_1.__exportStar(require("./opra-error-listener.js"), exports);
+tslib_1.__exportStar(require("./parse.js"), exports);

package/cjs/filter/parse.js

@@ -25,9 +25,7 @@ function parse(text, visitor) {
         const errMsgs = [];
         for (const err of errors) {
             errMsgs.push(err.message +
-                (text.includes('\n')
-                    ? (' at ' + 'line: ' + err.line + ' column: ' + err.column)
-                    : (' at ' + ' column: ' + err.column)));
+                (text.includes('\n') ? ' at line: ' + err.line + ' column: ' + err.column : ' at column: ' + err.column));
         }
         const e = new errors_js_1.SyntaxError(errMsgs.join('\n'));
         e.errors = errors;

package/cjs/filter/utils.js

@@ -11,9 +11,7 @@ function unescapeString(s) {
     return s.replace(unescapeRegEx, '$1');
 }
 function quoteFilterString(s) {
-    return "'" +
-        escapeString(s).replace(quotesRegEx, '\\\'') +
-        "'";
+    return "'" + escapeString(s).replace(quotesRegEx, "\\'") + "'";
 }
 exports.quoteFilterString = quoteFilterString;
 function unquoteFilterString(s) {

package/cjs/helpers/function-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveClass = exports.resolveThunk = void 0;
+exports.resolveThunk = void 0;
 const tslib_1 = require("tslib");
 const putil_promisify_1 = tslib_1.__importDefault(require("putil-promisify"));
 const type_guards_js_1 = require("./type-guards.js");
@@ -9,17 +9,8 @@ async function resolveThunk(thunk) {
     if (typeof thunk === 'function') {
         if ((0, type_guards_js_1.isConstructor)(thunk))
             return thunk;
-        return resolveClass(thunk());
+        return await thunk();
     }
     return thunk;
 }
 exports.resolveThunk = resolveThunk;
-async function resolveClass(thunk) {
-    thunk = putil_promisify_1.default.isPromise(thunk) ? await thunk : thunk;
-    if (typeof thunk !== 'function')
-        throw new Error(`No Class type resolved`);
-    if ((0, type_guards_js_1.isConstructor)(thunk))
-        return thunk;
-    return resolveClass(thunk());
-}
-exports.resolveClass = resolveClass;

package/cjs/helpers/get-stack-filename.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStackFileName = void 0;
+exports.getErrorStack = exports.getStackFileName = void 0;
 const PATH_PATTERN = /^(?:file:\/\/)?(.+)$/;
 function getStackFileName(position = 1) {
     if (position >= Error.stackTraceLimit) {
         throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
-            position + '` and Error.stackTraceLimit was: `' + Error.stackTraceLimit + '`');
+            position +
+            '` and Error.stackTraceLimit was: `' +
+            Error.stackTraceLimit +
+            '`');
     }
     const oldPrepareStackTrace = Error.prepareStackTrace;
     Error.prepareStackTrace = (_, stack) => stack;
@@ -14,11 +17,32 @@ function getStackFileName(position = 1) {
     if (stack !== null && typeof stack === 'object') {
         // stack[0] holds this file
         // stack[1] holds where this function was called
-        const s = stack[position] ?
-            stack[position].getFileName() : undefined;
+        const s = stack[position] ? stack[position].getFileName() : undefined;
         const m = s ? PATH_PATTERN.exec(s) : undefined;
         return m ? m[1] : '';
     }
     return '';
 }
 exports.getStackFileName = getStackFileName;
+function getErrorStack(position = 1) {
+    if (position >= Error.stackTraceLimit) {
+        throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
+            position +
+            '` and Error.stackTraceLimit was: `' +
+            Error.stackTraceLimit +
+            '`');
+    }
+    const oldPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    const stack = new Error().stack;
+    Error.prepareStackTrace = oldPrepareStackTrace;
+    if (stack !== null && typeof stack === 'object') {
+        // stack[0] holds this file
+        // stack[1] holds where this function was called
+        const s = stack[position] ? stack[position].getFileName() : undefined;
+        const m = s ? PATH_PATTERN.exec(s) : undefined;
+        return m ? m[1] : '';
+    }
+    return '';
+}
+exports.getErrorStack = getErrorStack;

package/cjs/helpers/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+require("./monkey-patches.js");
 tslib_1.__exportStar(require("./function-utils.js"), exports);
 tslib_1.__exportStar(require("./get-stack-filename.js"), exports);
-tslib_1.__exportStar(require("./is-url-string.js"), exports);
 tslib_1.__exportStar(require("./mixin-utils.js"), exports);
 tslib_1.__exportStar(require("./object-utils.js"), exports);
-tslib_1.__exportStar(require("./path-to-object-tree.js"), exports);
+tslib_1.__exportStar(require("./parse-fields-projection.js"), exports);
 tslib_1.__exportStar(require("./responsive-map.js"), exports);
 tslib_1.__exportStar(require("./type-guards.js"), exports);

package/cjs/helpers/mixin-utils.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.inheritPropertyInitializers = exports.mergePrototype = void 0;
 function mergePrototype(targetProto, baseProto, filter) {
     for (const k of Object.getOwnPropertyNames(baseProto)) {
-        if ((k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString') ||
-            filter && !filter(k))
+        if (k === 'constructor' || k === '__proto__' || k === 'toJSON' || k === 'toString' || (filter && !filter(k))) {
             continue;
-        Object.defineProperty(targetProto, k, Object.getOwnPropertyDescriptor(baseProto, k) ||
-            Object.create(null));
+        }
+        Object.defineProperty(targetProto, k, Object.getOwnPropertyDescriptor(baseProto, k) || Object.create(null));
     }
 }
 exports.mergePrototype = mergePrototype;
@@ -19,10 +18,9 @@ isPropertyInherited = (key) => true) {
         const tempInstance = new clazz();
         const propertyNames = Object.getOwnPropertyNames(tempInstance);
         propertyNames
-            .filter((propertyName) => typeof tempInstance[propertyName] !== 'undefined' &&
-            typeof target[propertyName] === 'undefined')
-            .filter((propertyName) => isPropertyInherited(propertyName))
-            .forEach((propertyName) => {
+            .filter(propertyName => typeof tempInstance[propertyName] !== 'undefined' && typeof target[propertyName] === 'undefined')
+            .filter(propertyName => isPropertyInherited(propertyName))
+            .forEach(propertyName => {
             target[propertyName] = tempInstance[propertyName];
         });
     }

package/cjs/helpers/monkey-patches.js

@@ -0,0 +1,14 @@
+"use strict";
+/** monkey patch (hijack)
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json
+ */
+if (!BigInt.prototype.toJSON) {
+    BigInt.prototype.toJSON = function () {
+        return this.toString();
+    };
+}
+if (!RegExp.prototype.toJSON) {
+    RegExp.prototype.toJSON = function () {
+        return this.toString();
+    };
+}

package/cjs/helpers/object-utils.js

@@ -7,13 +7,12 @@ const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const constants_js_1 = require("../document/constants.js");
 function cloneObject(obj, jsonOnly) {
     return (0, putil_merge_1.default)({}, obj, {
-        deep: (v) => (0, putil_isplainobject_1.default)(v) && !v[constants_js_1.DATATYPE_METADATA],
+        deep: v => (0, putil_isplainobject_1.default)(v) && !v[constants_js_1.DATATYPE_METADATA],
         filter: (source, key) => {
             const v = source[key];
-            return v != null &&
-                !jsonOnly || (typeof v !== 'function' &&
-                (typeof v !== 'object' || (0, putil_isplainobject_1.default)(v) || Array.isArray(v)));
-        }
+            return ((v != null && !jsonOnly) ||
+                (typeof v !== 'function' && (typeof v !== 'object' || (0, putil_isplainobject_1.default)(v) || Array.isArray(v))));
+        },
     });
 }
 exports.cloneObject = cloneObject;

package/cjs/helpers/parse-fields-projection.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.parseFieldsProjection = exports.FieldsProjection = void 0;
+const fast_tokenizer_1 = require("fast-tokenizer");
+const FIELD_PATTERN = /^([+-])?([a-z_$]\w*)$/i;
+const NO_DOT_BRACKET_PATTERN = /[^.]\(/g;
+class FieldsProjection {
+}
+exports.FieldsProjection = FieldsProjection;
+(function (FieldsProjection) {
+    class Item {
+    }
+    FieldsProjection.Item = Item;
+})(FieldsProjection || (exports.FieldsProjection = FieldsProjection = {}));
+function parseFieldsProjection(projection, keepCase) {
+    const arr = Array.isArray(projection) ? projection : [projection];
+    if (!(arr && arr.length))
+        return;
+    const out = new FieldsProjection();
+    for (let s of arr) {
+        if (!keepCase)
+            s = s.toLowerCase();
+        parse(s, out);
+    }
+    return out;
+}
+exports.parseFieldsProjection = parseFieldsProjection;
+function parse(input, target) {
+    /** Add dot before brackets which is required to split fields */
+    input = input.replace(NO_DOT_BRACKET_PATTERN, s => s.charAt(0) + '.' + s.substring(1));
+    const fields = (0, fast_tokenizer_1.splitString)(input, {
+        delimiters: '.',
+        brackets: true,
+        keepBrackets: false,
+    });
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (f.includes(',')) {
+            const subFields = (0, fast_tokenizer_1.splitString)(f, {
+                delimiters: ',',
+                brackets: true,
+                keepBrackets: true,
+            });
+            for (const n of subFields) {
+                parse(n, target);
+            }
+            continue;
+        }
+        const m = FIELD_PATTERN.exec(f);
+        /* istanbul ignore next */
+        if (!m)
+            throw new TypeError(`Invalid field path (${input})`);
+        const fieldName = m[2];
+        const treeItem = (target[fieldName] = target[fieldName] || new FieldsProjection.Item());
+        if (m[1])
+            treeItem.sign = m[1];
+        if (i === fields.length - 1) {
+            delete treeItem.projection;
+        }
+        else {
+            target = treeItem.projection = treeItem.projection || new FieldsProjection();
+        }
+    }
+}
+exports.parse = parse;

package/cjs/helpers/responsive-map.js

@@ -1,48 +1,90 @@
 "use strict";
-var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponsiveMap = void 0;
 function isMap(v) {
     return v && typeof v.forEach === 'function';
 }
+const kEntries = Symbol.for('kEntries');
 const kKeyMap = Symbol.for('kKeyMap');
-const kKeyOrder = Symbol.for('kKeyOrder');
 const kWellKnownKeys = Symbol.for('kWellKnownKeys');
 const kOptions = Symbol.for('kOptions');
+const kSize = Symbol.for('kSize');
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */
-class ResponsiveMap extends Map {
+class ResponsiveMap {
     constructor(init, options) {
-        super();
-        this[_a] = new Map();
-        this[_b] = [];
-        this[_c] = new Map();
-        this[_d] = { caseSensitive: false };
-        this[kOptions].caseSensitive = !!options?.caseSensitive;
-        if (options?.wellKnownKeys)
-            options.wellKnownKeys.forEach(k => this[kWellKnownKeys].set(k.toLowerCase(), k));
+        Object.defineProperty(this, kSize, {
+            value: 0,
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kEntries, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kKeyMap, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        Object.defineProperty(this, kWellKnownKeys, {
+            value: {},
+            enumerable: false,
+            writable: true,
+        });
+        const caseSensitive = !!options?.caseSensitive;
+        Object.defineProperty(this, kOptions, {
+            value: {
+                caseSensitive,
+            },
+            enumerable: false,
+        });
+        if (options?.wellKnownKeys) {
+            options.wellKnownKeys.forEach(k => {
+                if (caseSensitive)
+                    this[kWellKnownKeys][k] = k;
+                else
+                    this[kWellKnownKeys][k.toLowerCase()] = k;
+            });
+        }
+        this.clear();
         if (init)
             this.setAll(init);
     }
+    get size() {
+        return this[kSize];
+    }
     clear() {
-        super.clear();
-        this[kKeyMap].clear();
-        this[kKeyOrder] = [];
+        Object.keys(this[kEntries]).forEach(k => delete this[kEntries][k]);
+        Object.keys(this[kKeyMap]).forEach(k => delete this[kKeyMap][k]);
+        this[kSize] = 0;
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [k, v] of this.entries()) {
+            callbackfn.call(thisArg, v, k, this);
+        }
     }
     get(key) {
-        const orgKey = this._getOriginalKey(key);
-        return super.get(orgKey);
+        if (!key)
+            return;
+        return this[kEntries][this._getStoringKey(key)];
     }
     has(key) {
-        return this[kKeyMap].has(this._getStoringKey(key));
+        if (!key)
+            return false;
+        return Object.prototype.hasOwnProperty.call(this[kEntries], this._getStoringKey(key));
     }
     set(key, value) {
+        const storeKey = this._getStoringKey(key);
         key = this._getOriginalKey(key);
-        this[kKeyMap].set(this._getStoringKey(key), key);
-        if (!this[kKeyOrder].includes(key))
-            this[kKeyOrder].push(key);
-        return super.set(key, value);
+        const exists = Object.prototype.hasOwnProperty.call(this[kEntries], storeKey);
+        this[kEntries][storeKey] = value;
+        if (!exists)
+            this[kSize]++;
+        this[kKeyMap][storeKey] = key;
+        return this;
     }
     setAll(source) {
         if (isMap(source))
@@ -52,122 +94,57 @@ class ResponsiveMap extends Map {
         return this;
     }
     keys() {
-        return [...this[kKeyOrder]][Symbol.iterator]();
+        return Object.values(this[kKeyMap])[Symbol.iterator]();
     }
     values() {
-        let i = -1;
-        const arr = [...this[kKeyOrder]];
-        const map = this;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                i++;
-                return {
-                    done: i >= arr.length,
-                    value: map.get(arr[i])
-                };
-            }
-        };
+        return Object.values(this[kEntries])[Symbol.iterator]();
     }
     entries() {
-        let i = -1;
-        const arr = [...this[kKeyOrder]];
-        const map = this;
-        return {
-            [Symbol.iterator]() {
-                return this;
-            },
-            next() {
-                i++;
-                return {
-                    done: i >= arr.length,
-                    value: [arr[i], map.get(arr[i])]
-                };
-            }
-        };
+        return Object.entries(this[kEntries])[Symbol.iterator]();
     }
     delete(key) {
-        const orgKey = this._getOriginalKey(key);
-        const k = this._getStoringKey(key);
-        this[kKeyMap].delete(k);
-        const i = this[kKeyOrder].indexOf(orgKey);
-        if (i >= 0)
-            this[kKeyOrder].splice(i, 1);
-        return super.delete(orgKey);
+        const storeKey = this._getStoringKey(key);
+        const exists = Object.prototype.hasOwnProperty.call(this[kEntries], storeKey);
+        delete this[kEntries][storeKey];
+        delete this[kKeyMap][storeKey];
+        if (!exists)
+            this[kSize]--;
+        return exists;
     }
     sort(compareFn) {
+        const oldValues = { ...this[kEntries] };
+        const oldKeymap = { ...this[kKeyMap] };
+        const keys = Array.from(this.keys());
         if (compareFn)
-            this[kKeyOrder].sort(compareFn);
-        else if (this[kOptions].caseSensitive)
-            this[kKeyOrder].sort();
+            keys.sort(compareFn);
         else
-            this[kKeyOrder].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            keys.sort();
+        this.clear();
+        for (const k of keys) {
+            this[kEntries][k] = oldValues[k];
+            this[kKeyMap][k] = oldKeymap[k];
+        }
+        this[kSize] = keys.length;
         return this;
     }
-    getProxy(handler) {
-        const _this = this;
-        const finalHandler = {
-            get(target, p, receiver) {
-                if (typeof p === 'string')
-                    return _this.get(p);
-                return Reflect.get(target, p, receiver);
-            },
-            set(target, p, newValue, receiver) {
-                if (typeof p === 'string') {
-                    _this.set(p, newValue);
-                    return true;
-                }
-                return Reflect.set(target, p, newValue, receiver);
-            },
-            has(target, p) {
-                if (typeof p === 'string')
-                    return _this.has(p);
-                return Reflect.has(target, p);
-            },
-            ownKeys() {
-                return Array.from(_this.keys()).map(x => x.toLowerCase());
-            },
-            getPrototypeOf() {
-                return Object.prototype;
-            },
-            defineProperty(target, property, attributes) {
-                if (typeof property === 'string') {
-                    _this.set(property, attributes.value);
-                    return true;
-                }
-                return false;
-            },
-            deleteProperty(target, p) {
-                if (typeof p === 'string')
-                    return _this.delete(p);
-                return false;
-            },
-            getOwnPropertyDescriptor(target, key) {
-                if (typeof key === 'string') {
-                    const value = finalHandler.get(target, key);
-                    return { configurable: true, enumerable: true, writable: true, value };
-                }
-            },
-            ...handler
-        };
-        return new Proxy({}, finalHandler);
-    }
     toObject() {
-        return Object.keys(this.keys()).reduce((trg, k) => {
-            trg[k] = this.get(k);
-            return trg;
-        }, {});
+        const out = {};
+        for (const [storeKey, orgKey] of Object.entries(this[kKeyMap])) {
+            out[orgKey] = this[kEntries][storeKey];
+        }
+        return out;
     }
-    [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
+    [Symbol.iterator]() {
         return this.entries();
     }
+    get [Symbol.toStringTag]() {
+        return '[Object ResponsiveMap]';
+    }
     _getOriginalKey(key) {
         if (!key || this[kOptions].caseSensitive)
             return key;
-        return this[kKeyMap].get(key.toLowerCase()) ??
-            (this[kWellKnownKeys].get(key.toLowerCase()) ?? key);
+        const storeKey = this._getStoringKey(key);
+        return this[kKeyMap][storeKey] ?? this[kWellKnownKeys][storeKey] ?? key;
     }
     _getStoringKey(key) {
         if (this[kOptions].caseSensitive)