'use strict';
|
|
var GetIntrinsic = require('get-intrinsic');
|
var callBound = require('call-bind/callBound');
|
var inspect = require('object-inspect');
|
|
var $TypeError = GetIntrinsic('%TypeError%');
|
var $WeakMap = GetIntrinsic('%WeakMap%', true);
|
var $Map = GetIntrinsic('%Map%', true);
|
|
var $weakMapGet = callBound('WeakMap.prototype.get', true);
|
var $weakMapSet = callBound('WeakMap.prototype.set', true);
|
var $weakMapHas = callBound('WeakMap.prototype.has', true);
|
var $mapGet = callBound('Map.prototype.get', true);
|
var $mapSet = callBound('Map.prototype.set', true);
|
var $mapHas = callBound('Map.prototype.has', true);
|
|
/*
|
* This function traverses the list returning the node corresponding to the
|
* given key.
|
*
|
* That node is also moved to the head of the list, so that if it's accessed
|
* again we don't need to traverse the whole list. By doing so, all the recently
|
* used nodes can be accessed relatively quickly.
|
*/
|
var listGetNode = function (list, key) { // eslint-disable-line consistent-return
|
for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
|
if (curr.key === key) {
|
prev.next = curr.next;
|
curr.next = list.next;
|
list.next = curr; // eslint-disable-line no-param-reassign
|
return curr;
|
}
|
}
|
};
|
|
var listGet = function (objects, key) {
|
var node = listGetNode(objects, key);
|
return node && node.value;
|
};
|
var listSet = function (objects, key, value) {
|
var node = listGetNode(objects, key);
|
if (node) {
|
node.value = value;
|
} else {
|
// Prepend the new node to the beginning of the list
|
objects.next = { // eslint-disable-line no-param-reassign
|
key: key,
|
next: objects.next,
|
value: value
|
};
|
}
|
};
|
var listHas = function (objects, key) {
|
return !!listGetNode(objects, key);
|
};
|
|
module.exports = function getSideChannel() {
|
var $wm;
|
var $m;
|
var $o;
|
var channel = {
|
assert: function (key) {
|
if (!channel.has(key)) {
|
throw new $TypeError('Side channel does not contain ' + inspect(key));
|
}
|
},
|
get: function (key) { // eslint-disable-line consistent-return
|
if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
|
if ($wm) {
|
return $weakMapGet($wm, key);
|
}
|
} else if ($Map) {
|
if ($m) {
|
return $mapGet($m, key);
|
}
|
} else {
|
if ($o) { // eslint-disable-line no-lonely-if
|
return listGet($o, key);
|
}
|
}
|
},
|
has: function (key) {
|
if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
|
if ($wm) {
|
return $weakMapHas($wm, key);
|
}
|
} else if ($Map) {
|
if ($m) {
|
return $mapHas($m, key);
|
}
|
} else {
|
if ($o) { // eslint-disable-line no-lonely-if
|
return listHas($o, key);
|
}
|
}
|
return false;
|
},
|
set: function (key, value) {
|
if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
|
if (!$wm) {
|
$wm = new $WeakMap();
|
}
|
$weakMapSet($wm, key, value);
|
} else if ($Map) {
|
if (!$m) {
|
$m = new $Map();
|
}
|
$mapSet($m, key, value);
|
} else {
|
if (!$o) {
|
/*
|
* Initialize the linked list as an empty node, so that we don't have
|
* to special-case handling of the first node: we can always refer to
|
* it as (previous node).next, instead of something like (list).head
|
*/
|
$o = { key: {}, next: null };
|
}
|
listSet($o, key, value);
|
}
|
}
|
};
|
return channel;
|
};
|
