🚀. Socket Launch Week Day 2:Introducing Manifest Alerts.Learn more →
Sign In

@tko/provider.native

Package Overview
Dependencies
Maintainers
1
Versions
22
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@tko/provider.native - npm Package Compare versions

Comparing version
4.0.0-alpha8.4a
 to
4.0.0-beta1.0
+1337
dist/index.cjs
// @tko/provider.native 🥊 4.0.0-beta1.0 CommonJS
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// index.ts
var provider_exports = {};
__export(provider_exports, {
NATIVE_BINDINGS: () => NATIVE_BINDINGS,
NativeProvider: () => NativeProvider
});
module.exports = __toCommonJS(provider_exports);
// ../utils/dist/array.js
var { isArray } = Array;
function arrayForEach(array, action, thisArg) {
if (arguments.length > 2) {
action = action.bind(thisArg);
}
for (let i = 0, j = array.length; i < j; ++i) {
action(array[i], i, array);
}
}
function arrayIndexOf(array, item) {
return (isArray(array) ? array : [...array]).indexOf(item);
}
function arrayRemoveItem(array, itemToRemove) {
var index = arrayIndexOf(array, itemToRemove);
if (index > 0) {
array.splice(index, 1);
} else if (index === 0) {
array.shift();
}
}
function findMovesInArrayComparison(left, right, limitFailedCompares) {
if (left.length && right.length) {
var failedCompares, l, r, leftItem, rightItem;
for (failedCompares = l = 0; (!limitFailedCompares || failedCompares < limitFailedCompares) && (leftItem = left[l]); ++l) {
for (r = 0; rightItem = right[r]; ++r) {
if (leftItem.value === rightItem.value) {
leftItem.moved = rightItem.index;
rightItem.moved = leftItem.index;
right.splice(r, 1);
failedCompares = r = 0;
break;
}
}
failedCompares += r;
}
}
}
var statusNotInOld = "added";
var statusNotInNew = "deleted";
function compareArrays(oldArray, newArray, options2) {
options2 = typeof options2 === "boolean" ? { dontLimitMoves: options2 } : options2 || {};
oldArray = oldArray || [];
newArray = newArray || [];
if (oldArray.length < newArray.length) {
return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options2);
} else {
return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options2);
}
}
function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options2) {
var myMin = Math.min, myMax = Math.max, editDistanceMatrix = [], smlIndex, smlIndexMax = smlArray.length, bigIndex, bigIndexMax = bigArray.length, compareRange = bigIndexMax - smlIndexMax || 1, maxDistance = smlIndexMax + bigIndexMax + 1, thisRow, lastRow, bigIndexMaxForRow, bigIndexMinForRow;
for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
lastRow = thisRow;
editDistanceMatrix.push(thisRow = []);
bigIndexMaxForRow = myMin(bigIndexMax, smlIndex + compareRange);
bigIndexMinForRow = myMax(0, smlIndex - 1);
for (bigIndex = bigIndexMinForRow; bigIndex <= bigIndexMaxForRow; bigIndex++) {
if (!bigIndex) {
thisRow[bigIndex] = smlIndex + 1;
} else if (!smlIndex) {
thisRow[bigIndex] = bigIndex + 1;
} else if (smlArray[smlIndex - 1] === bigArray[bigIndex - 1]) {
thisRow[bigIndex] = lastRow[bigIndex - 1];
} else {
var northDistance = lastRow[bigIndex] || maxDistance;
var westDistance = thisRow[bigIndex - 1] || maxDistance;
thisRow[bigIndex] = myMin(northDistance, westDistance) + 1;
}
}
}
var editScript = [], meMinusOne, notInSml = [], notInBig = [];
for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex; ) {
meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1;
if (bigIndex && meMinusOne === editDistanceMatrix[smlIndex][bigIndex - 1]) {
notInSml.push(editScript[editScript.length] = {
"status": statusNotInSml,
"value": bigArray[--bigIndex],
"index": bigIndex
});
} else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {
notInBig.push(editScript[editScript.length] = {
"status": statusNotInBig,
"value": smlArray[--smlIndex],
"index": smlIndex
});
} else {
--bigIndex;
--smlIndex;
if (!options2.sparse) {
editScript.push({
"status": "retained",
"value": bigArray[bigIndex]
});
}
}
}
findMovesInArrayComparison(notInBig, notInSml, !options2.dontLimitMoves && smlIndexMax * 10);
return editScript.reverse();
}
// ../utils/dist/options.js
var options = {
deferUpdates: false,
useOnlyNativeEvents: false,
protoProperty: "__ko_proto__",
defaultBindingAttribute: "data-bind",
allowVirtualElements: true,
bindingGlobals: /* @__PURE__ */ Object.create(null),
bindingProviderInstance: null,
createChildContextWithAs: false,
jQuery: globalThis.jQuery,
Promise: globalThis.Promise,
taskScheduler: null,
debug: false,
global: globalThis,
document: globalThis.document,
filters: {},
includeDestroyed: false,
foreachHidesDestroyed: false,
onError: function(e) {
throw e;
},
set: function(name, value) {
options[name] = value;
},
getBindingHandler() {
},
cleanExternalData() {
}
};
Object.defineProperty(options, "$", {
get: function() {
return options.jQuery;
}
});
var options_default = options;
// ../utils/dist/error.js
function catchFunctionErrors(delegate) {
if (!options_default.onError) {
return delegate;
}
return (...args) => {
try {
return delegate(...args);
} catch (err) {
options_default.onError(err);
}
};
}
function deferError(error) {
safeSetTimeout(function() {
throw error;
}, 0);
}
function safeSetTimeout(handler, timeout) {
return setTimeout(catchFunctionErrors(handler), timeout);
}
// ../utils/dist/async.js
function throttle(callback, timeout) {
var timeoutInstance;
return function(...args) {
if (!timeoutInstance) {
timeoutInstance = safeSetTimeout(function() {
timeoutInstance = void 0;
callback(...args);
}, timeout);
}
};
}
function debounce(callback, timeout) {
var timeoutInstance;
return function(...args) {
clearTimeout(timeoutInstance);
timeoutInstance = safeSetTimeout(() => callback(...args), timeout);
};
}
// ../utils/dist/ie.js
var ieVersion = options_default.document && function() {
var version = 3, div = options_default.document.createElement("div"), iElems = div.getElementsByTagName("i");
while (div.innerHTML = "<!--[if gt IE " + ++version + "]><i></i><![endif]-->", iElems[0]) {
}
if (!version) {
const userAgent = window.navigator.userAgent;
return ua.match(/MSIE ([^ ]+)/) || ua.match(/rv:([^ )]+)/);
}
return version > 4 ? version : void 0;
}();
// ../utils/dist/object.js
function hasOwnProperty(obj, propName) {
return Object.prototype.hasOwnProperty.call(obj, propName);
}
function extend(target, source) {
if (source) {
for (var prop in source) {
if (hasOwnProperty(source, prop)) {
target[prop] = source[prop];
}
}
}
return target;
}
function objectForEach(obj, action) {
for (var prop in obj) {
if (hasOwnProperty(obj, prop)) {
action(prop, obj[prop]);
}
}
}
function objectMap(source, mapping, thisArg) {
if (!source) {
return source;
}
if (arguments.length > 2) {
mapping = mapping.bind(thisArg);
}
var target = {};
for (var prop in source) {
if (hasOwnProperty(source, prop)) {
target[prop] = mapping(source[prop], prop, source);
}
}
return target;
}
// ../utils/dist/function.js
function testOverwrite() {
try {
Object.defineProperty(function x() {
}, "length", {});
return true;
} catch (e) {
return false;
}
}
var functionSupportsLengthOverwrite = testOverwrite();
function overwriteLengthPropertyIfSupported(fn, descriptor) {
if (functionSupportsLengthOverwrite) {
Object.defineProperty(fn, "length", descriptor);
}
}
// ../utils/dist/jquery.js
var jQueryInstance = options_default.global && options_default.global.jQuery;
// ../utils/dist/dom/info.js
function tagNameLower(element) {
return element && element.tagName && element.tagName.toLowerCase();
}
// ../utils/dist/dom/data.js
var datastoreTime = new Date().getTime();
var dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`;
var dataStoreSymbol = Symbol("Knockout data");
var dataStore;
var uniqueId = 0;
var modern = {
getDataForNode(node, createIfNotFound) {
let dataForNode = node[dataStoreSymbol];
if (!dataForNode && createIfNotFound) {
dataForNode = node[dataStoreSymbol] = {};
}
return dataForNode;
},
clear(node) {
if (node[dataStoreSymbol]) {
delete node[dataStoreSymbol];
return true;
}
return false;
}
};
var IE = {
getDataforNode(node, createIfNotFound) {
let dataStoreKey = node[dataStoreKeyExpandoPropertyName];
const hasExistingDataStore = dataStoreKey && dataStoreKey !== "null" && dataStore[dataStoreKey];
if (!hasExistingDataStore) {
if (!createIfNotFound) {
return void 0;
}
dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;
dataStore[dataStoreKey] = {};
}
return dataStore[dataStoreKey];
},
clear(node) {
const dataStoreKey = node[dataStoreKeyExpandoPropertyName];
if (dataStoreKey) {
delete dataStore[dataStoreKey];
node[dataStoreKeyExpandoPropertyName] = null;
return true;
}
return false;
}
};
var { getDataForNode, clear } = ieVersion ? IE : modern;
function nextKey() {
return uniqueId++ + dataStoreKeyExpandoPropertyName;
}
function get(node, key) {
const dataForNode = getDataForNode(node, false);
return dataForNode && dataForNode[key];
}
function set(node, key, value) {
var dataForNode = getDataForNode(node, value !== void 0);
dataForNode && (dataForNode[key] = value);
}
// ../utils/dist/dom/disposal.js
var domDataKey = nextKey();
function getDisposeCallbacksCollection(node, createIfNotFound) {
var allDisposeCallbacks = get(node, domDataKey);
if (allDisposeCallbacks === void 0 && createIfNotFound) {
allDisposeCallbacks = [];
set(node, domDataKey, allDisposeCallbacks);
}
return allDisposeCallbacks;
}
function destroyCallbacksCollection(node) {
set(node, domDataKey, void 0);
}
function addDisposeCallback(node, callback) {
if (typeof callback !== "function") {
throw new Error("Callback must be a function");
}
getDisposeCallbacksCollection(node, true).push(callback);
}
function removeDisposeCallback(node, callback) {
var callbacksCollection = getDisposeCallbacksCollection(node, false);
if (callbacksCollection) {
arrayRemoveItem(callbacksCollection, callback);
if (callbacksCollection.length === 0) {
destroyCallbacksCollection(node);
}
}
}
var otherNodeCleanerFunctions = [];
function cleanjQueryData(node) {
var jQueryCleanNodeFn = jQueryInstance ? jQueryInstance.cleanData : null;
if (jQueryCleanNodeFn) {
jQueryCleanNodeFn([node]);
}
}
otherNodeCleanerFunctions.push(cleanjQueryData);
// ../utils/dist/dom/event.js
var knownEvents = {};
var knownEventTypesByEventName = {};
var keyEventTypeName = options_default.global.navigator && /Firefox\/2/i.test(options_default.global.navigator.userAgent) ? "KeyboardEvent" : "UIEvents";
knownEvents[keyEventTypeName] = ["keyup", "keydown", "keypress"];
knownEvents["MouseEvents"] = [
"click",
"dblclick",
"mousedown",
"mouseup",
"mousemove",
"mouseover",
"mouseout",
"mouseenter",
"mouseleave"
];
objectForEach(knownEvents, function(eventType, knownEventsForType) {
if (knownEventsForType.length) {
for (var i = 0, j = knownEventsForType.length; i < j; i++) {
knownEventTypesByEventName[knownEventsForType[i]] = eventType;
}
}
});
// ../utils/dist/dom/virtualElements.js
var commentNodesHaveTextProperty = options_default.document && options_default.document.createComment("test").text === "<!--test-->";
// ../utils/dist/dom/html.js
var supportsTemplateTag = options_default.document && "content" in options_default.document.createElement("template");
// ../utils/dist/dom/selectExtensions.js
var hasDomDataExpandoProperty = Symbol("Knockout selectExtensions hasDomDataProperty");
var selectExtensions = {
optionValueDomDataKey: nextKey(),
readValue: function(element) {
switch (tagNameLower(element)) {
case "option":
if (element[hasDomDataExpandoProperty] === true) {
return get(element, selectExtensions.optionValueDomDataKey);
}
return element.value;
case "select":
return element.selectedIndex >= 0 ? selectExtensions.readValue(element.options[element.selectedIndex]) : void 0;
default:
return element.value;
}
},
writeValue: function(element, value, allowUnset) {
switch (tagNameLower(element)) {
case "option":
if (typeof value === "string") {
set(element, selectExtensions.optionValueDomDataKey, void 0);
if (hasDomDataExpandoProperty in element) {
delete element[hasDomDataExpandoProperty];
}
element.value = value;
} else {
set(element, selectExtensions.optionValueDomDataKey, value);
element[hasDomDataExpandoProperty] = true;
element.value = typeof value === "number" ? value : "";
}
break;
case "select":
if (value === "" || value === null) {
value = void 0;
}
var selection = -1;
for (let i = 0, n = element.options.length, optionValue; i < n; ++i) {
optionValue = selectExtensions.readValue(element.options[i]);
const strictEqual = optionValue === value;
const blankEqual = optionValue === "" && value === void 0;
const numericEqual = typeof value === "number" && Number(optionValue) === value;
if (strictEqual || blankEqual || numericEqual) {
selection = i;
break;
}
}
if (allowUnset || selection >= 0 || value === void 0 && element.size > 1) {
element.selectedIndex = selection;
}
break;
default:
if (value === null || value === void 0) {
value = "";
}
element.value = value;
break;
}
}
};
// ../utils/dist/tasks.js
var tasks_exports = {};
__export(tasks_exports, {
cancel: () => cancel,
resetForTesting: () => resetForTesting,
runEarly: () => processTasks,
schedule: () => schedule
});
var taskQueue = [];
var taskQueueLength = 0;
var nextHandle = 1;
var nextIndexToProcess = 0;
var w = options_default.global;
if (w && w.MutationObserver && !(w.navigator && w.navigator.standalone)) {
options_default.taskScheduler = function(callback) {
var div = w.document.createElement("div");
new w.MutationObserver(callback).observe(div, { attributes: true });
return function() {
div.classList.toggle("foo");
};
}(scheduledProcess);
} else if (w && w.document && "onreadystatechange" in w.document.createElement("script")) {
options_default.taskScheduler = function(callback) {
var script = document.createElement("script");
script.onreadystatechange = function() {
script.onreadystatechange = null;
document.documentElement.removeChild(script);
script = null;
callback();
};
document.documentElement.appendChild(script);
};
} else {
options_default.taskScheduler = function(callback) {
setTimeout(callback, 0);
};
}
function processTasks() {
if (taskQueueLength) {
var mark = taskQueueLength, countMarks = 0;
for (var task; nextIndexToProcess < taskQueueLength; ) {
if (task = taskQueue[nextIndexToProcess++]) {
if (nextIndexToProcess > mark) {
if (++countMarks >= 5e3) {
nextIndexToProcess = taskQueueLength;
deferError(Error("'Too much recursion' after processing " + countMarks + " task groups."));
break;
}
mark = taskQueueLength;
}
try {
task();
} catch (ex) {
deferError(ex);
}
}
}
}
}
function scheduledProcess() {
processTasks();
nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
}
function scheduleTaskProcessing() {
options_default.taskScheduler(scheduledProcess);
}
function schedule(func) {
if (!taskQueueLength) {
scheduleTaskProcessing();
}
taskQueue[taskQueueLength++] = func;
return nextHandle++;
}
function cancel(handle) {
var index = handle - (nextHandle - taskQueueLength);
if (index >= nextIndexToProcess && index < taskQueueLength) {
taskQueue[index] = null;
}
}
function resetForTesting() {
var length = taskQueueLength - nextIndexToProcess;
nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
return length;
}
// ../observable/dist/dependencyDetection.js
var dependencyDetection_exports = {};
__export(dependencyDetection_exports, {
begin: () => begin,
end: () => end,
getDependencies: () => getDependencies,
getDependenciesCount: () => getDependenciesCount,
ignore: () => ignore,
ignoreDependencies: () => ignore,
isInitial: () => isInitial,
registerDependency: () => registerDependency
});
// ../observable/dist/subscribableSymbol.js
var SUBSCRIBABLE_SYM = Symbol("Knockout Subscribable");
function isSubscribable(instance) {
return instance && instance[SUBSCRIBABLE_SYM] || false;
}
// ../observable/dist/dependencyDetection.js
var outerFrames = [];
var currentFrame;
var lastId = 0;
function getId() {
return ++lastId;
}
function begin(options2) {
outerFrames.push(currentFrame);
currentFrame = options2;
}
function end() {
currentFrame = outerFrames.pop();
}
function registerDependency(subscribable2) {
if (currentFrame) {
if (!isSubscribable(subscribable2)) {
throw new Error("Only subscribable things can act as dependencies");
}
currentFrame.callback.call(currentFrame.callbackTarget, subscribable2, subscribable2._id || (subscribable2._id = getId()));
}
}
function ignore(callback, callbackTarget, callbackArgs) {
try {
begin();
return callback.apply(callbackTarget, callbackArgs || []);
} finally {
end();
}
}
function getDependenciesCount() {
if (currentFrame) {
return currentFrame.computed.getDependenciesCount();
}
}
function getDependencies() {
if (currentFrame) {
return currentFrame.computed.getDependencies();
}
}
function isInitial() {
if (currentFrame) {
return currentFrame.isInitial;
}
}
// ../observable/dist/defer.js
function deferUpdates(target) {
if (target._deferUpdates) {
return;
}
target._deferUpdates = true;
target.limit(function(callback) {
let handle;
let ignoreUpdates = false;
return function() {
if (!ignoreUpdates) {
tasks_exports.cancel(handle);
handle = tasks_exports.schedule(callback);
try {
ignoreUpdates = true;
target.notifySubscribers(void 0, "dirty");
} finally {
ignoreUpdates = false;
}
}
};
});
}
// ../observable/dist/Subscription.js
var Subscription = class {
constructor(target, observer, disposeCallback) {
this._target = target;
this._callback = observer.next;
this._disposeCallback = disposeCallback;
this._isDisposed = false;
this._domNodeDisposalCallback = null;
}
dispose() {
if (this._domNodeDisposalCallback) {
removeDisposeCallback(this._node, this._domNodeDisposalCallback);
}
this._isDisposed = true;
this._disposeCallback();
}
disposeWhenNodeIsRemoved(node) {
this._node = node;
addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));
}
unsubscribe() {
this.dispose();
}
get closed() {
return this._isDisposed;
}
};
// ../observable/dist/extenders.js
var primitiveTypes = {
"undefined": 1,
"boolean": 1,
"number": 1,
"string": 1
};
function valuesArePrimitiveAndEqual(a, b) {
var oldValueIsPrimitive = a === null || typeof a in primitiveTypes;
return oldValueIsPrimitive ? a === b : false;
}
function applyExtenders(requestedExtenders) {
var target = this;
if (requestedExtenders) {
objectForEach(requestedExtenders, function(key, value) {
var extenderHandler = extenders[key];
if (typeof extenderHandler === "function") {
target = extenderHandler(target, value) || target;
} else {
options_default.onError(new Error("Extender not found: " + key));
}
});
}
return target;
}
function notify(target, notifyWhen) {
target.equalityComparer = notifyWhen == "always" ? null : valuesArePrimitiveAndEqual;
}
function deferred(target, option) {
if (option !== true) {
throw new Error("The 'deferred' extender only accepts the value 'true', because it is not supported to turn deferral off once enabled.");
}
deferUpdates(target);
}
function rateLimit(target, options2) {
var timeout, method, limitFunction;
if (typeof options2 === "number") {
timeout = options2;
} else {
timeout = options2.timeout;
method = options2.method;
}
target._deferUpdates = false;
limitFunction = method === "notifyWhenChangesStop" ? debounce : throttle;
target.limit(function(callback) {
return limitFunction(callback, timeout);
});
}
var extenders = {
notify,
deferred,
rateLimit
};
// ../observable/dist/subscribable.js
var LATEST_VALUE = Symbol("Knockout latest value");
if (!Symbol.observable) {
Symbol.observable = Symbol.for("@tko/Symbol.observable");
}
function subscribable() {
Object.setPrototypeOf(this, ko_subscribable_fn);
ko_subscribable_fn.init(this);
}
var defaultEvent = "change";
var ko_subscribable_fn = {
[SUBSCRIBABLE_SYM]: true,
[Symbol.observable]() {
return this;
},
init(instance) {
instance._subscriptions = { change: [] };
instance._versionNumber = 1;
},
subscribe(callback, callbackTarget, event) {
const isTC39Callback = typeof callback === "object" && callback.next;
event = event || defaultEvent;
const observer = isTC39Callback ? callback : {
next: callbackTarget ? callback.bind(callbackTarget) : callback
};
const subscriptionInstance = new Subscription(this, observer, () => {
arrayRemoveItem(this._subscriptions[event], subscriptionInstance);
if (this.afterSubscriptionRemove) {
this.afterSubscriptionRemove(event);
}
});
if (this.beforeSubscriptionAdd) {
this.beforeSubscriptionAdd(event);
}
if (!this._subscriptions[event]) {
this._subscriptions[event] = [];
}
this._subscriptions[event].push(subscriptionInstance);
if (isTC39Callback && LATEST_VALUE in this) {
observer.next(this[LATEST_VALUE]);
}
return subscriptionInstance;
},
notifySubscribers(valueToNotify, event) {
event = event || defaultEvent;
if (event === defaultEvent) {
this.updateVersion();
}
if (this.hasSubscriptionsForEvent(event)) {
const subs = event === defaultEvent && this._changeSubscriptions || [...this._subscriptions[event]];
try {
begin();
for (let i = 0, subscriptionInstance; subscriptionInstance = subs[i]; ++i) {
if (!subscriptionInstance._isDisposed) {
subscriptionInstance._callback(valueToNotify);
}
}
} finally {
end();
}
}
},
getVersion() {
return this._versionNumber;
},
hasChanged(versionToCheck) {
return this.getVersion() !== versionToCheck;
},
updateVersion() {
++this._versionNumber;
},
hasSubscriptionsForEvent(event) {
return this._subscriptions[event] && this._subscriptions[event].length;
},
getSubscriptionsCount(event) {
if (event) {
return this._subscriptions[event] && this._subscriptions[event].length || 0;
} else {
var total = 0;
objectForEach(this._subscriptions, function(eventName, subscriptions) {
if (eventName !== "dirty") {
total += subscriptions.length;
}
});
return total;
}
},
isDifferent(oldValue, newValue) {
return !this.equalityComparer || !this.equalityComparer(oldValue, newValue);
},
once(cb) {
const subs = this.subscribe((nv) => {
subs.dispose();
cb(nv);
});
},
when(test, returnValue) {
const current = this.peek();
const givenRv = arguments.length > 1;
const testFn = typeof test === "function" ? test : (v) => v === test;
if (testFn(current)) {
return options_default.Promise.resolve(givenRv ? returnValue : current);
}
return new options_default.Promise((resolve, reject) => {
const subs = this.subscribe((newValue) => {
if (testFn(newValue)) {
subs.dispose();
resolve(givenRv ? returnValue : newValue);
}
});
});
},
yet(test, ...args) {
const testFn = typeof test === "function" ? test : (v) => v === test;
const negated = (v) => !testFn(v);
return this.when(negated, ...args);
},
next() {
return new Promise((resolve) => this.once(resolve));
},
toString() {
return "[object Object]";
},
extend: applyExtenders
};
Object.setPrototypeOf(ko_subscribable_fn, Function.prototype);
subscribable.fn = ko_subscribable_fn;
// ../observable/dist/observable.js
function observable(initialValue) {
function Observable() {
if (arguments.length > 0) {
if (Observable.isDifferent(Observable[LATEST_VALUE], arguments[0])) {
Observable.valueWillMutate();
Observable[LATEST_VALUE] = arguments[0];
Observable.valueHasMutated();
}
return this;
} else {
registerDependency(Observable);
return Observable[LATEST_VALUE];
}
}
overwriteLengthPropertyIfSupported(Observable, { value: void 0 });
Observable[LATEST_VALUE] = initialValue;
subscribable.fn.init(Observable);
Object.setPrototypeOf(Observable, observable.fn);
if (options_default.deferUpdates) {
deferUpdates(Observable);
}
return Observable;
}
observable.fn = {
equalityComparer: valuesArePrimitiveAndEqual,
peek() {
return this[LATEST_VALUE];
},
valueHasMutated() {
this.notifySubscribers(this[LATEST_VALUE], "spectate");
this.notifySubscribers(this[LATEST_VALUE]);
},
valueWillMutate() {
this.notifySubscribers(this[LATEST_VALUE], "beforeChange");
},
modify(fn, peek2 = true) {
return this(fn(peek2 ? this.peek() : this()));
},
isWriteable: true
};
function limitNotifySubscribers(value, event) {
if (!event || event === defaultEvent) {
this._limitChange(value);
} else if (event === "beforeChange") {
this._limitBeforeChange(value);
} else {
this._origNotifySubscribers(value, event);
}
}
subscribable.fn.limit = function limit(limitFunction) {
var self = this;
var selfIsObservable = isObservable(self);
var beforeChange = "beforeChange";
var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;
if (!self._origNotifySubscribers) {
self._origNotifySubscribers = self.notifySubscribers;
self.notifySubscribers = limitNotifySubscribers;
}
var finish = limitFunction(function() {
self._notificationIsPending = false;
if (selfIsObservable && pendingValue === self) {
pendingValue = self._evalIfChanged ? self._evalIfChanged() : self();
}
const shouldNotify = notifyNextChange || didUpdate && self.isDifferent(previousValue, pendingValue);
self._notifyNextChange = didUpdate = ignoreBeforeChange = false;
if (shouldNotify) {
self._origNotifySubscribers(previousValue = pendingValue);
}
});
Object.assign(self, {
_limitChange(value, isDirty) {
if (!isDirty || !self._notificationIsPending) {
didUpdate = !isDirty;
}
self._changeSubscriptions = [...self._subscriptions[defaultEvent]];
self._notificationIsPending = ignoreBeforeChange = true;
pendingValue = value;
finish();
},
_limitBeforeChange(value) {
if (!ignoreBeforeChange) {
previousValue = value;
self._origNotifySubscribers(value, beforeChange);
}
},
_notifyNextChangeIfValueIsDifferent() {
if (self.isDifferent(previousValue, self.peek(true))) {
notifyNextChange = true;
}
},
_recordUpdate() {
didUpdate = true;
}
});
};
Object.setPrototypeOf(observable.fn, subscribable.fn);
var protoProperty = observable.protoProperty = options_default.protoProperty;
observable.fn[protoProperty] = observable;
observable.observablePrototypes = /* @__PURE__ */ new Set([observable]);
function isObservable(instance) {
const proto = typeof instance === "function" && instance[protoProperty];
if (proto && !observable.observablePrototypes.has(proto)) {
throw Error("Invalid object that looks like an observable; possibly from another Knockout instance");
}
return !!proto;
}
// ../observable/dist/observableArray.changeTracking.js
var arrayChangeEventName = "arrayChange";
function trackArrayChanges(target, options2) {
target.compareArrayOptions = {};
if (options2 && typeof options2 === "object") {
extend(target.compareArrayOptions, options2);
}
target.compareArrayOptions.sparse = true;
if (target.cacheDiffForKnownOperation) {
return;
}
let trackingChanges = false;
let cachedDiff = null;
let arrayChangeSubscription;
let pendingNotifications = 0;
let underlyingNotifySubscribersFunction;
let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
target.beforeSubscriptionAdd = function(event) {
if (underlyingBeforeSubscriptionAddFunction) {
underlyingBeforeSubscriptionAddFunction.call(target, event);
}
if (event === arrayChangeEventName) {
trackChanges();
}
};
target.afterSubscriptionRemove = function(event) {
if (underlyingAfterSubscriptionRemoveFunction) {
underlyingAfterSubscriptionRemoveFunction.call(target, event);
}
if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
if (underlyingNotifySubscribersFunction) {
target.notifySubscribers = underlyingNotifySubscribersFunction;
underlyingNotifySubscribersFunction = void 0;
}
if (arrayChangeSubscription) {
arrayChangeSubscription.dispose();
}
arrayChangeSubscription = null;
trackingChanges = false;
}
};
function trackChanges() {
if (trackingChanges) {
return;
}
trackingChanges = true;
underlyingNotifySubscribersFunction = target["notifySubscribers"];
target.notifySubscribers = function(valueToNotify, event) {
if (!event || event === defaultEvent) {
++pendingNotifications;
}
return underlyingNotifySubscribersFunction.apply(this, arguments);
};
var previousContents = [].concat(target.peek() === void 0 ? [] : target.peek());
cachedDiff = null;
arrayChangeSubscription = target.subscribe(function(currentContents) {
let changes;
currentContents = [].concat(currentContents || []);
if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
changes = getChanges(previousContents, currentContents);
}
previousContents = currentContents;
cachedDiff = null;
pendingNotifications = 0;
if (changes && changes.length) {
target.notifySubscribers(changes, arrayChangeEventName);
}
});
}
function getChanges(previousContents, currentContents) {
if (!cachedDiff || pendingNotifications > 1) {
cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions);
}
return cachedDiff;
}
target.cacheDiffForKnownOperation = function(rawArray, operationName, args) {
if (!trackingChanges || pendingNotifications) {
return;
}
var diff = [], arrayLength = rawArray.length, argsLength = args.length, offset = 0;
function pushDiff(status, value, index) {
return diff[diff.length] = { "status": status, "value": value, "index": index };
}
switch (operationName) {
case "push":
offset = arrayLength;
case "unshift":
for (let index = 0; index < argsLength; index++) {
pushDiff("added", args[index], offset + index);
}
break;
case "pop":
offset = arrayLength - 1;
case "shift":
if (arrayLength) {
pushDiff("deleted", rawArray[offset], offset);
}
break;
case "splice":
var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength), endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength), endAddIndex = startIndex + argsLength - 2, endIndex = Math.max(endDeleteIndex, endAddIndex), additions = [], deletions = [];
for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
if (index < endDeleteIndex) {
deletions.push(pushDiff("deleted", rawArray[index], index));
}
if (index < endAddIndex) {
additions.push(pushDiff("added", args[argsIndex], index));
}
}
findMovesInArrayComparison(deletions, additions);
break;
default:
return;
}
cachedDiff = diff;
};
}
trackArrayChanges.compareArrays = compareArrays;
extenders.trackArrayChanges = trackArrayChanges;
// ../observable/dist/observableArray.js
function observableArray(initialValues) {
initialValues = initialValues || [];
if (typeof initialValues !== "object" || !("length" in initialValues)) {
throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
}
var result = observable(initialValues);
Object.setPrototypeOf(result, observableArray.fn);
trackArrayChanges(result);
overwriteLengthPropertyIfSupported(result, { get: () => result().length });
return result;
}
observableArray.fn = {
remove(valueOrPredicate) {
var underlyingArray = this.peek();
var removedValues = [];
var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
return value2 === valueOrPredicate;
};
for (var i = 0; i < underlyingArray.length; i++) {
var value = underlyingArray[i];
if (predicate(value)) {
if (removedValues.length === 0) {
this.valueWillMutate();
}
if (underlyingArray[i] !== value) {
throw Error("Array modified during remove; cannot remove item");
}
removedValues.push(value);
underlyingArray.splice(i, 1);
i--;
}
}
if (removedValues.length) {
this.valueHasMutated();
}
return removedValues;
},
removeAll(arrayOfValues) {
if (arrayOfValues === void 0) {
var underlyingArray = this.peek();
var allValues = underlyingArray.slice(0);
this.valueWillMutate();
underlyingArray.splice(0, underlyingArray.length);
this.valueHasMutated();
return allValues;
}
if (!arrayOfValues) {
return [];
}
return this["remove"](function(value) {
return arrayIndexOf(arrayOfValues, value) >= 0;
});
},
destroy(valueOrPredicate) {
var underlyingArray = this.peek();
var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
return value2 === valueOrPredicate;
};
this.valueWillMutate();
for (var i = underlyingArray.length - 1; i >= 0; i--) {
var value = underlyingArray[i];
if (predicate(value)) {
value["_destroy"] = true;
}
}
this.valueHasMutated();
},
destroyAll(arrayOfValues) {
if (arrayOfValues === void 0) {
return this.destroy(function() {
return true;
});
}
if (!arrayOfValues) {
return [];
}
return this.destroy(function(value) {
return arrayIndexOf(arrayOfValues, value) >= 0;
});
},
indexOf(item) {
return arrayIndexOf(this(), item);
},
replace(oldItem, newItem) {
var index = this.indexOf(oldItem);
if (index >= 0) {
this.valueWillMutate();
this.peek()[index] = newItem;
this.valueHasMutated();
}
},
sorted(compareFn) {
return [...this()].sort(compareFn);
},
reversed() {
return [...this()].reverse();
},
[Symbol.iterator]: function* () {
yield* this();
}
};
Object.setPrototypeOf(observableArray.fn, observable.fn);
arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function(methodName) {
observableArray.fn[methodName] = function() {
var underlyingArray = this.peek();
this.valueWillMutate();
this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
this.valueHasMutated();
return methodCallResult === underlyingArray ? this : methodCallResult;
};
});
arrayForEach(["slice"], function(methodName) {
observableArray.fn[methodName] = function() {
var underlyingArray = this();
return underlyingArray[methodName].apply(underlyingArray, arguments);
};
});
observableArray.trackArrayChanges = trackArrayChanges;
// ../provider/dist/BindingHandlerObject.js
var BindingHandlerObject = class {
set(nameOrObject, value) {
if (typeof nameOrObject === "string") {
this[nameOrObject] = value;
} else if (typeof nameOrObject === "object") {
if (value !== void 0) {
options_default.onError(new Error("Given extraneous `value` parameter (first param should be a string, but it was an object)." + nameOrObject));
}
Object.assign(this, nameOrObject);
} else {
options_default.onError(new Error("Given a bad binding handler type: " + nameOrObject));
}
}
get(nameOrDotted) {
const [name] = nameOrDotted.split(".");
return this[name];
}
};
// ../provider/dist/Provider.js
var Provider = class {
constructor(params = {}) {
if (this.constructor === Provider) {
throw new Error("Provider is an abstract base class.");
}
if (!("FOR_NODE_TYPES" in this)) {
throw new Error("Providers must have FOR_NODE_TYPES property");
}
this.bindingHandlers = params.bindingHandlers || new BindingHandlerObject();
this.globals = params.globals || {};
}
setGlobals(globals) {
this.globals = globals;
}
get preemptive() {
return false;
}
nodeHasBindings() {
}
getBindingAccessors() {
}
preprocessNode(node) {
}
postProcess() {
}
get instance() {
return this._overloadInstance || this;
}
set instance(provider) {
if (!provider || provider === this) {
this._overloadInstance = void 0;
} else {
this._overloadInstance = new LegacyProvider(provider, this);
}
}
makeAccessorsFromFunction(callback) {
return objectMap(dependencyDetection_exports.ignore(callback), (value, key) => () => callback()[key]);
}
makeValueAccessor(value) {
return () => value;
}
makeBindingAccessors(bindings, context, node) {
if (typeof bindings === "function") {
return this.makeAccessorsFromFunction(bindings.bind(null, context, node));
} else {
return objectMap(bindings, this.makeValueAccessor);
}
}
};
var LegacyProvider = class extends Provider {
get FOR_NODE_TYPES() {
return [1, 3, 8];
}
constructor(providerObject, parentProvider) {
super();
Object.assign(this, { providerObject });
this.bindingHandlers = providerObject.bindingHandlers || parentProvider.bindingHandlers;
}
getBindingsAndMakeAccessors(node, context) {
const bindingsFn = this.providerObject.getBindings.bind(this.providerObject, node, context);
return this.makeAccessorsFromFunction(bindingsFn);
}
getBindingAccessors(node, context) {
return this.providerObject.getBindingAccessors ? this.providerObject.getBindingAccessors(node, context) : this.getBindingsAndMakeAccessors(node, context);
}
nodeHasBindings(node) {
return this.providerObject.nodeHasBindings(node);
}
preprocessNode(node) {
if (this.providerObject.preprocessNode) {
return this.providerObject.preprocessNode(node);
}
}
};
// src/NativeProvider.ts
var NATIVE_BINDINGS = Symbol("Knockout native bindings");
var NativeProvider = class extends Provider {
get FOR_NODE_TYPES() {
return [1, 3];
}
get preemptive() {
return true;
}
nodeHasBindings(node) {
if (!node[NATIVE_BINDINGS]) {
return false;
}
return Object.keys(node[NATIVE_BINDINGS] || {}).some((key) => key.startsWith("ko-"));
}
preprocessNode(node) {
return node[NATIVE_BINDINGS] ? node : null;
}
onlyBindings([name]) {
return name.startsWith("ko-");
}
valueAsAccessor([name, value]) {
const bindingName = name.replace(/^ko-/, "");
const valueFn = isObservable(value) ? value : () => value;
return { [bindingName]: valueFn };
}
getBindingAccessors(node) {
const bindings = Object.entries(node[NATIVE_BINDINGS] || {}).filter(this.onlyBindings);
if (!bindings.length) {
return null;
}
return Object.assign({}, ...bindings.map(this.valueAsAccessor));
}
static addValueToNode(node, name, value) {
const obj = node[NATIVE_BINDINGS] || (node[NATIVE_BINDINGS] = {});
obj[name] = value;
}
static getNodeValues(node) {
return node[NATIVE_BINDINGS];
}
};
dist/index.cjs.map

Sorry, the diff of this file is too big to display

+5
dist/index.js
// @tko/provider.native 🥊 4.0.0-beta1.0 ESM
export {
default as NativeProvider,
NATIVE_BINDINGS
} from "./NativeProvider";
+7
dist/index.js.map
{
"version": 3,
"sources": ["../src/index.ts"],
"sourcesContent": ["export {\n default as NativeProvider, NATIVE_BINDINGS\n} from './NativeProvider'\n"],
"mappings": ";AAAA;AAAA;AAAA;AAAA;",
"names": []
}
+5
dist/index.mjs
// @tko/provider.native 🥊 4.0.0-beta1.0 MJS
export {
default as NativeProvider,
NATIVE_BINDINGS
} from "./NativeProvider";
+7
dist/index.mjs.map
{
"version": 3,
"sources": ["../src/index.ts"],
"sourcesContent": ["export {\n default as NativeProvider, NATIVE_BINDINGS\n} from './NativeProvider'\n"],
"mappings": ";AAAA;AAAA;AAAA;AAAA;",
"names": []
}
+47
dist/NativeProvider.js
// @tko/provider.native 🥊 4.0.0-beta1.0 ESM
import {
isObservable
} from "@tko/observable";
import {
Provider
} from "@tko/provider";
export const NATIVE_BINDINGS = Symbol("Knockout native bindings");
export default class NativeProvider extends Provider {
get FOR_NODE_TYPES() {
return [1, 3];
}
get preemptive() {
return true;
}
nodeHasBindings(node) {
if (!node[NATIVE_BINDINGS]) {
return false;
}
return Object.keys(node[NATIVE_BINDINGS] || {}).some((key) => key.startsWith("ko-"));
}
preprocessNode(node) {
return node[NATIVE_BINDINGS] ? node : null;
}
onlyBindings([name]) {
return name.startsWith("ko-");
}
valueAsAccessor([name, value]) {
const bindingName = name.replace(/^ko-/, "");
const valueFn = isObservable(value) ? value : () => value;
return { [bindingName]: valueFn };
}
getBindingAccessors(node) {
const bindings = Object.entries(node[NATIVE_BINDINGS] || {}).filter(this.onlyBindings);
if (!bindings.length) {
return null;
}
return Object.assign({}, ...bindings.map(this.valueAsAccessor));
}
static addValueToNode(node, name, value) {
const obj = node[NATIVE_BINDINGS] || (node[NATIVE_BINDINGS] = {});
obj[name] = value;
}
static getNodeValues(node) {
return node[NATIVE_BINDINGS];
}
}
+7
dist/NativeProvider.js.map
{
"version": 3,
"sources": ["../src/NativeProvider.ts"],
"sourcesContent": ["\nimport {\n isObservable\n} from '@tko/observable'\n\nimport {\n Provider\n} from '@tko/provider'\n\nexport const NATIVE_BINDINGS = Symbol('Knockout native bindings')\n\n/**\n * Retrieve the binding accessors that are already attached to\n * a node under the `NATIVE_BINDINGS` symbol.\n *\n * Used by the jsxToNode function.\n */\nexport default class NativeProvider extends Provider {\n get FOR_NODE_TYPES () { return [ 1, 3 ] }\n get preemptive () { return true }\n\n nodeHasBindings (node) {\n if (!node[NATIVE_BINDINGS]) { return false }\n return Object.keys(node[NATIVE_BINDINGS] || {})\n .some(key => key.startsWith('ko-'))\n }\n\n /**\n * There can be only one preprocessor; when there are native bindings,\n * prevent re-entrance (and likely XSS) from the `{{ }}` provider.\n */\n preprocessNode (node) {\n return node[NATIVE_BINDINGS] ? node : null\n }\n\n onlyBindings ([name]) {\n return name.startsWith('ko-')\n }\n\n valueAsAccessor ([name, value]) {\n const bindingName = name.replace(/^ko-/, '')\n const valueFn = isObservable(value) ? value : () => value\n return {[bindingName]: valueFn}\n }\n\n /**\n * Return as valueAccessor function all the entries matching `ko-*`\n * @param {HTMLElement} node\n */\n getBindingAccessors (node) {\n const bindings = Object.entries(node[NATIVE_BINDINGS] || {})\n .filter(this.onlyBindings)\n if (!bindings.length) { return null }\n return Object.assign({}, ...bindings.map(this.valueAsAccessor))\n }\n\n /**\n * Add a named-value to the given node.\n * @param {HTMLElement} node\n * @param {string} name\n * @param {any} value\n */\n static addValueToNode (node, name, value) {\n const obj = node[NATIVE_BINDINGS] || (node[NATIVE_BINDINGS] = {})\n obj[name] = value\n }\n\n /**\n *\n * @param {HTMLElement} node\n * @return {object} the stored values\n */\n static getNodeValues (node) {\n return node[NATIVE_BINDINGS]\n }\n}\n"],
"mappings": ";AACA;AAAA;AAAA;AAIA;AAAA;AAAA;AAIO,aAAM,kBAAkB,OAAO,0BAA0B;AAQhE,qBAAqB,uBAAuB,SAAS;AAAA,MAC/C,iBAAkB;AAAE,WAAO,CAAE,GAAG,CAAE;AAAA,EAAE;AAAA,MACpC,aAAc;AAAE,WAAO;AAAA,EAAK;AAAA,EAEhC,gBAAiB,MAAM;AACrB,QAAI,CAAC,KAAK,kBAAkB;AAAE,aAAO;AAAA,IAAM;AAC3C,WAAO,OAAO,KAAK,KAAK,oBAAoB,CAAC,CAAC,EAC3C,KAAK,SAAO,IAAI,WAAW,KAAK,CAAC;AAAA,EACtC;AAAA,EAMA,eAAgB,MAAM;AACpB,WAAO,KAAK,mBAAmB,OAAO;AAAA,EACxC;AAAA,EAEA,aAAc,CAAC,OAAO;AACpB,WAAO,KAAK,WAAW,KAAK;AAAA,EAC9B;AAAA,EAEA,gBAAiB,CAAC,MAAM,QAAQ;AAC9B,UAAM,cAAc,KAAK,QAAQ,QAAQ,EAAE;AAC3C,UAAM,UAAU,aAAa,KAAK,IAAI,QAAQ,MAAM;AACpD,WAAO,GAAE,cAAc,QAAO;AAAA,EAChC;AAAA,EAMA,oBAAqB,MAAM;AACzB,UAAM,WAAW,OAAO,QAAQ,KAAK,oBAAoB,CAAC,CAAC,EACxD,OAAO,KAAK,YAAY;AAC3B,QAAI,CAAC,SAAS,QAAQ;AAAE,aAAO;AAAA,IAAK;AACpC,WAAO,OAAO,OAAO,CAAC,GAAG,GAAG,SAAS,IAAI,KAAK,eAAe,CAAC;AAAA,EAChE;AAAA,SAQO,eAAgB,MAAM,MAAM,OAAO;AACxC,UAAM,MAAM,KAAK,oBAAqB,MAAK,mBAAmB,CAAC;AAC/D,QAAI,QAAQ;AAAA,EACd;AAAA,SAOO,cAAe,MAAM;AAC1B,WAAO,KAAK;AAAA,EACd;AACF;",
"names": []
}
+20
-22
package.json
{
"version": "4.0.0-beta1.0",
"name": "@tko/provider.native",
"version": "4.0.0-alpha8.4a",
"description": "Link binding handlers whose value is already attached to the node",

@@ -12,4 +12,4 @@ "module": "dist/provider.native.js",

"dependencies": {
"@tko/provider": "^4.0.0-alpha8.4",
"tslib": "^1.8.0"
"@tko/provider": "^4.0.0-beta1.0",
"tslib": "^2.2.0"
},

@@ -22,19 +22,2 @@ "karma": {

},
"__about__shared.package.json": "These properties are copied into all packages/*/package.json. Run `yarn repackage`",
"standard": {
"env": [
"browser",
"jasmine",
"mocha"
]
},
"scripts": {
"test": "npx karma start ../../karma.conf.js --once",
"build": "npx rollup -c ../../rollup.config.js",
"watch": "npx karma start ../../karma.conf.js",
"prepare": "npx rollup -c ../../rollup.config.js"
},
"publishConfig": {
"access": "public"
},
"homepage": "https://tko.io",

@@ -44,6 +27,21 @@ "licenses": [

"type": "MIT",
"url": "http://www.opensource.org/licenses/mit-license.php"
"url": "https://opensource.org/licenses/MIT"
}
],
"gitHead": "a3021e7ef7d23e32c4d179cf4ead178ba259819d"
"exports": {
".": {
"require": "./dist/index.cjs",
"import": "./dist/index.js"
},
"./helpers/*": "./helpers/*"
},
"bugs": {
"url": "https://github.com/knockout/tko/issues"
},
"author": "The Knockout Team",
"repository": {
"type": "git",
"url": "git+https://github.com/knockout/tko.git"
},
"gitHead": "99114c4deded3fc5dbddd5c7c9c63c845a18263b"
}
-79
dist/provider.native.es6.js
/*!
* Link binding handlers whose value is already attached to the node 🥊 @tko/provider.native@4.0.0-alpha8.4a
* (c) The Knockout.js Team - https://tko.io
* License: MIT (http://www.opensource.org/licenses/mit-license.php)
*/
import { isObservable } from '@tko/observable';
import { Provider } from '@tko/provider';
const NATIVE_BINDINGS = Symbol('Knockout native bindings');
/**
* Retrieve the binding accessors that are already attached to
* a node under the `NATIVE_BINDINGS` symbol.
*
* Used by the jsxToNode function.
*/
class NativeProvider extends Provider {
get FOR_NODE_TYPES () { return [ 1, 3 ] }
get preemptive () { return true }
nodeHasBindings (node) {
if (!node[NATIVE_BINDINGS]) { return false }
return Object.keys(node[NATIVE_BINDINGS] || {})
.some(key => key.startsWith('ko-'))
}
/**
* There can be only one preprocessor; when there are native bindings,
* prevent re-entrance (and likely XSS) from the `{{ }}` provider.
*/
preprocessNode (node) {
return node[NATIVE_BINDINGS] ? node : null
}
onlyBindings ([name]) {
return name.startsWith('ko-')
}
valueAsAccessor ([name, value]) {
const bindingName = name.replace(/^ko-/, '');
const valueFn = isObservable(value) ? value : () => value;
return {[bindingName]: valueFn}
}
/**
* Return as valueAccessor function all the entries matching `ko-*`
* @param {HTMLElement} node
*/
getBindingAccessors (node) {
const bindings = Object.entries(node[NATIVE_BINDINGS] || {})
.filter(this.onlyBindings);
if (!bindings.length) { return null }
return Object.assign({}, ...bindings.map(this.valueAsAccessor))
}
/**
* Add a named-value to the given node.
* @param {HTMLElement} node
* @param {string} name
* @param {any} value
*/
static addValueToNode (node, name, value) {
const obj = node[NATIVE_BINDINGS] || (node[NATIVE_BINDINGS] = {});
obj[name] = value;
}
/**
*
* @param {HTMLElement} node
* @return {object} the stored values
*/
static getNodeValues (node) {
return node[NATIVE_BINDINGS]
}
}
export { NativeProvider, NATIVE_BINDINGS };
//# sourceMappingURL=provider.native.es6.js.map
-1
dist/provider.native.es6.js.map
{"version":3,"file":"provider.native.es6.js","sources":["../src/NativeProvider.js"],"sourcesContent":["\nimport {\n isObservable\n} from '@tko/observable'\n\nimport {\n Provider\n} from '@tko/provider'\n\nexport const NATIVE_BINDINGS = Symbol('Knockout native bindings')\n\n/**\n * Retrieve the binding accessors that are already attached to\n * a node under the `NATIVE_BINDINGS` symbol.\n *\n * Used by the jsxToNode function.\n */\nexport default class NativeProvider extends Provider {\n get FOR_NODE_TYPES () { return [ 1, 3 ] }\n get preemptive () { return true }\n\n nodeHasBindings (node) {\n if (!node[NATIVE_BINDINGS]) { return false }\n return Object.keys(node[NATIVE_BINDINGS] || {})\n .some(key => key.startsWith('ko-'))\n }\n\n /**\n * There can be only one preprocessor; when there are native bindings,\n * prevent re-entrance (and likely XSS) from the `{{ }}` provider.\n */\n preprocessNode (node) {\n return node[NATIVE_BINDINGS] ? node : null\n }\n\n onlyBindings ([name]) {\n return name.startsWith('ko-')\n }\n\n valueAsAccessor ([name, value]) {\n const bindingName = name.replace(/^ko-/, '')\n const valueFn = isObservable(value) ? value : () => value\n return {[bindingName]: valueFn}\n }\n\n /**\n * Return as valueAccessor function all the entries matching `ko-*`\n * @param {HTMLElement} node\n */\n getBindingAccessors (node) {\n const bindings = Object.entries(node[NATIVE_BINDINGS] || {})\n .filter(this.onlyBindings)\n if (!bindings.length) { return null }\n return Object.assign({}, ...bindings.map(this.valueAsAccessor))\n }\n\n /**\n * Add a named-value to the given node.\n * @param {HTMLElement} node\n * @param {string} name\n * @param {any} value\n */\n static addValueToNode (node, name, value) {\n const obj = node[NATIVE_BINDINGS] || (node[NATIVE_BINDINGS] = {})\n obj[name] = value\n }\n\n /**\n *\n * @param {HTMLElement} node\n * @return {object} the stored values\n */\n static getNodeValues (node) {\n return node[NATIVE_BINDINGS]\n }\n}\n"],"names":[],"mappings":";;;;;;;;;AASY,MAAC,eAAe,GAAG,MAAM,CAAC,0BAA0B,EAAC;;;;;;;;AAQjE,MAAqB,cAAc,SAAS,QAAQ,CAAC;EACnD,IAAI,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;EACzC,IAAI,UAAU,CAAC,GAAG,EAAE,OAAO,IAAI,EAAE;;EAEjC,eAAe,CAAC,CAAC,IAAI,EAAE;IACrB,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,OAAO,KAAK,EAAE;IAC5C,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;OAC5C,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;GACtC;;;;;;EAMD,cAAc,CAAC,CAAC,IAAI,EAAE;IACpB,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,IAAI,GAAG,IAAI;GAC3C;;EAED,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE;IACpB,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;GAC9B;;EAED,eAAe,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE;IAC9B,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,EAAC;IAC5C,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,MAAM,MAAK;IACzD,OAAO,CAAC,CAAC,WAAW,GAAG,OAAO,CAAC;GAChC;;;;;;EAMD,mBAAmB,CAAC,CAAC,IAAI,EAAE;IACzB,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;OACzD,MAAM,CAAC,IAAI,CAAC,YAAY,EAAC;IAC5B,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,OAAO,IAAI,EAAE;IACrC,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;GAChE;;;;;;;;EAQD,OAAO,cAAc,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE;IACxC,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,EAAC;IACjE,GAAG,CAAC,IAAI,CAAC,GAAG,MAAK;GAClB;;;;;;;EAOD,OAAO,aAAa,CAAC,CAAC,IAAI,EAAE;IAC1B,OAAO,IAAI,CAAC,eAAe,CAAC;GAC7B;CACF;;"}
-143
dist/provider.native.js
/*!
* Link binding handlers whose value is already attached to the node 🥊 @tko/provider.native@4.0.0-alpha8.4a
* (c) The Knockout.js Team - https://tko.io
* License: MIT (http://www.opensource.org/licenses/mit-license.php)
*/
import { isObservable } from '@tko/observable';
import { Provider } from '@tko/provider';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
var NATIVE_BINDINGS = Symbol('Knockout native bindings');
/**
* Retrieve the binding accessors that are already attached to
* a node under the `NATIVE_BINDINGS` symbol.
*
* Used by the jsxToNode function.
*/
var NativeProvider = /** @class */ (function (_super) {
__extends(NativeProvider, _super);
function NativeProvider() {
return _super !== null && _super.apply(this, arguments) || this;
}
Object.defineProperty(NativeProvider.prototype, "FOR_NODE_TYPES", {
get: function () { return [1, 3]; },
enumerable: true,
configurable: true
});
Object.defineProperty(NativeProvider.prototype, "preemptive", {
get: function () { return true; },
enumerable: true,
configurable: true
});
NativeProvider.prototype.nodeHasBindings = function (node) {
if (!node[NATIVE_BINDINGS]) {
return false;
}
return Object.keys(node[NATIVE_BINDINGS] || {})
.some(function (key) { return key.startsWith('ko-'); });
};
/**
* There can be only one preprocessor; when there are native bindings,
* prevent re-entrance (and likely XSS) from the `{{ }}` provider.
*/
NativeProvider.prototype.preprocessNode = function (node) {
return node[NATIVE_BINDINGS] ? node : null;
};
NativeProvider.prototype.onlyBindings = function (_a) {
var _b = __read(_a, 1), name = _b[0];
return name.startsWith('ko-');
};
NativeProvider.prototype.valueAsAccessor = function (_a) {
var _b = __read(_a, 2), name = _b[0], value = _b[1];
var _c;
var bindingName = name.replace(/^ko-/, '');
var valueFn = isObservable(value) ? value : function () { return value; };
return _c = {}, _c[bindingName] = valueFn, _c;
};
/**
* Return as valueAccessor function all the entries matching `ko-*`
* @param {HTMLElement} node
*/
NativeProvider.prototype.getBindingAccessors = function (node) {
var bindings = Object.entries(node[NATIVE_BINDINGS] || {})
.filter(this.onlyBindings);
if (!bindings.length) {
return null;
}
return Object.assign.apply(Object, __spread([{}], bindings.map(this.valueAsAccessor)));
};
/**
* Add a named-value to the given node.
* @param {HTMLElement} node
* @param {string} name
* @param {any} value
*/
NativeProvider.addValueToNode = function (node, name, value) {
var obj = node[NATIVE_BINDINGS] || (node[NATIVE_BINDINGS] = {});
obj[name] = value;
};
/**
*
* @param {HTMLElement} node
* @return {object} the stored values
*/
NativeProvider.getNodeValues = function (node) {
return node[NATIVE_BINDINGS];
};
return NativeProvider;
}(Provider));
export { NativeProvider, NATIVE_BINDINGS };
//# sourceMappingURL=provider.native.js.map
-1
dist/provider.native.js.map
{"version":3,"file":"provider.native.js","sources":["../../../node_modules/tslib/tslib.es6.js"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n if (m) return m.call(o);\r\n return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n};\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n result.default = mod;\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n"],"names":[],"mappings":";;;;;;;;;AAAA;;;;;;;;;;;;;;;;AAgBA,IAAI,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE;IAC/B,aAAa,GAAG,MAAM,CAAC,cAAc;SAChC,EAAE,SAAS,EAAE,EAAE,EAAE,YAAY,KAAK,IAAI,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC;QAC5E,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/E,OAAO,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC9B,CAAC;;AAEF,SAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE;IAC5B,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACpB,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,EAAE;IACvC,CAAC,CAAC,SAAS,GAAG,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;CACxF;AACD;AA2FA,SAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE;IACzB,IAAI,CAAC,GAAG,OAAO,MAAM,KAAK,UAAU,IAAI,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC3D,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IACjB,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;IACjC,IAAI;QACA,OAAO,CAAC,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;KAC9E;IACD,OAAO,KAAK,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE;YAC/B;QACJ,IAAI;YACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACpD;gBACO,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,EAAE;KACpC;IACD,OAAO,EAAE,CAAC;CACb;;AAED,SAAgB,QAAQ,GAAG;IACvB,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE;QAC9C,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,OAAO,EAAE,CAAC;CACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}