@tko/provider.mustache
Version:
Interpolate text/node attributes {{ }}
1,589 lines (1,555 loc) • 85.3 kB
JavaScript
"use strict";
// @tko/provider.mustache 🥊 4.0.0-beta1.6 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 = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
// index.ts
var provider_exports = {};
__export(provider_exports, {
AttributeMustacheProvider: () => AttributeMustacheProvider,
TextMustacheProvider: () => TextMustacheProvider,
parseInterpolation: () => parseInterpolation
});
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, div2 = options_default.document.createElement("div"), iElems = div2.getElementsByTagName("i");
while (div2.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 isObjectLike(obj) {
if (obj === null) {
return false;
}
return typeof obj === "object" || typeof obj === "function";
}
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;
}
function clonePlainObjectDeep(obj, seen) {
if (!seen) {
seen = [];
}
if (!obj || typeof obj !== "object" || obj.constructor !== Object || seen.indexOf(obj) !== -1) {
return obj;
}
seen.push(obj);
var result = {};
for (var prop in obj) {
if (hasOwnProperty(obj, prop)) {
result[prop] = clonePlainObjectDeep(obj[prop], seen);
}
}
return result;
}
// ../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 div2 = w.document.createElement("div");
new w.MutationObserver(callback).observe(div2, { attributes: true });
return function() {
div2.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;
}
function unwrap(value) {
return isObservable(value) ? value() : value;
}
function isWriteableObservable(instance) {
return isObservable(instance) && instance.isWriteable;
}
// ../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);
}
}
};
// ../utils.parser/dist/operators.js
var __pow = Math.pow;
function LAMBDA() {
}
function unwrapOrCall(a, b) {
while (typeof b === "function") {
b = b();
}
return b;
}
var operators = {
"@": unwrapOrCall,
"#": (a, b) => () => unwrap(b),
"=>": LAMBDA,
"!": function not(a, b) {
return !b;
},
"!!": function notnot(a, b) {
return !!b;
},
"++": function preinc(a, b) {
return ++b;
},
"--": function preinc2(a, b) {
return --b;
},
"**": function exp(a, b) {
return __pow(a, b);
},
"*": function mul(a, b) {
return a * b;
},
"/": function div(a, b) {
return a / b;
},
"%": function mod(a, b) {
return a % b;
},
"+": function add(a, b) {
return a + b;
},
"-": function sub(a, b) {
return (a || 0) - (b || 0);
},
"&-": function neg(a, b) {
return -1 * b;
},
"<": function lt(a, b) {
return a < b;
},
"<=": function le(a, b) {
return a <= b;
},
">": function gt(a, b) {
return a > b;
},
">=": function ge(a, b) {
return a >= b;
},
"==": function equal(a, b) {
return a == b;
},
"!=": function ne(a, b) {
return a != b;
},
"===": function sequal(a, b) {
return a === b;
},
"!==": function sne(a, b) {
return a !== b;
},
"&": function bitAnd(a, b) {
return a & b;
},
"^": function xor(a, b) {
return a ^ b;
},
"|": function bitOr(a, b) {
return a | b;
},
"&&": function logicAnd(a, b) {
return a && b;
},
"||": function logicOr(a, b) {
return a || b;
},
"??": function nullishCoalesce(a, b) {
return a != null ? a : b;
},
".": function member(a, b) {
return a == null ? void 0 : a[b];
},
"?.": function omember(a, b) {
return a == null ? void 0 : a[b];
},
"[": function bmember(a, b) {
return a == null ? void 0 : a[b];
},
",": function comma(a, b) {
return b;
},
"call": function callOp(a, b) {
return a.apply(null, b);
}
};
operators["@"].precedence = 21;
operators["#"].precedence = 21;
operators["."].precedence = 19;
operators["["].precedence = 19;
operators["?."].precedence = 19;
operators["!"].precedence = 16;
operators["!!"].precedence = 16;
operators["++"].precedence = 16;
operators["--"].precedence = 16;
operators["&-"].precedence = 16;
operators["**"].precedent = 15;
operators["%"].precedence = 14;
operators["*"].precedence = 14;
operators["/"].precedence = 14;
operators["+"].precedence = 13;
operators["-"].precedence = 13;
operators["|"].precedence = 12;
operators["^"].precedence = 11;
operators["&"].precedence = 10;
operators["<"].precedence = 11;
operators["<="].precedence = 11;
operators[">"].precedence = 11;
operators[">="].precedence = 11;
operators["=="].precedence = 10;
operators["!="].precedence = 10;
operators["==="].precedence = 10;
operators["!=="].precedence = 10;
operators["&&"].precedence = 6;
operators["||"].precedence = 5;
operators["??"].precedence = 5;
operators["&&"].earlyOut = (a) => !a;
operators["||"].earlyOut = (a) => a;
operators["??"].earlyOut = (a) => a;
operators[","].precedence = 2;
operators["call"].precedence = 1;
operators["=>"].precedence = 1;
// ../utils.parser/dist/Node.js
var IS_EXPR_OR_IDENT = Symbol("Node - Is Expression Or Identifier");
var Node = class {
constructor(lhs, op, rhs) {
this.lhs = lhs;
this.op = op;
this.rhs = rhs;
}
static get operators() {
return operators;
}
get_leaf_value(leaf, context, globals, node) {
if (typeof leaf === "function") {
return unwrap(leaf());
}
if (typeof leaf !== "object" || leaf === null) {
return leaf;
}
if (leaf[Node.isExpressionOrIdentifierSymbol]) {
return unwrap(leaf.get_value(void 0, context, globals, node));
}
return leaf;
}
get_value(notused, context, globals, node) {
var node = this;
if (node.op === LAMBDA) {
return (...args) => {
let lambdaContext = context;
if (node.lhs) {
lambdaContext = node.lhs.extendContext(context, args);
}
return node.get_leaf_value(node.rhs, lambdaContext, globals, node);
};
}
const lhv = node.get_leaf_value(node.lhs, context, globals, node);
const earlyOut = node.op.earlyOut;
if (earlyOut && earlyOut(lhv)) {
return lhv;
}
const rhv = node.get_leaf_value(node.rhs, context, globals, node);
return node.op(lhv, rhv, context, globals);
}
static get isExpressionOrIdentifierSymbol() {
return IS_EXPR_OR_IDENT;
}
get [IS_EXPR_OR_IDENT]() {
return true;
}
static value_of(item, context, globals, node) {
if (item && item[Node.isExpressionOrIdentifierSymbol]) {
return item.get_value(item, context, globals, node);
}
return item;
}
static create_root(nodes, debug = false) {
const out = [];
const ops = [];
for (let i = 0; i < nodes.length; i += 2) {
out.push(nodes[i]);
const op = nodes[i + 1];
const prec = (op == null ? void 0 : op.precedence) || 0;
while (ops.length && prec <= ops[ops.length - 1].precedence) {
const rhs = out.pop();
const lhs = out.pop();
out.push(new Node(lhs, ops.pop(), rhs));
}
ops.push(op);
}
if (out.length !== 1) {
throw new Error(`unexpected nodes remain in shunting yard output stack: ${out}`);
}
return out[0];
}
};
operators["?"] = function ternary(a, b, context, globals, node) {
return Node.value_of(a ? b.yes : b.no, context, globals, node);
};
operators["?"].precedence = 4;
// ../utils.parser/dist/Expression.js
var Expression = class {
constructor(nodes) {
this.nodes = nodes;
this.root = Node.create_root(nodes);
}
get_value(parent, context, globals, node) {
if (!this.root) {
this.root = Node.create_root(this.nodes);
}
return this.root.get_value(parent, context, globals, node);
}
};
Expression.prototype[Node.isExpressionOrIdentifierSymbol] = true;
// ../utils.parser/dist/Arguments.js
var Arguments = class {
constructor(parser, args) {
this.parser = parser;
this.args = args;
}
get_value(parent, context, globals, node) {
var deReffedArgs = [];
for (var i = 0, j = this.args.length; i < j; ++i) {
deReffedArgs.push(Node.value_of(this.args[i], context, globals, node));
}
return deReffedArgs;
}
get [Node.isExpressionOrIdentifierSymbol]() {
return true;
}
};
// ../utils.parser/dist/identifierExpressions.js
var IDStart = /[\$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E