{"version":3,"sources":["jsdelivr-header.js","/npm/harmony-reflect@1.6.2/reflect.js"],"names":[],"mappings":"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","file":"/npm/harmony-reflect@1.6.2/reflect.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/harmony-reflect@1.6.2/reflect.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","// Copyright (C) 2011-2012 Software Languages Lab, Vrije Universiteit Brussel\n// This code is dual-licensed under both the Apache License and the MPL\n\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n/* Version: MPL 1.1\n *\n * The contents of this file are subject to the Mozilla Public License Version\n * 1.1 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n * http://www.mozilla.org/MPL/\n *\n * Software distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License\n * for the specific language governing rights and limitations under the\n * License.\n *\n * The Original Code is a shim for the ES-Harmony reflection module\n *\n * The Initial Developer of the Original Code is\n * Tom Van Cutsem, Vrije Universiteit Brussel.\n * Portions created by the Initial Developer are Copyright (C) 2011-2012\n * the Initial Developer. All Rights Reserved.\n *\n * Contributor(s):\n *\n */\n\n // ----------------------------------------------------------------------------\n\n // This file is a polyfill for the upcoming ECMAScript Reflect API,\n // including support for Proxies. See the draft specification at:\n // http://wiki.ecmascript.org/doku.php?id=harmony:reflect_api\n // http://wiki.ecmascript.org/doku.php?id=harmony:direct_proxies\n\n // For an implementation of the Handler API, see handlers.js, which implements:\n // http://wiki.ecmascript.org/doku.php?id=harmony:virtual_object_api\n\n // This implementation supersedes the earlier polyfill at:\n // code.google.com/p/es-lab/source/browse/trunk/src/proxies/DirectProxies.js\n\n // This code was tested on tracemonkey / Firefox 12\n// (and should run fine on older Firefox versions starting with FF4)\n // The code also works correctly on\n // v8 --harmony_proxies --harmony_weakmaps (v3.6.5.1)\n\n // Language Dependencies:\n // - ECMAScript 5/strict\n // - \"old\" (i.e. non-direct) Harmony Proxies\n // - Harmony WeakMaps\n // Patches:\n // - Object.{freeze,seal,preventExtensions}\n // - Object.{isFrozen,isSealed,isExtensible}\n // - Object.getPrototypeOf\n // - Object.keys\n // - Object.prototype.valueOf\n // - Object.prototype.isPrototypeOf\n // - Object.prototype.toString\n // - Object.prototype.hasOwnProperty\n // - Object.getOwnPropertyDescriptor\n // - Object.defineProperty\n // - Object.defineProperties\n // - Object.getOwnPropertyNames\n // - Object.getOwnPropertySymbols\n // - Object.getPrototypeOf\n // - Object.setPrototypeOf\n // - Object.assign\n // - Function.prototype.toString\n // - Date.prototype.toString\n // - Array.isArray\n // - Array.prototype.concat\n // - Proxy\n // Adds new globals:\n // - Reflect\n\n // Direct proxies can be created via Proxy(target, handler)\n\n // ----------------------------------------------------------------------------\n\n(function(global){ // function-as-module pattern\n\"use strict\";\n\n// === Direct Proxies: Invariant Enforcement ===\n\n// Direct proxies build on non-direct proxies by automatically wrapping\n// all user-defined proxy handlers in a Validator handler that checks and\n// enforces ES5 invariants.\n\n// A direct proxy is a proxy for an existing object called the target object.\n\n// A Validator handler is a wrapper for a target proxy handler H.\n// The Validator forwards all operations to H, but additionally\n// performs a number of integrity checks on the results of some traps,\n// to make sure H does not violate the ES5 invariants w.r.t. non-configurable\n// properties and non-extensible, sealed or frozen objects.\n\n// For each property that H exposes as own, non-configurable\n// (e.g. by returning a descriptor from a call to getOwnPropertyDescriptor)\n// the Validator handler defines those properties on the target object.\n// When the proxy becomes non-extensible, also configurable own properties\n// are checked against the target.\n// We will call properties that are defined on the target object\n// \"fixed properties\".\n\n// We will name fixed non-configurable properties \"sealed properties\".\n// We will name fixed non-configurable non-writable properties \"frozen\n// properties\".\n\n// The Validator handler upholds the following invariants w.r.t. non-configurability:\n// - getOwnPropertyDescriptor cannot report sealed properties as non-existent\n// - getOwnPropertyDescriptor cannot report incompatible changes to the\n// attributes of a sealed property (e.g. reporting a non-configurable\n// property as configurable, or reporting a non-configurable, non-writable\n// property as writable)\n// - getPropertyDescriptor cannot report sealed properties as non-existent\n// - getPropertyDescriptor cannot report incompatible changes to the\n// attributes of a sealed property. It _can_ report incompatible changes\n// to the attributes of non-own, inherited properties.\n// - defineProperty cannot make incompatible changes to the attributes of\n// sealed properties\n// - deleteProperty cannot report a successful deletion of a sealed property\n// - hasOwn cannot report a sealed property as non-existent\n// - has cannot report a sealed property as non-existent\n// - get cannot report inconsistent values for frozen data\n// properties, and must report undefined for sealed accessors with an\n// undefined getter\n// - set cannot report a successful assignment for frozen data\n// properties or sealed accessors with an undefined setter.\n// - get{Own}PropertyNames lists all sealed properties of the target.\n// - keys lists all enumerable sealed properties of the target.\n// - enumerate lists all enumerable sealed properties of the target.\n// - if a property of a non-extensible proxy is reported as non-existent,\n// then it must forever be reported as non-existent. This applies to\n// own and inherited properties and is enforced in the\n// deleteProperty, get{Own}PropertyDescriptor, has{Own},\n// get{Own}PropertyNames, keys and enumerate traps\n\n// Violation of any of these invariants by H will result in TypeError being\n// thrown.\n\n// Additionally, once Object.preventExtensions, Object.seal or Object.freeze\n// is invoked on the proxy, the set of own property names for the proxy is\n// fixed. Any property name that is not fixed is called a 'new' property.\n\n// The Validator upholds the following invariants regarding extensibility:\n// - getOwnPropertyDescriptor cannot report new properties as existent\n// (it must report them as non-existent by returning undefined)\n// - defineProperty cannot successfully add a new property (it must reject)\n// - getOwnPropertyNames cannot list new properties\n// - hasOwn cannot report true for new properties (it must report false)\n// - keys cannot list new properties\n\n// Invariants currently not enforced:\n// - getOwnPropertyNames lists only own property names\n// - keys lists only enumerable own property names\n// Both traps may list more property names than are actually defined on the\n// target.\n\n// Invariants with regard to inheritance are currently not enforced.\n// - a non-configurable potentially inherited property on a proxy with\n// non-mutable ancestry cannot be reported as non-existent\n// (An object with non-mutable ancestry is a non-extensible object whose\n// [[Prototype]] is either null or an object with non-mutable ancestry.)\n\n// Changes in Handler API compared to previous harmony:proxies, see:\n// http://wiki.ecmascript.org/doku.php?id=strawman:direct_proxies\n// http://wiki.ecmascript.org/doku.php?id=harmony:direct_proxies\n\n// ----------------------------------------------------------------------------\n\n// ---- WeakMap polyfill ----\n\n// TODO: find a proper WeakMap polyfill\n\n// define an empty WeakMap so that at least the Reflect module code\n// will work in the absence of WeakMaps. Proxy emulation depends on\n// actual WeakMaps, so will not work with this little shim.\nif (typeof WeakMap === \"undefined\") {\n global.WeakMap = function(){};\n global.WeakMap.prototype = {\n get: function(k) { return undefined; },\n set: function(k,v) { throw new Error(\"WeakMap not supported\"); }\n };\n}\n\n// ---- Normalization functions for property descriptors ----\n\nfunction isStandardAttribute(name) {\n return /^(get|set|value|writable|enumerable|configurable)$/.test(name);\n}\n\n// Adapted from ES5 section 8.10.5\nfunction toPropertyDescriptor(obj) {\n if (Object(obj) !== obj) {\n throw new TypeError(\"property descriptor should be an Object, given: \"+\n obj);\n }\n var desc = {};\n if ('enumerable' in obj) { desc.enumerable = !!obj.enumerable; }\n if ('configurable' in obj) { desc.configurable = !!obj.configurable; }\n if ('value' in obj) { desc.value = obj.value; }\n if ('writable' in obj) { desc.writable = !!obj.writable; }\n if ('get' in obj) {\n var getter = obj.get;\n if (getter !== undefined && typeof getter !== \"function\") {\n throw new TypeError(\"property descriptor 'get' attribute must be \"+\n \"callable or undefined, given: \"+getter);\n }\n desc.get = getter;\n }\n if ('set' in obj) {\n var setter = obj.set;\n if (setter !== undefined && typeof setter !== \"function\") {\n throw new TypeError(\"property descriptor 'set' attribute must be \"+\n \"callable or undefined, given: \"+setter);\n }\n desc.set = setter;\n }\n if ('get' in desc || 'set' in desc) {\n if ('value' in desc || 'writable' in desc) {\n throw new TypeError(\"property descriptor cannot be both a data and an \"+\n \"accessor descriptor: \"+obj);\n }\n }\n return desc;\n}\n\nfunction isAccessorDescriptor(desc) {\n if (desc === undefined) return false;\n return ('get' in desc || 'set' in desc);\n}\nfunction isDataDescriptor(desc) {\n if (desc === undefined) return false;\n return ('value' in desc || 'writable' in desc);\n}\nfunction isGenericDescriptor(desc) {\n if (desc === undefined) return false;\n return !isAccessorDescriptor(desc) && !isDataDescriptor(desc);\n}\n\nfunction toCompletePropertyDescriptor(desc) {\n var internalDesc = toPropertyDescriptor(desc);\n if (isGenericDescriptor(internalDesc) || isDataDescriptor(internalDesc)) {\n if (!('value' in internalDesc)) { internalDesc.value = undefined; }\n if (!('writable' in internalDesc)) { internalDesc.writable = false; }\n } else {\n if (!('get' in internalDesc)) { internalDesc.get = undefined; }\n if (!('set' in internalDesc)) { internalDesc.set = undefined; }\n }\n if (!('enumerable' in internalDesc)) { internalDesc.enumerable = false; }\n if (!('configurable' in internalDesc)) { internalDesc.configurable = false; }\n return internalDesc;\n}\n\nfunction isEmptyDescriptor(desc) {\n return !('get' in desc) &&\n !('set' in desc) &&\n !('value' in desc) &&\n !('writable' in desc) &&\n !('enumerable' in desc) &&\n !('configurable' in desc);\n}\n\nfunction isEquivalentDescriptor(desc1, desc2) {\n return sameValue(desc1.get, desc2.get) &&\n sameValue(desc1.set, desc2.set) &&\n sameValue(desc1.value, desc2.value) &&\n sameValue(desc1.writable, desc2.writable) &&\n sameValue(desc1.enumerable, desc2.enumerable) &&\n sameValue(desc1.configurable, desc2.configurable);\n}\n\n// copied from http://wiki.ecmascript.org/doku.php?id=harmony:egal\nfunction sameValue(x, y) {\n if (x === y) {\n // 0 === -0, but they are not identical\n return x !== 0 || 1 / x === 1 / y;\n }\n\n // NaN !== NaN, but they are identical.\n // NaNs are the only non-reflexive value, i.e., if x !== x,\n // then x is a NaN.\n // isNaN is broken: it converts its argument to number, so\n // isNaN(\"foo\") => true\n return x !== x && y !== y;\n}\n\n/**\n * Returns a fresh property descriptor that is guaranteed\n * to be complete (i.e. contain all the standard attributes).\n * Additionally, any non-standard enumerable properties of\n * attributes are copied over to the fresh descriptor.\n *\n * If attributes is undefined, returns undefined.\n *\n * See also: http://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics\n */\nfunction normalizeAndCompletePropertyDescriptor(attributes) {\n if (attributes === undefined) { return undefined; }\n var desc = toCompletePropertyDescriptor(attributes);\n // Note: no need to call FromPropertyDescriptor(desc), as we represent\n // \"internal\" property descriptors as proper Objects from the start\n for (var name in attributes) {\n if (!isStandardAttribute(name)) {\n Object.defineProperty(desc, name,\n { value: attributes[name],\n writable: true,\n enumerable: true,\n configurable: true });\n }\n }\n return desc;\n}\n\n/**\n * Returns a fresh property descriptor whose standard\n * attributes are guaranteed to be data properties of the right type.\n * Additionally, any non-standard enumerable properties of\n * attributes are copied over to the fresh descriptor.\n *\n * If attributes is undefined, will throw a TypeError.\n *\n * See also: http://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics\n */\nfunction normalizePropertyDescriptor(attributes) {\n var desc = toPropertyDescriptor(attributes);\n // Note: no need to call FromGenericPropertyDescriptor(desc), as we represent\n // \"internal\" property descriptors as proper Objects from the start\n for (var name in attributes) {\n if (!isStandardAttribute(name)) {\n Object.defineProperty(desc, name,\n { value: attributes[name],\n writable: true,\n enumerable: true,\n configurable: true });\n }\n }\n return desc;\n}\n\n// store a reference to the real ES5 primitives before patching them later\nvar prim_preventExtensions = Object.preventExtensions,\n prim_seal = Object.seal,\n prim_freeze = Object.freeze,\n prim_isExtensible = Object.isExtensible,\n prim_isSealed = Object.isSealed,\n prim_isFrozen = Object.isFrozen,\n prim_getPrototypeOf = Object.getPrototypeOf,\n prim_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,\n prim_defineProperty = Object.defineProperty,\n prim_defineProperties = Object.defineProperties,\n prim_keys = Object.keys,\n prim_getOwnPropertyNames = Object.getOwnPropertyNames,\n prim_getOwnPropertySymbols = Object.getOwnPropertySymbols,\n prim_assign = Object.assign,\n prim_isArray = Array.isArray,\n prim_concat = Array.prototype.concat,\n prim_isPrototypeOf = Object.prototype.isPrototypeOf,\n prim_hasOwnProperty = Object.prototype.hasOwnProperty;\n\n// these will point to the patched versions of the respective methods on\n// Object. They are used within this module as the \"intrinsic\" bindings\n// of these methods (i.e. the \"original\" bindings as defined in the spec)\nvar Object_isFrozen,\n Object_isSealed,\n Object_isExtensible,\n Object_getPrototypeOf,\n Object_getOwnPropertyNames;\n\n/**\n * A property 'name' is fixed if it is an own property of the target.\n */\nfunction isFixed(name, target) {\n return ({}).hasOwnProperty.call(target, name);\n}\nfunction isSealed(name, target) {\n var desc = Object.getOwnPropertyDescriptor(target, name);\n if (desc === undefined) { return false; }\n return desc.configurable === false;\n}\nfunction isSealedDesc(desc) {\n return desc !== undefined && desc.configurable === false;\n}\n\n/**\n * Performs all validation that Object.defineProperty performs,\n * without actually defining the property. Returns a boolean\n * indicating whether validation succeeded.\n *\n * Implementation transliterated from ES5.1 section 8.12.9\n */\nfunction isCompatibleDescriptor(extensible, current, desc) {\n if (current === undefined && extensible === false) {\n return false;\n }\n if (current === undefined && extensible === true) {\n return true;\n }\n if (isEmptyDescriptor(desc)) {\n return true;\n }\n if (isEquivalentDescriptor(current, desc)) {\n return true;\n }\n if (current.configurable === false) {\n if (desc.configurable === true) {\n return false;\n }\n if ('enumerable' in desc && desc.enumerable !== current.enumerable) {\n return false;\n }\n }\n if (isGenericDescriptor(desc)) {\n return true;\n }\n if (isDataDescriptor(current) !== isDataDescriptor(desc)) {\n if (current.configurable === false) {\n return false;\n }\n return true;\n }\n if (isDataDescriptor(current) && isDataDescriptor(desc)) {\n if (current.configurable === false) {\n if (current.writable === false && desc.writable === true) {\n return false;\n }\n if (current.writable === false) {\n if ('value' in desc && !sameValue(desc.value, current.value)) {\n return false;\n }\n }\n }\n return true;\n }\n if (isAccessorDescriptor(current) && isAccessorDescriptor(desc)) {\n if (current.configurable === false) {\n if ('set' in desc && !sameValue(desc.set, current.set)) {\n return false;\n }\n if ('get' in desc && !sameValue(desc.get, current.get)) {\n return false;\n }\n }\n }\n return true;\n}\n\n// ES6 7.3.11 SetIntegrityLevel\n// level is one of \"sealed\" or \"frozen\"\nfunction setIntegrityLevel(target, level) {\n var ownProps = Object_getOwnPropertyNames(target);\n var pendingException = undefined;\n if (level === \"sealed\") {\n var l = +ownProps.length;\n var k;\n for (var i = 0; i < l; i++) {\n k = String(ownProps[i]);\n try {\n Object.defineProperty(target, k, { configurable: false });\n } catch (e) {\n if (pendingException === undefined) {\n pendingException = e;\n }\n }\n }\n } else {\n // level === \"frozen\"\n var l = +ownProps.length;\n var k;\n for (var i = 0; i < l; i++) {\n k = String(ownProps[i]);\n try {\n var currentDesc = Object.getOwnPropertyDescriptor(target, k);\n if (currentDesc !== undefined) {\n var desc;\n if (isAccessorDescriptor(currentDesc)) {\n desc = { configurable: false }\n } else {\n desc = { configurable: false, writable: false }\n }\n Object.defineProperty(target, k, desc);\n } \n } catch (e) {\n if (pendingException === undefined) {\n pendingException = e;\n }\n }\n }\n }\n if (pendingException !== undefined) {\n throw pendingException;\n }\n return Reflect.preventExtensions(target);\n}\n\n// ES6 7.3.12 TestIntegrityLevel\n// level is one of \"sealed\" or \"frozen\"\nfunction testIntegrityLevel(target, level) {\n var isExtensible = Object_isExtensible(target);\n if (isExtensible) return false;\n \n var ownProps = Object_getOwnPropertyNames(target);\n var pendingException = undefined;\n var configurable = false;\n var writable = false;\n \n var l = +ownProps.length;\n var k;\n var currentDesc;\n for (var i = 0; i < l; i++) {\n k = String(ownProps[i]);\n try {\n currentDesc = Object.getOwnPropertyDescriptor(target, k);\n configurable = configurable || currentDesc.configurable;\n if (isDataDescriptor(currentDesc)) {\n writable = writable || currentDesc.writable;\n }\n } catch (e) {\n if (pendingException === undefined) {\n pendingException = e;\n configurable = true;\n }\n }\n }\n if (pendingException !== undefined) {\n throw pendingException;\n }\n if (level === \"frozen\" && writable === true) {\n return false;\n }\n if (configurable === true) {\n return false;\n }\n return true;\n}\n\n// ---- The Validator handler wrapper around user handlers ----\n\n/**\n * @param target the object wrapped by this proxy.\n * As long as the proxy is extensible, only non-configurable properties\n * are checked against the target. Once the proxy becomes non-extensible,\n * invariants w.r.t. non-extensibility are also enforced.\n *\n * @param handler the handler of the direct proxy. The object emulated by\n * this handler is validated against the target object of the direct proxy.\n * Any violations that the handler makes against the invariants\n * of the target will cause a TypeError to be thrown.\n *\n * Both target and handler must be proper Objects at initialization time.\n */\nfunction Validator(target, handler) {\n // for non-revokable proxies, these are const references\n // for revokable proxies, on revocation:\n // - this.target is set to null\n // - this.handler is set to a handler that throws on all traps\n this.target = target;\n this.handler = handler;\n}\n\nValidator.prototype = {\n\n /**\n * If getTrap returns undefined, the caller should perform the\n * default forwarding behavior.\n * If getTrap returns normally otherwise, the return value\n * will be a callable trap function. When calling the trap function,\n * the caller is responsible for binding its |this| to |this.handler|.\n */\n getTrap: function(trapName) {\n var trap = this.handler[trapName];\n if (trap === undefined) {\n // the trap was not defined,\n // perform the default forwarding behavior\n return undefined;\n }\n\n if (typeof trap !== \"function\") {\n throw new TypeError(trapName + \" trap is not callable: \"+trap);\n }\n\n return trap;\n },\n\n // === fundamental traps ===\n\n /**\n * If name denotes a fixed property, check:\n * - whether targetHandler reports it as existent\n * - whether the returned descriptor is compatible with the fixed property\n * If the proxy is non-extensible, check:\n * - whether name is not a new property\n * Additionally, the returned descriptor is normalized and completed.\n */\n getOwnPropertyDescriptor: function(name) {\n \"use strict\";\n\n var trap = this.getTrap(\"getOwnPropertyDescriptor\");\n if (trap === undefined) {\n return Reflect.getOwnPropertyDescriptor(this.target, name);\n }\n\n name = String(name);\n var desc = trap.call(this.handler, this.target, name);\n desc = normalizeAndCompletePropertyDescriptor(desc);\n\n var targetDesc = Object.getOwnPropertyDescriptor(this.target, name);\n var extensible = Object.isExtensible(this.target);\n\n if (desc === undefined) {\n if (isSealedDesc(targetDesc)) {\n throw new TypeError(\"cannot report non-configurable property '\"+name+\n \"' as non-existent\");\n }\n if (!extensible && targetDesc !== undefined) {\n // if handler is allowed to return undefined, we cannot guarantee\n // that it will not return a descriptor for this property later.\n // Once a property has been reported as non-existent on a non-extensible\n // object, it should forever be reported as non-existent\n throw new TypeError(\"cannot report existing own property '\"+name+\n \"' as non-existent on a non-extensible object\");\n }\n return undefined;\n }\n\n // at this point, we know (desc !== undefined), i.e.\n // targetHandler reports 'name' as an existing property\n\n // Note: we could collapse the following two if-tests into a single\n // test. Separating out the cases to improve error reporting.\n\n if (!extensible) {\n if (targetDesc === undefined) {\n throw new TypeError(\"cannot report a new own property '\"+\n name + \"' on a non-extensible object\");\n }\n }\n\n if (name !== undefined) {\n if (!isCompatibleDescriptor(extensible, targetDesc, desc)) {\n throw new TypeError(\"cannot report incompatible property descriptor \"+\n \"for property '\"+name+\"'\");\n }\n }\n \n if (desc.configurable === false) {\n if (targetDesc === undefined || targetDesc.configurable === true) {\n // if the property is configurable or non-existent on the target,\n // but is reported as a non-configurable property, it may later be\n // reported as configurable or non-existent, which violates the\n // invariant that if the property might change or disappear, the\n // configurable attribute must be true.\n throw new TypeError(\n \"cannot report a non-configurable descriptor \" +\n \"for configurable or non-existent property '\" + name + \"'\");\n }\n if ('writable' in desc && desc.writable === false) {\n if (targetDesc.writable === true) {\n // if the property is non-configurable, writable on the target,\n // but is reported as non-configurable, non-writable, it may later\n // be reported as non-configurable, writable again, which violates\n // the invariant that a non-configurable, non-writable property\n // may not change state.\n throw new TypeError(\n \"cannot report non-configurable, writable property '\" + name +\n \"' as non-configurable, non-writable\");\n }\n }\n }\n\n return desc;\n },\n\n /**\n * In the direct proxies design with refactored prototype climbing,\n * this trap is deprecated. For proxies-as-prototypes, instead\n * of calling this trap, the get, set, has or enumerate traps are\n * called instead.\n *\n * In this implementation, we \"abuse\" getPropertyDescriptor to\n * support trapping the get or set traps for proxies-as-prototypes.\n * We do this by returning a getter/setter pair that invokes\n * the corresponding traps.\n *\n * While this hack works for inherited property access, it has some\n * quirks:\n *\n * In Firefox, this trap is only called after a prior invocation\n * of the 'has' trap has returned true. Hence, expect the following\n * behavior:\n * \n * var child = Object.create(Proxy(target, handler));\n * child[name] // triggers handler.has(target, name)\n * // if that returns true, triggers handler.get(target, name, child)\n * \n *\n * On v8, the 'in' operator, when applied to an object that inherits\n * from a proxy, will call getPropertyDescriptor and walk the proto-chain.\n * That calls the below getPropertyDescriptor trap on the proxy. The\n * result of the 'in'-operator is then determined by whether this trap\n * returns undefined or a property descriptor object. That is why\n * we first explicitly trigger the 'has' trap to determine whether\n * the property exists.\n *\n * This has the side-effect that when enumerating properties on\n * an object that inherits from a proxy in v8, only properties\n * for which 'has' returns true are returned:\n *\n * \n * var child = Object.create(Proxy(target, handler));\n * for (var prop in child) {\n * // only enumerates prop if (prop in child) returns true\n * }\n * \n */\n getPropertyDescriptor: function(name) {\n var handler = this;\n\n if (!handler.has(name)) return undefined;\n\n return {\n get: function() {\n return handler.get(this, name);\n },\n set: function(val) {\n if (handler.set(this, name, val)) {\n return val;\n } else {\n throw new TypeError(\"failed assignment to \"+name);\n }\n },\n enumerable: true,\n configurable: true\n };\n },\n\n /**\n * If name denotes a fixed property, check for incompatible changes.\n * If the proxy is non-extensible, check that new properties are rejected.\n */\n defineProperty: function(name, desc) {\n // TODO(tvcutsem): the current tracemonkey implementation of proxies\n // auto-completes 'desc', which is not correct. 'desc' should be\n // normalized, but not completed. Consider:\n // Object.defineProperty(proxy, 'foo', {enumerable:false})\n // This trap will receive desc =\n // {value:undefined,writable:false,enumerable:false,configurable:false}\n // This will also set all other attributes to their default value,\n // which is unexpected and different from [[DefineOwnProperty]].\n // Bug filed: https://bugzilla.mozilla.org/show_bug.cgi?id=601329\n\n var trap = this.getTrap(\"defineProperty\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.defineProperty(this.target, name, desc);\n }\n\n name = String(name);\n var descObj = normalizePropertyDescriptor(desc);\n var success = trap.call(this.handler, this.target, name, descObj);\n success = !!success; // coerce to Boolean\n\n if (success === true) {\n\n var targetDesc = Object.getOwnPropertyDescriptor(this.target, name);\n var extensible = Object.isExtensible(this.target);\n\n // Note: we could collapse the following two if-tests into a single\n // test. Separating out the cases to improve error reporting.\n\n if (!extensible) {\n if (targetDesc === undefined) {\n throw new TypeError(\"cannot successfully add a new property '\"+\n name + \"' to a non-extensible object\");\n }\n }\n\n if (targetDesc !== undefined) {\n if (!isCompatibleDescriptor(extensible, targetDesc, desc)) {\n throw new TypeError(\"cannot define incompatible property \"+\n \"descriptor for property '\"+name+\"'\");\n }\n if (isDataDescriptor(targetDesc) &&\n targetDesc.configurable === false &&\n targetDesc.writable === true) {\n if (desc.configurable === false && desc.writable === false) {\n // if the property is non-configurable, writable on the target\n // but was successfully reported to be updated to\n // non-configurable, non-writable, it can later be reported\n // again as non-configurable, writable, which violates\n // the invariant that non-configurable, non-writable properties\n // cannot change state\n throw new TypeError(\n \"cannot successfully define non-configurable, writable \" +\n \" property '\" + name + \"' as non-configurable, non-writable\");\n }\n }\n }\n\n if (desc.configurable === false && !isSealedDesc(targetDesc)) {\n // if the property is configurable or non-existent on the target,\n // but is successfully being redefined as a non-configurable property,\n // it may later be reported as configurable or non-existent, which violates\n // the invariant that if the property might change or disappear, the\n // configurable attribute must be true.\n throw new TypeError(\n \"cannot successfully define a non-configurable \" +\n \"descriptor for configurable or non-existent property '\" +\n name + \"'\");\n }\n\n }\n\n return success;\n },\n\n /**\n * On success, check whether the target object is indeed non-extensible.\n */\n preventExtensions: function() {\n var trap = this.getTrap(\"preventExtensions\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.preventExtensions(this.target);\n }\n\n var success = trap.call(this.handler, this.target);\n success = !!success; // coerce to Boolean\n if (success) {\n if (Object_isExtensible(this.target)) {\n throw new TypeError(\"can't report extensible object as non-extensible: \"+\n this.target);\n }\n }\n return success;\n },\n\n /**\n * If name denotes a sealed property, check whether handler rejects.\n */\n delete: function(name) {\n \"use strict\";\n var trap = this.getTrap(\"deleteProperty\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.deleteProperty(this.target, name);\n }\n\n name = String(name);\n var res = trap.call(this.handler, this.target, name);\n res = !!res; // coerce to Boolean\n\n var targetDesc;\n if (res === true) {\n targetDesc = Object.getOwnPropertyDescriptor(this.target, name);\n if (targetDesc !== undefined && targetDesc.configurable === false) {\n throw new TypeError(\"property '\" + name + \"' is non-configurable \"+\n \"and can't be deleted\");\n }\n if (targetDesc !== undefined && !Object_isExtensible(this.target)) {\n // if the property still exists on a non-extensible target but\n // is reported as successfully deleted, it may later be reported\n // as present, which violates the invariant that an own property,\n // deleted from a non-extensible object cannot reappear.\n throw new TypeError(\n \"cannot successfully delete existing property '\" + name +\n \"' on a non-extensible object\");\n }\n }\n\n return res;\n },\n\n /**\n * The getOwnPropertyNames trap was replaced by the ownKeys trap,\n * which now also returns an array (of strings or symbols) and\n * which performs the same rigorous invariant checks as getOwnPropertyNames\n *\n * See issue #48 on how this trap can still get invoked by external libs\n * that don't use the patched Object.getOwnPropertyNames function.\n */\n getOwnPropertyNames: function() {\n // Note: removed deprecation warning to avoid dependency on 'console'\n // (and on node, should anyway use util.deprecate). Deprecation warnings\n // can also be annoying when they are outside of the user's control, e.g.\n // when an external library calls unpatched Object.getOwnPropertyNames.\n // Since there is a clean fallback to `ownKeys`, the fact that the\n // deprecated method is still called is mostly harmless anyway.\n // See also issues #65 and #66.\n // console.warn(\"getOwnPropertyNames trap is deprecated. Use ownKeys instead\");\n return this.ownKeys();\n },\n\n /**\n * Checks whether the trap result does not contain any new properties\n * if the proxy is non-extensible.\n *\n * Any own non-configurable properties of the target that are not included\n * in the trap result give rise to a TypeError. As such, we check whether the\n * returned result contains at least all sealed properties of the target\n * object.\n *\n * Additionally, the trap result is normalized.\n * Instead of returning the trap result directly:\n * - create and return a fresh Array,\n * - of which each element is coerced to a String\n *\n * This trap is called a.o. by Reflect.ownKeys, Object.getOwnPropertyNames\n * and Object.keys (the latter filters out only the enumerable own properties).\n */\n ownKeys: function() {\n var trap = this.getTrap(\"ownKeys\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.ownKeys(this.target);\n }\n\n var trapResult = trap.call(this.handler, this.target);\n\n // propNames is used as a set of strings\n var propNames = Object.create(null);\n var numProps = +trapResult.length;\n var result = new Array(numProps);\n\n for (var i = 0; i < numProps; i++) {\n var s = String(trapResult[i]);\n if (!Object.isExtensible(this.target) && !isFixed(s, this.target)) {\n // non-extensible proxies don't tolerate new own property names\n throw new TypeError(\"ownKeys trap cannot list a new \"+\n \"property '\"+s+\"' on a non-extensible object\");\n }\n\n propNames[s] = true;\n result[i] = s;\n }\n\n var ownProps = Object_getOwnPropertyNames(this.target);\n var target = this.target;\n ownProps.forEach(function (ownProp) {\n if (!propNames[ownProp]) {\n if (isSealed(ownProp, target)) {\n throw new TypeError(\"ownKeys trap failed to include \"+\n \"non-configurable property '\"+ownProp+\"'\");\n }\n if (!Object.isExtensible(target) &&\n isFixed(ownProp, target)) {\n // if handler is allowed to report ownProp as non-existent,\n // we cannot guarantee that it will never later report it as\n // existent. Once a property has been reported as non-existent\n // on a non-extensible object, it should forever be reported as\n // non-existent\n throw new TypeError(\"ownKeys trap cannot report existing own property '\"+\n ownProp+\"' as non-existent on a non-extensible object\");\n }\n }\n });\n\n return result;\n },\n\n /**\n * Checks whether the trap result is consistent with the state of the\n * wrapped target.\n */\n isExtensible: function() {\n var trap = this.getTrap(\"isExtensible\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.isExtensible(this.target);\n }\n\n var result = trap.call(this.handler, this.target);\n result = !!result; // coerce to Boolean\n var state = Object_isExtensible(this.target);\n if (result !== state) {\n if (result) {\n throw new TypeError(\"cannot report non-extensible object as extensible: \"+\n this.target);\n } else {\n throw new TypeError(\"cannot report extensible object as non-extensible: \"+\n this.target);\n }\n }\n return state;\n },\n\n /**\n * Check whether the trap result corresponds to the target's [[Prototype]]\n */\n getPrototypeOf: function() {\n var trap = this.getTrap(\"getPrototypeOf\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.getPrototypeOf(this.target);\n }\n\n var allegedProto = trap.call(this.handler, this.target);\n\n if (!Object_isExtensible(this.target)) {\n var actualProto = Object_getPrototypeOf(this.target);\n if (!sameValue(allegedProto, actualProto)) {\n throw new TypeError(\"prototype value does not match: \" + this.target);\n }\n }\n\n return allegedProto;\n },\n\n /**\n * If target is non-extensible and setPrototypeOf trap returns true,\n * check whether the trap result corresponds to the target's [[Prototype]]\n */\n setPrototypeOf: function(newProto) {\n var trap = this.getTrap(\"setPrototypeOf\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.setPrototypeOf(this.target, newProto);\n }\n\n var success = trap.call(this.handler, this.target, newProto);\n\n success = !!success;\n if (success && !Object_isExtensible(this.target)) {\n var actualProto = Object_getPrototypeOf(this.target);\n if (!sameValue(newProto, actualProto)) {\n throw new TypeError(\"prototype value does not match: \" + this.target);\n }\n }\n\n return success;\n },\n\n /**\n * In the direct proxies design with refactored prototype climbing,\n * this trap is deprecated. For proxies-as-prototypes, for-in will\n * call the enumerate() trap. If that trap is not defined, the\n * operation is forwarded to the target, no more fallback on this\n * fundamental trap.\n */\n getPropertyNames: function() {\n throw new TypeError(\"getPropertyNames trap is deprecated\");\n },\n\n // === derived traps ===\n\n /**\n * If name denotes a fixed property, check whether the trap returns true.\n */\n has: function(name) {\n var trap = this.getTrap(\"has\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.has(this.target, name);\n }\n\n name = String(name);\n var res = trap.call(this.handler, this.target, name);\n res = !!res; // coerce to Boolean\n\n if (res === false) {\n if (isSealed(name, this.target)) {\n throw new TypeError(\"cannot report existing non-configurable own \"+\n \"property '\"+ name + \"' as a non-existent \"+\n \"property\");\n }\n if (!Object.isExtensible(this.target) &&\n isFixed(name, this.target)) {\n // if handler is allowed to return false, we cannot guarantee\n // that it will not return true for this property later.\n // Once a property has been reported as non-existent on a non-extensible\n // object, it should forever be reported as non-existent\n throw new TypeError(\"cannot report existing own property '\"+name+\n \"' as non-existent on a non-extensible object\");\n }\n }\n\n // if res === true, we don't need to check for extensibility\n // even for a non-extensible proxy that has no own name property,\n // the property may have been inherited\n\n return res;\n },\n\n /**\n * If name denotes a fixed non-configurable, non-writable data property,\n * check its return value against the previously asserted value of the\n * fixed property.\n */\n get: function(receiver, name) {\n\n // experimental support for invoke() trap on platforms that\n // support __noSuchMethod__\n /*\n if (name === '__noSuchMethod__') {\n var handler = this;\n return function(name, args) {\n return handler.invoke(receiver, name, args);\n }\n }\n */\n\n var trap = this.getTrap(\"get\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.get(this.target, name, receiver);\n }\n\n name = String(name);\n var res = trap.call(this.handler, this.target, name, receiver);\n\n var fixedDesc = Object.getOwnPropertyDescriptor(this.target, name);\n // check consistency of the returned value\n if (fixedDesc !== undefined) { // getting an existing property\n if (isDataDescriptor(fixedDesc) &&\n fixedDesc.configurable === false &&\n fixedDesc.writable === false) { // own frozen data property\n if (!sameValue(res, fixedDesc.value)) {\n throw new TypeError(\"cannot report inconsistent value for \"+\n \"non-writable, non-configurable property '\"+\n name+\"'\");\n }\n } else { // it's an accessor property\n if (isAccessorDescriptor(fixedDesc) &&\n fixedDesc.configurable === false &&\n fixedDesc.get === undefined) {\n if (res !== undefined) {\n throw new TypeError(\"must report undefined for non-configurable \"+\n \"accessor property '\"+name+\"' without getter\");\n }\n }\n }\n }\n\n return res;\n },\n\n /**\n * If name denotes a fixed non-configurable, non-writable data property,\n * check that the trap rejects the assignment.\n */\n set: function(receiver, name, val) {\n var trap = this.getTrap(\"set\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.set(this.target, name, val, receiver);\n }\n\n name = String(name);\n var res = trap.call(this.handler, this.target, name, val, receiver);\n res = !!res; // coerce to Boolean\n\n // if success is reported, check whether property is truly assignable\n if (res === true) {\n var fixedDesc = Object.getOwnPropertyDescriptor(this.target, name);\n if (fixedDesc !== undefined) { // setting an existing property\n if (isDataDescriptor(fixedDesc) &&\n fixedDesc.configurable === false &&\n fixedDesc.writable === false) {\n if (!sameValue(val, fixedDesc.value)) {\n throw new TypeError(\"cannot successfully assign to a \"+\n \"non-writable, non-configurable property '\"+\n name+\"'\");\n }\n } else {\n if (isAccessorDescriptor(fixedDesc) &&\n fixedDesc.configurable === false && // non-configurable\n fixedDesc.set === undefined) { // accessor with undefined setter\n throw new TypeError(\"setting a property '\"+name+\"' that has \"+\n \" only a getter\");\n }\n }\n }\n }\n\n return res;\n },\n\n /**\n * Any own enumerable non-configurable properties of the target that are not\n * included in the trap result give rise to a TypeError. As such, we check\n * whether the returned result contains at least all sealed enumerable properties\n * of the target object.\n *\n * The trap should return an iterator.\n *\n * However, as implementations of pre-direct proxies still expect enumerate\n * to return an array of strings, we convert the iterator into an array.\n */\n enumerate: function() {\n var trap = this.getTrap(\"enumerate\");\n if (trap === undefined) {\n // default forwarding behavior\n var trapResult = Reflect.enumerate(this.target);\n var result = [];\n var nxt = trapResult.next();\n while (!nxt.done) {\n result.push(String(nxt.value));\n nxt = trapResult.next();\n }\n return result;\n }\n\n var trapResult = trap.call(this.handler, this.target);\n \n if (trapResult === null ||\n trapResult === undefined ||\n trapResult.next === undefined) {\n throw new TypeError(\"enumerate trap should return an iterator, got: \"+\n trapResult); \n }\n \n // propNames is used as a set of strings\n var propNames = Object.create(null);\n \n // var numProps = +trapResult.length;\n var result = []; // new Array(numProps);\n \n // trapResult is supposed to be an iterator\n // drain iterator to array as current implementations still expect\n // enumerate to return an array of strings\n var nxt = trapResult.next();\n \n while (!nxt.done) {\n var s = String(nxt.value);\n if (propNames[s]) {\n throw new TypeError(\"enumerate trap cannot list a \"+\n \"duplicate property '\"+s+\"'\");\n }\n propNames[s] = true;\n result.push(s);\n nxt = trapResult.next();\n }\n \n /*for (var i = 0; i < numProps; i++) {\n var s = String(trapResult[i]);\n if (propNames[s]) {\n throw new TypeError(\"enumerate trap cannot list a \"+\n \"duplicate property '\"+s+\"'\");\n }\n\n propNames[s] = true;\n result[i] = s;\n } */\n\n var ownEnumerableProps = Object.keys(this.target);\n var target = this.target;\n ownEnumerableProps.forEach(function (ownEnumerableProp) {\n if (!propNames[ownEnumerableProp]) {\n if (isSealed(ownEnumerableProp, target)) {\n throw new TypeError(\"enumerate trap failed to include \"+\n \"non-configurable enumerable property '\"+\n ownEnumerableProp+\"'\");\n }\n if (!Object.isExtensible(target) &&\n isFixed(ownEnumerableProp, target)) {\n // if handler is allowed not to report ownEnumerableProp as an own\n // property, we cannot guarantee that it will never report it as\n // an own property later. Once a property has been reported as\n // non-existent on a non-extensible object, it should forever be\n // reported as non-existent\n throw new TypeError(\"cannot report existing own property '\"+\n ownEnumerableProp+\"' as non-existent on a \"+\n \"non-extensible object\");\n }\n }\n });\n\n return result;\n },\n\n /**\n * The iterate trap is deprecated by the enumerate trap.\n */\n iterate: Validator.prototype.enumerate,\n\n /**\n * Any own non-configurable properties of the target that are not included\n * in the trap result give rise to a TypeError. As such, we check whether the\n * returned result contains at least all sealed properties of the target\n * object.\n *\n * The trap result is normalized.\n * The trap result is not returned directly. Instead:\n * - create and return a fresh Array,\n * - of which each element is coerced to String,\n * - which does not contain duplicates\n *\n * FIXME: keys trap is deprecated\n */\n /*\n keys: function() {\n var trap = this.getTrap(\"keys\");\n if (trap === undefined) {\n // default forwarding behavior\n return Reflect.keys(this.target);\n }\n\n var trapResult = trap.call(this.handler, this.target);\n\n // propNames is used as a set of strings\n var propNames = Object.create(null);\n var numProps = +trapResult.length;\n var result = new Array(numProps);\n\n for (var i = 0; i < numProps; i++) {\n var s = String(trapResult[i]);\n if (propNames[s]) {\n throw new TypeError(\"keys trap cannot list a \"+\n \"duplicate property '\"+s+\"'\");\n }\n if (!Object.isExtensible(this.target) && !isFixed(s, this.target)) {\n // non-extensible proxies don't tolerate new own property names\n throw new TypeError(\"keys trap cannot list a new \"+\n \"property '\"+s+\"' on a non-extensible object\");\n }\n\n propNames[s] = true;\n result[i] = s;\n }\n\n var ownEnumerableProps = Object.keys(this.target);\n var target = this.target;\n ownEnumerableProps.forEach(function (ownEnumerableProp) {\n if (!propNames[ownEnumerableProp]) {\n if (isSealed(ownEnumerableProp, target)) {\n throw new TypeError(\"keys trap failed to include \"+\n \"non-configurable enumerable property '\"+\n ownEnumerableProp+\"'\");\n }\n if (!Object.isExtensible(target) &&\n isFixed(ownEnumerableProp, target)) {\n // if handler is allowed not to report ownEnumerableProp as an own\n // property, we cannot guarantee that it will never report it as\n // an own property later. Once a property has been reported as\n // non-existent on a non-extensible object, it should forever be\n // reported as non-existent\n throw new TypeError(\"cannot report existing own property '\"+\n ownEnumerableProp+\"' as non-existent on a \"+\n \"non-extensible object\");\n }\n }\n });\n\n return result;\n },\n */\n \n /**\n * New trap that reifies [[Call]].\n * If the target is a function, then a call to\n * proxy(...args)\n * Triggers this trap\n */\n apply: function(target, thisBinding, args) {\n var trap = this.getTrap(\"apply\");\n if (trap === undefined) {\n return Reflect.apply(target, thisBinding, args);\n }\n\n if (typeof this.target === \"function\") {\n return trap.call(this.handler, target, thisBinding, args);\n } else {\n throw new TypeError(\"apply: \"+ target + \" is not a function\");\n }\n },\n\n /**\n * New trap that reifies [[Construct]].\n * If the target is a function, then a call to\n * new proxy(...args)\n * Triggers this trap\n */\n construct: function(target, args, newTarget) {\n var trap = this.getTrap(\"construct\");\n if (trap === undefined) {\n return Reflect.construct(target, args, newTarget);\n }\n\n if (typeof target !== \"function\") {\n throw new TypeError(\"new: \"+ target + \" is not a function\");\n }\n\n if (newTarget === undefined) {\n newTarget = target;\n } else {\n if (typeof newTarget !== \"function\") {\n throw new TypeError(\"new: \"+ newTarget + \" is not a function\");\n } \n }\n return trap.call(this.handler, target, args, newTarget);\n }\n};\n\n// ---- end of the Validator handler wrapper handler ----\n\n// In what follows, a 'direct proxy' is a proxy\n// whose handler is a Validator. Such proxies can be made non-extensible,\n// sealed or frozen without losing the ability to trap.\n\n// maps direct proxies to their Validator handlers\nvar directProxies = new WeakMap();\n\n// patch Object.{preventExtensions,seal,freeze} so that\n// they recognize fixable proxies and act accordingly\nObject.preventExtensions = function(subject) {\n var vhandler = directProxies.get(subject);\n if (vhandler !== undefined) {\n if (vhandler.preventExtensions()) {\n return subject;\n } else {\n throw new TypeError(\"preventExtensions on \"+subject+\" rejected\");\n }\n } else {\n return prim_preventExtensions(subject);\n }\n};\nObject.seal = function(subject) {\n setIntegrityLevel(subject, \"sealed\");\n return subject;\n};\nObject.freeze = function(subject) {\n setIntegrityLevel(subject, \"frozen\");\n return subject;\n};\nObject.isExtensible = Object_isExtensible = function(subject) {\n var vHandler = directProxies.get(subject);\n if (vHandler !== undefined) {\n return vHandler.isExtensible();\n } else {\n return prim_isExtensible(subject);\n }\n};\nObject.isSealed = Object_isSealed = function(subject) {\n return testIntegrityLevel(subject, \"sealed\");\n};\nObject.isFrozen = Object_isFrozen = function(subject) {\n return testIntegrityLevel(subject, \"frozen\");\n};\nObject.getPrototypeOf = Object_getPrototypeOf = function(subject) {\n var vHandler = directProxies.get(subject);\n if (vHandler !== undefined) {\n return vHandler.getPrototypeOf();\n } else {\n return prim_getPrototypeOf(subject);\n }\n};\n\n// patch Object.getOwnPropertyDescriptor to directly call\n// the Validator.prototype.getOwnPropertyDescriptor trap\n// This is to circumvent an assertion in the built-in Proxy\n// trapping mechanism of v8, which disallows that trap to\n// return non-configurable property descriptors (as per the\n// old Proxy design)\nObject.getOwnPropertyDescriptor = function(subject, name) {\n var vhandler = directProxies.get(subject);\n if (vhandler !== undefined) {\n return vhandler.getOwnPropertyDescriptor(name);\n } else {\n return prim_getOwnPropertyDescriptor(subject, name);\n }\n};\n\n// patch Object.defineProperty to directly call\n// the Validator.prototype.defineProperty trap\n// This is to circumvent two issues with the built-in\n// trap mechanism:\n// 1) the current tracemonkey implementation of proxies\n// auto-completes 'desc', which is not correct. 'desc' should be\n// normalized, but not completed. Consider:\n// Object.defineProperty(proxy, 'foo', {enumerable:false})\n// This trap will receive desc =\n// {value:undefined,writable:false,enumerable:false,configurable:false}\n// This will also set all other attributes to their default value,\n// which is unexpected and different from [[DefineOwnProperty]].\n// Bug filed: https://bugzilla.mozilla.org/show_bug.cgi?id=601329\n// 2) the current spidermonkey implementation does not\n// throw an exception when this trap returns 'false', but instead silently\n// ignores the operation (this is regardless of strict-mode)\n// 2a) v8 does throw an exception for this case, but includes the rather\n// unhelpful error message:\n// 'Proxy handler #