.
-
-
-
-
-
-
-
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. clock_timingprovider = performance.now() + skew.
+State vectors are communicated between timing provider and timing object.
+Timestamp defines a point in time when values for position, velocity and acceleration were|are|will-be valid.
+Timestamps (in seconds) are from the *timing provider clock*, i.e. clock_timingprovider = clock_client + skew.
```javascript
var vector = {
@@ -61,8 +61,10 @@ var state = timingProvider.readyState;
clock_timingprovider = performance.now() + skew
+Getter property for current skew estimate of the timing provider. The skew is defined as the difference between the clock used by the timing
+provider and the clock used by the client. The time unit used for the skew is *seconds*.
+
+clock_timingprovider = clock_client + skew
```javascript
var skew = timingProvider.skew;
@@ -73,7 +75,7 @@ var skew = timingProvider.skew;
Reset
Pause
Play Skip 5 Ahead
Skip 5 Back
+ Skip 5 Ahead
@@ -29,14 +29,14 @@ Synchronization and control of two video elements using timing object. Both vide
**Player 1**
-
+
**Player 2**
-
+
diff --git a/docs/doc/online_sequencer.md b/docs/doc/online_sequencer.md
index 1e970c4..ec4aac3 100644
--- a/docs/doc/online_sequencer.md
+++ b/docs/doc/online_sequencer.md
@@ -10,7 +10,7 @@ appidmcorp: 8456579076771837888
- [Sequencer Background](background_sequencer.html)
-- [Sequencer API](api_sequencer.html)
+- [Sequencer API](api_sequencer.html)
- [Sequencer Usage](usage_sequencer.html)
The Sequencer provides enter and exit events based on a moving point. This moving point is implemented and controlled by a timing object.
@@ -25,7 +25,7 @@ Sequencer events is used to control styling (red color).
#### Demo
-
+
Timing Object position
@@ -48,7 +48,7 @@ Sequencer events is used to control styling (red color).
var to = new TIMINGSRC.TimingObject({provider:timingProvider});
// Sequencer
-var s = new TIMINGSRC.Sequencer(to);
+var s = new TIMINGSRC.Sequencer(to);
// Load data
var r = s.request();
@@ -58,12 +58,12 @@ Object.keys(data).forEach(function (key) {
r.submit();
// Register Handlers
-s.on("enter", function (e) {
+s.on("change", function (e) {
var el = document.getElementById(e.key);
el.classList.add("active");
});
-s.on("exit", function (e) {
+s.on("remove", function (e) {
var el = document.getElementById(e.key);
el.classList.remove("active");
});
-```
+```
diff --git a/docs/doc/online_windowsequencer.md b/docs/doc/online_windowsequencer.md
index 82c420a..3855d18 100644
--- a/docs/doc/online_windowsequencer.md
+++ b/docs/doc/online_windowsequencer.md
@@ -7,10 +7,10 @@ appidmcorp: 8456579076771837888
+
- [Sequencer Background](background_sequencer.html)
-- [Sequencer API](api_sequencer.html)
+- [Sequencer API](api_sequencer.html)
- [Sequencer Usage](usage_sequencer.html)
The Sequencer may also provide enter and exit events based on a moving window. Window endpoints are implemented by two timing objects.
@@ -26,7 +26,7 @@ The two endpoints may therefore be controlled independently, though in this demo
#### Demo
-
+
Active Window : [
@@ -48,9 +48,9 @@ The two endpoints may therefore be controlled independently, though in this demo
var to = new TIMINGSRC.TimingObject({provider:timingProvider});
var toA = new TIMINGSRC.SkewConverter(to, -5.0);
var toB = new TIMINGSRC.SkewConverter(to, 4.0);
-
+
// Sequencer
-var s = new TIMINGSRC.Sequencer(toA, toB);
+var s = new TIMINGSRC.Sequencer(toA, toB);
// Load Data
var r = s.request();
@@ -60,13 +60,13 @@ Object.keys(data).forEach(function (key) {
r.submit();
// Register Handlers
-s.on("enter", function (e) {
+s.on("change", function (e) {
var el = document.getElementById(e.key);
el.classList.add("active");
});
-s.on("exit", function (e) {
+s.on("remove", function (e) {
var el = document.getElementById(e.key);
el.classList.remove("active");
});
-```
+```
diff --git a/docs/examples/mediasync.html b/docs/examples/mediasync.html
index 2fa75f0..8119e50 100644
--- a/docs/examples/mediasync.html
+++ b/docs/examples/mediasync.html
@@ -67,8 +67,8 @@
MediaSync
Reset
Pause
Play Skip 5 Ahead
Skip 5 Back
+ Skip 5 Ahead
@@ -77,13 +77,13 @@
MediaSync
-
+
-
+
diff --git a/docs/index.md b/docs/index.md
index d156785..eb62ccd 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -21,7 +21,8 @@ For **multi-device** timing support, simply plug a *timing provider* into your *
## Standardization
-The [W3C Multi-device Timing Community Group](https://www.w3.org/community/webtiming/) advocates standardization of the timing object.
+The [W3C Multi-device Timing Community Group](https://www.w3.org/community/webtiming/), advocated for the standardization of the timing object. The group was closed early 2025 but hopes that renewed discussions on a timing model for the Web will take place and encourages interested parties to reach out to the [Media and Entertainment Interest Group](https://www.w3.org/groups/ig/me) for coordination, through its [public-web-and-tv@w3.org](mailto:public-web-and-tv@w3.org) mailing-list.
+
Agreement on a common API for timing resources would enable:
#### 1) temporal interoperability
@@ -41,7 +42,7 @@ online timing providers may focus on the challenges of distributed timing, while
## Relation to timing object specification
-The timingsrc library serves as a reference implementation for the [Timing Object Draft Spec](http://webtiming.github.io/timingobject/) and will be maintained by the [W3C Multi-device Timing Community Group](https://www.w3.org/community/webtiming/).
+The timingsrc library serves as a reference implementation for the [Timing Object Draft Spec](http://webtiming.github.io/timingobject/). It was maintained by the [W3C Multi-device Timing Community Group](https://www.w3.org/community/webtiming/) until early 2025. It is now maintained by individual authors.
## Authors
@@ -60,8 +61,7 @@ Njål T. Borch
## Acknowledgements
-The timingsrc library is developed at [Norut Northern Research Institute](http://norut.no/) and funded in part by the [EU FP7 MediaScape project](http://mediascapeproject.eu). Results are contributed from MediaScape as reference implementation to the [W3C Multi-device Timing Community Group](https://www.w3.org/community/webtiming/).
-
+The timingsrc library is developed at [Norut Northern Research Institute](http://norut.no/) and received initial funding by the EU FP7 MediaScape project.
## License
diff --git a/docs/lib/timingsrc-esm-v3.js b/docs/lib/timingsrc-esm-v3.js
new file mode 100644
index 0000000..b84db25
--- /dev/null
+++ b/docs/lib/timingsrc-esm-v3.js
@@ -0,0 +1,8503 @@
+/*
+ Copyright 2020
+ Author : Ingar Arntzen
+
+ This file is part of the Timingsrc module.
+
+ Timingsrc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Timingsrc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with Timingsrc. If not, see not equal
+ if (aProps.length != bProps.length) {
+ return false;
+ }
+ for (let i=0; i not equal
+ if (a[propName] !== b[propName]) {
+ return false;
+ }
+ }
+ // equal
+ return true;
+}
+
+
+/* document readypromise */
+const docready = new Promise(function(resolve) {
+ if (document.readyState === 'complete') {
+ resolve();
+ } else {
+ let onReady = function () {
+ resolve();
+ document.removeEventListener('DOMContentLoaded', onReady, true);
+ window.removeEventListener('load', onReady, true);
+ };
+ document.addEventListener('DOMContentLoaded', onReady, true);
+ window.addEventListener('load', onReady, true);
+ }
+});
+
+var utils = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ random_string: random_string,
+ eqSet: eqSet,
+ all: all,
+ isIn: isIn,
+ set_difference: set_difference,
+ map_difference: map_difference,
+ map_intersect: map_intersect,
+ map_merge: map_merge,
+ divmod: divmod,
+ isIterable: isIterable,
+ array_concat: array_concat,
+ object_equals: object_equals,
+ docready: docready
+});
+
+/*
+ Copyright 2020
+ Author : Ingar Arntzen
+
+ This file is part of the Timingsrc module.
+
+ Timingsrc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Timingsrc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with Timingsrc. If not, see -1) {
+ indexes.push(index);
+ }
+ }
+ return indexes;
+ };
+
+ /*
+ element exists with value
+ */
+ has(x) {
+ return (this.indexOf(x) > -1) ? true : false;
+ };
+
+ get(index) {
+ return this.array[index];
+ };
+
+
+
+ /*
+ REMOVE
+ Removes all elements with given values
+ search for each one and splice remove them individually
+ (reverse order)
+
+ INSERT
+ binarysearch and splice
+ insert - binarysearch and splice
+
+ WARNING - there should be no need to insert elements that are already
+ present in the array. This function drops such duplicates
+ */
+ _update_splice(to_remove, to_insert, options) {
+
+ // REMOVE
+ if (this.array.length > 0) {
+ let indexes = this.indexOfElements(to_remove);
+ /*
+ sort indexes to make sure we are removing elements
+ in backwards order
+ optimization
+ - if elements were sorted in the first place this should not be necessary
+ */
+ indexes.sort(function(a,b){return a-b;});
+ for (let i=indexes.length-1; i > -1; i--) {
+ this.array.splice(indexes[i], 1);
+ }
+ }
+
+ // INSERT
+ let x, index;
+ let len = to_insert.length;
+ for (let i=0; i 0 && to_remove.length > 0) {
+ // visit all elements and set their value to undefined
+ // undefined values will be sorted to the end of the array
+ let indexes = this.indexOfElements(to_remove);
+ for (let i=0; i 0) {
+ let index = this.array.indexOf(undefined);
+ if (index > -1) {
+ this.array.splice(index, this.array.length-index);
+ }
+ }
+ // remove duplicates
+ this.array = unique(this.array);
+ };
+
+
+ /*
+ Update - removing and inserting elements in one operation
+
+ a single element should only be present once in the list, thus avoiding
+ multiple operations to one element. This is presumed solved externally.
+ - also objects must not be members of both lists.
+
+ - internally selects the best method - searchsplice or concatsort
+ - selection based on relative sizes of existing elements and new elements
+
+ */
+ update(to_remove, to_insert, options) {
+ let size = to_remove.length + to_insert.length;
+ if (size == 0) {
+ return;
+ }
+
+ // regular case
+ let approach = resolve_approach(this.array.length, size);
+ if (approach == "splice") {
+ this._update_splice(to_remove, to_insert, options);
+ } else if (approach == "sort"){
+ this._update_sort(to_remove, to_insert, options);
+ }
+ };
+
+
+ /*
+ Accessors
+ */
+
+ getMinimum() {
+ return (this.array.length > 0) ? this.array[0] : undefined;
+ };
+
+ getMaximum = function () {
+ return (this.array.length > 0) ? this.array[this.array.length - 1] : undefined;
+ };
+
+
+ /*
+ Internal search functions
+ */
+
+ /*
+ Find index of largest value less than x
+ Returns -1 if noe values exist that are less than x
+ */
+ ltIndexOf(x) {
+ var i = this.binaryIndexOf(x);
+ if (this.isFound(i, x)) {
+ /*
+ found - x is found on index i
+ consider element to the left
+ if we are at the left end of the array nothing is found
+ return -1
+ */
+ if (i > 0) {
+ return i-1;
+ } else {
+ return -1;
+ }
+ } else {
+ /*
+ not found - Math.abs(i) is index where x should be inserted
+ => Math.abs(i) - 1 is the largest value less than x
+ */
+ return Math.abs(i)-1;
+ }
+ };
+
+ /*
+ Find index of rightmost value less than x or equal to x
+ Returns -1 if noe values exist that are less than x or equal to x
+ */
+ leIndexOf(x) {
+ var i = this.binaryIndexOf(x);
+ if (this.isFound(i, x)) {
+ /*
+ element found
+ */
+ return i;
+ } else {
+ // not found - consider element to the left
+ i = Math.abs(i) - 1;
+ return (i >= 0) ? i : -1;
+ }
+ };
+
+ /*
+ Find index of leftmost value greater than x
+ Returns -1 if no values exist that are greater than x
+ */
+
+ gtIndexOf(x) {
+ var i = this.binaryIndexOf(x);
+ if (this.isFound(i, x)) {
+ /*
+ found - x is found on index i
+ if there are no elements to the right return -1
+ */
+ if (i < this.array.length -1) {
+ return i+1;
+ } else {
+ return -1;
+ }
+ } else {
+ /*
+ not found - Math.abs(i) is index where x should be inserted
+ => Math.abs(i) is the smallest value greater than x
+ unless we hit the end of the array, in which cas no smalles value
+ exist which is greater than x
+ */
+ let idx = Math.abs(i);
+ return (idx < this.array.length) ? idx : -1;
+ }
+ };
+
+
+ /*
+ Find index of leftmost value which is greater than x or equal to x
+ Returns -1 if noe values exist that are greater than x or equal to x
+ */
+
+ geIndexOf(x) {
+ var i = this.binaryIndexOf(x);
+ if (this.isFound(i, x)) {
+ /*
+ found element
+ */
+ return i;
+ } else {
+ // not found - consider the element where x would be inserted
+ i = Math.abs(i);
+ return (i -1) {
+ return [index, index + 1];
+ } else {
+ return [undefined, undefined];
+ }
+ }
+
+ // regular non-singular interval
+ var start_index = -1, end_index = -1;
+ if (interval.lowInclude) {
+ start_index = this.geIndexOf(interval.low);
+ } else {
+ start_index = this.gtIndexOf(interval.low);
+ }
+ if (start_index === -1) {
+ return [undefined, undefined];
+ }
+ if (interval.highInclude) {
+ end_index = this.leIndexOf(interval.high);
+ } else {
+ end_index = this.ltIndexOf(interval.high);
+ }
+ if (end_index === -1) { // not reachable - I think
+ return [undefined, undefined];
+ }
+ return [start_index, end_index + 1];
+ };
+
+
+ /*
+ lookup by interval
+ */
+ lookup(interval) {
+ let [start, end] = this.lookupIndexes(interval);
+ return (start != undefined) ? this.array.slice(start, end) : [];
+ };
+
+ /*
+ remove by interval
+ */
+ remove(interval) {
+ let [start, end] = this.lookupIndexes(interval);
+ return (start != undefined) ? this.array.splice(start, end-start) : [];
+ };
+
+
+ slice(start, end) {
+ return this.array.slice(start, end);
+ };
+
+ splice(start, length) {
+ return this.array.splice(start, length);
+ };
+
+
+
+ /*
+ method for removing multiple closely placed elements in place
+ - removeList is sorted
+ - changes only affect the part of the index between first and last element
+ - move remaining elements to the left, remove elements with a single splice
+ - efficent if removelist references elements that are close to eachother
+ */
+
+ removeInSlice(removeList) {
+ if (removeList.length == 0){
+ return;
+ }
+ const low = removeList[0];
+ const high = removeList[removeList.length-1];
+ let [start, end] = this.lookupIndexes(new Interval(low, high, true, true));
+
+ let rd_ptr = start;
+ let wr_ptr = start;
+ let rm_ptr = 0;
+
+ while (rd_ptr < end) {
+ let rd_elem = this.array[rd_ptr];
+ let rm_elem = removeList[rm_ptr];
+ if (rd_elem < rm_elem) {
+ this.array[wr_ptr] = this.array[rd_ptr];
+ wr_ptr++;
+ rd_ptr++;
+ } else if (rd_elem == rm_elem) {
+ rd_ptr++;
+ rm_ptr++;
+ } else {
+ // rd_elem > rm_elem
+ rm_ptr++;
+ }
+ if (rm_ptr == removeList.length) {
+ break
+ }
+ }
+ this.array.splice(wr_ptr, rd_ptr-wr_ptr);
+ };
+
+
+ values() {
+ return this.array.values();
+ };
+
+ clear() {
+ this.array = [];
+ };
+
+ get length () {
+ return this.array.length;
+ }
+
+}
+
+/*
+ Copyright 2020
+ Author : Ingar Arntzen
+
+ This file is part of the Timingsrc module.
+
+ Timingsrc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Timingsrc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with Timingsrc. If not, see {
+ return {name, eArg};
+ }));
+ }
+
+ /*
+ Trigger single event
+ */
+ function eventifyTrigger(name, eArg) {
+ return this.eventifyTriggerAll([{name, eArg}]);
+ }
+
+ _prototype.eventifyDefine = eventifyDefine;
+ _prototype.eventifyTrigger = eventifyTrigger;
+ _prototype.eventifyTriggerAlike = eventifyTriggerAlike;
+ _prototype.eventifyTriggerAll = eventifyTriggerAll;
+ _prototype.eventifySubscriptions = eventifySubscriptions;
+ _prototype.on = on;
+ _prototype.off = off;
+}
+
+/*
+ Event Variable
+
+ Objects with a single "change" event
+*/
+
+class EventVariable {
+
+ constructor (value) {
+ eventifyInstance(this);
+ this._value = value;
+ this.eventifyDefine("change", {init:true});
+ }
+
+ eventifyInitEventArgs(name) {
+ if (name == "change") {
+ return [this._value];
+ }
+ }
+
+ get value () {return this._value};
+ set value (value) {
+ if (value != this._value) {
+ this._value = value;
+ this.eventifyTrigger("change", value);
+ }
+ }
+}
+eventifyPrototype(EventVariable.prototype);
+
+/*
+ Event Boolean
+
+
+ Note : implementation uses falsiness of input parameter to constructor and set() operation,
+ so eventBoolean(-1) will actually set it to true because
+ (-1) ? true : false -> true !
+*/
+
+class EventBoolean extends EventVariable {
+ constructor(value) {
+ super(Boolean(value));
+ }
+
+ set value (value) {
+ super.value = Boolean(value);
+ }
+ get value () {return super.value};
+}
+
+
+/*
+ make a promise which is resolved when EventBoolean changes
+ value.
+*/
+function makePromise(eventObject, conditionFunc) {
+ conditionFunc = conditionFunc || function(val) {return val == true};
+ return new Promise (function (resolve, reject) {
+ let sub = eventObject.on("change", function (value) {
+ if (conditionFunc(value)) {
+ resolve(value);
+ eventObject.off(sub);
+ }
+ });
+ });
+}
+// module api
+var eventify = {
+ eventifyPrototype,
+ eventifyInstance,
+ EventVariable,
+ EventBoolean,
+ makePromise
+};
+
+/*
+ Copyright 2020
+ Author : Ingar Arntzen
+
+ This file is part of the Timingsrc module.
+
+ Timingsrc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Timingsrc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with Timingsrc. If not, see
+ fallback to order from constructor
+ noop if no ordering is defined
+ */
+ sortValues(iter, options={}) {
+ let order = this.sortOrder(options);
+ if (typeof order == "function") {
+ // sort
+ // if iterable not array - convert into array ahead of sorting
+ let arr = (Array.isArray(iter)) ? iter : [...iter];
+ return arr.sort(order);
+ } else {
+ // noop
+ return iter;
+ }
+ }
+
+ /*
+ Sort items (in-place) by value {new:value, old:value} using
+ ordering function for values
+ */
+ sortItems(items) {
+ let order = this.sortOrder();
+ if (typeof order == "function") {
+ items.sort(function(item_a, item_b) {
+ let cue_a = (item_a.new) ? item_a.new : item_a.old;
+ let cue_b = (item_b.new) ? item_b.new : item_b.old;
+ return order(cue_a, cue_b);
+ });
+ }
+ }
+
+ /***************************************************************
+ EVENTS
+ ***************************************************************/
+
+ /*
+ Eventify: immediate events
+ */
+ eventifyInitEventArgs(name) {
+ if (name == "batch" || name == "change") {
+ let items = [...this.datasource.entries()].map(([key, val]) => {
+ return {key:key, new:val, old:undefined};
+ });
+ // sort init items (if order defined)
+ this.sortItems(items);
+ return (name == "batch") ? [items] : items;
+ }
+ }
+
+ /*
+ Event Notification
+ */
+ _notifyEvents(items) {
+ // event notification
+ if (items.length == 0) {
+ return;
+ }
+ const has_update_subs = this.eventifySubscriptions("batch").length > 0;
+ const has_remove_subs = this.eventifySubscriptions("remove").length > 0;
+ const has_change_subs = this.eventifySubscriptions("change").length > 0;
+ // update
+ if (has_update_subs) {
+ this.eventifyTrigger("batch", items);
+ }
+ // change, remove
+ if (has_remove_subs || has_change_subs) {
+ for (let item of items) {
+ if (item.new == undefined && item.old != undefined) {
+ if (has_remove_subs) {
+ this.eventifyTrigger("remove", item);
+ }
+ } else {
+ if (has_change_subs) {
+ this.eventifyTrigger("change", item);
+ }
+ }
+ }
+ }
+ }
+
+
+ /***************************************************************
+ ACCESSORS
+ ***************************************************************/
+
+ get size () {
+ return this.datasource.size;
+ }
+
+ has(key) {
+ return this.datasource.has(key);
+ };
+
+ get(key) {
+ return this.datasource.get(key);
+ };
+
+ keys() {
+ return this.datasource.keys();
+ };
+
+ values() {
+ return this.datasource.values();
+ };
+
+ entries() {
+ return this.datasource.entries();
+ }
+
+
+ /***************************************************************
+ MODIFY
+ ***************************************************************/
+
+ set(key, value) {
+ let old = undefined;
+ if (this.datasource.has(key)) {
+ old = this.datasource.get(key);
+ }
+ this.datasource.set(key, value);
+ this._notifyEvents([{key: key, new:value, old: old}]);
+ return this;
+ }
+
+ delete(key) {
+ let result = false;
+ let old = undefined;
+ if (this.datasource.has(key)) {
+ old = this.datasource.get(key);
+ this.datasource.delete(key);
+ result = true;
+ }
+ this._notifyEvents([{key: key, new:undefined, old: old}]);
+ return result;
+ }
+
+ clear() {
+ // create change events for all cues
+ const items = [...this.datasource.entries()].map(([key, val]) => {
+ return {key: key, new: undefined, old: val};
+ });
+ // clear _map
+ this.datasource.clear();
+ // event notification
+ this._notifyEvents(items);
+ }
+
+}
+
+eventify.eventifyPrototype(ObservableMap.prototype);
+
+/*
+ Copyright 2020
+ Author : Ingar Arntzen
+
+ This file is part of the Timingsrc module.
+
+ Timingsrc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Timingsrc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with Timingsrc. If not, see {
+ return this._submit.bind(this)();
+ });
+ }
+
+ _push(cue_args) {
+ // append cue args
+ let m = this._cues.length;
+ let was_empty = m == 0;
+ let n = cue_args.length;
+ this._cues.length += n;
+ for (let i=0; i 0) {
+ // batch done immediately
+ // will be submitted by donePromise in next microtask
+ this._done.value = true;
+ }
+ }
+
+ _submit() {
+ let result = [];
+ // carry out update if necessary
+ if (this._cues.length > 0) {
+ result = this._ds.update(this._cues, this._options);
+ }
+ // reset cue arg builder
+ this._reset();
+ // update result
+ return result;
+ }
+
+ /*
+ add or change single cue
+
+ if both interval and data are undefined
+ this is not interpreted as remove,
+ but as a cue with no interval and a data value set
+ to undefined
+ */
+ addCue(key, interval, data) {
+ let cue_arg = {key:key};
+ cue_arg.interval = interval;
+ if (arguments.length > 2) {
+ cue_arg.data = data;
+ }
+ cue_arg = cue_check(cue_arg);
+ this._push([cue_arg]);
+ return this;
+ }
+
+ /* remove single cue */
+ removeCue(key) {
+ this._push([{key:key}]);
+ return this;
+ }
+
+ /* load array of cue args into argbuilder */
+ update(cue_args) {
+ cue_args = cue_args.map((cue_arg) => cue_check(cue_arg));
+ this._push(cue_args);
+ }
+
+ /* clear args currently in argbuilder */
+ clear() {
+ this._cues = [];
+ return this;
+ }
+
+ /* manually submit cue args from cue arg builder */
+ submit() {
+ if (this._options.autosubmit) {
+ throw new Error("manual submit while options.autosubmit is true");
+ }
+ // mark batch as done
+ // will be submitted by donePromise in next microtask
+ this._done.value = true;
+ }
+}
+
+
+/*
+ this implements Dataset, a data collection supporting
+ efficient lookup of cues tied to intervals on the timeline
+
+ - cues may be tied to one or two points on the timeline, this
+ is expressed by an Interval.
+ - cues are indexed both by key and by intervals
+ - the interval index is divided into a set of CueBuckets,
+ based on cue interval length, for efficient lookup
+*/
+
+class Dataset extends CueCollection {
+
+ constructor(options) {
+ super(options);
+
+ this._map = new Map();
+ this._builder = new CueArgBuilder(this);
+
+ /*
+ Initialise set of CueBuckets
+ Each CueBucket is responsible for cues of a certain length
+ */
+ this._cueBuckets = new Map(); // CueBucketId -> CueBucket
+ for (let i=0; i -1) {
+ this._update_callbacks.splice(index, 1);
+ }
+ };
+
+
+ _notify_callbacks (batchMap, relevanceInterval) {
+ this._update_callbacks.forEach(function(handle) {
+ handle.handler(batchMap, relevanceInterval);
+ });
+ };
+
+ /***************************************************************
+ MAP METHODS
+ */
+
+ set (key, value) {
+ throw new Error("not implemented");
+ }
+
+ delete (key) {
+ throw new Error("not implemented");
+ }
+
+
+ /***************************************************************
+ CUE ARG BUILDER
+ */
+
+ makeBuilder(options) {
+ return new CueArgBuilder(this, options);
+ }
+
+ // not really useful (v2 complience)
+ get builder () {return this._builder;};
+
+
+ /***************************************************************
+ ADD CUE, REMOVE CUE
+
+ - COMPATIBILTY WITH V2
+ - SAFE TO USE repeatedly (batched using promise)
+ */
+
+ addCue(key, interval, data) {
+ if (arguments.length > 2) {
+ this._builder.addCue(key, interval, data);
+ } else {
+ this._builder.addCue(key, interval);
+ }
+ return this;
+ }
+
+ removeCue(key) {
+ this._builder.removeCue(key);
+ return this;
+ }
+
+ get updateDone() {return this._builder.updateDone};
+
+ /***************************************************************
+ ADD CUE, REMOVE CUE - INTERACTIVE USE
+
+ - CONVENIENCE for interactive use
+ - COMPATIBILTY WITH V2
+ - NOT RECOMMENDED TO USE repeatedly (batched using promise)
+ */
+
+ _addCue(key, interval, data, options) {
+ let cue = {key:key, interval:interval, data:data};
+ cue = cue_check(cue);
+ return this.update(cue, options);
+ }
+
+ _removeCue(key, options) {
+ return this.update({key:key}, options);
+ }
+
+ /***************************************************************
+ UPDATE
+
+ - insert, replace or delete cues
+
+ update(cues, equals, check)
+
+ ordered list of cues to be updated
+ - equality function for data objects
+
+ cue = {
+ key:key,
+ interval: Interval,
+ data: data
+ }
+
+ required
+ - cue.key property is defined and value is != undefined
+ - if cue.interval != undefined, it must be instance of Interval
+
+ EXAMPLES
+
+ // INSERT (no pre-existing cue)
+
+ cue = {key:1, interval: new Interval(3,4), data: {}}
+ // insert cue with only interval
+ cue = {key:1, interval: new Interval(3,4)}
+ // insert cue with only data
+ cue = {key:1, data: {}}
+
+
+ // REPLACE (pre-existing cue)
+ preexisting_cue = {key:1, interval: new Interval(3,4), data: {}}
+
+ cue = {key:1, interval: new Interval(3,5), data: {foo:"bar"}}
+ // replace interval, keep data
+ cue = {key:1, interval: new Interval(3,5)}
+ // replace interval, delete data
+ cue = {key:1, interval: new Interval(3,5), data: undefined
+ // replace data, keep interval
+ cue = {key:1, data: {foo:"bar"}}
+ // replace data, delete interval
+ cue = {key:1, interval: undefined, data: {foo:"bar"}}
+
+ // DELETE (pre-existing)
+ cue = {key:1}
+ // delete interval, keep data
+ cue = {key:1, interval: undefined}
+ // delete data, keep interval
+ cue = {key:1, data: undefined}
+
+
+ Update returns a list of event items - describes the effects of an update.
+ {
+ new: new_cue,
+ old: old_cue,
+ delta: {
+ interval: Delta,
+ data: Delta
+ }
+ }
+
+ with independent delta values for interval and data:
+ Delta.NOOP: 0
+ Delta.INSERT: 1
+ Delta.REPLACE: 2
+ Delta.DELETE: 3
+
+ Duplicates
+ - if there are multiple cue operations for the same key,
+ within the same batch of cues,
+ these will be processed in order.
+
+ - The old cue will always be the state of the cue,
+ before the batch started.
+
+ - The returned delta values will be calcultated relative to
+ the cue before the batch started (old).
+
+ This way, external mirroring observers may will be able to
+ replicate the effects of the update operation.
+
+ ***************************************************************/
+
+
+
+
+ update(cues, options = {}) {
+ const batchMap = new Map();
+ let current_cue;
+ let has_interval, has_data;
+
+ // options
+ let {debug=false, equals, check_needed=true} = options;
+
+ // support single cue arg for convenience
+ if (!isIterable(cues)) {
+ cues = [cues];
+ }
+
+ /***********************************************************
+ process all cues
+ ***********************************************************/
+ const epoch_ts = epoch();
+ const info = {
+ ts: epoch_ts,
+ author: options.author
+ };
+
+ for (let cue of cues) {
+
+ /*******************************************************
+ check validity of cue argument
+ *******************************************************/
+ if (check_needed) {
+ try {
+ cue = cue_check(cue);
+ } catch (err) {
+ console.log(err, cue);
+ continue;
+ }
+ }
+ has_interval = cue.hasOwnProperty("interval");
+ has_data = cue.hasOwnProperty("data");
+
+ /*******************************************************
+ adjust cue so that it correctly represents
+ the new cue to replace the current cue
+ - includes preservation of values from current cue
+ *******************************************************/
+
+ current_cue = this._map.get(cue.key);
+ if (current_cue == undefined) {
+ // make sure properties are defined
+ if (!has_interval) {
+ cue.interval = undefined;
+ }
+ if (!has_data) {
+ cue.data = undefined;
+ }
+ } else if (current_cue != undefined) {
+ if (!has_interval && !has_data) {
+ // make sure properties are defined
+ cue.interval = undefined;
+ cue.data = undefined;
+ } else if (!has_data) {
+ // REPLACE_INTERVAL, preserve data
+ cue.data = current_cue.data;
+ } else if (!has_interval) {
+ // REPLACE_DATA, preserve interval
+ cue.interval = current_cue.interval;
+ }
+ }
+
+ /*******************************************************
+ update cue
+ - update _map
+ - update cueBuckets
+ - create batchMap
+ *******************************************************/
+ this._update_cue(batchMap, current_cue, cue, info, options);
+ }
+
+ // flush all buckets so updates take effect
+ this._call_buckets("flush");
+
+ if (batchMap.size > 0) {
+
+ /*
+ create events without delta property
+ and accumulate relevance interval for batch
+ */
+ let relevance = {low: Infinity, high: -Infinity};
+
+ // create list of events and remove delta property
+ let items = [...batchMap.values()].map(item => {
+ if (item.new && item.new.interval) {
+ relevance.low = endpoint.min(relevance.low, item.new.interval.endpointLow);
+ relevance.high = endpoint.max(relevance.high, item.new.interval.endpointHigh);
+ }
+ if (item.old && item.old.interval) {
+ relevance.low = endpoint.min(relevance.low, item.old.interval.endpointLow);
+ relevance.high = endpoint.max(relevance.high, item.old.interval.endpointHigh);
+ }
+ return {key:item.key, new:item.new, old:item.old, info: item.info};
+ });
+
+ // extra filter items to remove NOOP transitions
+ let event_items = items.filter((item) => {
+ let delta = cue_delta(item.new, item.old, equals);
+ return (delta.interval != Delta.NOOP || delta.data != Delta.NOOP);
+ });
+
+ // event notification
+ this._notifyEvents(event_items);
+
+ // create relevance Interval
+ let relevanceInterval = undefined;
+ if (relevance.low != Infinity) {
+ relevanceInterval = Interval.fromEndpoints(relevance.low, relevance.high);
+ }
+
+ /*
+ notify sequencer last so that change event
+ from the dataset will be applied before change
+ events from sequencers.
+ */
+ this._notify_callbacks(batchMap, relevanceInterval);
+
+ // debug
+ if (debug) {this.integrity();}
+ return items;
+ }
+ // debug
+ if (debug) {this.integrity();}
+ return [];
+ };
+
+
+
+ /***************************************************************
+ UPDATE CUE
+
+ update operation for a single cue
+
+ - update _map
+ - generate entry for batchMap
+ - update CueBucket
+ ***************************************************************/
+
+ _update_cue(batchMap, current_cue, cue, info, options) {
+
+ let old_cue, new_cue;
+ let item, _item;
+ let oldCueBucket, newCueBucket;
+ let low_changed, high_changed;
+ let remove_needed, add_needed;
+
+ // options
+ let {chaining=true, safe=false, equals} = options;
+
+ if (current_cue === cue) {
+ throw Error("illegal cue arg: same object as current cue");
+ }
+
+ // check for equality
+ let delta = cue_delta(current_cue, cue, equals);
+
+ // (NOOP, NOOP)
+ if (delta.interval == Delta.NOOP && delta.data == Delta.NOOP) {
+ item = {
+ key:cue.key, new:current_cue,
+ old:current_cue, delta: delta
+ };
+ batchMap.set(cue.key, item);
+ return;
+ }
+
+
+ /***********************************************************
+ update _map and batchMap
+ ***********************************************************/
+
+ if (current_cue == undefined) {
+ // INSERT - add cue object to _map
+
+ // cue info: add if missing
+ if (cue.info == undefined) {
+ cue.info = {
+ ts: info.ts,
+ change_ts: info.ts,
+ change_id: 0
+ };
+ }
+
+ old_cue = undefined;
+ new_cue = (safe)? Object.freeze(cue) : cue;
+ this._map.set(cue.key, new_cue);
+
+
+ } else if (cue.interval == undefined && cue.data == undefined) {
+ // DELETE - remove cue object from _map
+ old_cue = current_cue;
+ new_cue = undefined;
+ this._map.delete(cue.key);
+
+ // cue info: noop
+
+ } else {
+ // REPLACE
+
+ // cue info - update if missing
+ // preserve ts from current cue, update update_ts
+ if (cue.info == undefined) {
+ cue.info = {
+ ts: current_cue.info.ts,
+ change_ts: info.ts,
+ change_id: current_cue.info.change_id + 1
+ };
+ }
+
+ /*
+ Solution used to be in-place modification
+ of current cue.
+ Now we instead implement replace by inserting
+ a new cue object as current cue.
+ Since current cue is referenced both in
+ _map and in pointMap - it must be replaced both
+ places.
+
+ Adjustments to pointMap as a result of interval
+ changes are handled further down
+
+ Another design option would be to let point map
+ manage only keys of cues. This however would
+ impose an extra map lookup per item in lookup -
+ so better to pay this modest price in update
+ */
+ old_cue = current_cue;
+ new_cue = {
+ key: cue.key,
+ interval: cue.interval,
+ data: cue.data,
+ info: cue.info
+ };
+
+ if (safe) {
+ new_cue = Object.freeze(new_cue);
+ }
+
+ // replace in cue map
+ this._map.set(cue.key, new_cue);
+
+ // replace in point map
+ // - only necessary if old cue is in pointMap
+ // i.e. if old_cue has interval
+ if (old_cue.interval) {
+ let bid = getCueBucketId(old_cue.interval.length);
+ let cueBucket = this._cueBuckets.get(bid);
+ // replace for low
+ cueBucket.replace_endpoint(old_cue.interval.low, new_cue);
+ // replace for high
+ if (!old_cue.singular) {
+ cueBucket.replace_endpoint(old_cue.interval.high, new_cue);
+ }
+ }
+ }
+ item = {key:cue.key, new:new_cue, old:old_cue, delta:delta, info};
+
+ /*
+ if this item has been set earlier in batchMap
+ restore the correct old_cue by getting it from
+ the previous batchMap item
+
+ recalculate delta relative to old_cue
+ - continue processing with the original (delta, old_cue) defined
+ above, as this is required to correctly change cueBuckets
+ which have already been affected by previous item.
+ */
+ if (chaining) {
+ _item = batchMap.get(cue.key);
+ if (_item != undefined) {
+ item.old = _item.old;
+ item.delta = cue_delta(new_cue, item.old, equals);
+ }
+ }
+
+ batchMap.set(cue.key, item);
+
+ //console.log("OLD:", cue_to_string(old_cue));
+ //console.log("NEW:", cue_to_string(new_cue));
+
+ /***********************************************************
+ update cueBuckets
+
+ - use delta.interval to avoid unnessesary changes
+
+ - interval may change in several ways:
+ - low changed
+ - high changed
+ - low and high changed
+ - changed intervals may stay in bucket or change bucket:
+ - changing to/from singular may require special consideration
+ with respect to how many endpoints are being updated
+ - singular -> singular
+ - singular -> regular
+ - regular -> singular
+ - regular -> regular
+ - changes to interval.lowInclude and interval highInclude
+ do not require any changes to CueBuckets, as long
+ as interval.low and interval.high values stay unchanged.
+ ***********************************************************/
+
+ if (delta.interval == Delta.NOOP) {
+ // no changes to interval - no change needed in pointMap
+ return;
+ } else if (delta.interval == Delta.INSERT) {
+ remove_needed = false;
+ add_needed = true;
+ low_changed = true;
+ high_changed = true;
+ } else if (delta.interval == Delta.DELETE) {
+ remove_needed = true;
+ add_needed = false;
+ low_changed = true;
+ high_changed = true;
+ } else if (delta.interval == Delta.REPLACE) {
+ remove_needed = true;
+ add_needed = true;
+ low_changed = new_cue.interval.low != old_cue.interval.low;
+ high_changed = new_cue.interval.high != old_cue.interval.high;
+ }
+
+ /*
+ old cue and new cue might not belong to the same cue bucket
+ */
+ if (remove_needed){
+ let old_bid = getCueBucketId(old_cue.interval.length);
+ oldCueBucket = this._cueBuckets.get(old_bid);
+ }
+ if (add_needed) {
+ let new_bid = getCueBucketId(new_cue.interval.length);
+ newCueBucket = this._cueBuckets.get(new_bid);
+ }
+
+ /*
+ if old CueBucket is different from the new cue Buckets
+ both low and high must be moved, even it one was not
+ changed
+ */
+ if (oldCueBucket && newCueBucket) {
+ if (oldCueBucket != newCueBucket) {
+ remove_needed = true;
+ add_needed = true;
+ low_changed = true;
+ high_changed = true;
+ }
+ }
+
+ /*
+ dispatch add and remove operations for interval points
+
+ cues in CueBucket may be removed using a copy of the cue,
+ because remove is by key.
+
+ cues added to CueBucket must be the correct object
+ (current_cue), so that later in-place modifications become
+ reflected in CueBucket.
+ */
+
+ // update low point - if changed
+ if (low_changed) {
+ if (remove_needed) {
+ oldCueBucket.del_endpoint(old_cue.interval.low, old_cue);
+ }
+ if (add_needed) {
+ newCueBucket.add_endpoint(new_cue.interval.low, new_cue);
+ }
+ }
+ // update high point - if changed
+ if (high_changed) {
+ if (remove_needed && !old_cue.interval.singular) {
+ oldCueBucket.del_endpoint(old_cue.interval.high, old_cue);
+ }
+ if (add_needed && !new_cue.interval.singular) {
+ newCueBucket.add_endpoint(new_cue.interval.high, new_cue);
+ }
+ }
+ }
+
+
+ /*
+ INTERNAL FUNCTION
+ execute method across all cue buckets
+ and aggregate results
+ */
+ _call_buckets(method, ...args) {
+ const arrays = [];
+ for (let cueBucket of this._cueBuckets.values()) {
+ let cues = cueBucket[method](...args);
+ if (cues != undefined && cues.length > 0) {
+ arrays.push(cues);
+ }
+ }
+ return array_concat(arrays);
+ };
+
+
+ /*
+ LOOKUP ENDPOINTS
+
+ returns (endpoint, cue) for all endpoints covered by given interval
+
+ returns:
+ - [{endpoint: endpoint, cue:cue}]
+ */
+
+ lookup_endpoints(interval) {
+ interval = asInterval(interval);
+ return this._call_buckets("lookup_endpoints", interval);
+ };
+
+
+ /*
+ LOOKUP
+ */
+
+ lookup(interval, mask) {
+ interval = asInterval(interval);
+ return this._call_buckets("lookup", interval, mask);
+ };
+
+
+ /*
+ REMOVE CUES BY INTERVAL
+ */
+ lookup_delete(interval, mask, options={}) {
+ interval = asInterval(interval);
+ const cues = this._call_buckets("lookup_delete", interval, mask);
+ // remove from _map and make event items
+ const items = [];
+ const info = {
+ ts: epoch(),
+ author: options.author
+ };
+ let cue;
+ for (let i=0; i cue.interval == undefined);
+
+ let count_buckets = cues.length;
+ let count_no_interval = no_interval_cues.length;
+ let count_map = this._map.size;
+ let diff = count_map - count_buckets - count_no_interval;
+ if (diff != 0) {
+ console.log("count buckets", count_buckets);
+ console.log("count no intervals", count_no_interval);
+ console.log("count map", count_map);
+ console.log("count diff", diff);
+ throw new Error("inconsistent cue count");
+ }
+
+ // check that cue maps are non overlapping
+ let bucket_map = new Map(cues.map(cue => [cue.key, cue]));
+ let map_map = new Map([...this._map.entries()].filter(([key, cue]) => {
+ return (cue.interval != undefined);
+ }));
+
+ let missing = map_difference(bucket_map, map_map);
+ if (missing.size > 0) {
+ console.log("buckets missing cues:");
+ console.log([...missing.keys()]);
+ throw new Error(`buckets missing cues: ${[...missing.keys()]}`);
+ }
+
+ missing = map_difference(map_map, bucket_map);
+ if (missing.size > 0) {
+ throw new Error(`buckets too many cues: ${[...missing.keys()]}`);
+ }
+
+ return {
+ cues: cues.length,
+ points: points.length
+ };
+ };
+
+}
+
+
+Dataset.Delta = Delta;
+Dataset.cue_delta = cue_delta;
+Dataset.cue_equals = cue_equals;
+
+
+/*
+ CueBucket is a bucket of cues limited to specific length
+*/
+
+
+class CueBucket {
+
+
+ constructor(maxLength) {
+
+ // max length of cues in this bucket
+ this._maxLength = maxLength;
+
+ /*
+ pointMap maintains the associations between values (points on
+ the timeline) and cues that reference such points. A single point value may be
+ referenced by multiple cues, so one point value maps to a list of cues.
+
+ value -> [cue, ....]
+ */
+ this._pointMap = new Map();
+
+
+ /*
+ pointIndex maintains a sorted list of numbers for efficient lookup.
+ A large volume of insert and remove operations may be problematic
+ with respect to performance, so the implementation seeks to
+ do a single bulk update on this structure, for each batch of cue
+ operations (i.e. each invocations of addCues). In order to do this
+ all cue operations are processed to calculate a single batch
+ of deletes and a single batch of inserts which then will be applied to
+ the pointIndex in one atomic operation.
+
+ [1.2, 3, 4, 8.1, ....]
+ */
+ this._pointIndex = new BinarySearch();
+
+ // bookeeping during batch processing
+ this._created = new Set(); // point
+ this._dirty = new Set(); // point
+
+ };
+
+
+ /*
+
+ ENDPOINT BATCH PROCESSING
+
+ Needs to translate endpoint operations into a minimum set of
+ operations on the pointIndex.
+
+ To do this, we need to record points that are created and
+ points that are removed.
+
+ The total difference that the batch of cue operations
+ amounts to is expressed as one list of values to be
+ deleted, and and one list of values to be inserted.
+ The update operation of the pointIndex will process both
+ in one atomic operation.
+
+ On flush both the pointMap and the pointIndex will be brought
+ up to speed
+
+ created and dirty are used for bookeeping during
+ processing of a cue batch. They are needed to
+ create the correct diff operation to be applied on pointIndex.
+
+ created : includes values that were not in pointMap
+ before current batch was processed
+
+ dirty : includes values that were in pointMap
+ before current batch was processed, and that
+ have been become empty at least at one point during cue
+ processing.
+
+ created and dirty are used as temporary alternatives to pointMap.
+ after the cue processing, pointmap will updated based on the
+ contents of these two.
+
+ process buffers operations for pointMap and index so that
+ all operations may be applied in one batch. This happens in flush
+ */
+
+ add_endpoint(point, cue) {
+ let init = (this._pointMap.size == 0);
+ let cues = (init) ? undefined : this._pointMap.get(point);
+ if (cues == undefined) {
+ this._pointMap.set(point, [cue]);
+ this._created.add(point);
+ } else {
+ cues.push(cue);
+ //addCueToArray(cues, cue);
+ }
+ }
+
+ del_endpoint(point, cue) {
+ let init = (this._pointMap.size == 0);
+ let cues = (init) ? undefined : this._pointMap.get(point);
+ if (cues != undefined) {
+ let empty = removeCueFromArray(cues, cue);
+ if (empty) {
+ this._dirty.add(point);
+ }
+ }
+ };
+
+ /*
+ in case of data update without touching the interval
+ the new cue needs to be insert in place of the old
+ */
+ replace_endpoint(point, cue) {
+ let init = (this._pointMap.size == 0);
+ let cues = (init) ? undefined : this._pointMap.get(point);
+ if (cues != undefined) {
+ let ok = replaceCueInArray (cues, cue);
+ if (!ok) {
+ console.log("WARNING: attempt to replace non-existent cue in pointMap");
+ }
+ }
+ }
+
+
+ /*
+ Batch processing is completed
+ Commit changes to pointIndex and pointMap.
+
+ pointMap
+ - update with contents of created
+
+ pointIndex
+ - points to delete - dirty and empty
+ - points to insert - created and non-empty
+
+ it is possible that a cue ends up in both created and dirty
+
+ */
+ flush() {
+ if (this._created.size == 0 && this._dirty.size == 0) {
+ return;
+ }
+
+ // update pointIndex
+ let to_remove = [];
+ let to_insert = [];
+ for (let point of this._created.values()) {
+ let cues = this._pointMap.get(point);
+ if (cues.length > 0) {
+ to_insert.push(point);
+ } else {
+ this._pointMap.delete(point);
+ }
+ }
+ for (let point of this._dirty.values()) {
+ let cues = this._pointMap.get(point);
+ if (cues == undefined) {
+ // point already deleted from created set - ignore
+ continue;
+ }
+ if (cues.length == 0) {
+ to_remove.push(point);
+ this._pointMap.delete(point);
+ }
+ }
+ this._pointIndex.update(to_remove, to_insert);
+ // cleanup
+ this._created.clear();
+ this._dirty.clear();
+ };
+
+
+ /*
+ LOOKUP_ENDPOINTS
+
+ returns all (endpoint, cue) pairs where
+ - endpoint is a cue endpoint (cue.endpointLow or cue.endpointHigh)
+ - endpoint is INSIDE search interval
+ - [{endpoint:endpoint, cue: cue}]
+
+ - a given endpoint may appear multiple times in the result,
+ as multiple cues may be tied to the same endpoint
+ - a given cue may appear two times in the result, if
+ both cue.endpointLow and cue.endpointHigh are both INSIDE interval
+ - a singular cue will appear only once
+ - ordering: no specific order is guaranteed
+ - results are concatenated from multiple CueBuckets
+ - internally in a single CueBucket
+ - no defined order for cues tied to the same endpoint
+ - the natural order is endpoint order
+ - but this can be added on the outside if needed
+ - no order is defined if two cues have exactly the
+ same endpoint
+
+ */
+
+ lookup_endpoints(interval) {
+ if (this._pointMap.size == 0) {
+ return [];
+ }
+ const broader_interval = new Interval(interval.low, interval.high, true, true);
+ const points = this._pointIndex.lookup(broader_interval);
+ const result = [];
+ const len = points.length;
+ let point, _endpoint;
+ for (let i=0; i this._maxLength) {
+ return cues;
+ }
+
+ /*
+ handle match with COVERS separately
+
+ search left of search interval for cues
+ that covers the search interval
+ search left is limited by CueBucket maxlength
+ left_interval: [interval.high-maxLength, interval.low]
+
+ it would be possible to search right too, but we
+ have to choose one.
+ */
+ if (mask & Relation$1.COVERS) {
+
+ let left_interval;
+ if (this._maxLength == Infinity) {
+ // no limitation on interval length
+ // must search entire timeline to the left
+ left_interval = new Interval(-Infinity, interval.low);
+ } else {
+ let low = interval.high - this._maxLength;
+ let high = interval.low;
+ // protect against float rounding effects creating
+ // high < low by a very small margin
+ [low, high] = [Math.min(low, high), Math.max(low, high)];
+ left_interval = new Interval(low, high, true, true);
+ }
+ this._lookup_cues(left_interval)
+ .forEach(function(cue){
+ if (cue.interval.match(interval, Relation$1.COVERS)) {
+ cues.push(cue);
+ }
+ });
+ }
+
+ return cues;
+ }
+
+
+ /*
+ REMOVE CUES
+ */
+ lookup_delete(interval, mask) {
+ /*
+ update pointMap
+ - remove all cues from pointMap
+ - remove empty entries in pointMap
+ - record points that became empty, as these need to be deleted in pointIndex
+ - separate into two bucketes, inside and outside
+ */
+ const cues = this.lookup(interval, mask);
+ const to_remove = [];
+ let cue, point, points;
+ for (let i=0; i 0) {
+ throw new Error(`pointMap missing points: ${[...missing]}`);
+ }
+
+ missing = set_difference(map_point_set, index_point_set);
+ if (missing.size > 0) {
+ throw new Error(`pointIndex missing points: ${[...missing]}`);
+ }
+ }
+
+ /*
+ invariable - pointIndex shall always be sorted and not contain duplicates
+ */
+ let points = [...this._pointIndex.values()];
+ if (points.length != index_point_set.size) {
+ throw new Error("pointIndex include duplicate points");
+ }
+ for (let i=1; i= points[i]) {
+ throw new Error("pointIndex not ordered");
+ }
+ }
+
+ /**
+ * invariable - pointMap point -> cues
+ * cues shall only include cues which are relevant to given point
+ */
+ for (let point of points) {
+ let cues = this._pointMap.get(point);
+ for (let cue of cues) {
+ // figure out if point is endpoint low or high
+ if (point == cue.interval.low) {
+ continue;
+ } else if (point == cue.interval.high) {
+ continue;
+ } else {
+ console.log("POINT:", point);
+ console.log("CUE:", cue.interval.toString());
+ throw new Error("pointMap: wrong cue");
+ }
+ }
+ }
+
+
+ /**
+ * invariable - all endpoints from all cues from pointMap are found as points in pointMap
+ */
+
+ for (let _cue_list of [...this._pointMap.values()]) {
+ for (let cue of _cue_list) {
+ for (let p of [cue.interval.low, cue.interval.high]) {
+ if (!this._pointMap.has(p)) {
+ throw new Error(`cue found with low or high point not in pointMap ${p} -> ${cue.interval.toString()} `);
+ }
+ }
+ }
+ }
+
+
+ /*
+ invariable - all cues in pointMap with same key are same object
+ */
+
+ // collect all cues from pointMap
+ let _cues = [];
+ for (let _cue_list of this._pointMap.values()) {
+ for (let cue of _cue_list) {
+ _cues.push(cue);
+ }
+ }
+
+ // remove and check duplicates
+ let cueMap = new Map();
+ for (let cue of _cues) {
+ let _cue = cueMap.get(cue.key);
+ if (_cue == undefined) {
+ cueMap.set(cue.key, cue);
+ } else {
+ // duplicate
+ if (cue !== _cue) {
+ throw new Error("pointMap: different cue objects for same key");
+ }
+ }
+ }
+ let cues = [...cueMap.values()];
+
+ /**
+ * invariable - all cues belong to this bucket
+ */
+
+ for (let cue of cues.values()) {
+ // check that cue belongs to this bucket
+ if (cue.interval.length > this._maxLength) {
+ throw new Error(`cue in wrong cue bucket ${this._maxLength}, ${cue.interval.toString()}`);
+ }
+ }
+
+ return [{
+ maxLength: this._maxLength,
+ points: [...this._pointMap.keys()],
+ cues: cues
+ }];
+ };
+}
+
+/*
+ Copyright 2020
+ Author : Ingar Arntzen
+
+ This file is part of the Timingsrc module.
+
+ Timingsrc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Timingsrc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with Timingsrc. If not, see
+ - : if defined only include cues that match the interval
+ - : filter by cue key
+ function keep(key) returns boolena
+ - : filter by cue data
+ function keep(data) returns boolean
+ - : change cue data
+ function convert(data) returns data
+ NOTE: filtering occurs BEFORE convert
+ and only impacts the presentation of cues
+ WARNING: it is possible to change the value
+ in such a way that filtering appears incorrect
+
+ This subset implementation is STATELESS
+ It does not manage its own state, only implements a
+ stateless frontend over its source dataset.
+
+*/
+
+class Subset extends CueCollection {
+
+ constructor(dataset, options={}) {
+ super(options);
+ this._key_filter = options.key_filter;
+ this._data_filter = options.data_filter;
+ this._interval = options.interval;
+ this._data_convert = options.data_convert;
+ this._size = 0;
+
+ // Callbacks
+ this._callbacks = [];
+
+ // Source Dataset
+ this._src_ds = dataset;
+ let cb = this._onDatasetCallback.bind(this);
+ this._src_ds_cb = this._src_ds.add_callback(cb);
+ }
+
+
+ /***************************************************************
+ ACCESSORS
+ ***************************************************************/
+
+ get datasource () {
+ return this._src_ds;
+ }
+
+ get dataset () {
+ return this._src_ds;
+ }
+
+
+ get interval () {
+ return this._interval;
+ }
+
+ set interval (itv) {
+ this._setInterval(itv);
+ }
+
+
+ /***************************************************************
+ EVENT CALLBACKS - FOR SEQUENCERS
+ ***************************************************************/
+
+ add_callback (handler) {
+ let handle = {
+ handler: handler
+ };
+ this._callbacks.push(handle);
+ return handle;
+ };
+
+
+ del_callback (handle) {
+ let index = this._callbacks.indexof(handle);
+ if (index > -1) {
+ this._callbacks.splice(index, 1);
+ }
+ };
+
+
+ _notify_callbacks (batchMap, relevanceInterval) {
+ this._callbacks.forEach(function(handle) {
+ handle.handler(batchMap, relevanceInterval);
+ });
+ };
+
+
+ /***************************************************************
+ FILTER & CONVER
+ ***************************************************************/
+
+ /*
+ Keep cue
+ */
+
+ _cue_keep(cue) {
+ if (cue == undefined) {
+ return false;
+ }
+ // check if cue matches interval
+ if (this._interval) {
+ if (!this._interval.match(cue.interval)) {
+ return false;
+ }
+ }
+ // check key filter
+ if (this._key_filter) {
+ if (!this._key_filter(cue.key)) {
+ return false;
+ }
+ }
+ // check data filter
+ if (this._data_filter) {
+ if (!this._data_filter(cue.data)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Convert cue
+ */
+ _cue_convert(cue) {
+ if (cue != undefined && this._data_convert) {
+ // copy
+ return {
+ key: cue.key,
+ interval: cue.interval,
+ data: this._data_convert(cue.data)
+ }
+ }
+ return cue;
+ }
+
+ /**
+ * Filter (and modify) event items based on key_filter and data_filter
+ */
+
+ _items_filter_convert(items) {
+ let _items = [];
+ for (let item of items) {
+ if (item.new == undefined && item.old == undefined) {
+ continue;
+ }
+ /*
+ use cue filter function to check relevance of both old and new
+ consider change of unrelevant cue into relevant cue.
+ old cue would be non-relevant, new cue would be relevant
+ Since old cue was not part of the subset before, it needs
+ to be removed from the item - effectively turning the change
+ operation into an add operation.
+ */
+ let _old = (this._cue_keep(item.old)) ? item.old : undefined;
+ let _new = (this._cue_keep(item.new)) ? item.new : undefined;
+ if (_old == undefined && _new == undefined) {
+ continue;
+ }
+ // convert
+ _old = this._cue_convert(_old);
+ _new = this._cue_convert(_new);
+ // push
+ _items.push({key:item.key, new: _new, old: _old});
+ }
+ return _items;
+ }
+
+
+ /***************************************************************
+ LOOKUP
+ ***************************************************************/
+
+ _check_interval(interval) {
+ if (this._interval) {
+ // subset interval
+ if (interval) {
+ // lookup interval - find intersection
+ let intersects = Interval.intersect(interval, this._interval);
+ if (intersects.length == 0) {
+ console.log(`warning - lookup interval ${interval.toString()} outside the subset interval ${this._interval.toString()}`);
+ return [];
+ } else {
+ interval = intersects[0];
+ }
+ } else {
+ // no lookup interval - use subset interval
+ interval = this._interval;
+ }
+ }
+ return interval;
+ }
+
+ /**
+ * lookup cues
+ */
+
+ lookup(interval, mask) {
+ let _interval = this._check_interval(interval);
+ let cues;
+ if (_interval) {
+ cues = this.datasource.lookup(_interval, mask);
+ } else {
+ cues = [...this.datasource.values()];
+ }
+ // filter & convert cues
+ return cues.filter(this._cue_keep, this)
+ .map(this._cue_convert, this);
+ }
+
+ /*
+ lookup endpoints
+ used by sequencers
+ */
+
+ lookup_endpoints(interval) {
+ let _interval = this._check_interval(interval);
+ let items = this.datasource.lookup_endpoints(_interval);
+ // filter and convert
+ return items.filter((item) => {
+ return this._cue_keep(item.cue);
+ }, this).map((item) => {
+ return {endpoint: item.endpoint, cue: this._cue_convert(item.cue)};
+ }, this);
+ }
+
+ /***************************************************************
+ INITIAL STATE
+ ***************************************************************/
+
+ eventifyInitEventArgs(name) {
+ if (name == "batch" || name == "change") {
+ // find cues
+ let cues = this.lookup();
+ // make event items
+ let items = cues.map((cue) => {
+ return {key:cue.key, new:cue, old:undefined};
+ });
+ // sort
+ this.sortItems(items);
+ return (name == "batch") ? [items] : items;
+ }
+ }
+
+ /***************************************************************
+ DATASET CALLBACK
+ ***************************************************************/
+
+ _onDatasetCallback(eventMap, relevanceInterval) {
+ let items = [...eventMap.values()];
+ items = this._items_filter_convert(items);
+ // update size
+ for (let item of items) {
+ if (item.new != undefined && item.old == undefined) {
+ // add
+ this._size += 1;
+ } else if (item.new == undefined && item.old != undefined) {
+ // remove
+ this._size -= 1;
+ }
+ }
+ // forward as events
+ super._notifyEvents(items);
+ // forward as callbacks
+ let batchMap = new Map(items.map((item) => {
+ return [item.key, item];
+ }));
+ if (this._interval) {
+ relevanceInterval = Interval.intersect(this._inverval, relevanceInterval);
+ }
+ this._notify_callbacks(batchMap, relevanceInterval);
+ }
+
+
+ /***************************************************************
+ SET INTERVAL
+ ***************************************************************/
+
+ _setInterval (itv) {
+ if (!itv instanceof Interval) {
+ throw new Error("must be interval", itv.toString());
+ }
+ if (!this._interval || !this._interval.equals(itv)) {
+ // current cues (before interval update)
+ let current_cues = this.lookup();
+ // update interval
+ this._interval = itv;
+ // cues (after interval update)
+ let new_cues = this.datasource.lookup(itv);
+ // filter & convert cues
+ new_cues = new_cues
+ .filter(this._cue_keep, this)
+ .map(this._cue_convert, this);
+ // switch to map representation
+ let currentCueMap = new Map([...current_cues].map((cue) => {
+ return [cue.key, cue];
+ }));
+ let newCueMap = new Map([...new_cues].map((cue) => {
+ return [cue.key, cue];
+ }));
+ // exit and enter cues
+ let exitCueMap = map_difference(currentCueMap, newCueMap);
+ let enterCueMap = map_difference(newCueMap, currentCueMap);
+ // make list of event items
+ let exitItems = [...exitCueMap.values()].map((cue) => {
+ return {key: cue.key, new:undefined, old: cue}
+ });
+ let enterItems = [...enterCueMap.values()].map((cue) => {
+ return {key: cue.key, new:cue, old: undefined}
+ });
+ // update size
+ this._size -= exitItems.length;
+ this._size += enterItems.length;
+ // event notification
+ const items = array_concat([exitItems, enterItems], {copy:false, order:true});
+ this._notifyEvents(items);
+ }
+ }
+
+ /***************************************************************
+ MAP ACCESSORS
+ ***************************************************************/
+
+ get size () {
+ return this._size;
+ }
+
+ has(key) {
+ return (this.get(key) != undefined);
+ };
+
+ get(key) {
+ let cue = super.get(key);
+ if (cue != undefined && this._cue_keep(cue)) {
+ return this._cue_convert(cue);
+ }
+ };
+
+ keys() {
+ return this.values().map((cue => {
+ return cue.key;
+ }));
+ };
+
+ values() {
+ return [...super.values()]
+ .filter((cue) => {
+ return this._cue_keep(cue);
+ }, this)
+ .map((cue) => {
+ return this._cue_convert(cue);
+ }, this);
+ };
+
+ entries() {
+ return this.values().map((cue) => {
+ return [cue.key, cue];
+ });
+ };
+
+
+ /***************************************************************
+ MAP MODIFICATION METHODS
+ ***************************************************************/
+
+ update(cues, options) {
+ throw new Error("not implemented");
+ }
+
+ set (key, value) {
+ throw new Error("not implemented");
+ }
+
+ delete (key) {
+ throw new Error("not implemented");
+ }
+
+ clear (key) {
+ throw new Error("not implemented");
+ }
+
+}
+
+/*
+ Copyright 2020
+ Author : Ingar Arntzen
+
+ This file is part of the Timingsrc module.
+
+ Timingsrc is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Timingsrc is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with Timingsrc. If not, see not equal\n if (aProps.length != bProps.length) {\n return false;\n }\n for (let i=0; i not equal\n if (a[propName] !== b[propName]) {\n return false;\n }\n }\n // equal\n return true;\n}\n\n\n/* document readypromise */\nexport const docready = new Promise(function(resolve) {\n if (document.readyState === 'complete') {\n resolve();\n } else {\n let onReady = function () {\n resolve();\n document.removeEventListener('DOMContentLoaded', onReady, true);\n window.removeEventListener('load', onReady, true);\n };\n document.addEventListener('DOMContentLoaded', onReady, true);\n window.addEventListener('load', onReady, true);\n }\n});\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see -1) {\n indexes.push(index);\n }\n }\n return indexes;\n };\n\n /*\n element exists with value\n */\n has(x) {\n return (this.indexOf(x) > -1) ? true : false;\n };\n\n get(index) {\n return this.array[index];\n };\n\n\n\n /*\n REMOVE\n Removes all elements with given values\n search for each one and splice remove them individually\n (reverse order)\n\n INSERT\n binarysearch and splice\n insert - binarysearch and splice\n\n WARNING - there should be no need to insert elements that are already\n present in the array. This function drops such duplicates\n */\n _update_splice(to_remove, to_insert, options) {\n\n // REMOVE\n if (this.array.length > 0) {\n let indexes = this.indexOfElements(to_remove);\n /*\n sort indexes to make sure we are removing elements\n in backwards order\n optimization\n - if elements were sorted in the first place this should not be necessary\n */\n indexes.sort(function(a,b){return a-b;});\n for (let i=indexes.length-1; i > -1; i--) {\n this.array.splice(indexes[i], 1);\n }\n }\n\n // INSERT\n let x, index;\n let len = to_insert.length;\n for (let i=0; i 0 && to_remove.length > 0) {\n // visit all elements and set their value to undefined\n // undefined values will be sorted to the end of the array\n let indexes = this.indexOfElements(to_remove);\n for (let i=0; i 0) {\n let index = this.array.indexOf(undefined);\n if (index > -1) {\n this.array.splice(index, this.array.length-index);\n }\n }\n // remove duplicates\n this.array = unique(this.array);\n };\n\n\n /*\n Update - removing and inserting elements in one operation\n\n a single element should only be present once in the list, thus avoiding\n multiple operations to one element. This is presumed solved externally.\n - also objects must not be members of both lists.\n\n - internally selects the best method - searchsplice or concatsort\n - selection based on relative sizes of existing elements and new elements\n\n */\n update(to_remove, to_insert, options) {\n let size = to_remove.length + to_insert.length;\n if (size == 0) {\n return;\n }\n\n // regular case\n let approach = resolve_approach(this.array.length, size);\n if (approach == \"splice\") {\n this._update_splice(to_remove, to_insert, options);\n } else if (approach == \"sort\"){\n this._update_sort(to_remove, to_insert, options);\n }\n };\n\n\n /*\n Accessors\n */\n\n getMinimum() {\n return (this.array.length > 0) ? this.array[0] : undefined;\n };\n\n getMaximum = function () {\n return (this.array.length > 0) ? this.array[this.array.length - 1] : undefined;\n };\n\n\n /*\n Internal search functions\n */\n\n /*\n Find index of largest value less than x\n Returns -1 if noe values exist that are less than x\n */\n ltIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n consider element to the left\n if we are at the left end of the array nothing is found\n return -1\n */\n if (i > 0) {\n return i-1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) - 1 is the largest value less than x\n */\n return Math.abs(i)-1;\n }\n };\n\n /*\n Find index of rightmost value less than x or equal to x\n Returns -1 if noe values exist that are less than x or equal to x\n */\n leIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n element found\n */\n return i;\n } else {\n // not found - consider element to the left\n i = Math.abs(i) - 1;\n return (i >= 0) ? i : -1;\n }\n };\n\n /*\n \tFind index of leftmost value greater than x\n \tReturns -1 if no values exist that are greater than x\n */\n\n gtIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n if there are no elements to the right return -1\n */\n if (i < this.array.length -1) {\n return i+1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) is the smallest value greater than x\n unless we hit the end of the array, in which cas no smalles value\n exist which is greater than x\n */\n let idx = Math.abs(i);\n return (idx < this.array.length) ? idx : -1;\n }\n };\n\n\n /*\n Find index of leftmost value which is greater than x or equal to x\n Returns -1 if noe values exist that are greater than x or equal to x\n */\n\n geIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found element\n */\n return i;\n } else {\n // not found - consider the element where x would be inserted\n i = Math.abs(i);\n return (i -1) {\n return [index, index + 1];\n } else {\n return [undefined, undefined];\n }\n }\n\n // regular non-singular interval\n var start_index = -1, end_index = -1;\n if (interval.lowInclude) {\n start_index = this.geIndexOf(interval.low);\n } else {\n start_index = this.gtIndexOf(interval.low);\n }\n if (start_index === -1) {\n return [undefined, undefined];\n }\n if (interval.highInclude) {\n end_index = this.leIndexOf(interval.high);\n } else {\n end_index = this.ltIndexOf(interval.high);\n }\n if (end_index === -1) { // not reachable - I think\n return [undefined, undefined];\n }\n return [start_index, end_index + 1];\n };\n\n\n /*\n lookup by interval\n */\n lookup(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.slice(start, end) : [];\n };\n\n /*\n remove by interval\n */\n remove(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.splice(start, end-start) : [];\n };\n\n\n slice(start, end) {\n return this.array.slice(start, end);\n };\n\n splice(start, length) {\n return this.array.splice(start, length);\n };\n\n\n\n /*\n method for removing multiple closely placed elements in place\n - removeList is sorted\n - changes only affect the part of the index between first and last element\n - move remaining elements to the left, remove elements with a single splice\n - efficent if removelist references elements that are close to eachother\n */\n\n removeInSlice(removeList) {\n if (removeList.length == 0){\n return;\n }\n const low = removeList[0];\n const high = removeList[removeList.length-1];\n let [start, end] = this.lookupIndexes(new Interval(low, high, true, true));\n\n let rd_ptr = start;\n let wr_ptr = start;\n let rm_ptr = 0;\n\n while (rd_ptr < end) {\n let rd_elem = this.array[rd_ptr];\n let rm_elem = removeList[rm_ptr];\n if (rd_elem < rm_elem) {\n this.array[wr_ptr] = this.array[rd_ptr];\n wr_ptr++;\n rd_ptr++;\n } else if (rd_elem == rm_elem) {\n rd_ptr++;\n rm_ptr++;\n } else {\n // rd_elem > rm_elem\n rm_ptr++;\n }\n if (rm_ptr == removeList.length) {\n break\n }\n }\n this.array.splice(wr_ptr, rd_ptr-wr_ptr);\n };\n\n\n values() {\n return this.array.values();\n };\n\n clear() {\n this.array = [];\n };\n\n get length () {\n return this.array.length;\n }\n\n}\n\nexport default BinarySearch;\n\n\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see {\n\t\t\treturn {name, eArg};\n\t\t}));\n\t}\n\n\t/*\n\t\tTrigger single event\n\t*/\n\tfunction eventifyTrigger(name, eArg) {\n\t\treturn this.eventifyTriggerAll([{name, eArg}]);\n\t}\n\n\t_prototype.eventifyDefine = eventifyDefine;\n\t_prototype.eventifyTrigger = eventifyTrigger;\n\t_prototype.eventifyTriggerAlike = eventifyTriggerAlike;\n\t_prototype.eventifyTriggerAll = eventifyTriggerAll;\n\t_prototype.eventifySubscriptions = eventifySubscriptions;\n\t_prototype.on = on;\n\t_prototype.off = off;\n};\n\n\n/*\n\tEvent Variable\n\n\tObjects with a single \"change\" event\n*/\n\nexport class EventVariable {\n\n\tconstructor (value) {\n\t\teventifyInstance(this);\n\t\tthis._value = value;\n\t\tthis.eventifyDefine(\"change\", {init:true});\n\t}\n\n\teventifyInitEventArgs(name) {\n\t\tif (name == \"change\") {\n\t\t\treturn [this._value];\n\t\t}\n\t}\n\n\tget value () {return this._value};\n\tset value (value) {\n\t\tif (value != this._value) {\n\t\t\tthis._value = value;\n\t\t\tthis.eventifyTrigger(\"change\", value);\n\t\t}\n\t}\n}\neventifyPrototype(EventVariable.prototype);\n\n/*\n\tEvent Boolean\n\n\n\tNote : implementation uses falsiness of input parameter to constructor and set() operation,\n\tso eventBoolean(-1) will actually set it to true because\n\t(-1) ? true : false -> true !\n*/\n\nexport class EventBoolean extends EventVariable {\n\tconstructor(value) {\n\t\tsuper(Boolean(value));\n\t}\n\n\tset value (value) {\n\t\tsuper.value = Boolean(value);\n\t}\n\tget value () {return super.value};\n}\n\n\n/*\n\tmake a promise which is resolved when EventBoolean changes\n\tvalue.\n*/\nexport function makePromise(eventObject, conditionFunc) {\n\tconditionFunc = conditionFunc || function(val) {return val == true};\n\treturn new Promise (function (resolve, reject) {\n\t\tlet sub = eventObject.on(\"change\", function (value) {\n\t\t\tif (conditionFunc(value)) {\n\t\t\t\tresolve(value);\n\t\t\t\teventObject.off(sub);\n\t\t\t}\n\t\t});\n\t});\n};\n\n// module api\nexport default {\n\teventifyPrototype,\n\teventifyInstance,\n\tEventVariable,\n\tEventBoolean,\n\tmakePromise\n};\n\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n fallback to order from constructor\n noop if no ordering is defined\n */\n sortValues(iter, options={}) {\n let order = this.sortOrder(options);\n if (typeof order == \"function\") {\n // sort\n // if iterable not array - convert into array ahead of sorting\n let arr = (Array.isArray(iter)) ? iter : [...iter];\n return arr.sort(order);\n } else {\n // noop\n return iter;\n }\n }\n\n /* \n Sort items (in-place) by value {new:value, old:value} using\n ordering function for values\n */\n sortItems(items) {\n let order = this.sortOrder(); \n if (typeof order == \"function\") {\n items.sort(function(item_a, item_b) {\n let cue_a = (item_a.new) ? item_a.new : item_a.old;\n let cue_b = (item_b.new) ? item_b.new : item_b.old;\n return order(cue_a, cue_b);\n });\n }\n }\n\n /***************************************************************\n EVENTS\n ***************************************************************/\n\n /*\n Eventify: immediate events\n */\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n let items = [...this.datasource.entries()].map(([key, val]) => {\n return {key:key, new:val, old:undefined};\n });\n // sort init items (if order defined)\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /*\n Event Notification\n */\n _notifyEvents(items) {\n // event notification\n if (items.length == 0) {\n return;\n }\n const has_update_subs = this.eventifySubscriptions(\"batch\").length > 0;\n const has_remove_subs = this.eventifySubscriptions(\"remove\").length > 0;\n const has_change_subs = this.eventifySubscriptions(\"change\").length > 0;\n // update\n if (has_update_subs) {\n this.eventifyTrigger(\"batch\", items);\n }\n // change, remove\n if (has_remove_subs || has_change_subs) {\n for (let item of items) {\n if (item.new == undefined && item.old != undefined) {\n if (has_remove_subs) {\n this.eventifyTrigger(\"remove\", item);\n }\n } else {\n if (has_change_subs) {\n this.eventifyTrigger(\"change\", item);\n }\n }\n }\n }\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get size () {\n return this.datasource.size;\n }\n\n has(key) {\n return this.datasource.has(key);\n };\n\n get(key) {\n return this.datasource.get(key);\n };\n\n keys() {\n return this.datasource.keys();\n };\n\n values() {\n return this.datasource.values();\n };\n\n entries() {\n return this.datasource.entries();\n }\n\n\n /***************************************************************\n MODIFY\n ***************************************************************/\n\n set(key, value) {\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n }\n this.datasource.set(key, value);\n this._notifyEvents([{key: key, new:value, old: old}]);\n return this;\n }\n\n delete(key) {\n let result = false;\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n this.datasource.delete(key);\n result = true;\n }\n this._notifyEvents([{key: key, new:undefined, old: old}]);\n return result;\n }\n\n clear() {\n // create change events for all cues\n const items = [...this.datasource.entries()].map(([key, val]) => {\n return {key: key, new: undefined, old: val};\n })\n // clear _map\n this.datasource.clear();\n // event notification\n this._notifyEvents(items);\n }\n\n}\n\neventify.eventifyPrototype(ObservableMap.prototype);\n\nexport default ObservableMap;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see {\n return this._submit.bind(this)();\n });\n }\n\n _push(cue_args) {\n // append cue args\n let m = this._cues.length;\n let was_empty = m == 0;\n let n = cue_args.length;\n this._cues.length += n;\n for (let i=0; i 0) {\n // batch done immediately \n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n }\n\n _submit() {\n let result = [];\n // carry out update if necessary\n if (this._cues.length > 0) {\n result = this._ds.update(this._cues, this._options); \n }\n // reset cue arg builder\n this._reset();\n // update result\n return result;\n } \n \n /*\n add or change single cue\n \n if both interval and data are undefined\n this is not interpreted as remove,\n but as a cue with no interval and a data value set\n to undefined\n */\n addCue(key, interval, data) {\n let cue_arg = {key:key};\n cue_arg.interval = interval; \n if (arguments.length > 2) {\n cue_arg.data = data;\n }\n cue_arg = cue_check(cue_arg)\n this._push([cue_arg]);\n return this;\n }\n\n /* remove single cue */\n removeCue(key) {\n this._push([{key:key}]);\n return this;\n }\n\n /* load array of cue args into argbuilder */\n update(cue_args) {\n cue_args = cue_args.map((cue_arg) => cue_check(cue_arg));\n this._push(cue_args);\n }\n\n /* clear args currently in argbuilder */\n clear() {\n this._cues = [];\n return this;\n }\n\n /* manually submit cue args from cue arg builder */\n submit() {\n if (this._options.autosubmit) {\n throw new Error(\"manual submit while options.autosubmit is true\");\n }\n // mark batch as done\n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n}\n\n\n/*\n this implements Dataset, a data collection supporting\n efficient lookup of cues tied to intervals on the timeline\n\n - cues may be tied to one or two points on the timeline, this\n is expressed by an Interval.\n - cues are indexed both by key and by intervals\n - the interval index is divided into a set of CueBuckets,\n based on cue interval length, for efficient lookup\n*/\n\nclass Dataset extends CueCollection {\n\n constructor(options) {\n super(options);\n\n this._map = new Map();\n this._builder = new CueArgBuilder(this);\n\n /*\n Initialise set of CueBuckets\n Each CueBucket is responsible for cues of a certain length\n */\n this._cueBuckets = new Map(); // CueBucketId -> CueBucket\n for (let i=0; i -1) {\n this._update_callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._update_callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n /***************************************************************\n MAP METHODS\n */\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n\n /***************************************************************\n CUE ARG BUILDER\n */\n \n makeBuilder(options) {\n return new CueArgBuilder(this, options);\n }\n\n // not really useful (v2 complience)\n get builder () {return this._builder;};\n\n \n /***************************************************************\n ADD CUE, REMOVE CUE\n\n - COMPATIBILTY WITH V2\n - SAFE TO USE repeatedly (batched using promise)\n */\n\n addCue(key, interval, data) {\n if (arguments.length > 2) {\n this._builder.addCue(key, interval, data);\n } else {\n this._builder.addCue(key, interval);\n }\n return this;\n }\n\n removeCue(key) {\n this._builder.removeCue(key);\n return this;\n }\n\n get updateDone() {return this._builder.updateDone};\n\n /***************************************************************\n ADD CUE, REMOVE CUE - INTERACTIVE USE\n\n - CONVENIENCE for interactive use\n - COMPATIBILTY WITH V2\n - NOT RECOMMENDED TO USE repeatedly (batched using promise)\n */\n\n _addCue(key, interval, data, options) {\n let cue = {key:key, interval:interval, data:data};\n cue = cue_check(cue);\n return this.update(cue, options);\n }\n\n _removeCue(key, options) {\n return this.update({key:key}, options);\n }\n\n /***************************************************************\n UPDATE\n\n - insert, replace or delete cues\n\n update(cues, equals, check)\n\n ordered list of cues to be updated\n - equality function for data objects\n\n cue = {\n key:key,\n interval: Interval,\n data: data\n }\n\n required\n - cue.key property is defined and value is != undefined\n - if cue.interval != undefined, it must be instance of Interval\n\n EXAMPLES\n\n // INSERT (no pre-existing cue)\n\n cue = {key:1, interval: new Interval(3,4), data: {}}\n // insert cue with only interval\n cue = {key:1, interval: new Interval(3,4)}\n // insert cue with only data\n cue = {key:1, data: {}}\n\n\n // REPLACE (pre-existing cue)\n preexisting_cue = {key:1, interval: new Interval(3,4), data: {}}\n\n cue = {key:1, interval: new Interval(3,5), data: {foo:\"bar\"}}\n // replace interval, keep data\n cue = {key:1, interval: new Interval(3,5)}\n // replace interval, delete data\n cue = {key:1, interval: new Interval(3,5), data: undefined\n // replace data, keep interval\n cue = {key:1, data: {foo:\"bar\"}}\n // replace data, delete interval\n cue = {key:1, interval: undefined, data: {foo:\"bar\"}}\n\n // DELETE (pre-existing)\n cue = {key:1}\n // delete interval, keep data\n cue = {key:1, interval: undefined}\n // delete data, keep interval\n cue = {key:1, data: undefined}\n\n\n Update returns a list of event items - describes the effects of an update.\n {\n new: new_cue,\n old: old_cue,\n delta: {\n interval: Delta,\n data: Delta\n }\n }\n\n with independent delta values for interval and data:\n Delta.NOOP: 0\n Delta.INSERT: 1\n Delta.REPLACE: 2\n Delta.DELETE: 3\n\n Duplicates\n - if there are multiple cue operations for the same key,\n within the same batch of cues,\n these will be processed in order.\n\n - The old cue will always be the state of the cue,\n before the batch started.\n\n - The returned delta values will be calcultated relative to\n the cue before the batch started (old).\n\n This way, external mirroring observers may will be able to\n replicate the effects of the update operation.\n\n ***************************************************************/\n\n\n\n\n update(cues, options = {}) {\n const batchMap = new Map();\n let current_cue;\n let has_interval, has_data;\n\n // options\n let {debug=false, equals, check_needed=true} = options;\n\n // support single cue arg for convenience\n if (!utils.isIterable(cues)) {\n cues = [cues];\n }\n\n /***********************************************************\n process all cues\n ***********************************************************/\n const epoch_ts = epoch();\n const info = {\n ts: epoch_ts,\n author: options.author\n };\n\n for (let cue of cues) {\n\n /*******************************************************\n check validity of cue argument\n *******************************************************/\n if (check_needed) {\n try {\n cue = cue_check(cue)\n } catch (err) {\n console.log(err, cue)\n continue;\n }\n }\n has_interval = cue.hasOwnProperty(\"interval\");\n has_data = cue.hasOwnProperty(\"data\");\n\n /*******************************************************\n adjust cue so that it correctly represents\n the new cue to replace the current cue\n - includes preservation of values from current cue\n *******************************************************/\n\n current_cue = this._map.get(cue.key);\n if (current_cue == undefined) {\n // make sure properties are defined\n if (!has_interval) {\n cue.interval = undefined;\n }\n if (!has_data) {\n cue.data = undefined;\n }\n } else if (current_cue != undefined) {\n if (!has_interval && !has_data) {\n // make sure properties are defined\n cue.interval = undefined;\n cue.data = undefined;\n } else if (!has_data) {\n // REPLACE_INTERVAL, preserve data\n cue.data = current_cue.data;\n } else if (!has_interval) {\n // REPLACE_DATA, preserve interval\n cue.interval = current_cue.interval;\n } else {\n // REPLACE CUE\n }\n }\n\n /*******************************************************\n update cue\n - update _map\n - update cueBuckets\n - create batchMap\n *******************************************************/\n this._update_cue(batchMap, current_cue, cue, info, options);\n }\n\n // flush all buckets so updates take effect\n this._call_buckets(\"flush\");\n\n if (batchMap.size > 0) {\n\n /*\n create events without delta property\n and accumulate relevance interval for batch\n */\n let relevance = {low: Infinity, high: -Infinity};\n\n // create list of events and remove delta property\n let items = [...batchMap.values()].map(item => {\n if (item.new && item.new.interval) {\n relevance.low = endpoint.min(relevance.low, item.new.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.new.interval.endpointHigh);\n }\n if (item.old && item.old.interval) {\n relevance.low = endpoint.min(relevance.low, item.old.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.old.interval.endpointHigh);\n }\n return {key:item.key, new:item.new, old:item.old, info: item.info};\n });\n\n // extra filter items to remove NOOP transitions\n let event_items = items.filter((item) => {\n let delta = cue_delta(item.new, item.old, equals);\n return (delta.interval != Delta.NOOP || delta.data != Delta.NOOP);\n });\n\n // event notification\n this._notifyEvents(event_items);\n\n // create relevance Interval\n let relevanceInterval = undefined;\n if (relevance.low != Infinity) {\n relevanceInterval = Interval.fromEndpoints(relevance.low, relevance.high);\n }\n\n /*\n notify sequencer last so that change event\n from the dataset will be applied before change\n events from sequencers.\n */\n this._notify_callbacks(batchMap, relevanceInterval);\n \n // debug\n if (debug) {this.integrity();}\n return items;\n }\n // debug\n if (debug) {this.integrity();}\n return [];\n };\n\n\n\n /***************************************************************\n UPDATE CUE\n\n update operation for a single cue\n\n - update _map\n - generate entry for batchMap\n - update CueBucket\n ***************************************************************/\n\n _update_cue(batchMap, current_cue, cue, info, options) {\n\n let old_cue, new_cue;\n let item, _item;\n let oldCueBucket, newCueBucket;\n let low_changed, high_changed;\n let remove_needed, add_needed;\n\n // options\n let {chaining=true, safe=false, equals} = options;\n \n if (current_cue === cue) {\n throw Error(\"illegal cue arg: same object as current cue\");\n }\n\n // check for equality\n let delta = cue_delta(current_cue, cue, equals);\n\n // (NOOP, NOOP)\n if (delta.interval == Delta.NOOP && delta.data == Delta.NOOP) {\n item = {\n key:cue.key, new:current_cue,\n old:current_cue, delta: delta\n }\n batchMap.set(cue.key, item);\n return;\n }\n\n\n /***********************************************************\n update _map and batchMap\n ***********************************************************/\n\n if (current_cue == undefined) {\n // INSERT - add cue object to _map\n\n // cue info: add if missing\n if (cue.info == undefined) {\n cue.info = {\n ts: info.ts,\n change_ts: info.ts,\n change_id: 0\n }\n }\n\n old_cue = undefined;\n new_cue = (safe)? Object.freeze(cue) : cue;\n this._map.set(cue.key, new_cue);\n\n\n } else if (cue.interval == undefined && cue.data == undefined) {\n // DELETE - remove cue object from _map\n old_cue = current_cue;\n new_cue = undefined;\n this._map.delete(cue.key);\n\n // cue info: noop\n\n } else {\n // REPLACE\n\n // cue info - update if missing\n // preserve ts from current cue, update update_ts\n if (cue.info == undefined) {\n cue.info = {\n ts: current_cue.info.ts,\n change_ts: info.ts,\n change_id: current_cue.info.change_id + 1\n };\n }\n\n /*\n Solution used to be in-place modification\n of current cue.\n Now we instead implement replace by inserting\n a new cue object as current cue.\n Since current cue is referenced both in\n _map and in pointMap - it must be replaced both\n places.\n\n Adjustments to pointMap as a result of interval\n changes are handled further down\n\n Another design option would be to let point map\n manage only keys of cues. This however would \n impose an extra map lookup per item in lookup - \n so better to pay this modest price in update\n */\n old_cue = current_cue;\n new_cue = {\n key: cue.key,\n interval: cue.interval,\n data: cue.data,\n info: cue.info\n }\n\n if (safe) {\n new_cue = Object.freeze(new_cue);\n }\n\n // replace in cue map\n this._map.set(cue.key, new_cue);\n\n // replace in point map\n // - only necessary if old cue is in pointMap\n // i.e. if old_cue has interval\n if (old_cue.interval) {\n let bid = getCueBucketId(old_cue.interval.length);\n let cueBucket = this._cueBuckets.get(bid);\n // replace for low\n cueBucket.replace_endpoint(old_cue.interval.low, new_cue);\n // replace for high\n if (!old_cue.singular) {\n cueBucket.replace_endpoint(old_cue.interval.high, new_cue);\n }\n }\n }\n item = {key:cue.key, new:new_cue, old:old_cue, delta:delta, info};\n\n /*\n if this item has been set earlier in batchMap\n restore the correct old_cue by getting it from\n the previous batchMap item\n\n recalculate delta relative to old_cue\n - continue processing with the original (delta, old_cue) defined\n above, as this is required to correctly change cueBuckets\n which have already been affected by previous item.\n */\n if (chaining) {\n _item = batchMap.get(cue.key);\n if (_item != undefined) {\n item.old = _item.old;\n item.delta = cue_delta(new_cue, item.old, equals);\n }\n }\n\n batchMap.set(cue.key, item)\n\n //console.log(\"OLD:\", cue_to_string(old_cue));\n //console.log(\"NEW:\", cue_to_string(new_cue));\n\n /***********************************************************\n update cueBuckets\n\n - use delta.interval to avoid unnessesary changes\n\n - interval may change in several ways:\n - low changed\n - high changed\n - low and high changed\n - changed intervals may stay in bucket or change bucket:\n - changing to/from singular may require special consideration\n with respect to how many endpoints are being updated\n - singular -> singular\n - singular -> regular\n - regular -> singular\n - regular -> regular\n - changes to interval.lowInclude and interval highInclude\n do not require any changes to CueBuckets, as long\n as interval.low and interval.high values stay unchanged.\n ***********************************************************/\n\n if (delta.interval == Delta.NOOP) {\n // no changes to interval - no change needed in pointMap \n return;\n } else if (delta.interval == Delta.INSERT) {\n remove_needed = false;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.DELETE) {\n remove_needed = true;\n add_needed = false;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.REPLACE) {\n remove_needed = true;\n add_needed = true;\n low_changed = new_cue.interval.low != old_cue.interval.low;\n high_changed = new_cue.interval.high != old_cue.interval.high;\n }\n\n /*\n old cue and new cue might not belong to the same cue bucket\n */\n if (remove_needed){\n let old_bid = getCueBucketId(old_cue.interval.length);\n oldCueBucket = this._cueBuckets.get(old_bid);\n }\n if (add_needed) {\n let new_bid = getCueBucketId(new_cue.interval.length);\n newCueBucket = this._cueBuckets.get(new_bid);\n }\n\n /*\n if old CueBucket is different from the new cue Buckets\n both low and high must be moved, even it one was not\n changed\n */\n if (oldCueBucket && newCueBucket) {\n if (oldCueBucket != newCueBucket) {\n remove_needed = true;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n }\n }\n\n /*\n dispatch add and remove operations for interval points\n\n cues in CueBucket may be removed using a copy of the cue,\n because remove is by key.\n\n cues added to CueBucket must be the correct object\n (current_cue), so that later in-place modifications become\n reflected in CueBucket.\n */\n\n // update low point - if changed\n if (low_changed) {\n if (remove_needed) {\n oldCueBucket.del_endpoint(old_cue.interval.low, old_cue);\n }\n if (add_needed) {\n newCueBucket.add_endpoint(new_cue.interval.low, new_cue);\n }\n }\n // update high point - if changed\n if (high_changed) {\n if (remove_needed && !old_cue.interval.singular) {\n oldCueBucket.del_endpoint(old_cue.interval.high, old_cue);\n }\n if (add_needed && !new_cue.interval.singular) {\n newCueBucket.add_endpoint(new_cue.interval.high, new_cue);\n }\n }\n }\n\n\n /*\n INTERNAL FUNCTION\n execute method across all cue buckets\n and aggregate results\n */\n _call_buckets(method, ...args) {\n const arrays = [];\n for (let cueBucket of this._cueBuckets.values()) {\n let cues = cueBucket[method](...args);\n if (cues != undefined && cues.length > 0) {\n arrays.push(cues);\n }\n }\n return utils.array_concat(arrays);\n };\n\n\n /*\n LOOKUP ENDPOINTS\n\n returns (endpoint, cue) for all endpoints covered by given interval\n\n returns:\n - [{endpoint: endpoint, cue:cue}]\n */\n\n lookup_endpoints(interval) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup_endpoints\", interval);\n };\n\n\n /*\n LOOKUP\n */\n\n lookup(interval, mask) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup\", interval, mask);\n };\n\n\n /*\n REMOVE CUES BY INTERVAL\n */\n lookup_delete(interval, mask, options={}) {\n interval = asInterval(interval);\n const cues = this._call_buckets(\"lookup_delete\", interval, mask);\n // remove from _map and make event items\n const items = [];\n const info = {\n ts: epoch(),\n author: options.author\n };\n let cue;\n for (let i=0; i cue.interval == undefined);\n\n let count_buckets = cues.length;\n let count_no_interval = no_interval_cues.length;\n let count_map = this._map.size;\n let diff = count_map - count_buckets - count_no_interval;\n if (diff != 0) {\n console.log(\"count buckets\", count_buckets);\n console.log(\"count no intervals\", count_no_interval);\n console.log(\"count map\", count_map);\n console.log(\"count diff\", diff);\n throw new Error(\"inconsistent cue count\");\n }\n\n // check that cue maps are non overlapping\n let bucket_map = new Map(cues.map(cue => [cue.key, cue]));\n let map_map = new Map([...this._map.entries()].filter(([key, cue]) => {\n return (cue.interval != undefined);\n }));\n\n let missing = utils.map_difference(bucket_map, map_map);\n if (missing.size > 0) {\n console.log(\"buckets missing cues:\")\n console.log([...missing.keys()])\n throw new Error(`buckets missing cues: ${[...missing.keys()]}`);\n }\n \n missing = utils.map_difference(map_map, bucket_map);\n if (missing.size > 0) {\n throw new Error(`buckets too many cues: ${[...missing.keys()]}`);\n }\n\n return {\n cues: cues.length,\n points: points.length\n };\n };\n\n}\n\n\nDataset.Delta = Delta;\nDataset.cue_delta = cue_delta;\nDataset.cue_equals = cue_equals;\n\n\n/*\n CueBucket is a bucket of cues limited to specific length\n*/\n\n\nclass CueBucket {\n\n\n constructor(maxLength) {\n\n // max length of cues in this bucket\n this._maxLength = maxLength;\n\n /*\n pointMap maintains the associations between values (points on\n the timeline) and cues that reference such points. A single point value may be\n referenced by multiple cues, so one point value maps to a list of cues.\n\n value -> [cue, ....]\n */\n this._pointMap = new Map();\n\n\n /*\n pointIndex maintains a sorted list of numbers for efficient lookup.\n A large volume of insert and remove operations may be problematic\n with respect to performance, so the implementation seeks to\n do a single bulk update on this structure, for each batch of cue\n operations (i.e. each invocations of addCues). In order to do this\n all cue operations are processed to calculate a single batch\n of deletes and a single batch of inserts which then will be applied to\n the pointIndex in one atomic operation.\n\n [1.2, 3, 4, 8.1, ....]\n */\n this._pointIndex = new BinarySearch();\n\n // bookeeping during batch processing\n this._created = new Set(); // point\n this._dirty = new Set(); // point\n\n };\n\n\n /*\n\n ENDPOINT BATCH PROCESSING\n\n Needs to translate endpoint operations into a minimum set of\n operations on the pointIndex.\n\n To do this, we need to record points that are created and\n points that are removed.\n\n The total difference that the batch of cue operations\n amounts to is expressed as one list of values to be\n deleted, and and one list of values to be inserted.\n The update operation of the pointIndex will process both\n in one atomic operation.\n\n On flush both the pointMap and the pointIndex will be brought\n up to speed\n\n created and dirty are used for bookeeping during\n processing of a cue batch. They are needed to\n create the correct diff operation to be applied on pointIndex.\n\n created : includes values that were not in pointMap\n before current batch was processed\n\n dirty : includes values that were in pointMap\n before current batch was processed, and that\n have been become empty at least at one point during cue\n processing.\n\n created and dirty are used as temporary alternatives to pointMap.\n after the cue processing, pointmap will updated based on the\n contents of these two.\n\n process buffers operations for pointMap and index so that\n all operations may be applied in one batch. This happens in flush\n */\n\n add_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues == undefined) {\n this._pointMap.set(point, [cue]);\n this._created.add(point);\n } else {\n cues.push(cue);\n //addCueToArray(cues, cue);\n }\n }\n\n del_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let empty = removeCueFromArray(cues, cue);\n if (empty) {\n this._dirty.add(point);\n }\n }\n };\n\n /* \n in case of data update without touching the interval\n the new cue needs to be insert in place of the old\n */\n replace_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let ok = replaceCueInArray (cues, cue);\n if (!ok) {\n console.log(\"WARNING: attempt to replace non-existent cue in pointMap\")\n }\n }\n }\n\n\n /*\n Batch processing is completed\n Commit changes to pointIndex and pointMap.\n\n pointMap\n - update with contents of created\n\n pointIndex\n - points to delete - dirty and empty\n - points to insert - created and non-empty\n\n it is possible that a cue ends up in both created and dirty\n\n */\n flush() {\n if (this._created.size == 0 && this._dirty.size == 0) {\n return;\n }\n\n // update pointIndex\n let to_remove = [];\n let to_insert = [];\n for (let point of this._created.values()) {\n let cues = this._pointMap.get(point);\n if (cues.length > 0) {\n to_insert.push(point);\n } else {\n this._pointMap.delete(point);\n }\n }\n for (let point of this._dirty.values()) {\n let cues = this._pointMap.get(point);\n if (cues == undefined) {\n // point already deleted from created set - ignore\n continue;\n }\n if (cues.length == 0) {\n to_remove.push(point);\n this._pointMap.delete(point);\n }\n }\n this._pointIndex.update(to_remove, to_insert);\n // cleanup\n this._created.clear();\n this._dirty.clear();\n };\n\n\n /*\n LOOKUP_ENDPOINTS\n\n returns all (endpoint, cue) pairs where\n - endpoint is a cue endpoint (cue.endpointLow or cue.endpointHigh)\n - endpoint is INSIDE search interval\n - [{endpoint:endpoint, cue: cue}]\n\n - a given endpoint may appear multiple times in the result,\n as multiple cues may be tied to the same endpoint\n - a given cue may appear two times in the result, if\n both cue.endpointLow and cue.endpointHigh are both INSIDE interval\n - a singular cue will appear only once\n - ordering: no specific order is guaranteed\n - results are concatenated from multiple CueBuckets\n - internally in a single CueBucket\n - no defined order for cues tied to the same endpoint\n - the natural order is endpoint order\n - but this can be added on the outside if needed\n - no order is defined if two cues have exactly the\n same endpoint\n\n */\n\n lookup_endpoints(interval) {\n if (this._pointMap.size == 0) {\n return [];\n }\n const broader_interval = new Interval(interval.low, interval.high, true, true);\n const points = this._pointIndex.lookup(broader_interval);\n const result = [];\n const len = points.length;\n let point, _endpoint;\n for (let i=0; i this._maxLength) {\n return cues;\n }\n\n /*\n handle match with COVERS separately\n\n search left of search interval for cues\n that covers the search interval\n search left is limited by CueBucket maxlength\n left_interval: [interval.high-maxLength, interval.low]\n\n it would be possible to search right too, but we\n have to choose one.\n */\n if (mask & Relation.COVERS) {\n\n let left_interval;\n if (this._maxLength == Infinity) {\n // no limitation on interval length\n // must search entire timeline to the left\n left_interval = new Interval(-Infinity, interval.low);\n } else {\n let low = interval.high - this._maxLength;\n let high = interval.low;\n // protect against float rounding effects creating\n // high < low by a very small margin\n [low, high] = [Math.min(low, high), Math.max(low, high)];\n left_interval = new Interval(low, high, true, true);\n }\n this._lookup_cues(left_interval)\n .forEach(function(cue){\n if (cue.interval.match(interval, Relation.COVERS)) {\n cues.push(cue);\n }\n });\n }\n\n return cues;\n }\n\n\n /*\n REMOVE CUES\n */\n lookup_delete(interval, mask) {\n /*\n update pointMap\n - remove all cues from pointMap\n - remove empty entries in pointMap\n - record points that became empty, as these need to be deleted in pointIndex\n - separate into two bucketes, inside and outside\n */\n const cues = this.lookup(interval, mask);\n const to_remove = [];\n let cue, point, points;\n for (let i=0; i 0) {\n throw new Error(`pointMap missing points: ${[...missing]}`);\n }\n \n missing = utils.set_difference(map_point_set, index_point_set);\n if (missing.size > 0) {\n throw new Error(`pointIndex missing points: ${[...missing]}`);\n }\n }\n\n /*\n invariable - pointIndex shall always be sorted and not contain duplicates\n */\n let points = [...this._pointIndex.values()];\n if (points.length != index_point_set.size) {\n throw new Error(\"pointIndex include duplicate points\");\n }\n for (let i=1; i= points[i]) {\n throw new Error(\"pointIndex not ordered\");\n } \n }\n\n /**\n * invariable - pointMap point -> cues \n * cues shall only include cues which are relevant to given point\n */\n for (let point of points) {\n let cues = this._pointMap.get(point);\n for (let cue of cues) {\n // figure out if point is endpoint low or high\n if (point == cue.interval.low) {\n continue;\n } else if (point == cue.interval.high) {\n continue;\n } else {\n console.log(\"POINT:\", point); \n console.log(\"CUE:\", cue.interval.toString());\n throw new Error(\"pointMap: wrong cue\");\n }\n } \n }\n\n\n /**\n * invariable - all endpoints from all cues from pointMap are found as points in pointMap\n */\n\n for (let _cue_list of [...this._pointMap.values()]) {\n for (let cue of _cue_list) {\n for (let p of [cue.interval.low, cue.interval.high]) {\n if (!this._pointMap.has(p)) {\n throw new Error(`cue found with low or high point not in pointMap ${p} -> ${cue.interval.toString()} `);\n }\n }\n }\n }\n\n\n /*\n invariable - all cues in pointMap with same key are same object\n */\n\n // collect all cues from pointMap\n let _cues = [];\n for (let _cue_list of this._pointMap.values()) {\n for (let cue of _cue_list) {\n _cues.push(cue);\n }\n }\n\n // remove and check duplicates\n let cueMap = new Map();\n for (let cue of _cues) {\n let _cue = cueMap.get(cue.key);\n if (_cue == undefined) {\n cueMap.set(cue.key, cue);\n } else {\n // duplicate\n if (cue !== _cue) {\n throw new Error(\"pointMap: different cue objects for same key\");\n }\n }\n }\n let cues = [...cueMap.values()];\n\n /**\n * invariable - all cues belong to this bucket\n */\n\n for (let cue of cues.values()) {\n // check that cue belongs to this bucket\n if (cue.interval.length > this._maxLength) {\n throw new Error(`cue in wrong cue bucket ${this._maxLength}, ${cue.interval.toString()}`);\n }\n }\n\n return [{\n maxLength: this._maxLength,\n points: [...this._pointMap.keys()],\n cues: cues\n }];\n };\n}\n\n// module definition\nexport default Dataset;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n - : if defined only include cues that match the interval\n - : filter by cue key\n function keep(key) returns boolena\n - : filter by cue data\n function keep(data) returns boolean\n - : change cue data\n function convert(data) returns data\n NOTE: filtering occurs BEFORE convert\n and only impacts the presentation of cues\n WARNING: it is possible to change the value\n in such a way that filtering appears incorrect\n\n This subset implementation is STATELESS\n It does not manage its own state, only implements a\n stateless frontend over its source dataset.\n\n*/\n\nclass Subset extends CueCollection {\n\n constructor(dataset, options={}) {\n super(options);\n this._key_filter = options.key_filter;\n this._data_filter = options.data_filter;\n this._interval = options.interval;\n this._data_convert = options.data_convert;\n this._size = 0;\n\n // Callbacks\n this._callbacks = [];\n\n // Source Dataset\n this._src_ds = dataset;\n let cb = this._onDatasetCallback.bind(this)\n this._src_ds_cb = this._src_ds.add_callback(cb);\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get datasource () {\n return this._src_ds;\n }\n\n get dataset () {\n return this._src_ds;\n }\n\n\n get interval () {\n return this._interval;\n }\n\n set interval (itv) {\n this._setInterval(itv);\n }\n\n\n /***************************************************************\n EVENT CALLBACKS - FOR SEQUENCERS\n ***************************************************************/\n\n add_callback (handler) {\n let handle = {\n handler: handler\n }\n this._callbacks.push(handle);\n return handle;\n };\n\n\n del_callback (handle) {\n let index = this._callbacks.indexof(handle);\n if (index > -1) {\n this._callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n\n /***************************************************************\n FILTER & CONVER\n ***************************************************************/\n\n /* \n Keep cue \n */\n\n _cue_keep(cue) {\n if (cue == undefined) {\n return false;\n }\n // check if cue matches interval\n if (this._interval) {\n if (!this._interval.match(cue.interval)) {\n return false;\n }\n }\n // check key filter\n if (this._key_filter) {\n if (!this._key_filter(cue.key)) {\n return false;\n }\n }\n // check data filter\n if (this._data_filter) {\n if (!this._data_filter(cue.data)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Convert cue\n */\n _cue_convert(cue) {\n if (cue != undefined && this._data_convert) {\n // copy\n return {\n key: cue.key,\n interval: cue.interval,\n data: this._data_convert(cue.data)\n }\n }\n return cue;\n }\n\n /**\n * Filter (and modify) event items based on key_filter and data_filter\n */\n\n _items_filter_convert(items) {\n let _items = [];\n for (let item of items) {\n if (item.new == undefined && item.old == undefined) {\n continue;\n }\n /* \n use cue filter function to check relevance of both old and new\n consider change of unrelevant cue into relevant cue.\n old cue would be non-relevant, new cue would be relevant\n Since old cue was not part of the subset before, it needs\n to be removed from the item - effectively turning the change\n operation into an add operation. \n */\n let _old = (this._cue_keep(item.old)) ? item.old : undefined;\n let _new = (this._cue_keep(item.new)) ? item.new : undefined;\n if (_old == undefined && _new == undefined) {\n continue;\n }\n // convert\n _old = this._cue_convert(_old);\n _new = this._cue_convert(_new);\n // push\n _items.push({key:item.key, new: _new, old: _old});\n }\n return _items;\n }\n\n\n /***************************************************************\n LOOKUP\n ***************************************************************/\n\n _check_interval(interval) {\n if (this._interval) {\n // subset interval\n if (interval) {\n // lookup interval - find intersection\n let intersects = Interval.intersect(interval, this._interval);\n if (intersects.length == 0) {\n console.log(`warning - lookup interval ${interval.toString()} outside the subset interval ${this._interval.toString()}`);\n return [];\n } else {\n interval = intersects[0];\n }\n } else {\n // no lookup interval - use subset interval \n interval = this._interval;\n }\n }\n return interval;\n }\n\n /** \n * lookup cues\n */\n\n lookup(interval, mask) {\n let _interval = this._check_interval(interval);\n let cues;\n if (_interval) {\n cues = this.datasource.lookup(_interval, mask);\n } else {\n cues = [...this.datasource.values()];\n }\n // filter & convert cues\n return cues.filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n }\n\n /* \n lookup endpoints\n used by sequencers\n */\n\n lookup_endpoints(interval) {\n let _interval = this._check_interval(interval);\n let items = this.datasource.lookup_endpoints(_interval);\n // filter and convert\n return items.filter((item) => {\n return this._cue_keep(item.cue);\n }, this).map((item) => {\n return {endpoint: item.endpoint, cue: this._cue_convert(item.cue)};\n }, this);\n }\n\n /***************************************************************\n INITIAL STATE\n ***************************************************************/\n\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n // find cues\n let cues = this.lookup();\n // make event items\n let items = cues.map((cue) => {\n return {key:cue.key, new:cue, old:undefined};\n });\n // sort\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /***************************************************************\n DATASET CALLBACK\n ***************************************************************/\n\n _onDatasetCallback(eventMap, relevanceInterval) {\n let items = [...eventMap.values()];\n items = this._items_filter_convert(items);\n // update size\n for (let item of items) {\n if (item.new != undefined && item.old == undefined) {\n // add\n this._size += 1;\n } else if (item.new == undefined && item.old != undefined) {\n // remove\n this._size -= 1;\n } \n } \n // forward as events\n super._notifyEvents(items);\n // forward as callbacks\n let batchMap = new Map(items.map((item) => {\n return [item.key, item];\n }));\n if (this._interval) {\n relevanceInterval = Interval.intersect(this._inverval, relevanceInterval);\n }\n this._notify_callbacks(batchMap, relevanceInterval);\n }\n\n\n /***************************************************************\n SET INTERVAL\n ***************************************************************/\n\n _setInterval (itv) {\n if (!itv instanceof Interval) {\n throw new Error(\"must be interval\", itv.toString());\n }\n if (!this._interval || !this._interval.equals(itv)) {\n // current cues (before interval update)\n let current_cues = this.lookup();\n // update interval\n this._interval = itv;\n // cues (after interval update)\n let new_cues = this.datasource.lookup(itv);\n // filter & convert cues\n new_cues = new_cues\n .filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n // switch to map representation\n let currentCueMap = new Map([...current_cues].map((cue) => {\n return [cue.key, cue];\n }));\n let newCueMap = new Map([...new_cues].map((cue) => {\n return [cue.key, cue];\n }));\n // exit and enter cues\n let exitCueMap = map_difference(currentCueMap, newCueMap);\n let enterCueMap = map_difference(newCueMap, currentCueMap);\n // make list of event items\n let exitItems = [...exitCueMap.values()].map((cue) => {\n return {key: cue.key, new:undefined, old: cue}\n });\n let enterItems = [...enterCueMap.values()].map((cue) => {\n return {key: cue.key, new:cue, old: undefined}\n });\n // update size\n this._size -= exitItems.length;\n this._size += enterItems.length; \n // event notification\n const items = array_concat([exitItems, enterItems], {copy:false, order:true});\n this._notifyEvents(items);\n }\n }\n\n /***************************************************************\n MAP ACCESSORS\n ***************************************************************/\n\n get size () {\n return this._size;\n }\n\n has(key) {\n return (this.get(key) != undefined);\n };\n\n get(key) {\n let cue = super.get(key);\n if (cue != undefined && this._cue_keep(cue)) {\n return this._cue_convert(cue);\n }\n };\n\n keys() {\n return this.values().map((cue => {\n return cue.key;\n }));\n };\n\n values() {\n return [...super.values()]\n .filter((cue) => {\n return this._cue_keep(cue);\n }, this)\n .map((cue) => {\n return this._cue_convert(cue);\n }, this);\n };\n\n entries() {\n return this.values().map((cue) => {\n return [cue.key, cue];\n });\n };\n\n\n /***************************************************************\n MAP MODIFICATION METHODS\n ***************************************************************/\n\n update(cues, options) {\n throw new Error(\"not implemented\");\n }\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n clear (key) {\n throw new Error(\"not implemented\");\n }\n\n}\n\n// module definition\nexport default Subset;","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see !e.has(t)))}const r=function(t,e){return 0==t.size?new Map:0==e.size?t:new Map([...t].filter((function([t,i]){return!e.has(t)})))},o=function(t,e){return[t,e]=t.size<=e.size?[t,e]:[e,t],0==t.size?new Map:new Map([...t].filter((function([t,i]){return e.has(t)})))};function l(t){return null!=t&&"function"==typeof t[Symbol.iterator]}function a(t,e={}){let{copy:i=!1,order:n=!1}=e;if(0==t.length)return[];if(1==t.length)return t[0];let s=t.reduce((t,e)=>t+e.length,0);n||t.sort((t,e)=>e.length-t.length);let r,o,l=i?[]:t.shift(),a=l.length;l.length=s;for(let e of t){o=e.length,r=a+o;for(let t=0;tt instanceof Map).every(t=>1==t))throw new Error("some object in array_of_maps is not a Map",t);n||t.sort((t,e)=>e.size-t.size);let s=i?new Map:t.shift();for(let e of t)for(let[t,i]of e.entries())s.set(t,i);return s},divmod:function(t,e){let i=t%e;return[(t-i)/e,i]},isIterable:l,array_concat:a,object_equals:h,docready:c});const _=function(t){let e=parseFloat(t);return t===e&&!isNaN(e)};function d(t,e,i,n){if(t==1/0&&(0==e||0==i))throw new Error("Infinity endpoint must be right-closed or singular");if(t==-1/0&&(1==e||0==i))throw new Error("-Infinity endpoint must be left-closed or singular");return[t,e,i,n]}function p(t){let[e,i,n,s]=t;return s||null==i?2:i?n?3:0:n?1:4}function f(t,e){if(void 0===t.length){if(!_(t))throw new Error("e1 not a number",t);t=d(t,void 0,void 0,!0)}if(void 0===e.length){if(!_(e))throw new Error("e2 not a number",e);e=d(e,void 0,void 0,!0)}return t[0]!=e[0]?[t[0],e[0]]:[p(t),p(e)]}function v(t,e){let[i,n]=f(t,e),s=i-n;return 0==s?0:s>0?1:-1}var g={cmp:v,toString:function(t){if(void 0===t.length)return t.toString();{let e=p(t),i=t[0];if(i!=1/0&&i!=-1/0||(i="--"),0==e)return i+")";if(1==e)return"["+i;if(2==e)return`[${i}]`;if(3==e)return i+"]";if(4==e)return"("+i}},equals:function(t,e){let[i,n]=f(t,e);return i==n},rightof:function(t,e){let[i,n]=f(t,e);return i>n},leftof:function(t,e){let[i,n]=f(t,e);return ie)throw new y(`low > high, ${t}, ${e}`);if(t===e&&(i=!0,n=!0),t===-1/0&&(i=!0),e===1/0&&(n=!0),void 0===i&&(i=!0),void 0===n&&(n=!1),"boolean"!=typeof i)throw new y("lowInclude not boolean, "+i);if("boolean"!=typeof n)throw new y("highInclude not boolean, "+n);this._low=t,this._high=e,this._lowInclude=i,this._highInclude=n,this._length=this._high-this._low,this._singular=this._low===this._high,this._finite=isFinite(this._low)&&isFinite(this._high),this._endpointLow=g.create(this._low,!1,this._lowInclude,this._singular),this._endpointHigh=g.create(this._high,!0,this._highInclude,this._singular)}get low(){return this._low}get high(){return this._high}get lowInclude(){return this._lowInclude}get highInclude(){return this._highInclude}get length(){return this._length}get singular(){return this._singular}get finite(){return this._finite}get endpointLow(){return this._endpointLow}get endpointHigh(){return this._endpointHigh}toString(){if(this._singular){return`[${this._endpointLow[0]}]`}return`${g.toString(this._endpointLow)},${g.toString(this._endpointHigh)}`}asArray(){return[this._low,this._high,this._lowInclude,this._highInclude]}covers_endpoint(t){let e=g.leftof(t,this._endpointLow),i=g.rightof(t,this._endpointHigh);return!e&&!i}compare(t){return S(this,t)}equals(t){return S(this,t)==w.EQUALS}match(t,e=I){let i=S(this,t);return Boolean(e&i)}}A.Relation=w,A.Match=T,A.cmpLow=M(!0),A.cmpHigh=M(!1),A.fromEndpoints=function(t,e){let[i,n,s,r]=t,[o,l,a,h]=e;if(n)throw new y("illegal endpointLow - bracket must be left");if(!l)throw new y("illegal endpointHigh - bracket must be right");return new A(i,o,s,a)},A.intersect=function(t,e){let i=S(t,e);return i==w.OUTSIDE_LEFT?[]:i==w.OVERLAP_LEFT?[A.fromEndpoints(e.endpointLow,t.endpointHigh)]:i==w.COVERS?[e]:i==w.EQUALS||i==w.COVERED?[t]:i==w.OVERLAP_RIGHT?[A.fromEndpoints(t.endpointLow,e.endpointHigh)]:i==w.OUTSIDE_RIGHT?[]:void 0},A.union=function(t,e){let i=S(t,e);return i==w.OUTSIDE_LEFT?t.high!=e.low||!t.highInclude&&!e.lowInclude?[t,e]:[A.fromEndpoints(t.endpointLow,e.endpointHigh)]:i==w.OVERLAP_LEFT?[A.fromEndpoints(t.endpointLow,e.endpointHigh)]:i==w.COVERS||i==w.EQUALS?[t]:i==w.COVERED?[e]:i==w.OVERLAP_RIGHT?[A.fromEndpoints(e.endpointLow,t.endpointHigh)]:i==w.OUTSIDE_RIGHT?e.high!=t.low||!e.highInclude&&!t.lowInclude?[e,t]:[A.fromEndpoints(e.endpointLow,t.endpointHigh)]:void 0},A.intersectAll=function(t){if(t.sort(A.cmpLow),t.length<=1)return t;const e=[t.shift()];for(;t.length>0;){let i=e.pop(),n=t.shift();e.push(...A.intersect(i,n))}return e},A.unionAll=function(t){if(t.sort(A.cmpLow),t.length<=1)return t;const e=[t.shift()];for(;t.length>0;){let i=e.pop(),n=t.shift();e.push(...A.union(i,n))}return e},function(){function t(t,e,i){return void 0===i||0==+i?Math[t](e):(e=+e,i=+i,isNaN(e)||"number"!=typeof i||i%1!=0?NaN:(e=e.toString().split("e"),+((e=(e=Math[t](+(e[0]+"e"+(e[1]?+e[1]-i:-i)))).toString().split("e"))[0]+"e"+(e[1]?+e[1]+i:i))))}Math.round10||(Math.round10=function(e,i){return t("round",e,i)}),Math.floor10||(Math.floor10=function(e,i){return t("floor",e,i)}),Math.ceil10||(Math.ceil10=function(e,i){return t("ceil",e,i)})}();const R=function(t,e){return t-e};function L(t,e){let i=t.position==e.position,n=t.velocity==e.velocity,s=t.acceleration==e.acceleration,r=t.timestamp==e.timestamp;return i&&n&&s&&r}function D(t,e){if(void 0===e)throw new Error("no ts provided for calculateVector");const i=e-t.timestamp;return{position:t.position+t.velocity*i+.5*t.acceleration*i*i,velocity:t.velocity+t.acceleration*i,acceleration:t.acceleration,timestamp:e}}function N(t,e){let i;i=null==e?t:D(t,e);let n=R(i.velocity,0);return 0===n&&(n=R(t.acceleration,0)),n}function x(t){return 0!==t.velocity||0!==t.acceleration}const C=Object.freeze({INIT:"init",INSIDE:"inside",OUTSIDE_LOW:"outsidelow",OUTSIDE_HIGH:"outsidehigh"});function P(t,e){const{position:i,velocity:n,acceleration:s}=t;if(i>e[1])return C.OUTSIDE_HIGH;if(i0)return C.OUTSIDE_HIGH;if(0===n&&s>0)return C.OUTSIDE_HIGH}else if(i===e[0]){if(n<0)return C.OUTSIDE_LOW;if(0==n&&s<0)return C.OUTSIDE_HIGH}return C.INSIDE}function H(t,e){return P(t,e)!=C.INSIDE}function V(t,e){const i=P(t,e);return i!==C.INSIDE&&(t.velocity=0,t.acceleration=0,i===C.OUTSIDE_HIGH?t.position=e[1]:t.position=e[0]),t}function z(t,e){let i=t.timestamp,n=q(t,e[0]),s=q(t,e[1]);return void 0!==n&&void 0!==s?n=0}function B(t,e,i,n){if(0===i&&0===e)return t!=n?[]:[0];if(0===i)return[(n-t)/e];if(!1===U(t,e,i,n))return[];if(0===e*e-2*i*(t-n))return[-e/i];const s=Math.sqrt(Math.pow(e,2)-2*i*(t-n)),r=(-e+s)/i,o=(-e-s)/i;return[Math.min(r,o),Math.max(r,o)]}function q(t,e){const{position:i,velocity:n,acceleration:s}=t,r=function(t,e,i,n){const s=B(t,e,i,n);return 0===s.length?[]:1==s.length?s[0]>0?[s[0]]:[]:2==s.length?s[1]<0?[]:s[0]>0?[s[0],s[1]]:s[1]>0?[s[1]]:[]:[]}(i,n,s,e);return 0===r.length?void 0:r[0]}function G(t,e){let i=q(t,e[0]),n=q(t,e[1]);return i==1/0&&(i=void 0),n==1/0&&(n=void 0),void 0!==i&&void 0!==n?i0?lt))return e;s=e-1}return~s}isFound(t,e){return t>0||0==t&&this.array.length>0&&this.array[0]==e}indexOf(t){var e=this.binaryIndexOf(t);return this.isFound(e,t)?e:-1}indexOfElements(t){let e,i,n=[];for(let s=0;s-1&&n.push(i);return n}has(t){return this.indexOf(t)>-1}get(t){return this.array[t]}_update_splice(t,e,i){if(this.array.length>0){let e=this.indexOfElements(t);e.sort((function(t,e){return t-e}));for(let t=e.length-1;t>-1;t--)this.array.splice(e[t],1)}let n,s,r=e.length;for(let t=0;t0&&t.length>0){let e=this.indexOfElements(t);for(let t=0;t0){let t=this.array.indexOf(void 0);t>-1&&this.array.splice(t,this.array.length-t)}var n;this.array=(n=this.array,[...new Set(n)])}update(t,e,i){let n=t.length+e.length;if(0==n)return;let s=(r=this.array.length,o=n,0==r?"sort":o<=100?"splice":"sort");var r,o;"splice"==s?this._update_splice(t,e,i):"sort"==s&&this._update_sort(t,e,i)}getMinimum(){return this.array.length>0?this.array[0]:void 0}getMaximum=function(){return this.array.length>0?this.array[this.array.length-1]:void 0};ltIndexOf(t){var e=this.binaryIndexOf(t);return this.isFound(e,t)?e>0?e-1:-1:Math.abs(e)-1}leIndexOf(t){var e=this.binaryIndexOf(t);return this.isFound(e,t)||(e=Math.abs(e)-1)>=0?e:-1}gtIndexOf(t){var e=this.binaryIndexOf(t);if(this.isFound(e,t))return e-1?[e,e+1]:[void 0,void 0]}var e=-1,i=-1;return-1===(e=t.lowInclude?this.geIndexOf(t.low):this.gtIndexOf(t.low))||-1===(i=t.highInclude?this.leIndexOf(t.high):this.ltIndexOf(t.high))?[void 0,void 0]:[e,i+1]}lookup(t){let[e,i]=this.lookupIndexes(t);return null!=e?this.array.slice(e,i):[]}remove(t){let[e,i]=this.lookupIndexes(t);return null!=e?this.array.splice(e,i-e):[]}slice(t,e){return this.array.slice(t,e)}splice(t,e){return this.array.splice(t,e)}removeInSlice(t){if(0==t.length)return;const e=t[0],i=t[t.length-1];let[n,s]=this.lookupIndexes(new A(e,i,!0,!0)),r=n,o=n,l=0;for(;r-1&&(this.subscriptions.splice(e,1),t.terminate())}}class et{constructor(t,e,i){i=i||{},this.event=t,this.name=t.name,this.callback=e,this.init=void 0===i.init?this.event.init:i.init,this.init_pending=!1,this.terminated=!1,this.ctx=i.ctx}terminate(){this.terminated=!0,this.callback=void 0,this.event.unsubscribe(this)}}function it(t){return t.__eventify_eventMap=new Map,t.__eventify_buffer=[],t}function nt(t){function e(t,e){const i=t.__eventify_eventMap.get(e);if(null==i)throw new Error("Event undefined",e);return i}t.eventifyDefine=function(t,e){if(this.__eventify_eventMap.has(t))throw new Error("Event already defined",t);this.__eventify_eventMap.set(t,new tt(this,t,e))},t.eventifyTrigger=function(t,e){return this.eventifyTriggerAll([{name:t,eArg:e}])},t.eventifyTriggerAlike=function(t,e){return this.eventifyTriggerAll(e.map(e=>({name:t,eArg:e})))},t.eventifyTriggerAll=function(t){if(0==t.length)return;let i=t.map(t=>{let{name:i,eArg:n}=t,s=e(this,i),r=s.subscriptions.filter(t=>0==t.init_pending);return[s,n,r]},this);const n=i.length,s=this.__eventify_buffer,r=this.__eventify_buffer.length;this.__eventify_buffer.length=r+n;for(let t=0;t({key:t,new:e,old:void 0}));return this.sortItems(e),"batch"==t?[e]:e}}_notifyEvents(t){if(0==t.length)return;const e=this.eventifySubscriptions("batch").length>0,i=this.eventifySubscriptions("remove").length>0,n=this.eventifySubscriptions("change").length>0;if(e&&this.eventifyTrigger("batch",t),i||n)for(let e of t)null==e.new&&null!=e.old?i&&this.eventifyTrigger("remove",e):n&&this.eventifyTrigger("change",e)}get size(){return this.datasource.size}has(t){return this.datasource.has(t)}get(t){return this.datasource.get(t)}keys(){return this.datasource.keys()}values(){return this.datasource.values()}entries(){return this.datasource.entries()}set(t,e){let i=void 0;return this.datasource.has(t)&&(i=this.datasource.get(t)),this.datasource.set(t,e),this._notifyEvents([{key:t,new:e,old:i}]),this}delete(t){let e=!1,i=void 0;return this.datasource.has(t)&&(i=this.datasource.get(t),this.datasource.delete(t),e=!0),this._notifyEvents([{key:t,new:void 0,old:i}]),e}clear(){const t=[...this.datasource.entries()].map(([t,e])=>({key:t,new:void 0,old:e}));this.datasource.clear(),this._notifyEvents(t)}}rt.eventifyPrototype(ot.prototype);class lt extends ot{static cmpLow(t,e){return A.cmpLow(t.interval,e.interval)}static cmpHigh(t,e){return A.cmpHigh(t.interval,e.interval)}sortOrder(t={}){let e=t.order||super.sortOrder(t);return"low"==e?lt.cmpLow:"high"==e?lt.cmpHigh:"function"==typeof e?e:void 0}cues(t={}){let e=this.sortValues(this.values(),t);return Array.isArray(e)?e:[...e]}}class at{constructor(t,e){this.tid=void 0,this.to=t,this.callback=e}isSet(){return null!=this.tid}setTimeout(t,e){if(null!=this.tid)throw new Error("at most on timeout");let i=this.to.clock.now(),n=1e3*Math.max(t-i,0);this.tid=setTimeout(this.onTimeout.bind(this),n,t,e)}onTimeout(t,e){if(null!=this.tid){this.tid=void 0;let i=this.to.clock.now();inull!=t);return this.__update(t),n}__handleEvent(t){let{range:e,live:i=!0,...n}=t;null!=e&&(e=[e[0],e[1]]);let s={range:e,live:i,...n};if(s=this.onUpdateStart(s),null!=s)return this.__process(s)}__handleTimeout(t,e){this.__process({...e})}__process(t){let{range:e,position:i,velocity:n,acceleration:s,timestamp:r,live:o=!0,...l}=t,a=!1;if(null!=e){let[t,i]=e;t0&&(e=this._buffer[0].timestamp+this._delay,!(i0&&(e=this._buffer[0].timestamp+this._delay,this._timeout.setTimeout(e))}update(t){throw new Error("update is not legal on delayed (non-live) timingobject")}get delay(){return this._delay}set delay(t){t!=this._delay&&(this._delay=t,this._timeout.clear(),this.__handleDelayed(),this.eventifyTrigger("delaychange",t))}}class gt extends pt{constructor(t,e){super(t),this._factor=e,this.eventifyDefine("scalechange",{init:!0})}eventifyInitEventArgs(t){return"scalechange"==t?[this._factor]:super.eventifyInitEventArgs(t)}onUpdateStart(t){return null!=t.range&&(t.range=[t.range[0]*this._factor,t.range[1]*this._factor]),null!=t.position&&(t.position*=this._factor),null!=t.velocity&&(t.velocity*=this._factor),null!=t.acceleration&&(t.acceleration*=this._factor),t}update(t){return null!=t.position&&(t.position/=this._factor),null!=t.velocity&&(t.velocity/=this._factor),null!=t.acceleration&&(t.acceleration/=this._factor),super.update(t)}get scale(){return this._factor}set scale(t){t!=this._factor&&(this._factor=t,this.__handleEvent({...this.__get_timingsrc().vector,range:this.__get_timingsrc().range}),this.eventifyTrigger("scalechange",t))}}function mt(t,e){let i=e[0],n=e[1]-e[0];return i+((t-i)%(s=n)+s)%s;var s}class yt extends pt{constructor(t,e){if(super(t,{timeout:!0}),!Array.isArray(e)||2!=e.length)throw new Error("range must be array [low, high], "+e);this.__range=e}update(t){if(null!=t.range){let[e,i]=t.range;if(e>=i)throw new Error("illegal range",t.range);if(e!=this.__range[0]||i!=this.__range[1]){this.__range=[e,i];let t=this.__get_timingsrc().query();t.position=mt(t.position,this.__range),this.__vector=t;let n={range:this.__range,...this.__vector,live:!0};this.__dispatchEvents(n,!0,!0)}delete t.range}if(null!=t.position){let e=this.clock.now(),i=D(this.vector,e).position-t.position,n=D(this.__get_timingsrc().vector,e);t.position=n.position-i}return super.update(t)}onRangeViolation(t){return t.position=mt(t.position,this.__range),t}onUpdateStart(t){return null!=t.range&&(t.range=this.__range),null!=t.position&&(t.position=mt(t.position,this.__range)),t}}function wt(){var t=C.INIT,e=null;return{get:function(){return t},set:function(i,n){var s=!1,r=!1;return i===t&&n===e||(s=!0),i!==t&&(r=function(t,e){return(t!==C.OUTSIDE_HIGH||e!==C.OUTSIDE_LOW)&&((t!==C.OUTSIDE_LOW||e!==C.OUTSIDE_HIGH)&&t!==C.INIT)}(t,i)),n!==e&&(e=n),i!==t&&(t=i),{special:r,absolute:s}}}}class kt extends pt{constructor(t,e){super(t,{timeout:!0}),this.__state=wt(),this.__range=e}update(t){throw Error("Not Implemented!")}onUpdateStart(t){if(null!=t.range&&delete t.range,null!=t.position){let{position:e,velocity:i,acceleration:n,timestamp:s}=t,r={position:e,velocity:i,acceleration:n,timestamp:s};if(r=this.onVectorChange(r),null==r)return void this.__renewTimeout(this.__get_timingsrc().vector,this.__range);t.position=r.position,t.velocity=r.velocity,t.acceleration=r.acceleration,t.timestamp=r.timestamp}return t}onVectorChange(t){var e=P(t,this.__range),i=this.__state.set(e,this.__range);if(i.special)this.__state.get()===C.INSIDE||(t=V(t,this.__range));else if(this.__state.get()===C.INSIDE);else{if(!i.absolute)return;t=V(t,this.__range)}return t}}class Et extends pt{constructor(t,e){super(t),this._offset=e,this.eventifyDefine("offsetchange",{init:!0})}eventifyInitEventArgs(t){return"offsetchange"==t?[this._offset]:super.eventifyInitEventArgs(t)}onUpdateStart(t){if(null!=t.range&&(t.range=[-1/0,1/0]),null!=t.position){let e=t.timestamp,i=D(t,e+this._offset);t.position=i.position,t.velocity=i.velocity,t.acceleration=i.acceleration,t.timestamp=e}return t}get offset(){return this._offset}set offset(t){t!=this._offset&&(this._offset=t,this.__handleEvent({...this.__get_timingsrc().vector,range:this.__get_timingsrc().range}),this.eventifyTrigger("offsetchange",t))}}class bt{constructor(t,e={}){this._to=t,this._tid;let{period:i,frequency:n}=e;this._period=200,null!=i?this._period=i:null!=n&&(this._period=1/n),rt.eventifyInstance(this),this.eventifyDefine("change",{init:!0}),this._sub=this._to.on("change",this._onChange.bind(this))}eventifyInitEventArgs(t){if("change"==t&&this._to.isReady())return[this._to.pos]}_onChange(){let t=this._to.query(),e=0!=t.velocity||0!=t.acceleration;e&&null==this._tid&&(this._tid=setInterval(function(){this._onSample()}.bind(this),this._period)),e||null==this._tid||(clearTimeout(this._tid),this._tid=void 0),this._onSample(t.position)}_onSample(t){t=null!=t?t:this._to.pos,this.eventifyTrigger("change",t)}clear(){this._tid&&(clearTimeout(this._tid),this._tid=void 0),this._to.off(this._sub)}}function It(t,e,i){return function(t,e){return[Math.floor(t/e),function(t,e){return(t%e+e)%e}(t,e)]}(t-i,e)}function Ot(t,e,i){let[n,s]=t;return i+n*e+s}rt.eventifyPrototype(bt.prototype);class Tt{constructor(t,e,i={}){this._to=t;let{stride:n=1,offset:s=0}=i;this._offset=s,this._stride=n,this._callback=e,this._timeout=new at(this._to,this._handleTimeout.bind(this)),this._to.on("timingsrc",this._onChange.bind(this))}_onChange(t,e){let i=t.live?t.position:this._to.pos;this._renewTimeout(i)}_calculateTimeout(t,e){let i=this._to.query(),[n,s]=G(i,[t,e]);if(null==n)return;let[r,o]=this._to.range;return s-1&&t.splice(i,1),0==t.length}}const Lt=[0,10,100,1e3,1e4,1e5,1/0];var Dt=function(t){for(let e=0;ethis._submit.bind(this)())}_push(t){let e=this._cues.length,i=0==e,n=t.length;this._cues.length+=n;for(let i=0;i0&&(this._done.value=!0)}_submit(){let t=[];return this._cues.length>0&&(t=this._ds.update(this._cues,this._options)),this._reset(),t}addCue(t,e,i){let n={key:t};return n.interval=e,arguments.length>2&&(n.data=i),n=Ct(n),this._push([n]),this}removeCue(t){return this._push([{key:t}]),this}update(t){t=t.map(t=>Ct(t)),this._push(t)}clear(){return this._cues=[],this}submit(){if(this._options.autosubmit)throw new Error("manual submit while options.autosubmit is true");this._done.value=!0}}class Ht extends lt{constructor(t){super(t),this._map=new Map,this._builder=new Pt(this),this._cueBuckets=new Map;for(let t=0;t-1&&this._update_callbacks.splice(e,1)}_notify_callbacks(t,e){this._update_callbacks.forEach((function(i){i.handler(t,e)}))}set(t,e){throw new Error("not implemented")}delete(t){throw new Error("not implemented")}makeBuilder(t){return new Pt(this,t)}get builder(){return this._builder}addCue(t,e,i){return arguments.length>2?this._builder.addCue(t,e,i):this._builder.addCue(t,e),this}removeCue(t){return this._builder.removeCue(t),this}get updateDone(){return this._builder.updateDone}_addCue(t,e,i,n){let s={key:t,interval:e,data:i};return s=Ct(s),this.update(s,n)}_removeCue(t,e){return this.update({key:t},e)}update(t,e={}){const i=new Map;let n,s,r,{debug:o=!1,equals:a,check_needed:h=!0}=e;l(t)||(t=[t]);const c={ts:Mt(),author:e.author};for(let o of t){if(h)try{o=Ct(o)}catch(t){console.log(t,o);continue}s=o.hasOwnProperty("interval"),r=o.hasOwnProperty("data"),n=this._map.get(o.key),null==n?(s||(o.interval=void 0),r||(o.data=void 0)):null!=n&&(s||r?r?s||(o.interval=n.interval):o.data=n.data:(o.interval=void 0,o.data=void 0)),this._update_cue(i,n,o,c,e)}if(this._call_buckets("flush"),i.size>0){let t={low:1/0,high:-1/0},e=[...i.values()].map(e=>(e.new&&e.new.interval&&(t.low=g.min(t.low,e.new.interval.endpointLow),t.high=g.max(t.high,e.new.interval.endpointHigh)),e.old&&e.old.interval&&(t.low=g.min(t.low,e.old.interval.endpointLow),t.high=g.max(t.high,e.old.interval.endpointHigh)),{key:e.key,new:e.new,old:e.old,info:e.info})),n=e.filter(t=>{let e=xt(t.new,t.old,a);return e.interval!=Nt.NOOP||e.data!=Nt.NOOP});this._notifyEvents(n);let s=void 0;return t.low!=1/0&&(s=A.fromEndpoints(t.low,t.high)),this._notify_callbacks(i,s),o&&this.integrity(),e}return o&&this.integrity(),[]}_update_cue(t,e,i,n,s){let r,o,l,a,h,c,u,_,d,p,{chaining:f=!0,safe:v=!1,equals:g}=s;if(e===i)throw Error("illegal cue arg: same object as current cue");let m=xt(e,i,g);if(m.interval==Nt.NOOP&&m.data==Nt.NOOP)return l={key:i.key,new:e,old:e,delta:m},void t.set(i.key,l);if(null==e)null==i.info&&(i.info={ts:n.ts,change_ts:n.ts,change_id:0}),r=void 0,o=v?Object.freeze(i):i,this._map.set(i.key,o);else if(null==i.interval&&null==i.data)r=e,o=void 0,this._map.delete(i.key);else if(null==i.info&&(i.info={ts:e.info.ts,change_ts:n.ts,change_id:e.info.change_id+1}),r=e,o={key:i.key,interval:i.interval,data:i.data,info:i.info},v&&(o=Object.freeze(o)),this._map.set(i.key,o),r.interval){let t=Dt(r.interval.length),e=this._cueBuckets.get(t);e.replace_endpoint(r.interval.low,o),r.singular||e.replace_endpoint(r.interval.high,o)}if(l={key:i.key,new:o,old:r,delta:m,info:n},f&&(a=t.get(i.key),null!=a&&(l.old=a.old,l.delta=xt(o,l.old,g))),t.set(i.key,l),m.interval!=Nt.NOOP){if(m.interval==Nt.INSERT?(d=!1,p=!0,u=!0,_=!0):m.interval==Nt.DELETE?(d=!0,p=!1,u=!0,_=!0):m.interval==Nt.REPLACE&&(d=!0,p=!0,u=o.interval.low!=r.interval.low,_=o.interval.high!=r.interval.high),d){let t=Dt(r.interval.length);h=this._cueBuckets.get(t)}if(p){let t=Dt(o.interval.length);c=this._cueBuckets.get(t)}h&&c&&h!=c&&(d=!0,p=!0,u=!0,_=!0),u&&(d&&h.del_endpoint(r.interval.low,r),p&&c.add_endpoint(o.interval.low,o)),_&&(d&&!r.interval.singular&&h.del_endpoint(r.interval.high,r),p&&!o.interval.singular&&c.add_endpoint(o.interval.high,o))}}_call_buckets(t,...e){const i=[];for(let n of this._cueBuckets.values()){let s=n[t](...e);null!=s&&s.length>0&&i.push(s)}return a(i)}lookup_endpoints(t){return t=At(t),this._call_buckets("lookup_endpoints",t)}lookup(t,e){return t=At(t),this._call_buckets("lookup",t,e)}lookup_delete(t,e,i={}){t=At(t);const n=this._call_buckets("lookup_delete",t,e),s=[],r={ts:Mt(),author:i.author};let o;for(let t=0;tnull==t.interval),s=e.length,o=n.length,l=this._map.size,a=l-s-o;if(0!=a)throw console.log("count buckets",s),console.log("count no intervals",o),console.log("count map",l),console.log("count diff",a),new Error("inconsistent cue count");let h=new Map(e.map(t=>[t.key,t])),c=new Map([...this._map.entries()].filter(([t,e])=>null!=e.interval)),u=r(h,c);if(u.size>0)throw console.log("buckets missing cues:"),console.log([...u.keys()]),new Error("buckets missing cues: "+[...u.keys()]);if(u=r(c,h),u.size>0)throw new Error("buckets too many cues: "+[...u.keys()]);return{cues:e.length,points:i.length}}}Ht.Delta=Nt,Ht.cue_delta=xt,Ht.cue_equals=function(t,e){let i=xt(t,e);return i.interval==Nt.NOOP&&i.data==Nt.NOOP};class Vt{constructor(t){this._maxLength=t,this._pointMap=new Map,this._pointIndex=new Z,this._created=new Set,this._dirty=new Set}add_endpoint(t,e){let i=0==this._pointMap.size?void 0:this._pointMap.get(t);null==i?(this._pointMap.set(t,[e]),this._created.add(t)):i.push(e)}del_endpoint(t,e){let i=0==this._pointMap.size?void 0:this._pointMap.get(t);if(null!=i){Rt(i,e)&&this._dirty.add(t)}}replace_endpoint(t,e){let i=0==this._pointMap.size?void 0:this._pointMap.get(t);if(null!=i){(function(t,e){if(0==t.length)return!1;if(1==t.length){if(t[0].key==e.key)return t[0]=e,!0}else{let i=t.findIndex((function(t){return t.key==e.key}));if(i>-1)return t[i]=e,!0}return!1})(i,e)||console.log("WARNING: attempt to replace non-existent cue in pointMap")}}flush(){if(0==this._created.size&&0==this._dirty.size)return;let t=[],e=[];for(let t of this._created.values()){this._pointMap.get(t).length>0?e.push(t):this._pointMap.delete(t)}for(let e of this._dirty.values()){let i=this._pointMap.get(e);null!=i&&(0==i.length&&(t.push(e),this._pointMap.delete(e)))}this._pointIndex.update(t,e),this._created.clear(),this._dirty.clear()}lookup_endpoints(t){if(0==this._pointMap.size)return[];const e=new A(t.low,t.high,!0,!0),i=this._pointIndex.lookup(e),n=[],s=i.length;let r,o;for(let l=0;lthis._maxLength)return i;if(e&St.COVERS){let e;if(this._maxLength==1/0)e=new A(-1/0,t.low);else{let i=t.high-this._maxLength,n=t.low;[i,n]=[Math.min(i,n),Math.max(i,n)],e=new A(i,n,!0,!0)}this._lookup_cues(e).forEach((function(e){e.interval.match(t,St.COVERS)&&i.push(e)}))}return i}lookup_delete(t,e){const i=this.lookup(t,e),n=[];let s,r,o;for(let t=0;t0)throw new Error("pointMap missing points: "+[...e]);if(e=s(i,t),e.size>0)throw new Error("pointIndex missing points: "+[...e])}let n=[...this._pointIndex.values()];if(n.length!=t.size)throw new Error("pointIndex include duplicate points");for(let t=1;t=n[t])throw new Error("pointIndex not ordered");for(let t of n){let e=this._pointMap.get(t);for(let i of e)if(t!=i.interval.low&&t!=i.interval.high)throw console.log("POINT:",t),console.log("CUE:",i.interval.toString()),new Error("pointMap: wrong cue")}for(let t of[...this._pointMap.values()])for(let e of t)for(let t of[e.interval.low,e.interval.high])if(!this._pointMap.has(t))throw new Error(`cue found with low or high point not in pointMap ${t} -> ${e.interval.toString()} `);let r=[];for(let t of this._pointMap.values())for(let e of t)r.push(e);let o=new Map;for(let t of r){let e=o.get(t.key);if(null==e)o.set(t.key,t);else if(t!==e)throw new Error("pointMap: different cue objects for same key")}let l=[...o.values()];for(let t of l.values())if(t.interval.length>this._maxLength)throw new Error(`cue in wrong cue bucket ${this._maxLength}, ${t.interval.toString()}`);return[{maxLength:this._maxLength,points:[...this._pointMap.keys()],cues:l}]}}class zt extends lt{constructor(t,e={}){super(e),this._key_filter=e.key_filter,this._data_filter=e.data_filter,this._interval=e.interval,this._data_convert=e.data_convert,this._size=0,this._callbacks=[],this._src_ds=t;let i=this._onDatasetCallback.bind(this);this._src_ds_cb=this._src_ds.add_callback(i)}get datasource(){return this._src_ds}get dataset(){return this._src_ds}get interval(){return this._interval}set interval(t){this._setInterval(t)}add_callback(t){let e={handler:t};return this._callbacks.push(e),e}del_callback(t){let e=this._callbacks.indexof(t);e>-1&&this._callbacks.splice(e,1)}_notify_callbacks(t,e){this._callbacks.forEach((function(i){i.handler(t,e)}))}_cue_keep(t){return null!=t&&(!(this._interval&&!this._interval.match(t.interval))&&(!(this._key_filter&&!this._key_filter(t.key))&&!(this._data_filter&&!this._data_filter(t.data))))}_cue_convert(t){return null!=t&&this._data_convert?{key:t.key,interval:t.interval,data:this._data_convert(t.data)}:t}_items_filter_convert(t){let e=[];for(let i of t){if(null==i.new&&null==i.old)continue;let t=this._cue_keep(i.old)?i.old:void 0,n=this._cue_keep(i.new)?i.new:void 0;null==t&&null==n||(t=this._cue_convert(t),n=this._cue_convert(n),e.push({key:i.key,new:n,old:t}))}return e}_check_interval(t){if(this._interval)if(t){let e=A.intersect(t,this._interval);if(0==e.length)return console.log(`warning - lookup interval ${t.toString()} outside the subset interval ${this._interval.toString()}`),[];t=e[0]}else t=this._interval;return t}lookup(t,e){let i,n=this._check_interval(t);return i=n?this.datasource.lookup(n,e):[...this.datasource.values()],i.filter(this._cue_keep,this).map(this._cue_convert,this)}lookup_endpoints(t){let e=this._check_interval(t);return this.datasource.lookup_endpoints(e).filter(t=>this._cue_keep(t.cue),this).map(t=>({endpoint:t.endpoint,cue:this._cue_convert(t.cue)}),this)}eventifyInitEventArgs(t){if("batch"==t||"change"==t){let e=this.lookup().map(t=>({key:t.key,new:t,old:void 0}));return this.sortItems(e),"batch"==t?[e]:e}}_onDatasetCallback(t,e){let i=[...t.values()];i=this._items_filter_convert(i);for(let t of i)null!=t.new&&null==t.old?this._size+=1:null==t.new&&null!=t.old&&(this._size-=1);super._notifyEvents(i);let n=new Map(i.map(t=>[t.key,t]));this._interval&&(e=A.intersect(this._inverval,e)),this._notify_callbacks(n,e)}_setInterval(t){if(!t instanceof A)throw new Error("must be interval",t.toString());if(!this._interval||!this._interval.equals(t)){let e=this.lookup();this._interval=t;let i=this.datasource.lookup(t);i=i.filter(this._cue_keep,this).map(this._cue_convert,this);let n=new Map([...e].map(t=>[t.key,t])),s=new Map([...i].map(t=>[t.key,t])),o=r(n,s),l=r(s,n),h=[...o.values()].map(t=>({key:t.key,new:void 0,old:t})),c=[...l.values()].map(t=>({key:t.key,new:t,old:void 0}));this._size-=h.length,this._size+=c.length;const u=a([h,c],{copy:!1,order:!0});this._notifyEvents(u)}}get size(){return this._size}has(t){return null!=this.get(t)}get(t){let e=super.get(t);if(null!=e&&this._cue_keep(e))return this._cue_convert(e)}keys(){return this.values().map(t=>t.key)}values(){return[...super.values()].filter(t=>this._cue_keep(t),this).map(t=>this._cue_convert(t),this)}entries(){return this.values().map(t=>[t.key,t])}update(t,e){throw new Error("not implemented")}set(t,e){throw new Error("not implemented")}delete(t){throw new Error("not implemented")}clear(t){throw new Error("not implemented")}}const Ut=j;function Bt(t,e){return g.cmp(t.tsEndpoint,e.tsEndpoint)}class qt{constructor(t,e,i){this.to=e,this.timeout=new at(e,this.run.bind(this)),this.vector,this.timeInterval,this.posInterval,this.dataset=t,this.queue=[],this.callbacks=[],(i=i||{}).lookahead=i.lookahead||5,this.options=i}add_callback(t){let e={handler:t};return this.callbacks.push(e),e}del_callback(t){let e=this.callbacks.indexof(t);e>-1&&this.callbacks.splice(e,1)}_notify_callbacks(...t){this.callbacks.forEach((function(e){e.handler(...t)}))}setVector(t){let e=t.timestamp;this.vector;null!=this.vector&&(this.timeout.clear(),this.timeInterval=void 0,this.posInterval=void 0,this.queue=[]),this.vector=t,x(this.vector)&&this.run(e)}push(t){t.forEach((function(t){this.timeInterval.covers_endpoint(t.tsEndpoint)&&this.queue.push(t)}),this),this.queue.sort(Bt)}pop(t){let e=[];this.queue.length;for(;this.queue.length>0&&this.queue[0].tsEndpoint[0]<=t;)e.push(this.queue.shift());return e}next(){return this.queue.length>0?this.queue[0].tsEndpoint[0]:void 0}advance(t){let e,i=this.options.lookahead,n=!1;return null==this.timeInterval?(e=t,n=!0):g.leftof(this.timeInterval.endpointHigh,t)&&(e=this.timeInterval.high,n=!0),n&&(this.timeInterval=new A(e,e+i,!0,!1),this.posInterval=Ut(this.timeInterval,this.vector),this.queue=[]),n}load(t,e){let i=F(this.timeInterval,this.posInterval,this.vector,t),n=z(this.vector,this.to.range)[0];return null==e&&(e=this.timeInterval.endpointLow),i.filter((function(t){if(n<=t.tsEndpoint[0])return!1;if(g.leftof(t.tsEndpoint,e))return!1;if(0!=this.vector.acceleration){let e=t.tsEndpoint[0];if(e>this.timeInterval.endpointLow[0]){let i=D(this.vector,e);if(i.position==t.endpoint[0]&&0==i.velocity)return!1}}return!0}),this)}run(t){let e=this.pop(t);if(this.advance(t)){let i=this.dataset.lookup_endpoints(this.posInterval),n=this.load(i);this.push(n);let s=this.pop(t);e.push(...s)}e.length>0&&this._notify_callbacks(t,e,this);let i=this.next()||this.timeInterval.high;this.timeout.setTimeout(Math.min(i,this.timeInterval.high))}}function Gt(t){return t.interval==Ht.Delta.NOOP&&t.data==Ht.Delta.NOOP}const jt=Object.freeze({ENTER:1,STAY:0,EXIT:-1,ENTER_EXIT:2}),$t=new Map([["LRL",jt.STAY],["LRR",jt.EXIT],["LRS",jt.EXIT],["LLL",jt.STAY],["LLR",jt.ENTER],["LLS",jt.ENTER],["RRL",jt.ENTER],["RRR",jt.STAY],["RRS",jt.ENTER],["RLL",jt.EXIT],["RLR",jt.STAY],["RLS",jt.EXIT],["SRL",jt.ENTER],["SRR",jt.EXIT],["SRS",jt.ENTER_EXIT],["SLL",jt.EXIT],["SLR",jt.ENTER],["SLS",jt.ENTER_EXIT]]);function Ft(t,e){return A.cmpLow(t.interval,e.interval)}function Xt(t,e){return-1*A.cmpHigh(t.interval,e.interval)}function Qt(t,e){return Ft(t.new?t.new:t.old,e.new?e.new:e.old)}function Wt(t,e){return Xt(t.new?t.new:t.old,e.new?e.new:e.old)}class Yt extends lt{constructor(t,e){super(e),this._map=new Map,this._ds=t;let i=this._onDatasetCallback.bind(this);this._ds_cb=this._ds.add_callback(i)}get datasource(){return this._map}get dataset(){return this._ds}_movementDirection(){throw new Error("not implemented")}sortValues(t,e={}){if("function"==typeof this.sortOrder(e))return super.sortValues(t,e);{let e=Array.isArray(t)?t:[...t];return this._movementDirection()>=0?e.sort(Ft):e.sort(Xt),e}}sortItems(t,e){let i=this.sortOrder();if("function"==typeof i)return super.sortItems(t);null==i&&(null==e&&(e=this._movementDirection()),e>=0?t.sort(Qt):t.sort(Wt))}set(t,e){throw new Error("not implemented")}delete(t){throw new Error("not implemented")}clear(t){throw new Error("not implemented")}_onDatasetCallback(t,e){throw new Error("not implemented")}_items_from_dataset_events(t,e){const i=[],n=[],s=[],r=0==this._map.size;let o,l,a;for(let h of t.values())Gt(h.delta)||(o=!r&&this._map.has(h.key),l=!1,null!=h.new&&h.new.interval.match(e)&&(l=!0),o&&!l?(a={key:h.key,new:void 0,old:h.old,info:h.info},s.push(a)):!o&&l?(a={key:h.key,new:h.new,old:void 0,info:h.info},i.push(a)):o&&l&&(a={key:h.key,new:h.new,old:h.old,info:h.info},n.push(a)));return[s,n,i]}_items_from_dataset_lookup(t,e){const i=new Map(this._ds.lookup(e).map((function(t){return[t.key,t]})));let n,s=[],l=[],a=0==this._map.size;if(!a){let e=o(this._map,i);if(e.size>0){let i,n;for(let r of t.values())i=e.get(r.key),null==i||Gt(r.delta)||(n={key:r.key,new:r.new,old:r.old},s.push(n))}l=[...r(this._map,i).values()].map(t=>({key:t.key,new:void 0,old:t}))}n=a?i:r(i,this._map);let h=[...n.values()].map(t=>({key:t.key,new:t,old:void 0}));for(let e in[l,s,h])for(let i of e){let e=t.get(i.key);null!=e&&(i.info=e.info)}return[l,s,h]}get builder(){return this.dataset.builder}addCue(t,e,i){return this.dataset.addCue(t,e,i)}removeCue(t){return this.dataset.removeCue(t)}_addCue(t,e,i){return this.dataset._addCue(t,e,i)}_removeCue(t){return this.dataset._removeCue(t)}update(t,e){return this.dataset.update(t,e)}clear(){return this.dataset.clear()}hasCue(t){return this.dataset.has(t)}getCue(t){return this.dataset.get(t)}getCues(){return this.dataset.cues()}getActiveKeys(){return[...this.keys()]}getActiveCues(){return this.cues()}isActive(t){return this.has(t)}}Yt.Active=jt,Yt.ActiveMap=$t;const Jt=W.PosDelta,Kt=W.MoveDelta,Zt=Yt.Active,te=Yt.ActiveMap;class ee extends Yt{constructor(t,e,i){super(t,i),this._to=e,this._sub=this._to.on("timingsrc",this._onTimingCallback.bind(this)),this._sched=new qt(this._ds,e);let n=this._onScheduleCallback.bind(this);this._sched_cb=this._sched.add_callback(n)}_movementDirection(){const t=this._to.clock.now();return N(this._to.vector,t)}_onDatasetCallback(t,e){if(!this._to.isReady())return;if(null==e)return;const i=this._to.clock.now(),n=D(this._to.vector,i),s=new A(n.position);if(!s.match(e,A.Match.OUTSIDE)){let e=this._items_from_dataset_events.bind(this);5e3{this._map.delete(t.key)}),r.forEach(t=>{this._map.set(t.key,t.new)}),o.forEach(t=>{this._map.set(t.key,t.new)});let l=N(n);this.sortItems(i,l),this.sortItems(r,l),this.sortItems(o,l);const h=a([i,r,o],{copy:!0,order:!0});this._notifyEvents(h)}this._sched.posInterval&&(this._sched.posInterval.match(e,A.Match.OUTSIDE)||this._sched.setVector(n))}_onTimingCallback(t){let e=D(t,this._to.clock.now()),i=new W(this._to.old_vector,e);if(i.posDelta==Jt.CHANGE||i.moveDelta==Kt.STOP){let t=e.position,i=e.position,n=new A(t,i,!0,!0),s=new Map(this._ds.lookup(n).map(t=>[t.key,t])),o=r(this._map,s),l=r(s,this._map);this._map=s;let h=[...o.values()].map(t=>({key:t.key,new:void 0,old:t})),c=[...l.values()].map(t=>({key:t.key,new:t,old:void 0})),u=N(e);this.sortItems(h,u),this.sortItems(c,u);const _=a([h,c],{copy:!0,order:!0});this._notifyEvents(_)}this._sched.setVector(e)}_onScheduleCallback=function(t,e,i){if(!this._to.isReady())return;const n=[];e.forEach((function(t){let e=t.cue,i=this._map.has(e.key),[s,r,o,l]=t.endpoint,a=t.direction>0?"R":"L",h=l?"S":r?"R":"L",c=te.get(`S${a}${h}`);c==Zt.ENTER_EXIT?i?(n.push({key:e.key,new:void 0,old:e}),this._map.delete(e.key)):(n.push({key:e.key,new:e,old:void 0}),n.push({key:e.key,new:void 0,old:e})):c==Zt.ENTER?i||(n.push({key:e.key,new:e,old:void 0}),this._map.set(e.key,e)):c==Zt.EXIT&&i&&(n.push({key:e.key,new:void 0,old:e}),this._map.delete(e.key))}),this),this._notifyEvents(n)}}const ie=W.PosDelta,ne=W.MoveDelta,se=Yt.Active,re=Yt.ActiveMap;function oe(t,e){let i=N(t)+N(e);return i>0?1:i<0?-1:0}class le extends Yt{constructor(t,e,i,n){super(t,n),this._toA=e,this._toA_ready=!1,this._toB=i,this._toB_ready=!1;let s=this._onTimingCallback.bind(this);this._subA=this._toA.on("timingsrc",s),this._subB=this._toB.on("timingsrc",s);let r=this._onScheduleCallback.bind(this);this._schedA=new qt(this._ds,e),this._schedA_cb=this._schedA.add_callback(r),this._schedB=new qt(this._ds,i),this._schedB_cb=this._schedB.add_callback(r),this._toA_vector,this._toB_vector}_isReady(){return this._toA_ready&&this._toB_ready}_movementDirection(){const t=this._toA.clock.now();return oe(D(this._toA.vector,t),D(this._toB.vector,t))}_onDatasetCallback(t,e){if(!this._isReady())return;if(null==e)return;const i=this._toA.clock.now(),n=D(this._toA_vector,i),s=D(this._toB_vector,i);let[r,o]=[n.position,s.position],[l,h]=r<=o?[r,o]:[o,r];const c=new A(l,h,!0,!0);if(!c.match(e,A.Match.OUTSIDE)){let e=this._items_from_dataset_events.bind(this);5e3{this._map.delete(t.key)}),r.forEach(t=>{this._map.set(t.key,t.new)}),o.forEach(t=>{this._map.set(t.key,t.new)});let l=oe(n,s);this.sortItems(i,l),this.sortItems(r,l),this.sortItems(o,l);const h=a([i,r,o],{copy:!0,order:!0});this._notifyEvents(h,l)}this._schedA.posInterval&&(this._schedA.posInterval.match(e,A.Match.OUTSIDE)||this._schedA.setVector(n)),this._schedB.posInterval&&(this._schedB.posInterval.match(e,A.Match.OUTSIDE)||this._schedB.setVector(s))}_onTimingCallback(t,e){let i=!1;if(!this._isReady()){if(e.src==this._toA?this._toA_ready=!0:this._toB_ready=!0,!this._isReady())return;i=!0}this._toA_vector=this._toA.vector,this._toB_vector=this._toB.vector;const n=e.src,s=n==this._toA?this._toB:this._toA;let o=D(n.vector,n.clock.now());const l=new W(n.old_vector,o);let h=o.timestamp,c=D(s.vector,h);if(l.posDelta==ie.CHANGE||l.MoveDelta==ne.STOP){let t=Math.min(o.position,c.position),e=Math.max(o.position,c.position),i=new A(t,e,!0,!0),n=new Map(this._ds.lookup(i).map(t=>[t.key,t])),s=r(this._map,n),l=r(n,this._map);this._map=n;let h=[...s.values()].map(t=>({key:t.key,new:void 0,old:t})),u=[...l.values()].map(t=>({key:t.key,new:t,old:void 0})),_=oe(o,c);this.sortItems(h,_),this.sortItems(u,_);const d=a([h,u],{copy:!0,order:!0});this._notifyEvents(d)}n==this._toA?this._schedA.setVector(o):n==this._toB&&this._schedB.setVector(o),i&&(s==this._toA?this._schedA.setVector(c):s==this._toB&&this._schedB.setVector(c))}_onScheduleCallback=function(t,e,i){if(!this._isReady())return;const n=i.to==this._toA?this._toB:this._toA,s=[];e.forEach((function(t){let[e,i,r,o]=t.endpoint,l=t.tsEndpoint[0],a=D(n.vector,l),h=a.position,c=e0?"R":"L",_=o?"S":i?"R":"L",d=re.get(`${c}${u}${_}`),p=t.cue,f=this._map.has(p.key);if(d==se.ENTER_EXIT){if(x(a)){d=N(a)!=t.direction?se.ENTER:se.EXIT}else d=se.ENTER}d==se.STAY&&(d=se.ENTER),d==se.ENTER&&f||(d!=se.EXIT||f)&&(d==se.ENTER?(s.push({key:p.key,new:p,old:void 0}),this._map.set(p.key,p)):d==se.EXIT&&(s.push({key:p.key,new:void 0,old:p}),this._map.delete(p.key)))}),this),this._notifyEvents(s)}}class ae{constructor(e,i){this.ds=e,this.elem=i,this.nonce=t(4),this.ds.on("change",this.onchange.bind(this)),this.ds.on("remove",this.onremove.bind(this))}cue2string(t){let e=t.interval?t.interval.toString():"undefined",i=JSON.stringify(t.data);return`${t.key}, ${e}, ${i}`}onchange(t){let e=`${this.nonce}-${t.key}`,i=this.elem.querySelector("#"+e);if(i)i.innerHTML=this.cue2string(t.new);else{let i=document.createElement("div");i.innerHTML=this.cue2string(t.new),i.setAttribute("id",e),this.elem.appendChild(i)}}onremove(t){let e=`${this.nonce}-${t.key}`,i=document.getElementById(e);i&&i.parentNode.removeChild(i)}}class he{static position2percent(t,e){let[i,n]=e;return 100*(t-i)/(n-i)}static percent2position(t,e){let[i,n]=e;return t=Math.max(0,t),i+(n-i)*(t=Math.min(100,t))/100}constructor(t,e,i={}){this._to=t,this._sampler=i.sampler,this._progress_elem=e,this._lock=!1,this._options=i,this._range=i.range||this._to.range;let[n,s]=this._range;if(n==-1/0||s==1/0)throw new Error("illegal range",this._range);this._progress_elem.addEventListener("input",function(){this._lock_value=!0}.bind(this)),this._progress_elem.addEventListener("change",function(){this._lock_value=!1;let t=parseInt(this._progress_elem.value),e=he.percent2position(t,this._range);this._to.update({position:e})}.bind(this)),this._sampler&&this._sampler.on("change",this.refresh.bind(this))}refresh(){let t=this._to.pos;if(!this._lock_value){let e=he.position2percent(t,this._range);if(this._options.thumb){if(e<0||100t instanceof Ht),e=t.length>0?t[0]:new Ht,i=[...arguments].filter(t=>t instanceof pt),n=[...arguments].filter(t=>Object.getPrototypeOf(t)===Object.prototype),s=n.length>0?n[0]:{};if(0==i.length)throw new Error("no timingobject in arguments");return 1==i.length?new ee(e,i[0],s):new le(e,i[0],i[1],s)}ee.prototype.clone=function(){let t=[this.dataset];return t.push.apply(t,[...arguments]),ce(...t)},le.prototype.clone=function(){let t=[this.dataset];return t.push.apply(t,[...arguments]),ce(...t)};const ue="v3.0";export{Z as BinarySearch,lt as CueCollection,Ht as Dataset,ae as DatasetViewer,vt as DelayConverter,A as Interval,yt as LoopConverter,Tt as PositionCallback,kt as RangeConverter,gt as ScaleConverter,ce as Sequencer,ft as SkewConverter,zt as Subset,at as Timeout,Et as TimeshiftConverter,pt as TimingObject,he as TimingProgress,bt as TimingSampler,g as endpoint,rt as eventify,Y as motionutils,u as utils,ue as version};
+//# sourceMappingURL=timingsrc-min-esm-v3.js.map
diff --git a/docs/lib/timingsrc-min-esm-v3.js.map b/docs/lib/timingsrc-min-esm-v3.js.map
new file mode 100644
index 0000000..b5071db
--- /dev/null
+++ b/docs/lib/timingsrc-min-esm-v3.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"timingsrc-min-esm-v3.js","sources":["../../v3/util/utils.js","../../v3/util/endpoint.js","../../v3/util/interval.js","../../v3/util/motionutils.js","../../v3/util/binarysearch.js","../../v3/util/eventify.js","../../v3/util/observablemap.js","../../v3/dataset/cuecollection.js","../../v3/util/timeout.js","../../v3/timingobject/masterclock.js","../../v3/timingobject/internalprovider.js","../../v3/timingobject/externalprovider.js","../../v3/timingobject/timingobject.js","../../v3/timingobject/skewconverter.js","../../v3/timingobject/delayconverter.js","../../v3/timingobject/scaleconverter.js","../../v3/timingobject/loopconverter.js","../../v3/timingobject/rangeconverter.js","../../v3/timingobject/timeshiftconverter.js","../../v3/timingobject/timingsampler.js","../../v3/timingobject/positioncallback.js","../../v3/dataset/dataset.js","../../v3/dataset/subset.js","../../v3/sequencing/schedule.js","../../v3/sequencing/basesequencer.js","../../v3/sequencing/pointsequencer.js","../../v3/sequencing/intervalsequencer.js","../../v3/ui/datasetviewer.js","../../v3/ui/timingprogress.js","../../v3/index.js"],"sourcesContent":["/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see not equal\n if (aProps.length != bProps.length) {\n return false;\n }\n for (let i=0; i not equal\n if (a[propName] !== b[propName]) {\n return false;\n }\n }\n // equal\n return true;\n}\n\n\n/* document readypromise */\nexport const docready = new Promise(function(resolve) {\n if (document.readyState === 'complete') {\n resolve();\n } else {\n let onReady = function () {\n resolve();\n document.removeEventListener('DOMContentLoaded', onReady, true);\n window.removeEventListener('load', onReady, true);\n };\n document.addEventListener('DOMContentLoaded', onReady, true);\n window.addEventListener('load', onReady, true);\n }\n});\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see -1) {\n indexes.push(index);\n }\n }\n return indexes;\n };\n\n /*\n element exists with value\n */\n has(x) {\n return (this.indexOf(x) > -1) ? true : false;\n };\n\n get(index) {\n return this.array[index];\n };\n\n\n\n /*\n REMOVE\n Removes all elements with given values\n search for each one and splice remove them individually\n (reverse order)\n\n INSERT\n binarysearch and splice\n insert - binarysearch and splice\n\n WARNING - there should be no need to insert elements that are already\n present in the array. This function drops such duplicates\n */\n _update_splice(to_remove, to_insert, options) {\n\n // REMOVE\n if (this.array.length > 0) {\n let indexes = this.indexOfElements(to_remove);\n /*\n sort indexes to make sure we are removing elements\n in backwards order\n optimization\n - if elements were sorted in the first place this should not be necessary\n */\n indexes.sort(function(a,b){return a-b;});\n for (let i=indexes.length-1; i > -1; i--) {\n this.array.splice(indexes[i], 1);\n }\n }\n\n // INSERT\n let x, index;\n let len = to_insert.length;\n for (let i=0; i 0 && to_remove.length > 0) {\n // visit all elements and set their value to undefined\n // undefined values will be sorted to the end of the array\n let indexes = this.indexOfElements(to_remove);\n for (let i=0; i 0) {\n let index = this.array.indexOf(undefined);\n if (index > -1) {\n this.array.splice(index, this.array.length-index);\n }\n }\n // remove duplicates\n this.array = unique(this.array);\n };\n\n\n /*\n Update - removing and inserting elements in one operation\n\n a single element should only be present once in the list, thus avoiding\n multiple operations to one element. This is presumed solved externally.\n - also objects must not be members of both lists.\n\n - internally selects the best method - searchsplice or concatsort\n - selection based on relative sizes of existing elements and new elements\n\n */\n update(to_remove, to_insert, options) {\n let size = to_remove.length + to_insert.length;\n if (size == 0) {\n return;\n }\n\n // regular case\n let approach = resolve_approach(this.array.length, size);\n if (approach == \"splice\") {\n this._update_splice(to_remove, to_insert, options);\n } else if (approach == \"sort\"){\n this._update_sort(to_remove, to_insert, options);\n }\n };\n\n\n /*\n Accessors\n */\n\n getMinimum() {\n return (this.array.length > 0) ? this.array[0] : undefined;\n };\n\n getMaximum = function () {\n return (this.array.length > 0) ? this.array[this.array.length - 1] : undefined;\n };\n\n\n /*\n Internal search functions\n */\n\n /*\n Find index of largest value less than x\n Returns -1 if noe values exist that are less than x\n */\n ltIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n consider element to the left\n if we are at the left end of the array nothing is found\n return -1\n */\n if (i > 0) {\n return i-1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) - 1 is the largest value less than x\n */\n return Math.abs(i)-1;\n }\n };\n\n /*\n Find index of rightmost value less than x or equal to x\n Returns -1 if noe values exist that are less than x or equal to x\n */\n leIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n element found\n */\n return i;\n } else {\n // not found - consider element to the left\n i = Math.abs(i) - 1;\n return (i >= 0) ? i : -1;\n }\n };\n\n /*\n \tFind index of leftmost value greater than x\n \tReturns -1 if no values exist that are greater than x\n */\n\n gtIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n if there are no elements to the right return -1\n */\n if (i < this.array.length -1) {\n return i+1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) is the smallest value greater than x\n unless we hit the end of the array, in which cas no smalles value\n exist which is greater than x\n */\n let idx = Math.abs(i);\n return (idx < this.array.length) ? idx : -1;\n }\n };\n\n\n /*\n Find index of leftmost value which is greater than x or equal to x\n Returns -1 if noe values exist that are greater than x or equal to x\n */\n\n geIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found element\n */\n return i;\n } else {\n // not found - consider the element where x would be inserted\n i = Math.abs(i);\n return (i -1) {\n return [index, index + 1];\n } else {\n return [undefined, undefined];\n }\n }\n\n // regular non-singular interval\n var start_index = -1, end_index = -1;\n if (interval.lowInclude) {\n start_index = this.geIndexOf(interval.low);\n } else {\n start_index = this.gtIndexOf(interval.low);\n }\n if (start_index === -1) {\n return [undefined, undefined];\n }\n if (interval.highInclude) {\n end_index = this.leIndexOf(interval.high);\n } else {\n end_index = this.ltIndexOf(interval.high);\n }\n if (end_index === -1) { // not reachable - I think\n return [undefined, undefined];\n }\n return [start_index, end_index + 1];\n };\n\n\n /*\n lookup by interval\n */\n lookup(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.slice(start, end) : [];\n };\n\n /*\n remove by interval\n */\n remove(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.splice(start, end-start) : [];\n };\n\n\n slice(start, end) {\n return this.array.slice(start, end);\n };\n\n splice(start, length) {\n return this.array.splice(start, length);\n };\n\n\n\n /*\n method for removing multiple closely placed elements in place\n - removeList is sorted\n - changes only affect the part of the index between first and last element\n - move remaining elements to the left, remove elements with a single splice\n - efficent if removelist references elements that are close to eachother\n */\n\n removeInSlice(removeList) {\n if (removeList.length == 0){\n return;\n }\n const low = removeList[0];\n const high = removeList[removeList.length-1];\n let [start, end] = this.lookupIndexes(new Interval(low, high, true, true));\n\n let rd_ptr = start;\n let wr_ptr = start;\n let rm_ptr = 0;\n\n while (rd_ptr < end) {\n let rd_elem = this.array[rd_ptr];\n let rm_elem = removeList[rm_ptr];\n if (rd_elem < rm_elem) {\n this.array[wr_ptr] = this.array[rd_ptr];\n wr_ptr++;\n rd_ptr++;\n } else if (rd_elem == rm_elem) {\n rd_ptr++;\n rm_ptr++;\n } else {\n // rd_elem > rm_elem\n rm_ptr++;\n }\n if (rm_ptr == removeList.length) {\n break\n }\n }\n this.array.splice(wr_ptr, rd_ptr-wr_ptr);\n };\n\n\n values() {\n return this.array.values();\n };\n\n clear() {\n this.array = [];\n };\n\n get length () {\n return this.array.length;\n }\n\n}\n\nexport default BinarySearch;\n\n\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see {\n\t\t\treturn {name, eArg};\n\t\t}));\n\t}\n\n\t/*\n\t\tTrigger single event\n\t*/\n\tfunction eventifyTrigger(name, eArg) {\n\t\treturn this.eventifyTriggerAll([{name, eArg}]);\n\t}\n\n\t_prototype.eventifyDefine = eventifyDefine;\n\t_prototype.eventifyTrigger = eventifyTrigger;\n\t_prototype.eventifyTriggerAlike = eventifyTriggerAlike;\n\t_prototype.eventifyTriggerAll = eventifyTriggerAll;\n\t_prototype.eventifySubscriptions = eventifySubscriptions;\n\t_prototype.on = on;\n\t_prototype.off = off;\n};\n\n\n/*\n\tEvent Variable\n\n\tObjects with a single \"change\" event\n*/\n\nexport class EventVariable {\n\n\tconstructor (value) {\n\t\teventifyInstance(this);\n\t\tthis._value = value;\n\t\tthis.eventifyDefine(\"change\", {init:true});\n\t}\n\n\teventifyInitEventArgs(name) {\n\t\tif (name == \"change\") {\n\t\t\treturn [this._value];\n\t\t}\n\t}\n\n\tget value () {return this._value};\n\tset value (value) {\n\t\tif (value != this._value) {\n\t\t\tthis._value = value;\n\t\t\tthis.eventifyTrigger(\"change\", value);\n\t\t}\n\t}\n}\neventifyPrototype(EventVariable.prototype);\n\n/*\n\tEvent Boolean\n\n\n\tNote : implementation uses falsiness of input parameter to constructor and set() operation,\n\tso eventBoolean(-1) will actually set it to true because\n\t(-1) ? true : false -> true !\n*/\n\nexport class EventBoolean extends EventVariable {\n\tconstructor(value) {\n\t\tsuper(Boolean(value));\n\t}\n\n\tset value (value) {\n\t\tsuper.value = Boolean(value);\n\t}\n\tget value () {return super.value};\n}\n\n\n/*\n\tmake a promise which is resolved when EventBoolean changes\n\tvalue.\n*/\nexport function makePromise(eventObject, conditionFunc) {\n\tconditionFunc = conditionFunc || function(val) {return val == true};\n\treturn new Promise (function (resolve, reject) {\n\t\tlet sub = eventObject.on(\"change\", function (value) {\n\t\t\tif (conditionFunc(value)) {\n\t\t\t\tresolve(value);\n\t\t\t\teventObject.off(sub);\n\t\t\t}\n\t\t});\n\t});\n};\n\n// module api\nexport default {\n\teventifyPrototype,\n\teventifyInstance,\n\tEventVariable,\n\tEventBoolean,\n\tmakePromise\n};\n\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n fallback to order from constructor\n noop if no ordering is defined\n */\n sortValues(iter, options={}) {\n let order = this.sortOrder(options);\n if (typeof order == \"function\") {\n // sort\n // if iterable not array - convert into array ahead of sorting\n let arr = (Array.isArray(iter)) ? iter : [...iter];\n return arr.sort(order);\n } else {\n // noop\n return iter;\n }\n }\n\n /* \n Sort items (in-place) by value {new:value, old:value} using\n ordering function for values\n */\n sortItems(items) {\n let order = this.sortOrder(); \n if (typeof order == \"function\") {\n items.sort(function(item_a, item_b) {\n let cue_a = (item_a.new) ? item_a.new : item_a.old;\n let cue_b = (item_b.new) ? item_b.new : item_b.old;\n return order(cue_a, cue_b);\n });\n }\n }\n\n /***************************************************************\n EVENTS\n ***************************************************************/\n\n /*\n Eventify: immediate events\n */\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n let items = [...this.datasource.entries()].map(([key, val]) => {\n return {key:key, new:val, old:undefined};\n });\n // sort init items (if order defined)\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /*\n Event Notification\n */\n _notifyEvents(items) {\n // event notification\n if (items.length == 0) {\n return;\n }\n const has_update_subs = this.eventifySubscriptions(\"batch\").length > 0;\n const has_remove_subs = this.eventifySubscriptions(\"remove\").length > 0;\n const has_change_subs = this.eventifySubscriptions(\"change\").length > 0;\n // update\n if (has_update_subs) {\n this.eventifyTrigger(\"batch\", items);\n }\n // change, remove\n if (has_remove_subs || has_change_subs) {\n for (let item of items) {\n if (item.new == undefined && item.old != undefined) {\n if (has_remove_subs) {\n this.eventifyTrigger(\"remove\", item);\n }\n } else {\n if (has_change_subs) {\n this.eventifyTrigger(\"change\", item);\n }\n }\n }\n }\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get size () {\n return this.datasource.size;\n }\n\n has(key) {\n return this.datasource.has(key);\n };\n\n get(key) {\n return this.datasource.get(key);\n };\n\n keys() {\n return this.datasource.keys();\n };\n\n values() {\n return this.datasource.values();\n };\n\n entries() {\n return this.datasource.entries();\n }\n\n\n /***************************************************************\n MODIFY\n ***************************************************************/\n\n set(key, value) {\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n }\n this.datasource.set(key, value);\n this._notifyEvents([{key: key, new:value, old: old}]);\n return this;\n }\n\n delete(key) {\n let result = false;\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n this.datasource.delete(key);\n result = true;\n }\n this._notifyEvents([{key: key, new:undefined, old: old}]);\n return result;\n }\n\n clear() {\n // create change events for all cues\n const items = [...this.datasource.entries()].map(([key, val]) => {\n return {key: key, new: undefined, old: val};\n })\n // clear _map\n this.datasource.clear();\n // event notification\n this._notifyEvents(items);\n }\n\n}\n\neventify.eventifyPrototype(ObservableMap.prototype);\n\nexport default ObservableMap;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see {\n return this._submit.bind(this)();\n });\n }\n\n _push(cue_args) {\n // append cue args\n let m = this._cues.length;\n let was_empty = m == 0;\n let n = cue_args.length;\n this._cues.length += n;\n for (let i=0; i 0) {\n // batch done immediately \n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n }\n\n _submit() {\n let result = [];\n // carry out update if necessary\n if (this._cues.length > 0) {\n result = this._ds.update(this._cues, this._options); \n }\n // reset cue arg builder\n this._reset();\n // update result\n return result;\n } \n \n /*\n add or change single cue\n \n if both interval and data are undefined\n this is not interpreted as remove,\n but as a cue with no interval and a data value set\n to undefined\n */\n addCue(key, interval, data) {\n let cue_arg = {key:key};\n cue_arg.interval = interval; \n if (arguments.length > 2) {\n cue_arg.data = data;\n }\n cue_arg = cue_check(cue_arg)\n this._push([cue_arg]);\n return this;\n }\n\n /* remove single cue */\n removeCue(key) {\n this._push([{key:key}]);\n return this;\n }\n\n /* load array of cue args into argbuilder */\n update(cue_args) {\n cue_args = cue_args.map((cue_arg) => cue_check(cue_arg));\n this._push(cue_args);\n }\n\n /* clear args currently in argbuilder */\n clear() {\n this._cues = [];\n return this;\n }\n\n /* manually submit cue args from cue arg builder */\n submit() {\n if (this._options.autosubmit) {\n throw new Error(\"manual submit while options.autosubmit is true\");\n }\n // mark batch as done\n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n}\n\n\n/*\n this implements Dataset, a data collection supporting\n efficient lookup of cues tied to intervals on the timeline\n\n - cues may be tied to one or two points on the timeline, this\n is expressed by an Interval.\n - cues are indexed both by key and by intervals\n - the interval index is divided into a set of CueBuckets,\n based on cue interval length, for efficient lookup\n*/\n\nclass Dataset extends CueCollection {\n\n constructor(options) {\n super(options);\n\n this._map = new Map();\n this._builder = new CueArgBuilder(this);\n\n /*\n Initialise set of CueBuckets\n Each CueBucket is responsible for cues of a certain length\n */\n this._cueBuckets = new Map(); // CueBucketId -> CueBucket\n for (let i=0; i -1) {\n this._update_callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._update_callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n /***************************************************************\n MAP METHODS\n */\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n\n /***************************************************************\n CUE ARG BUILDER\n */\n \n makeBuilder(options) {\n return new CueArgBuilder(this, options);\n }\n\n // not really useful (v2 complience)\n get builder () {return this._builder;};\n\n \n /***************************************************************\n ADD CUE, REMOVE CUE\n\n - COMPATIBILTY WITH V2\n - SAFE TO USE repeatedly (batched using promise)\n */\n\n addCue(key, interval, data) {\n if (arguments.length > 2) {\n this._builder.addCue(key, interval, data);\n } else {\n this._builder.addCue(key, interval);\n }\n return this;\n }\n\n removeCue(key) {\n this._builder.removeCue(key);\n return this;\n }\n\n get updateDone() {return this._builder.updateDone};\n\n /***************************************************************\n ADD CUE, REMOVE CUE - INTERACTIVE USE\n\n - CONVENIENCE for interactive use\n - COMPATIBILTY WITH V2\n - NOT RECOMMENDED TO USE repeatedly (batched using promise)\n */\n\n _addCue(key, interval, data, options) {\n let cue = {key:key, interval:interval, data:data};\n cue = cue_check(cue);\n return this.update(cue, options);\n }\n\n _removeCue(key, options) {\n return this.update({key:key}, options);\n }\n\n /***************************************************************\n UPDATE\n\n - insert, replace or delete cues\n\n update(cues, equals, check)\n\n ordered list of cues to be updated\n - equality function for data objects\n\n cue = {\n key:key,\n interval: Interval,\n data: data\n }\n\n required\n - cue.key property is defined and value is != undefined\n - if cue.interval != undefined, it must be instance of Interval\n\n EXAMPLES\n\n // INSERT (no pre-existing cue)\n\n cue = {key:1, interval: new Interval(3,4), data: {}}\n // insert cue with only interval\n cue = {key:1, interval: new Interval(3,4)}\n // insert cue with only data\n cue = {key:1, data: {}}\n\n\n // REPLACE (pre-existing cue)\n preexisting_cue = {key:1, interval: new Interval(3,4), data: {}}\n\n cue = {key:1, interval: new Interval(3,5), data: {foo:\"bar\"}}\n // replace interval, keep data\n cue = {key:1, interval: new Interval(3,5)}\n // replace interval, delete data\n cue = {key:1, interval: new Interval(3,5), data: undefined\n // replace data, keep interval\n cue = {key:1, data: {foo:\"bar\"}}\n // replace data, delete interval\n cue = {key:1, interval: undefined, data: {foo:\"bar\"}}\n\n // DELETE (pre-existing)\n cue = {key:1}\n // delete interval, keep data\n cue = {key:1, interval: undefined}\n // delete data, keep interval\n cue = {key:1, data: undefined}\n\n\n Update returns a list of event items - describes the effects of an update.\n {\n new: new_cue,\n old: old_cue,\n delta: {\n interval: Delta,\n data: Delta\n }\n }\n\n with independent delta values for interval and data:\n Delta.NOOP: 0\n Delta.INSERT: 1\n Delta.REPLACE: 2\n Delta.DELETE: 3\n\n Duplicates\n - if there are multiple cue operations for the same key,\n within the same batch of cues,\n these will be processed in order.\n\n - The old cue will always be the state of the cue,\n before the batch started.\n\n - The returned delta values will be calcultated relative to\n the cue before the batch started (old).\n\n This way, external mirroring observers may will be able to\n replicate the effects of the update operation.\n\n ***************************************************************/\n\n\n\n\n update(cues, options = {}) {\n const batchMap = new Map();\n let current_cue;\n let has_interval, has_data;\n\n // options\n let {debug=false, equals, check_needed=true} = options;\n\n // support single cue arg for convenience\n if (!utils.isIterable(cues)) {\n cues = [cues];\n }\n\n /***********************************************************\n process all cues\n ***********************************************************/\n const epoch_ts = epoch();\n const info = {\n ts: epoch_ts,\n author: options.author\n };\n\n for (let cue of cues) {\n\n /*******************************************************\n check validity of cue argument\n *******************************************************/\n if (check_needed) {\n try {\n cue = cue_check(cue)\n } catch (err) {\n console.log(err, cue)\n continue;\n }\n }\n has_interval = cue.hasOwnProperty(\"interval\");\n has_data = cue.hasOwnProperty(\"data\");\n\n /*******************************************************\n adjust cue so that it correctly represents\n the new cue to replace the current cue\n - includes preservation of values from current cue\n *******************************************************/\n\n current_cue = this._map.get(cue.key);\n if (current_cue == undefined) {\n // make sure properties are defined\n if (!has_interval) {\n cue.interval = undefined;\n }\n if (!has_data) {\n cue.data = undefined;\n }\n } else if (current_cue != undefined) {\n if (!has_interval && !has_data) {\n // make sure properties are defined\n cue.interval = undefined;\n cue.data = undefined;\n } else if (!has_data) {\n // REPLACE_INTERVAL, preserve data\n cue.data = current_cue.data;\n } else if (!has_interval) {\n // REPLACE_DATA, preserve interval\n cue.interval = current_cue.interval;\n } else {\n // REPLACE CUE\n }\n }\n\n /*******************************************************\n update cue\n - update _map\n - update cueBuckets\n - create batchMap\n *******************************************************/\n this._update_cue(batchMap, current_cue, cue, info, options);\n }\n\n // flush all buckets so updates take effect\n this._call_buckets(\"flush\");\n\n if (batchMap.size > 0) {\n\n /*\n create events without delta property\n and accumulate relevance interval for batch\n */\n let relevance = {low: Infinity, high: -Infinity};\n\n // create list of events and remove delta property\n let items = [...batchMap.values()].map(item => {\n if (item.new && item.new.interval) {\n relevance.low = endpoint.min(relevance.low, item.new.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.new.interval.endpointHigh);\n }\n if (item.old && item.old.interval) {\n relevance.low = endpoint.min(relevance.low, item.old.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.old.interval.endpointHigh);\n }\n return {key:item.key, new:item.new, old:item.old, info: item.info};\n });\n\n // extra filter items to remove NOOP transitions\n let event_items = items.filter((item) => {\n let delta = cue_delta(item.new, item.old, equals);\n return (delta.interval != Delta.NOOP || delta.data != Delta.NOOP);\n });\n\n // event notification\n this._notifyEvents(event_items);\n\n // create relevance Interval\n let relevanceInterval = undefined;\n if (relevance.low != Infinity) {\n relevanceInterval = Interval.fromEndpoints(relevance.low, relevance.high);\n }\n\n /*\n notify sequencer last so that change event\n from the dataset will be applied before change\n events from sequencers.\n */\n this._notify_callbacks(batchMap, relevanceInterval);\n \n // debug\n if (debug) {this.integrity();}\n return items;\n }\n // debug\n if (debug) {this.integrity();}\n return [];\n };\n\n\n\n /***************************************************************\n UPDATE CUE\n\n update operation for a single cue\n\n - update _map\n - generate entry for batchMap\n - update CueBucket\n ***************************************************************/\n\n _update_cue(batchMap, current_cue, cue, info, options) {\n\n let old_cue, new_cue;\n let item, _item;\n let oldCueBucket, newCueBucket;\n let low_changed, high_changed;\n let remove_needed, add_needed;\n\n // options\n let {chaining=true, safe=false, equals} = options;\n \n if (current_cue === cue) {\n throw Error(\"illegal cue arg: same object as current cue\");\n }\n\n // check for equality\n let delta = cue_delta(current_cue, cue, equals);\n\n // (NOOP, NOOP)\n if (delta.interval == Delta.NOOP && delta.data == Delta.NOOP) {\n item = {\n key:cue.key, new:current_cue,\n old:current_cue, delta: delta\n }\n batchMap.set(cue.key, item);\n return;\n }\n\n\n /***********************************************************\n update _map and batchMap\n ***********************************************************/\n\n if (current_cue == undefined) {\n // INSERT - add cue object to _map\n\n // cue info: add if missing\n if (cue.info == undefined) {\n cue.info = {\n ts: info.ts,\n change_ts: info.ts,\n change_id: 0\n }\n }\n\n old_cue = undefined;\n new_cue = (safe)? Object.freeze(cue) : cue;\n this._map.set(cue.key, new_cue);\n\n\n } else if (cue.interval == undefined && cue.data == undefined) {\n // DELETE - remove cue object from _map\n old_cue = current_cue;\n new_cue = undefined;\n this._map.delete(cue.key);\n\n // cue info: noop\n\n } else {\n // REPLACE\n\n // cue info - update if missing\n // preserve ts from current cue, update update_ts\n if (cue.info == undefined) {\n cue.info = {\n ts: current_cue.info.ts,\n change_ts: info.ts,\n change_id: current_cue.info.change_id + 1\n };\n }\n\n /*\n Solution used to be in-place modification\n of current cue.\n Now we instead implement replace by inserting\n a new cue object as current cue.\n Since current cue is referenced both in\n _map and in pointMap - it must be replaced both\n places.\n\n Adjustments to pointMap as a result of interval\n changes are handled further down\n\n Another design option would be to let point map\n manage only keys of cues. This however would \n impose an extra map lookup per item in lookup - \n so better to pay this modest price in update\n */\n old_cue = current_cue;\n new_cue = {\n key: cue.key,\n interval: cue.interval,\n data: cue.data,\n info: cue.info\n }\n\n if (safe) {\n new_cue = Object.freeze(new_cue);\n }\n\n // replace in cue map\n this._map.set(cue.key, new_cue);\n\n // replace in point map\n // - only necessary if old cue is in pointMap\n // i.e. if old_cue has interval\n if (old_cue.interval) {\n let bid = getCueBucketId(old_cue.interval.length);\n let cueBucket = this._cueBuckets.get(bid);\n // replace for low\n cueBucket.replace_endpoint(old_cue.interval.low, new_cue);\n // replace for high\n if (!old_cue.singular) {\n cueBucket.replace_endpoint(old_cue.interval.high, new_cue);\n }\n }\n }\n item = {key:cue.key, new:new_cue, old:old_cue, delta:delta, info};\n\n /*\n if this item has been set earlier in batchMap\n restore the correct old_cue by getting it from\n the previous batchMap item\n\n recalculate delta relative to old_cue\n - continue processing with the original (delta, old_cue) defined\n above, as this is required to correctly change cueBuckets\n which have already been affected by previous item.\n */\n if (chaining) {\n _item = batchMap.get(cue.key);\n if (_item != undefined) {\n item.old = _item.old;\n item.delta = cue_delta(new_cue, item.old, equals);\n }\n }\n\n batchMap.set(cue.key, item)\n\n //console.log(\"OLD:\", cue_to_string(old_cue));\n //console.log(\"NEW:\", cue_to_string(new_cue));\n\n /***********************************************************\n update cueBuckets\n\n - use delta.interval to avoid unnessesary changes\n\n - interval may change in several ways:\n - low changed\n - high changed\n - low and high changed\n - changed intervals may stay in bucket or change bucket:\n - changing to/from singular may require special consideration\n with respect to how many endpoints are being updated\n - singular -> singular\n - singular -> regular\n - regular -> singular\n - regular -> regular\n - changes to interval.lowInclude and interval highInclude\n do not require any changes to CueBuckets, as long\n as interval.low and interval.high values stay unchanged.\n ***********************************************************/\n\n if (delta.interval == Delta.NOOP) {\n // no changes to interval - no change needed in pointMap \n return;\n } else if (delta.interval == Delta.INSERT) {\n remove_needed = false;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.DELETE) {\n remove_needed = true;\n add_needed = false;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.REPLACE) {\n remove_needed = true;\n add_needed = true;\n low_changed = new_cue.interval.low != old_cue.interval.low;\n high_changed = new_cue.interval.high != old_cue.interval.high;\n }\n\n /*\n old cue and new cue might not belong to the same cue bucket\n */\n if (remove_needed){\n let old_bid = getCueBucketId(old_cue.interval.length);\n oldCueBucket = this._cueBuckets.get(old_bid);\n }\n if (add_needed) {\n let new_bid = getCueBucketId(new_cue.interval.length);\n newCueBucket = this._cueBuckets.get(new_bid);\n }\n\n /*\n if old CueBucket is different from the new cue Buckets\n both low and high must be moved, even it one was not\n changed\n */\n if (oldCueBucket && newCueBucket) {\n if (oldCueBucket != newCueBucket) {\n remove_needed = true;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n }\n }\n\n /*\n dispatch add and remove operations for interval points\n\n cues in CueBucket may be removed using a copy of the cue,\n because remove is by key.\n\n cues added to CueBucket must be the correct object\n (current_cue), so that later in-place modifications become\n reflected in CueBucket.\n */\n\n // update low point - if changed\n if (low_changed) {\n if (remove_needed) {\n oldCueBucket.del_endpoint(old_cue.interval.low, old_cue);\n }\n if (add_needed) {\n newCueBucket.add_endpoint(new_cue.interval.low, new_cue);\n }\n }\n // update high point - if changed\n if (high_changed) {\n if (remove_needed && !old_cue.interval.singular) {\n oldCueBucket.del_endpoint(old_cue.interval.high, old_cue);\n }\n if (add_needed && !new_cue.interval.singular) {\n newCueBucket.add_endpoint(new_cue.interval.high, new_cue);\n }\n }\n }\n\n\n /*\n INTERNAL FUNCTION\n execute method across all cue buckets\n and aggregate results\n */\n _call_buckets(method, ...args) {\n const arrays = [];\n for (let cueBucket of this._cueBuckets.values()) {\n let cues = cueBucket[method](...args);\n if (cues != undefined && cues.length > 0) {\n arrays.push(cues);\n }\n }\n return utils.array_concat(arrays);\n };\n\n\n /*\n LOOKUP ENDPOINTS\n\n returns (endpoint, cue) for all endpoints covered by given interval\n\n returns:\n - [{endpoint: endpoint, cue:cue}]\n */\n\n lookup_endpoints(interval) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup_endpoints\", interval);\n };\n\n\n /*\n LOOKUP\n */\n\n lookup(interval, mask) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup\", interval, mask);\n };\n\n\n /*\n REMOVE CUES BY INTERVAL\n */\n lookup_delete(interval, mask, options={}) {\n interval = asInterval(interval);\n const cues = this._call_buckets(\"lookup_delete\", interval, mask);\n // remove from _map and make event items\n const items = [];\n const info = {\n ts: epoch(),\n author: options.author\n };\n let cue;\n for (let i=0; i cue.interval == undefined);\n\n let count_buckets = cues.length;\n let count_no_interval = no_interval_cues.length;\n let count_map = this._map.size;\n let diff = count_map - count_buckets - count_no_interval;\n if (diff != 0) {\n console.log(\"count buckets\", count_buckets);\n console.log(\"count no intervals\", count_no_interval);\n console.log(\"count map\", count_map);\n console.log(\"count diff\", diff);\n throw new Error(\"inconsistent cue count\");\n }\n\n // check that cue maps are non overlapping\n let bucket_map = new Map(cues.map(cue => [cue.key, cue]));\n let map_map = new Map([...this._map.entries()].filter(([key, cue]) => {\n return (cue.interval != undefined);\n }));\n\n let missing = utils.map_difference(bucket_map, map_map);\n if (missing.size > 0) {\n console.log(\"buckets missing cues:\")\n console.log([...missing.keys()])\n throw new Error(`buckets missing cues: ${[...missing.keys()]}`);\n }\n \n missing = utils.map_difference(map_map, bucket_map);\n if (missing.size > 0) {\n throw new Error(`buckets too many cues: ${[...missing.keys()]}`);\n }\n\n return {\n cues: cues.length,\n points: points.length\n };\n };\n\n}\n\n\nDataset.Delta = Delta;\nDataset.cue_delta = cue_delta;\nDataset.cue_equals = cue_equals;\n\n\n/*\n CueBucket is a bucket of cues limited to specific length\n*/\n\n\nclass CueBucket {\n\n\n constructor(maxLength) {\n\n // max length of cues in this bucket\n this._maxLength = maxLength;\n\n /*\n pointMap maintains the associations between values (points on\n the timeline) and cues that reference such points. A single point value may be\n referenced by multiple cues, so one point value maps to a list of cues.\n\n value -> [cue, ....]\n */\n this._pointMap = new Map();\n\n\n /*\n pointIndex maintains a sorted list of numbers for efficient lookup.\n A large volume of insert and remove operations may be problematic\n with respect to performance, so the implementation seeks to\n do a single bulk update on this structure, for each batch of cue\n operations (i.e. each invocations of addCues). In order to do this\n all cue operations are processed to calculate a single batch\n of deletes and a single batch of inserts which then will be applied to\n the pointIndex in one atomic operation.\n\n [1.2, 3, 4, 8.1, ....]\n */\n this._pointIndex = new BinarySearch();\n\n // bookeeping during batch processing\n this._created = new Set(); // point\n this._dirty = new Set(); // point\n\n };\n\n\n /*\n\n ENDPOINT BATCH PROCESSING\n\n Needs to translate endpoint operations into a minimum set of\n operations on the pointIndex.\n\n To do this, we need to record points that are created and\n points that are removed.\n\n The total difference that the batch of cue operations\n amounts to is expressed as one list of values to be\n deleted, and and one list of values to be inserted.\n The update operation of the pointIndex will process both\n in one atomic operation.\n\n On flush both the pointMap and the pointIndex will be brought\n up to speed\n\n created and dirty are used for bookeeping during\n processing of a cue batch. They are needed to\n create the correct diff operation to be applied on pointIndex.\n\n created : includes values that were not in pointMap\n before current batch was processed\n\n dirty : includes values that were in pointMap\n before current batch was processed, and that\n have been become empty at least at one point during cue\n processing.\n\n created and dirty are used as temporary alternatives to pointMap.\n after the cue processing, pointmap will updated based on the\n contents of these two.\n\n process buffers operations for pointMap and index so that\n all operations may be applied in one batch. This happens in flush\n */\n\n add_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues == undefined) {\n this._pointMap.set(point, [cue]);\n this._created.add(point);\n } else {\n cues.push(cue);\n //addCueToArray(cues, cue);\n }\n }\n\n del_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let empty = removeCueFromArray(cues, cue);\n if (empty) {\n this._dirty.add(point);\n }\n }\n };\n\n /* \n in case of data update without touching the interval\n the new cue needs to be insert in place of the old\n */\n replace_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let ok = replaceCueInArray (cues, cue);\n if (!ok) {\n console.log(\"WARNING: attempt to replace non-existent cue in pointMap\")\n }\n }\n }\n\n\n /*\n Batch processing is completed\n Commit changes to pointIndex and pointMap.\n\n pointMap\n - update with contents of created\n\n pointIndex\n - points to delete - dirty and empty\n - points to insert - created and non-empty\n\n it is possible that a cue ends up in both created and dirty\n\n */\n flush() {\n if (this._created.size == 0 && this._dirty.size == 0) {\n return;\n }\n\n // update pointIndex\n let to_remove = [];\n let to_insert = [];\n for (let point of this._created.values()) {\n let cues = this._pointMap.get(point);\n if (cues.length > 0) {\n to_insert.push(point);\n } else {\n this._pointMap.delete(point);\n }\n }\n for (let point of this._dirty.values()) {\n let cues = this._pointMap.get(point);\n if (cues == undefined) {\n // point already deleted from created set - ignore\n continue;\n }\n if (cues.length == 0) {\n to_remove.push(point);\n this._pointMap.delete(point);\n }\n }\n this._pointIndex.update(to_remove, to_insert);\n // cleanup\n this._created.clear();\n this._dirty.clear();\n };\n\n\n /*\n LOOKUP_ENDPOINTS\n\n returns all (endpoint, cue) pairs where\n - endpoint is a cue endpoint (cue.endpointLow or cue.endpointHigh)\n - endpoint is INSIDE search interval\n - [{endpoint:endpoint, cue: cue}]\n\n - a given endpoint may appear multiple times in the result,\n as multiple cues may be tied to the same endpoint\n - a given cue may appear two times in the result, if\n both cue.endpointLow and cue.endpointHigh are both INSIDE interval\n - a singular cue will appear only once\n - ordering: no specific order is guaranteed\n - results are concatenated from multiple CueBuckets\n - internally in a single CueBucket\n - no defined order for cues tied to the same endpoint\n - the natural order is endpoint order\n - but this can be added on the outside if needed\n - no order is defined if two cues have exactly the\n same endpoint\n\n */\n\n lookup_endpoints(interval) {\n if (this._pointMap.size == 0) {\n return [];\n }\n const broader_interval = new Interval(interval.low, interval.high, true, true);\n const points = this._pointIndex.lookup(broader_interval);\n const result = [];\n const len = points.length;\n let point, _endpoint;\n for (let i=0; i this._maxLength) {\n return cues;\n }\n\n /*\n handle match with COVERS separately\n\n search left of search interval for cues\n that covers the search interval\n search left is limited by CueBucket maxlength\n left_interval: [interval.high-maxLength, interval.low]\n\n it would be possible to search right too, but we\n have to choose one.\n */\n if (mask & Relation.COVERS) {\n\n let left_interval;\n if (this._maxLength == Infinity) {\n // no limitation on interval length\n // must search entire timeline to the left\n left_interval = new Interval(-Infinity, interval.low);\n } else {\n let low = interval.high - this._maxLength;\n let high = interval.low;\n // protect against float rounding effects creating\n // high < low by a very small margin\n [low, high] = [Math.min(low, high), Math.max(low, high)];\n left_interval = new Interval(low, high, true, true);\n }\n this._lookup_cues(left_interval)\n .forEach(function(cue){\n if (cue.interval.match(interval, Relation.COVERS)) {\n cues.push(cue);\n }\n });\n }\n\n return cues;\n }\n\n\n /*\n REMOVE CUES\n */\n lookup_delete(interval, mask) {\n /*\n update pointMap\n - remove all cues from pointMap\n - remove empty entries in pointMap\n - record points that became empty, as these need to be deleted in pointIndex\n - separate into two bucketes, inside and outside\n */\n const cues = this.lookup(interval, mask);\n const to_remove = [];\n let cue, point, points;\n for (let i=0; i 0) {\n throw new Error(`pointMap missing points: ${[...missing]}`);\n }\n \n missing = utils.set_difference(map_point_set, index_point_set);\n if (missing.size > 0) {\n throw new Error(`pointIndex missing points: ${[...missing]}`);\n }\n }\n\n /*\n invariable - pointIndex shall always be sorted and not contain duplicates\n */\n let points = [...this._pointIndex.values()];\n if (points.length != index_point_set.size) {\n throw new Error(\"pointIndex include duplicate points\");\n }\n for (let i=1; i= points[i]) {\n throw new Error(\"pointIndex not ordered\");\n } \n }\n\n /**\n * invariable - pointMap point -> cues \n * cues shall only include cues which are relevant to given point\n */\n for (let point of points) {\n let cues = this._pointMap.get(point);\n for (let cue of cues) {\n // figure out if point is endpoint low or high\n if (point == cue.interval.low) {\n continue;\n } else if (point == cue.interval.high) {\n continue;\n } else {\n console.log(\"POINT:\", point); \n console.log(\"CUE:\", cue.interval.toString());\n throw new Error(\"pointMap: wrong cue\");\n }\n } \n }\n\n\n /**\n * invariable - all endpoints from all cues from pointMap are found as points in pointMap\n */\n\n for (let _cue_list of [...this._pointMap.values()]) {\n for (let cue of _cue_list) {\n for (let p of [cue.interval.low, cue.interval.high]) {\n if (!this._pointMap.has(p)) {\n throw new Error(`cue found with low or high point not in pointMap ${p} -> ${cue.interval.toString()} `);\n }\n }\n }\n }\n\n\n /*\n invariable - all cues in pointMap with same key are same object\n */\n\n // collect all cues from pointMap\n let _cues = [];\n for (let _cue_list of this._pointMap.values()) {\n for (let cue of _cue_list) {\n _cues.push(cue);\n }\n }\n\n // remove and check duplicates\n let cueMap = new Map();\n for (let cue of _cues) {\n let _cue = cueMap.get(cue.key);\n if (_cue == undefined) {\n cueMap.set(cue.key, cue);\n } else {\n // duplicate\n if (cue !== _cue) {\n throw new Error(\"pointMap: different cue objects for same key\");\n }\n }\n }\n let cues = [...cueMap.values()];\n\n /**\n * invariable - all cues belong to this bucket\n */\n\n for (let cue of cues.values()) {\n // check that cue belongs to this bucket\n if (cue.interval.length > this._maxLength) {\n throw new Error(`cue in wrong cue bucket ${this._maxLength}, ${cue.interval.toString()}`);\n }\n }\n\n return [{\n maxLength: this._maxLength,\n points: [...this._pointMap.keys()],\n cues: cues\n }];\n };\n}\n\n// module definition\nexport default Dataset;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n - : if defined only include cues that match the interval\n - : filter by cue key\n function keep(key) returns boolena\n - : filter by cue data\n function keep(data) returns boolean\n - : change cue data\n function convert(data) returns data\n NOTE: filtering occurs BEFORE convert\n and only impacts the presentation of cues\n WARNING: it is possible to change the value\n in such a way that filtering appears incorrect\n\n This subset implementation is STATELESS\n It does not manage its own state, only implements a\n stateless frontend over its source dataset.\n\n*/\n\nclass Subset extends CueCollection {\n\n constructor(dataset, options={}) {\n super(options);\n this._key_filter = options.key_filter;\n this._data_filter = options.data_filter;\n this._interval = options.interval;\n this._data_convert = options.data_convert;\n this._size = 0;\n\n // Callbacks\n this._callbacks = [];\n\n // Source Dataset\n this._src_ds = dataset;\n let cb = this._onDatasetCallback.bind(this)\n this._src_ds_cb = this._src_ds.add_callback(cb);\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get datasource () {\n return this._src_ds;\n }\n\n get dataset () {\n return this._src_ds;\n }\n\n\n get interval () {\n return this._interval;\n }\n\n set interval (itv) {\n this._setInterval(itv);\n }\n\n\n /***************************************************************\n EVENT CALLBACKS - FOR SEQUENCERS\n ***************************************************************/\n\n add_callback (handler) {\n let handle = {\n handler: handler\n }\n this._callbacks.push(handle);\n return handle;\n };\n\n\n del_callback (handle) {\n let index = this._callbacks.indexof(handle);\n if (index > -1) {\n this._callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n\n /***************************************************************\n FILTER & CONVER\n ***************************************************************/\n\n /* \n Keep cue \n */\n\n _cue_keep(cue) {\n if (cue == undefined) {\n return false;\n }\n // check if cue matches interval\n if (this._interval) {\n if (!this._interval.match(cue.interval)) {\n return false;\n }\n }\n // check key filter\n if (this._key_filter) {\n if (!this._key_filter(cue.key)) {\n return false;\n }\n }\n // check data filter\n if (this._data_filter) {\n if (!this._data_filter(cue.data)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Convert cue\n */\n _cue_convert(cue) {\n if (cue != undefined && this._data_convert) {\n // copy\n return {\n key: cue.key,\n interval: cue.interval,\n data: this._data_convert(cue.data)\n }\n }\n return cue;\n }\n\n /**\n * Filter (and modify) event items based on key_filter and data_filter\n */\n\n _items_filter_convert(items) {\n let _items = [];\n for (let item of items) {\n if (item.new == undefined && item.old == undefined) {\n continue;\n }\n /* \n use cue filter function to check relevance of both old and new\n consider change of unrelevant cue into relevant cue.\n old cue would be non-relevant, new cue would be relevant\n Since old cue was not part of the subset before, it needs\n to be removed from the item - effectively turning the change\n operation into an add operation. \n */\n let _old = (this._cue_keep(item.old)) ? item.old : undefined;\n let _new = (this._cue_keep(item.new)) ? item.new : undefined;\n if (_old == undefined && _new == undefined) {\n continue;\n }\n // convert\n _old = this._cue_convert(_old);\n _new = this._cue_convert(_new);\n // push\n _items.push({key:item.key, new: _new, old: _old});\n }\n return _items;\n }\n\n\n /***************************************************************\n LOOKUP\n ***************************************************************/\n\n _check_interval(interval) {\n if (this._interval) {\n // subset interval\n if (interval) {\n // lookup interval - find intersection\n let intersects = Interval.intersect(interval, this._interval);\n if (intersects.length == 0) {\n console.log(`warning - lookup interval ${interval.toString()} outside the subset interval ${this._interval.toString()}`);\n return [];\n } else {\n interval = intersects[0];\n }\n } else {\n // no lookup interval - use subset interval \n interval = this._interval;\n }\n }\n return interval;\n }\n\n /** \n * lookup cues\n */\n\n lookup(interval, mask) {\n let _interval = this._check_interval(interval);\n let cues;\n if (_interval) {\n cues = this.datasource.lookup(_interval, mask);\n } else {\n cues = [...this.datasource.values()];\n }\n // filter & convert cues\n return cues.filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n }\n\n /* \n lookup endpoints\n used by sequencers\n */\n\n lookup_endpoints(interval) {\n let _interval = this._check_interval(interval);\n let items = this.datasource.lookup_endpoints(_interval);\n // filter and convert\n return items.filter((item) => {\n return this._cue_keep(item.cue);\n }, this).map((item) => {\n return {endpoint: item.endpoint, cue: this._cue_convert(item.cue)};\n }, this);\n }\n\n /***************************************************************\n INITIAL STATE\n ***************************************************************/\n\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n // find cues\n let cues = this.lookup();\n // make event items\n let items = cues.map((cue) => {\n return {key:cue.key, new:cue, old:undefined};\n });\n // sort\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /***************************************************************\n DATASET CALLBACK\n ***************************************************************/\n\n _onDatasetCallback(eventMap, relevanceInterval) {\n let items = [...eventMap.values()];\n items = this._items_filter_convert(items);\n // update size\n for (let item of items) {\n if (item.new != undefined && item.old == undefined) {\n // add\n this._size += 1;\n } else if (item.new == undefined && item.old != undefined) {\n // remove\n this._size -= 1;\n } \n } \n // forward as events\n super._notifyEvents(items);\n // forward as callbacks\n let batchMap = new Map(items.map((item) => {\n return [item.key, item];\n }));\n if (this._interval) {\n relevanceInterval = Interval.intersect(this._inverval, relevanceInterval);\n }\n this._notify_callbacks(batchMap, relevanceInterval);\n }\n\n\n /***************************************************************\n SET INTERVAL\n ***************************************************************/\n\n _setInterval (itv) {\n if (!itv instanceof Interval) {\n throw new Error(\"must be interval\", itv.toString());\n }\n if (!this._interval || !this._interval.equals(itv)) {\n // current cues (before interval update)\n let current_cues = this.lookup();\n // update interval\n this._interval = itv;\n // cues (after interval update)\n let new_cues = this.datasource.lookup(itv);\n // filter & convert cues\n new_cues = new_cues\n .filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n // switch to map representation\n let currentCueMap = new Map([...current_cues].map((cue) => {\n return [cue.key, cue];\n }));\n let newCueMap = new Map([...new_cues].map((cue) => {\n return [cue.key, cue];\n }));\n // exit and enter cues\n let exitCueMap = map_difference(currentCueMap, newCueMap);\n let enterCueMap = map_difference(newCueMap, currentCueMap);\n // make list of event items\n let exitItems = [...exitCueMap.values()].map((cue) => {\n return {key: cue.key, new:undefined, old: cue}\n });\n let enterItems = [...enterCueMap.values()].map((cue) => {\n return {key: cue.key, new:cue, old: undefined}\n });\n // update size\n this._size -= exitItems.length;\n this._size += enterItems.length; \n // event notification\n const items = array_concat([exitItems, enterItems], {copy:false, order:true});\n this._notifyEvents(items);\n }\n }\n\n /***************************************************************\n MAP ACCESSORS\n ***************************************************************/\n\n get size () {\n return this._size;\n }\n\n has(key) {\n return (this.get(key) != undefined);\n };\n\n get(key) {\n let cue = super.get(key);\n if (cue != undefined && this._cue_keep(cue)) {\n return this._cue_convert(cue);\n }\n };\n\n keys() {\n return this.values().map((cue => {\n return cue.key;\n }));\n };\n\n values() {\n return [...super.values()]\n .filter((cue) => {\n return this._cue_keep(cue);\n }, this)\n .map((cue) => {\n return this._cue_convert(cue);\n }, this);\n };\n\n entries() {\n return this.values().map((cue) => {\n return [cue.key, cue];\n });\n };\n\n\n /***************************************************************\n MAP MODIFICATION METHODS\n ***************************************************************/\n\n update(cues, options) {\n throw new Error(\"not implemented\");\n }\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n clear (key) {\n throw new Error(\"not implemented\");\n }\n\n}\n\n// module definition\nexport default Subset;","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see 0&&(e.splice(c-1,2),c-=2)}}e=e.join("/")}else e.indexOf("./")===0&&(e=e.substring(2));if((v||g)&&m){n=e.split("/");for(c=n.length;c>0;c-=1){r=n.slice(0,c).join("/");if(v)for(h=v.length;h>0;h-=1){i=m[v.slice(0,h).join("/")];if(i){i=i[r];if(i){s=i,u=c;break}}}if(s)break;!a&&g&&g[r]&&(a=g[r],f=c)}!s&&a&&(s=a,u=f),s&&(n.splice(0,u,s),e=n.join("/"))}return e}function g(e,t){return function(){var n=p.call(arguments,0);return typeof n[0]!="string"&&n.length===1&&n.push(null),s.apply(r,n.concat([e,t]))}}function y(e){return function(t){return m(t,e)}}function b(e){return function(t){a[e]=t}}function w(e){if(v(f,e)){var t=f[e];delete f[e],c[e]=!0,i.apply(r,t)}if(!v(a,e)&&!v(c,e))throw new Error("No "+e);return a[e]}function E(e){var t,n=e?e.indexOf("!"):-1;return n>-1&&(t=e.substring(0,n),e=e.substring(n+1,e.length)),[t,e]}function S(e){return function(){return l&&l.config&&l.config[e]||{}}}var i,s,o,u,a={},f={},l={},c={},h=Object.prototype.hasOwnProperty,p=[].slice,d=/\.js$/;o=function(e,t){var n,r=E(e),i=r[0];return e=r[1],i&&(i=m(i,t),n=w(i)),i?n&&n.normalize?e=n.normalize(e,y(t)):e=m(e,t):(e=m(e,t),r=E(e),i=r[0],e=r[1],i&&(n=w(i))),{f:i?i+"!"+e:e,n:e,pr:i,p:n}},u={require:function(e){return g(e)},exports:function(e){var t=a[e];return typeof t!="undefined"?t:a[e]={}},module:function(e){return{id:e,uri:"",exports:a[e],config:S(e)}}},i=function(e,t,n,i){var s,l,h,p,d,m=[],y=typeof n,E;i=i||e;if(y==="undefined"||y==="function"){t=!t.length&&n.length?["require","exports","module"]:t;for(d=0;d0?n[0]:-1},t.prototype.getItem=function(e){return this._map[e]},t.prototype.register=function(e,t){var n=this._getID(e);if(n>-1)throw new Error("handler already registered");return n=this._newID(),this._map[n]={ID:n,handler:e,ctx:t,count:0,pending:!1},n},t.prototype.unregister=function(e){var t=this._getID(e);t!==-1&&delete this._map[t]},t.prototype.getItems=function(){return Object.keys(this._map).map(function(e){return this.getItem(e)},this)};var n=function(n,r){return n._ID=e(4),n._callbacks={},n._callbacks.events=new t,n._callbacks.events._options={init:!0},r.eventifyDefineEvent=function(e,n){if(e==="events")throw new Error("Illegal event type : 'events' is protected");n=n||{},n.init=n.init===undefined?!1:n.init,this._callbacks[e]=new t,this._callbacks[e]._options=n},r._eventifyMakeInitEvents=function(e){var t=this.eventifyMakeInitEvents||function(e){return[]},n;return e!=="events"?n=[e]:n=Object.keys(this._callbacks).filter(function(e){return e!=="events"&&this._callbacks[e]._options.init===!0},this),n.concatMap(function(e){return t.call(this,e)},this)},r._eventifyEventFormatter=function(e,t){var n=this.eventifyEventFormatter||function(e,t){return t};return e==="events"&&(t=t.map(function(e){return n.call(this,e.type,e.e)})),n(e,t)},r._eventifyCallbackFormatter=function(e,t,n){var r=this.eventifyCallbackFormatter||function(e,t,n){return[t]};return r.call(this,e,t,n)},r.eventifyTriggerEvents=function(e){e.forEach(function(e){if(e.type===undefined)throw new Error("Illegal event type; undefined");if(e.type==="events")throw new Error("Illegal event type; triggering of events on protocted event type 'events'")},this);if(e.length===0)return;return this._eventifyTriggerProtectedEvents(e),this._eventifyTriggerRegularEvents(e),this},r.eventifyTriggerEvent=function(e,t){return this.eventifyTriggerEvents([{type:e,e:t}])},r._eventifyTriggerProtectedEvents=function(e,t){this._eventifyTriggerEvent("events",{type:"events",e:e},t)},r._eventifyTriggerRegularEvents=function(e,t){e.forEach(function(e){this._eventifyTriggerEvent(e.type,e,t)},this)},r._eventifyTriggerEvent=function(e,t,n){var r,i,s={};if(!this._callbacks.hasOwnProperty(e))throw new Error("Unsupported event type "+e);var o=this._callbacks[e],u=o._options.init;return o.getItems().forEach(function(o){if(n===undefined){if(o.pending)return!1}else{if(o.ID!==n)return!1;s.init=!0,o.pending=!1}u&&(s.init=o.ID===n?!0:!1),s.count=o.count,s.src=this,i=this._eventifyEventFormatter(t.type,t.e),r=this._eventifyCallbackFormatter(e,i,s);try{return o.handler.apply(o.ctx,r),o.count+=1,!0}catch(a){console.log("Error in "+e+": "+o.handler+" "+o.ctx+": ",a)}},this),!1},r.on=function(e,t,n){if(!t||typeof t!="function")throw new Error("Illegal handler");if(!this._callbacks.hasOwnProperty(e))throw new Error("Unsupported event type "+e);var r=this._callbacks[e];n=n||this;var i=r.register(t,n);if(r._options.init){var s=r.getItem(i);s.pending=!0;var o=this;setTimeout(function(){var t=o._eventifyMakeInitEvents(e);t.length>0?e==="events"?o._eventifyTriggerProtectedEvents(t,i):o._eventifyTriggerRegularEvents(t,i):s.pending=!1},0)}return this},r.off=function(e,t){if(this._callbacks[e]!==undefined){var n=this._callbacks[e];n.unregister(t)}return this},n};return{eventify:n}}),n("util/motionutils",[],function(){"use strict";var e=function(e,t){if(t===undefined)throw new Error("no ts provided for calculateVector");var n=t-e.timestamp;return{position:e.position+e.velocity*n+.5*e.acceleration*n*n,velocity:e.velocity+e.acceleration*n,acceleration:e.acceleration,timestamp:t}},t=Object.freeze({INIT:"init",INSIDE:"inside",OUTSIDE_LOW:"outsidelow",OUTSIDE_HIGH:"outsidehigh"}),n=function(e,n){var r=e.position,i=e.velocity,s=e.acceleration;if(r>n[1])return t.OUTSIDE_HIGH;if(r0)return t.OUTSIDE_HIGH;if(i===0&&s>0)return t.OUTSIDE_HIGH}else if(r===n[0]){if(i<0)return t.OUTSIDE_LOW;if(i==0&&s<0)return t.OUTSIDE_HIGH}return t.INSIDE},r=function(e,r){var i=n(e,r);return i!==t.INSIDE&&(e.velocity=0,e.acceleration=0,i===t.OUTSIDE_HIGH?e.position=r[1]:e.position=r[0]),e},i=function(e,t){if(e>t)return 1;if(e===t)return 0;if(e=0?!0:!1},u=function(e,t,n,r){if(n===0&&t===0)return e!=r?[]:[0];if(n===0)return[(r-e)/t];if(o(e,t,n,r)===!1)return[];var i=t*t-2*n*(e-r);if(i===0)return[-t/n];var s=Math.sqrt(Math.pow(t,2)-2*n*(e-r)),u=(-t+s)/n,a=(-t-s)/n;return[Math.min(u,a),Math.max(u,a)]},a=function(e,t,n,r){var i=u(e,t,n,r);return i.length===0?[]:i.length==1?i[0]>0?[i[0]]:[]:i.length==2?i[1]<0?[]:i[0]>0?[i[0],i[1]]:i[1]>0?[i[1]]:[]:[]},f=function(e,t){var n=e.position,r=e.velocity,i=e.acceleration,s=a(n,r,i,t);return s.length===0?null:s[0]},l=function(e,t){var n=f(e,t[0]),r=f(e,t[1]);return n!==null&&r!==null?n0?[u,Math.max(n,s)]:[Math.min(n,s),u]}}return[Math.min(n,s),Math.max(n,s)]};return{calculateVector:e,calculateDirection:s,calculateMinPositiveRealSolution:f,calculateDelta:l,calculateInterval:p,calculateSolutionsInInterval:h,getCorrectRangeState:n,checkRange:r,RangeState:t}}),n("timingobject/timingbase",["util/eventutils","util/motionutils"],function(e,t){"use strict";var n=function(e,t){var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.uber=t.prototype,e.prototype.constructor=e},r=function(t){this._version=3,this._options=t||{},this._options.hasOwnProperty("timeout")||(this._options.timeout=!1),this._vector=null,this._range=null,this._timeout=null,this._tid=null,this._ready=!1,e.eventify(this,r.prototype),this.eventifyDefineEvent("ready",{init:!0}),this.eventifyDefineEvent("change",{init:!0}),this.eventifyDefineEvent("timeupdate",{init:!0})};Object.defineProperty(r.prototype,"version",{get:function(){return this._version}}),Object.defineProperty(r.prototype,"range",{get:function(){return this._range===null?null:[this._range[0],this._range[1]]}}),Object.defineProperty(r.prototype,"vector",{get:function(){return this._vector===null?null:{position:this._vector.position,velocity:this._vector.velocity,acceleration:this._vector.acceleration,timestamp:this._vector.timestamp}}}),Object.defineProperty(r.prototype,"ready",{get:function(){return this._ready}}),Object.defineProperty(r.prototype,"readyPromise",{get:function(){var e=this;return new Promise(function(t,n){if(e._ready)t();else{var r=function(){e.off("ready",r),t()};e.on("ready",r)}})}}),Object.defineProperty(r.prototype,"pos",{get:function(){return this.query().position}}),Object.defineProperty(r.prototype,"vel",{get:function(){return this.query().velocity}}),Object.defineProperty(r.prototype,"acc",{get:function(){return this.query().acceleration}}),r.prototype.eventifyMakeInitEvents=function(e){return e==="change"?this._ready?[{type:e,e:undefined}]:[]:e==="timeupdate"?this._ready?[{type:e,e:undefined}]:[]:e==="ready"?this._ready?[{type:e,e:undefined}]:[]:[]},r.prototype.query=function(){return this.vector===null?{position:undefined,velocity:undefined,acceleration:undefined}:t.calculateVector(this.vector,this.clock.now())},r.prototype.update=function(e){},r.prototype._getRange=function(){return null},r.prototype._preProcess=function(e){this._range===null&&(this._range=this._getRange());var e=this._onChange(e);this._process(e)},r.prototype._onChange=function(e){return e},r.prototype._renewTimeout=function(){if(this._options.timeout===!0){this._clearTimeout();var e=this._calculateTimeoutVector();if(e===null)return;var t=this.clock.now(),n=e.timestamp-t,r=this;this._timeout=this.clock.setTimeout(function(){r._process(r._onTimeout(e))},n,{anchor:t,early:.005})}},r.prototype._calculateTimeoutVector=function(){return null},r.prototype._clearTimeout=function(){this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)},r.prototype._onTimeout=function(e){return e},r.prototype._process=function(e){if(e!==null){var t=this._vector;this._vector=e,t===null&&(this._ready=!0,this.eventifyTriggerEvent("ready")),this._postProcess(this.vector)}this._renewTimeout()},r.prototype._postProcess=function(e){this.eventifyTriggerEvent("change"),this.eventifyTriggerEvent("timeupdate");var t=e.velocity!==0||e.acceleration!==0;if(t&&this._tid===null){var n=this;this._tid=setInterval(function(){n.eventifyTriggerEvent("timeupdate")},200)}else!t&&this._tid!==null&&(clearTimeout(this._tid),this._tid=null)};var i=function(e,t){r.call(this,t),this._timingsrc=null;var n=this;this._internalOnChange=function(){var e=n.timingsrc.vector;n._preProcess(e)},this.timingsrc=e};return n(i,r),Object.defineProperty(i.prototype,"clock",{get:function(){return this.timingsrc.clock}}),Object.defineProperty(i.prototype,"timingsrc",{get:function(){return this._timingsrc},set:function(e){this._timingsrc&&this._timingsrc.off("change",this._internalOnChange,this),this._range=null,this._vector=null,this._clearTimeout(),clearTimeout(this._tid),this._timingsrc=e,this._timingsrc.on("change",this._internalOnChange,this)}}),i.prototype.update=function(e){return this.timingsrc.update(e)},i.prototype._getRange=function(){return this.timingsrc.range},{TimingBase:r,ConverterBase:i,inherit:n,motionutils:t}}),n("timingobject/skewconverter",["./timingbase"],function(e){"use strict";var t=e.ConverterBase,n=e.inherit,r=function(e,n){this._skew=n,t.call(this,e)};return n(r,t),r.prototype._getRange=function(){var e=this.timingsrc.range;return e[0]=e[0]===-Infinity?e[0]:e[0]+this._skew,e[1]=e[1]===Infinity?e[1]:e[1]+this._skew,e},r.prototype._onChange=function(e){return e.position+=this._skew,e},r.prototype.update=function(e){return e.position!==undefined&&e.position!==null&&(e.position=e.position-this._skew),this.timingsrc.update(e)},Object.defineProperty(r.prototype,"skew",{get:function(){return this._skew}}),r.prototype.setSkew=function(e){this._skew=e;var t=this.timingsrc.vector;this._preProcess(t)},r}),n("timingobject/delayconverter",["./timingbase"],function(e){"use strict";var t=e.ConverterBase,n=e.inherit,r=function(e,n){if(n<0)throw new Error("negative delay not supported");if(n===0)throw new Error("zero delay makes delayconverter pointless");t.call(this,e),this._delay=n};return n(r,t),r.prototype._onChange=function(e){var t=this.clock.now()-e.timestamp;e.timestamp+=this._delay;if(tthis._range[1])this._process(this._calculateInitialVector());else{if(!(e.position10?this._tid=setTimeout(function(){s._ontimeout()},o-3e3):this._tid=setTimeout(function(){s._ontimeout()},(o-s._options.early)*1e3)};return Object.defineProperty(e.prototype,"target",{get:function(){return this._target}}),e.prototype._ontimeout=function(){if(this._tid!==null){var e=this._target-this._clock.now();if(e<=0)this.cancel(),this._callback();else if(e>this._options.early){var t=this;this._tid=setTimeout(function(){t._ontimeout()},(e-this._options.early)*1e3)}else this._smalldelay()}},e.prototype.handleEvent=function(e){if(e.source===window&&e.data.indexOf("smalldelaymsg_")===0){e.stopPropagation();var t=parseInt(e.data.split("_")[1]);this._tid!==null&&this._tid===t&&this._ontimeout()}},e.prototype._smalldelay=function(){this._delay_counter++;var e=this;window.postMessage("smalldelaymsg_"+e._tid,"*")},e.prototype.cancel=function(){if(this._tid!==null){clearTimeout(this._tid),this._tid=null;var e=this;window.removeEventListener("message",this,!0)}},{setTimeout:function(t,n,r,i){return new e(t,n,r,i)}}}),n("util/masterclock",["./eventutils","./timeoututils"],function(e,t){"use strict";(function(){"performance"in window==0&&(window.performance={},window.performance.offset=(new Date).getTime()),"now"in window.performance==0&&(window.performance.now=function(){return(new Date).getTime()-window.performance.offset})})();var n={now:function(){return performance.now()/1e3}},r=function(e,t){t===undefined&&(t=n.now());var r=t-e.timestamp;return{position:e.position+e.velocity*r,velocity:e.velocity,timestamp:t}},i=function(t){var r=n.now();t=t||{},this._vector={position:r,velocity:1,timestamp:r},e.eventify(this,i.prototype),this.eventifyDefineEvent("change"),this.adjust(t)};return i.prototype.adjust=function(e){e=e||{};var t=n.now(),r=this.query(t);if(e.skew===undefined&&e.rate===undefined)return;this._vector={position:e.skew!==undefined?t+e.skew:r.position,velocity:e.rate!==undefined?e.rate:r.velocity,timestamp:r.timestamp},this.eventifyTriggerEvent("change")},i.prototype.now=function(){return r(this._vector,n.now()).position},i.prototype.query=function(e){return r(this._vector,e)},i.prototype.setTimeout=function(e,n,r){return t.setTimeout(this,e,n,r)},i}),n("timingobject/timingobject",["./timingbase","./timingprovider","util/masterclock"],function(e,t,n){"use strict";var r=e.motionutils,i=e.TimingBase,s=e.inherit,o=t.LocalTimingProvider,u=t.TimingProviderState,a=function(e){e=e||{},i.call(this,{timeout:!0}),this._clock=null,this._range=null,this._vector=null;var t=this;this._provider=e.provider||new o(e),this._onSkewChangeWrapper=function(){t._onSkewChange()},this._onVectorChangeWrapper=function(){t._onVectorChange()},this._onReadystateChangeWrapper=function(){t._onReadystateChange()},this._provider.on("readystatechange",this._onReadystateChangeWrapper,this),this._initialise()};return s(a,i),a.prototype._initialise=function(){if(this._provider.readyState!==u.OPEN)return;this._clock===null&&(this._range=this._provider.range,this._clock=new n({skew:this._provider.skew}),this._preProcess(this._provider.vector),this._provider.on("vectorchange",this._onVectorChangeWrapper,this),this._provider.on("skewchange",this._onSkewChangeWrapper,this))},a.prototype._onReadystateChange=function(){this._initialise()},a.prototype._onSkewChange=function(){this._clock.adjust({skew:this._provider.skew})},a.prototype._onVectorChange=function(){this._preProcess(this._provider.vector)},Object.defineProperty(a.prototype,"clock",{get:function(){return this._clock}}),Object.defineProperty(a.prototype,"provider",{get:function(){return this._provider}}),a.prototype.query=function(){if(this.vector===null)return{position:undefined,velocity:undefined,acceleration:undefined};var e=r.calculateVector(this.vector,this.clock.now()),t=r.getCorrectRangeState(e,this._range);return t!==r.RangeState.INSIDE&&this._preProcess(e),r.calculateVector(this.vector,this.clock.now())},a.prototype.update=function(e){return this._provider.update(e)},a.prototype._onChange=function(e){return r.checkRange(e,this._range)},a.prototype._calculateTimeoutVector=function(){var e=this.query(),t=r.calculateDelta(e,this.range),n=t[0];if(n===null)return null;if(n===Infinity)return null;var i=t[1],s=r.calculateVector(e,e.timestamp+n);return s.position=i,s},a.prototype._onTimeout=function(e){return r.checkRange(e,this._range)},a}),n("timingobject/main",["./timingbase","./skewconverter","./delayconverter","./scaleconverter","./loopconverter","./rangeconverter","./timeshiftconverter","./localconverter","./derivativeconverter","./timingobject","./timingprovider"],function(e,t,n,r,i,s,o,u,a,f,l){"use strict";return{inherit:e.inherit,ConverterBase:e.ConverterBase,SkewConverter:t,DelayConverter:n,ScaleConverter:r,LoopConverter:i,RangeConverter:s,TimeShiftConverter:o,LocalConverter:u,DerivativeConverter:a,TimingObject:f,TimingProviderState:l.TimingProviderState}}),n("util/interval",[],function(){"use strict";var e=function(e){var t=parseFloat(e);return e===t&&!isNaN(t)},t=function(e){this.name="IntervalError",this.message=e||""};t.prototype=Error.prototype;var n=function(n,r,i,s){var o=e(n),u=e(r);o&&r===undefined&&(r=n);if(!e(n))throw new t("low not a number");if(!e(r))throw new t("high not a number");if(n>r)throw new t("low > high");n===r&&(i=!0,s=!0),n===-Infinity&&(i=!0),r===Infinity&&(s=!0),i===undefined&&(i=!0),s===undefined&&(s=!1);if(typeof i!="boolean")throw new t("lowInclude not boolean");if(typeof s!="boolean")throw new t("highInclude not boolean");this.__defineGetter__("length",function(){return r-n}),this.__defineGetter__("low",function(){return n}),this.__defineGetter__("high",function(){return r}),this.__defineGetter__("lowInclude",function(){return i}),this.__defineGetter__("highInclude",function(){return s})};return n.prototype.toString=function(){var e=this.lowInclude?"[":"<",t=this.highInclude?"]":">",n=this.low===-Infinity?"<--":this.low.toFixed(2),r=this.high===Infinity?"-->":this.high.toFixed(2);return this.isSingular()?e+n+t:e+n+","+r+t},n.prototype.isFinite=function(){return isFinite(this.low)&&isFinite(this.high)},n.prototype.isSingular=function(){return this.low===this.high},n.prototype.coversPoint=function(e){return this.lowe.high?!1:this.low===e.high?this.coversPoint(e.high)&&e.coversPoint(this.low):!0},n.prototype.coversInterval=function(e){if(e instanceof n==0)throw new t("paramenter not instance of Interval");return e.lowe))return r;n=r-1}}return~n},r.prototype.insert=function(e){var t=this.binaryIndexOf(e);(t<0||t===0&&this.array[0]!==e)&&this.array.splice(Math.abs(t),0,e)},r.prototype.indexOf=function(e){var t=this.binaryIndexOf(e);return t<0||t===0&&this.array[0]!==e?-1:t},r.prototype.hasElement=function(e){var t=this.binaryIndexOf(e);return t<0||t===0&&this.array[0]!==e?!1:!0},r.prototype.remove=function(e){var t=this.binaryIndexOf(e);if(t<0||t===0&&this.array[0]!==e)return;this.array.splice(t,1)},r.prototype.getMinimum=function(){return this.array.length>0?this.array[0]:null},r.prototype.getMaximum=function(){return this.array.length>0?this.array[this.array.length-1]:null},r.prototype.ltIndexOf=function(e){var t=this.binaryIndexOf(e);return t=t<0?Math.abs(t)-1:t-1,t>=0?t:-1},r.prototype.leIndexOf=function(e){var t=this.binaryIndexOf(e);return t>0||t===0&&this.array[0]===e?t:(t=Math.abs(t)-1,t>=0?t:-1)},r.prototype.gtIndexOf=function(e){var t=this.binaryIndexOf(e);return t===0?this.array[0]===e&&(t=1):t=t<0?Math.abs(t):t+1,t0||t===0&&this.array[0]===e?t:(t=Math.abs(t),t-1&&(n.splice(t,1),r.push(e),n.length===0&&delete this._map[e.key]))},this),r},e.prototype.hasKey=function(e){return this._map.hasOwnProperty(e)},e.prototype.keys=function(){return Object.keys(this._map)},e.prototype.getItemsByKey=function(e){var t=[];return this.hasKey(e)&&this._map[e].forEach(function(n){t.push({key:e,value:n})}),t},e.prototype.getItemsByKeys=function(e){e===undefined&&(e=this.keys());var t=[];return e.forEach(function(e){t=t.concat(this.getItemsByKey(e))},this),t},e.prototype.list=e.prototype.getItemsByKeys,e}),n("sequencing/axis",["util/interval","./sortedarraybinary","./multimap"],function(e,t,n){"use strict";var r=function(e){this.name="AxisError",this.message=e||""};r.prototype=Error.prototype;var i=Object.freeze({NOOP:"noop",CREATE:"create",UPDATE:"update",REMOVE:"remove"}),s=Object.freeze({LOW:"low",SINGULAR:"singular",HIGH:"high",INSIDE:"inside",OUTSIDE:"outside",toInteger:function(e){if(e===s.LOW)return-1;if(e===s.HIGH)return 1;if(e===s.INSIDE)return 2;if(e===s.OUTSIDE)return 3;if(e===s.SINGULAR)return 0;throw new r("illegal string value for point type")},fromInteger:function(e){if(e===-1)return s.LOW;if(e===0)return s.SINGULAR;if(e===1)return s.HIGH;if(e===2)return s.INSIDE;if(e===3)return s.OUTSIDE;throw new r("illegal integer value for point type")}}),o=function(){this._map={},this._reverse=new n,this._index=new t,this._callbacks={change:[]}};return o.prototype._insert=function(e,t){this._map[e]=t,this._reverse.hasKey(t.low)||this._index.insert(t.low),this._reverse.hasKey(t.high)||this._index.insert(t.high),this._reverse.insert(t.low,e),this._reverse.insert(t.high,e)},o.prototype._remove=function(e){if(!this._map.hasOwnProperty(e))throw new r("attempt to remove non-existing key");var t=this._map[e];return delete this._map[e],this._reverse.remove(t.low,e),this._reverse.remove(t.high,e),this._reverse.hasKey(t.low)||this._index.remove(t.low),this._reverse.hasKey(t.high)||this._index.remove(t.high),t},o.prototype.updateAll=function(t){var n,s=[],o,u,a;return t.forEach(function(t){u=t.key;if(typeof u!="string")throw new r("key is "+typeof u+" - must be string");a=t.interval;if(a===undefined)this._map.hasOwnProperty(u)?(o=this._remove(u),n={type:i.REMOVE,key:u,interval:o,data:t.data}):n={type:i.NOOP,key:u,interval:undefined,data:undefined};else{if(a instanceof e==0)throw new r("parameter must be instanceof Interval");this._map.hasOwnProperty(u)?(o=this._map[u],a.equals(o)?n={type:i.NOOP,key:u,interval:o,data:t.data}:(this._remove(u),this._insert(u,a),n={type:i.UPDATE,key:u,interval:a,data:t.data})):(this._insert(u,a),n={type:i.CREATE,key:u,interval:a,data:t.data})}s.push(n)},this),this._doCallbacks("change",s),s},o.prototype.update=function(e,t){return this.updateAll([{key:e,interval:t}])},o.prototype.on=function(e,t,n){if(!t||typeof t!="function")throw new r("Illegal handler");if(!this._callbacks.hasOwnProperty(e))throw new r("Unsupported event "+e);var i=this._callbacks[e].indexOf(t);return i===-1&&(t._ctx_=n||this,this._callbacks[e].push(t)),this},o.prototype.off=function(e,t){if(this._callbacks[e]!==undefined){var n=this._callbacks[e].indexOf(t);n>-1&&this._callbacks[e].splice(n,1)}return this},o.prototype._doCallbacks=function(e,t){var n;this._callbacks[e].forEach(function(n){try{n.call(n._ctx_,t)}catch(r){console.log("Error in "+e+": "+n+": "+r)}},this)},o.prototype.lookupByPoint=function(e){var t,n=[];return Object.keys(this._map).forEach(function(r){t=this._map[r],(e===undefined||t.coversPoint(e))&&n.push({key:r,interval:t})},this),n},o.prototype.lookupByInterval=function(e){var t=this._index.lookup(e),n=[],r,i;return this._index.lookup(e).forEach(function(t){this._reverse.getItemsByKey(t).forEach(function(r){t=r.key,e=this._map[r.value],n.push({key:r.value,interval:e,point:t,pointType:this.getPointType(t,e)})},this)},this),n},o.prototype.items=function(){return this.lookupByPoint()},o.prototype.keys=function(){return Object.keys(this._map)},o.prototype.getPointType=function(e,t){return t.isSingular()&&e===t.low?s.SINGULAR:e===t.low?s.LOW:e===t.high?s.HIGH:t.low=e)return this.queue.push(r),this.queue.sort(this.sortFunc),!0;console.log("Schedule : task pushed a bit too late, ts < now ",t-e)}return!1},a.prototype.pop=function(e){var t=[];while(this.queue.length>0&&this.queue[0].ts<=e){var n=this.queue.shift(),r={task:n.task,pop_ts:e,push_ts:n.push_ts,ts:n.ts};t.push(r)}return t},a.prototype.invalidate=function(e){var t,n,r,i=[];for(t=0;t-1&&this.queue.splice(n,1)},a.prototype.advance=function(e){ethis.timeInterval.high},a.prototype.getDelayNextTs=function(e){return this.queue.length>0?Math.max(0,this.queue[0].ts-e):Math.max(0,this.timeInterval.high-e)},a.prototype.getNextTaskPoint=function(){return this.queue.length>0?this.queue[0].task.point:null};var f=function(e){this._argOrder=[],this._argMap={},this._sequencer=e};f.prototype.addCue=function(e,t,n){return this._argOrder.push(e),this._argMap[e]={key:e,interval:t,data:n},this},f.prototype.removeCue=function(e,t){return this.addCue(e,undefined,t)},f.prototype.submit=function(){var e=[];return this._argOrder.forEach(function(t){e.push(this._argMap[t])},this),this._argMap={},this._argOrder=[],e.length>0?this._sequencer.updateAll(e):[]};var l=function(e){this.name="SequencerError",this.message=e||""};l.prototype=Error.prototype;var c=function(e,t,n,r,i,s,o,u,a,f){this.src=e,this.key=t,this.interval=n,this.point=i,this.pointType=s,this.dueTs=u,this.delay=o-u,this.directionType=a,this.type=f,this.data=r};c.prototype.toString=function(){var e="["+this.point.toFixed(2)+"]";return e+=" "+this.key,e+=" "+this.interval.toString(),e+=" "+this.type,e+=" "+this.directionType,e+=" "+this.pointType,e+=" delay:"+this.delay.toFixed(4),this.data&&(e+=" "+JSON.stringify(this.data)),e};var h=function(e,t,n){this.key=e,this.interval=t,this.data=n};h.prototype.toString=function(){var e=this.key+" "+this.interval.toString();return this.data&&(e+=" "+JSON.stringify(this.data)),e};var p=function(e,n){this._to=e,this._clock=e.clock,this._axis=n||new r.Axis,this._schedule=null,this._timeout=null,this._currentTimeoutPoint=null,this._activeKeys=[],t.eventify(this,p.prototype),this.eventifyDefineEvent("enter",{init:!0}),this.eventifyDefineEvent("exit"),this.eventifyDefineEvent("change"),this._wrappedOnTimingChange=function(){this._onTimingChange()},this._wrappedOnAxisChange=function(e){this._onAxisChange(e)},this._to.on("change",this._wrappedOnTimingChange,this),this.loadData()};Object.defineProperty(p.prototype,"Interval",{get:function(){return n}}),p.prototype.eventifyMakeInitEvents=function(e){return e==="enter"?this._processInitialEvents():[]},p.prototype.loadData=function(){},p.prototype.getData=function(e){},p.prototype._isReady=function(){return this._schedule!==null},p.prototype._onTimingChange=function(t){var o=this._clock.now(),f=this._to.vector;this._isReady()===!1?(this._schedule=new a(o),this._axis.on("change",this._wrappedOnAxisChange,this)):(o=f.timestamp,this._schedule.advance(o));var l=e.calculateVector(f,o),c=this._activeKeys,h=this._axis.lookupByPoint(l.position).map(function(e){return e.key}),p=s(c,h),d=s(h,c),v=i(f);if(v){var m=l.position,g=this._axis.lookupByInterval(new n(m,m,!0,!0));g.forEach(function(t){if(t.pointType===r.PointType.SINGULAR)p.push(t.key);else{var n=t.interval,i=!1;t.pointType===r.PointType.LOW&&n.lowInclude?i=!0:t.pointType===r.PointType.HIGH&&n.highInclude&&(i=!0);var s=u.fromInteger(e.calculateDirection(f,o)),a=!0;t.pointType===r.PointType.LOW&&s===u.BACKWARDS&&(a=!1),t.pointType===r.PointType.HIGH&&s===u.FORWARDS&&(a=!1),!a&&i&&p.push(t.key),a&&!i&&d.push(t.key)}},this)}var y=p.map(function(e){return{key:e,interval:this._axis.getIntervalByKey(e),data:this.getData(e)}},this),b=d.map(function(e){return{key:e,interval:this._axis.getIntervalByKey(e),data:this.getData(e)}},this);this._processIntervalEvents(o,y,b,[]),this._load(o),this._main(o)},p.prototype.updateAll=function(e){this._axis.updateAll(e)},p.prototype._onAxisChange=function(t){var n=this,s,o,u,a,f,l=t.filter(function(e){return e.type!==r.OpType.NOOP}),c=this._clock.now(),h=e.calculateVector(this._to.vector,c),p=h.position,d=[],v=[],m,g;l.forEach(function(e){a=e.interval,u=e.key,m=this.isActive(u),g=!1,(e.type===r.OpType.CREATE||e.type===r.OpType.UPDATE)&&a.coversPoint(p)&&(g=!0),e.type===r.OpType.REMOVE?f=e.data:f=e.data||this.getData(u),m&&!g?v.push({key:u,interval:a,data:f}):!m&&g&&d.push({key:u,interval:a,data:f})},this);var y=v.map(function(e){return e.key}),b=t.filter(function(e){return this.isActive(e.key)&&y.indexOf(e.key)===-1},this).map(function(e){return{key:e.key,interval:e.interval,data:e.data}},this);if(l.length===0){b.length>0&&setTimeout(function(){n._processIntervalEvents(c,[],[],b)},0);return}var w=i(h);if(!w){setTimeout(function(){n._processIntervalEvents(c,v,d,b)},0);return}if(!w)this._schedule.advance(c);else{l.forEach(function(e){this._schedule.invalidate(e.key)},this);var E,S=[];l.forEach(function(e){a=e.interval,u=e.key;if(e.type===r.OpType.REMOVE)return;if(w){var t={key:u,interval:a},n=this._schedule.getPosInterval();n!==null&&(n.coversPoint(a.low)&&(t.point=a.low),n.coversPoint(a.high)&&(t.point=a.high),t.pointType=this._axis.getPointType(t.point,t.interval),S.push(t))}},this),S.length>0&&this._load(c,S)}setTimeout(function(){n._processIntervalEvents(c,v,d,b),n._main(c)},0)},p.prototype._main=function(e){var t;e=e||this._clock.now(),t=this._processScheduleEvents(e,this._schedule.pop(e)),this.eventifyTriggerEvents(t);var n=i(this._to.vector);n&&this._schedule.isExpired(e)&&(e=this._schedule.getTimeInterval().high,this._schedule.advance(e),this._load(e),t=this._processScheduleEvents(e,this._schedule.pop(e)),this.eventifyTriggerEvents(t));if(n){var r=!1;if(this._timeout===null)r=!0;else{var s=this._schedule.getNextTaskPoint();s!==null&&s!==this._currentTimeoutPoint&&(r=!0)}if(r){this._clearTimeout();var o=this._clock.now(),u=this._schedule.getDelayNextTs(o);this._currentTimeoutPoint=s;var a=this;this._timeout=this._clock.setTimeout(function(){a._clearTimeout(),a._main()},u,{anchor:o,early:.005})}}},p.prototype._clearTimeout=function(){this._currentTimeoutPoint=null,this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)},p.prototype._load=function(t,s){var o=this._to.vector;if(!i(o))return;var u=this._schedule.getTimeInterval(),a=u.low,f=u.high,l=f-a,c=this._to.range,h=e.calculateVector(o,a),p=s;if(!p){var d=e.calculateInterval(h,l),v=Math.max(d[0],c[0]),m=Math.min(d[1],c[1]),g=new n(v,m,!0,!0);this._schedule.setPosInterval(g),p=this._axis.lookupByInterval(g)}p.forEach(function(e){e.data=this.getData(e.key)},this);var y=e.calculateSolutionsInInterval(h,l,p),b=e.calculateDelta(h,c)[0];y.forEach(function(n){var i=n[0],s=n[1],u=!0;i===0&&(u=!1),i>b&&(u=!1),i===b&&(u=!1);if(s.pointType===r.PointType.LOW||s.pointType===r.PointType.HIGH){var f=e.calculateVector(o,a+i);f.velocity===0&&(u=!1)}u&&this._schedule.push(t,a+i,s)},this)},p.prototype._makeEArgs=function(e,t,n,i,s,a,f,l){var h=u.fromInteger(i),p=this._axis.getPointType(a,t);if(s===undefined){var d=r.PointType.toInteger(p),v=d*i*-1;s=o.fromInteger(v)}return new c(this,e,t,n,a,p,f,l,h,s)},p.prototype._processScheduleEvents=function(t,n){var r,i=[],s=e.calculateVector(this._to.vector,t),u=e.calculateDirection(s,t),a=this._clock.now();return n.forEach(function(e){e.task.interval.isSingular()?(r=this._makeEArgs(e.task.key,e.task.interval,e.task.data,u,o.ENTER,e.task.point,a,e.ts),i.push(r),r=this._makeEArgs(e.task.key,e.task.interval,e.task.data,u,o.EXIT,e.task.point,a,e.ts),i.push(r)):(r=this._makeEArgs(e.task.key,e.task.interval,e.task.data,u,undefined,e.task.point,a,e.ts),i.push(r))},this),this._makeEvents(t,i)},p.prototype._processIntervalEvents=function(t,n,r,i){if(n.length+r.length+i.length===0)return;var s=e.calculateVector(this._to.vector,t),u=e.calculateDirection(s,t),a=this._clock.now(),f=[];n.forEach(function(e){f.push(this._makeEArgs(e.key,e.interval,e.data,u,o.EXIT,s.position,a,t))},this),r.forEach(function(e){f.push(this._makeEArgs(e.key,e.interval,e.data,u,o.ENTER,s.position,a,t))},this),i.forEach(function(e){f.push(this._makeEArgs(e.key,e.interval,e.data,u,o.CHANGE,s.position,a,t))},this),this.eventifyTriggerEvents(this._makeEvents(t,f))},p.prototype._processInitialEvents=function(){var t,n,r,i=this._clock.now(),s=e.calculateVector(this._to.vector,i),u=e.calculateDirection(s,i),a=this._clock.now();return this._activeKeys.map(function(e){return t=this._axis.getIntervalByKey(e),n=this.getData(e),r=this._makeEArgs(e,t,n,u,o.ENTER,s.position,a,i),{type:o.ENTER,e:r}},this)},p.prototype._makeEvents=function(e,t){if(t.length===0)return[];var n,r=[];return t.forEach(function(e){e.type===o.EXIT&&(n=this._activeKeys.indexOf(e.key),n>-1&&this._activeKeys.splice(n,1)),e.type===o.ENTER&&(n=this._activeKeys.indexOf(e.key),n===-1&&this._activeKeys.push(e.key)),r.push(e)},this),r=this._reorderEventList(r),r.map(function(e){return{type:e.type,e:e}})},p.prototype._reorderEventList=function(e){if(e.length<2)return e;var t,n,i=[],s={a:[],x:[],b:[],c:[],y:[],d:[]};return e.forEach(function(e){if(e.point!==t||e.dueTs!==n)i=i.concat(s.a).concat(s.x).concat(s.b).concat(s.c).concat(s.y).concat(s.d),s={a:[],x:[],b:[],c:[],y:[],d:[]},t=e.point,n=e.dueTs;if(e.pointType===r.PointType.SINGULAR)e.type===o.ENTER?s.b.push(e):s.c.push(e);else{var u=!1;e.pointType===r.PointType.LOW&&e.interval.lowInclude?u=!0:e.pointType===r.PointType.HIGH&&e.interval.highInclude&&(u=!0),e.type===o.ENTER?u?s.x.push(e):s.d.push(e):u?s.y.push(e):s.a.push(e)}},this),i.concat(s.a).concat(s.x).concat(s.b).concat(s.c).concat(s.y).concat(s.d)},p.prototype.request=function(){return new f(this)},p.prototype.addCue=function(e,t,n){return this.updateAll([{key:e,interval:t,data:n}])},p.prototype.removeCue=function(e,t){return this.updateAll([{key:e,interval:undefined,data:t}])},p.prototype.hasCue=function(e){return this._axis.hasKey(e)},p.prototype.keys=function(){return this._axis.keys()},p.prototype.getCue=function(e){if(this._axis.hasKey(e))return new h(e,this._axis.getIntervalByKey(e),this.getData(e))},p.prototype.getCues=function(){return this.keys().map(function(e){return this.getCue(e)},this)},p.prototype.isActive=function(e){return this._activeKeys.indexOf(e)>-1},p.prototype.getActiveKeys=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(t)},this),e},p.prototype.getActiveCues=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(this.getCue(t))},this),e},p.prototype.getCuesByPoint=function(e){return this._axis.lookupByPoint(e).map(function(e){return this.getCue(e.key)},this)},p.prototype.getCuesByInterval=function(e){var t={};return this._axis.lookupByInterval(e).forEach(function(e){t[e.key]=e.interval}),Object.keys(t).map(function(e){return this.getCue(e)},this).filter(function(t){return e.overlapsInterval(t.interval)},this)},p.prototype.getCuesCoveredByInterval=function(e){return this.getCuesByInterval(e).filter(function(t){return e.coversInterval(t.interval)?!0:!1},this)},p.prototype.close=function(){this._to.off("change",this._wrappedOnTimingChange,this),this._axis.off("change",this._wrappedOnAxisChange,this),this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)};var d=function(e,t){var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.uber=t.prototype,e.prototype.constructor=e};return{inherit:d,Interval:n,DefaultSequencer:p,Axis:r.Axis,SequencerError:l}}),n("sequencing/windowsequencer",["util/eventutils","util/motionutils","./axis","./sequencer"],function(e,t,n,r){"use strict";var i=function(e,t){var n=[];for(var r=0;r-1&&s.indexOf(e.key)>-1&&a.push(e.key)}),this._activeKeys=s;var f=[],l=o.forEach(function(t){var r=this._getOpFromAxisOpList(e,t),i,s;r.type===n.OpType.REMOVE?(i=r.interval,s=r.data):(i=this._axis.getIntervalByKey(t),s=this.getData(t)),f.push({type:"exit",e:{key:t,interval:i,type:"exit",data:s}})},this),c=u.forEach(function(e){f.push({type:"enter",e:{key:e,interval:this._axis.getIntervalByKey(e),type:"enter",data:this.getData(e)}})},this),h=a.forEach(function(e){f.push({type:"change",e:{key:e,interval:this._axis.getIntervalByKey(e),type:"change",data:this.getData(e)}})},this);return this.eventifyTriggerEvents(f),this._activeKeys.map(function(e){return{type:"enter",e:{key:e,interval:this._axis.getIntervalByKey(e),type:"enter"}}},this)},o.prototype.request=function(){return this._seqA.request()},o.prototype.addCue=function(e,t,n){return this._seqA.addCue(e,t,n)},o.prototype.removeCue=function(e,t){return this._seqA.removeCue(e,t)},o.prototype.hasCue=function(e){return this._seqA.hasCue(e)},o.prototype.keys=function(){return this._seqA.keys()},o.prototype.getCue=function(e){return this._seqA.getCue(e)},o.prototype.getCues=function(){return this._seqA.getCues()},o.prototype.isActive=function(e){return this._activeKeys.indexOf(e)>-1},o.prototype.getActiveKeys=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(t)},this),e},o.prototype.getActiveCues=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(this.getCue(t))},this),e},o.prototype.getCuesByPoint=function(e){return this._seqA.getCuesByPoint(e)},o.prototype.getCuesByInterval=function(e){return this._seqA.getCuesByInterval(e)},o.prototype.getCuesCoveredByInterval=function(e){return this._seqA.getCuesCoveredByInterval(e)},o.prototype.close=function(){this._axis.off("change",this._wrappedOnAxisChange),this._toA.off("change",this._wrappedOnTimingChangeA),this._toB.off("change",this._wrappedOnTimingChangeB),this._seqA.off("events",this._wrappedOnSequencerChangeA),this._seqB.off("events",this._wrappedOnSequencerChangeB),this._seqA.close(),this._seqB.close()},o.prototype.loadData=function(){},o.prototype.getData=function(e){},o}),n("sequencing/timingcallbacks",["util/motionutils"],function(e){"use strict";var t=function(e,t){var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.uber=t.prototype,e.prototype.constructor=e},n=function(e,t){this._timingsrc=e,this._handler=t,this._timeout=null,this._wrappedOnChange=function(){this._onChange()},this.timingsrc=e};n.prototype._renewTimeout=function(){this._clearTimeout();var e=this._calculateTimeout();if(e.delay===null)return null;var t=this;this._timeout=this._timingsrc.clock.setTimeout(function(){t._onTimeout()},e.delay,{anchor:e.anchor,early:.005})},n.prototype._clearTimeout=function(){this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)},n.prototype.cancel=function(){this._clearTimeout(),this._timingsrc.off("change",this._wrappedOnChange,this)},Object.defineProperty(n.prototype,"timingsrc",{get:function(){return this._timingsrc},set:function(e){this._timingsrc&&this._timingsrc.off("change",this._wrappedOnChange,this),clearTimeout(this._tid),this._timingsrc=e,this._timingsrc.on("change",this._wrappedOnChange,this)}});var r=function(e,t,r,i){n.call(this,e,t),this._options=i||{},this._options.repeat=this._options.repeat!==undefined?this._options.repeat:!1,this._point=r};t(r,n),r.prototype._onChange=function(){this._timingsrc.query().position===this._point&&this._handler(),this._renewTimeout()},r.prototype._onTimeout=function(){this._options.repeat||this.cancel(),this._handler(),this._renewTimeout()},r.prototype._calculateTimeout=function(){var t=this._timingsrc.query(),n=e.calculateMinPositiveRealSolution(t,this._point);return{anchor:t.timestamp,delay:n}};var i=function(e,t,r,i){n.call(this,e,t),this._options=i||{},this._options.offset=this._options.offset!==undefined?this._options.offset:0,this._length=r};return t(i,n),i.prototype._mod=function(e,t){return(e%t+t)%t},i.prototype._getPoint=function(e){var t=this._options.offset;return{n:Math.floor((e-t)/this._length),offset:this._mod(e-t,this._length)}},i.prototype._getFloat=function(e){var t=this._options.offset;return t+e.n*this._length+e.offset},i.prototype._onChange=function(){var e=this._calculatePoints(this._timingsrc.query().position);e.isTarget&&this._handler(),this._renewTimeout()},i.prototype._onTimeout=function(){this._handler(),this._renewTimeout()},i.prototype._calculatePoints=function(e){var t={},n={},r,i=this._getPoint(e);return i.offset===0?(r=!0,t.n=i.n-1,t.offset=i.offset,n.n=i.n+1,n.offset=i.offset):(r=!1,t.n=i.n,t.offset=0,n.n=i.n+1,n.offset=0),{isTarget:r,before:this._getFloat(t),after:this._getFloat(n)}},i.prototype._calculateTimeout=function(){var t=this._timingsrc.query(),n=this._calculatePoints(t.position),r=e.calculateDelta(t,[n.before,n.after])[0];return{anchor:t.timestamp,delay:r}},{setPointCallback:function(e,t,n,i){return new r(e,t,n,i)},setIntervalCallback:function(e,t,n,r){return new i(e,t,n,r)}}}),n("sequencing/jerkyinterval",["util/eventutils","util/motionutils"],function(e,t){var n=function(t,r,i){this._toA=t,this._toB=r,this._toList=[this._toA],this._toB&&this._toList.push(this._toB),this._timeout=null,i=i||{},this._left=i.left||5,this._right=i.right||5,this._low,this._high,this._ready=!1,e.eventify(this,n.prototype),this.eventifyDefineEvent("ready",{init:!0}),this.eventifyDefineEvent("change",{init:!0});var s=this,o=this._toList.map(function(e){return e.readyPromise});Promise.all(o).then(function(e){s._initialise()}),this._toList.forEach(function(e){e.on("change",this._onChange,this)},this)};return n.prototype._initialise=function(){this._ready=!0,this.eventifyTriggerEvent("ready")},n.prototype.eventifyMakeInitEvents=function(e){return e==="change"?[{type:e,e:undefined}]:e==="ready"?this._ready?[{type:e,e:undefined}]:[]:[]},Object.defineProperty(n.prototype,"ready",{get:function(){return this._ready}}),Object.defineProperty(n.prototype,"low",{get:function(){return this._low}}),Object.defineProperty(n.prototype,"high",{get:function(){return this._high}}),Object.defineProperty(n.prototype,"readyPromise",{get:function(){var e=this;return new Promise(function(t,n){if(e._ready)t();else{var r=function(){e.off("ready",r),t()};e.on("ready",r)}})}}),Object.defineProperty(n.prototype,"range",{get:function(){return[this._low,this._high]}}),n.prototype._onChange=function(){this._refresh()},n.prototype._onTimeout=function(){this._refresh()},n.prototype._refresh=function(){var e=this,t=this._toList.map(function(e){return e.query()}),n=this._checkRange(t);n||this._update(t),this._resetTimeout()},n.prototype._update=function(e){var t=e.reduce(function(e,t){return Math.min(e,t.position)},Infinity)-this._left,n=e.reduce(function(e,t){return Math.max(e,t.position)},-Infinity)+this._right,r=!1;t!==this._low&&(this._low=t,r=!0),n!==this._high&&(this._high=n,r=!0),r&&this.eventifyTriggerEvent("change")},n.prototype._checkRange=function(e){return e.map(function(e){var n=t.calculateDirection(e,e.timestamp),r=!0;return this._low===undefined||this._high===undefined?r=!1:e.position3&&(K("Lost all confidence (thrashing)"),i.target=Math.min(1,i.target*2),V("target_change",{event:"target_change",target:i.target,reason:"thrashing"}),k=0)):k=0;var s=(r-C.ts)/1e3,o=e.currentTime,u=A(C.pos+s)-o;n=C.adjust+u,Math.abs(n)>5&&(n=0)}e.playbackRate=1,K({type:"skip",pos:t+n,target:A(l.pos),adjust:n}),T=Math.min(5,T+5),l.vel!=1?e.currentTime=t:(e.currentTime=t+n,C={ts:r,pos:t,adjust:n}),N&&(N=!1,V("sync",{event:"sync",sync:!1})),V("skip",{event:"skip",pos:t+n,target:l.pos,adjust:n})},O=function(t){if(a||f)return;var n=I();if(A(n.pos)==w)return;w=A(n.pos);var r=A(n.pos+i.skew),o=e.duration;if(o)if(r<0||r>o){e.paused||e.pause();return}n.vel!=0?e.paused&&e.play():e.paused||e.pause();try{if(!S&&y>40)throw s&&(e.muted=!1,s=!1),V("muted",{event:"muted",muted:!1}),new Error("Variable playback rate seems broken - "+y+" bad");var u=r-e.currentTime;if(u<-1||n.vel==0||Math.abs(u)>1){K({type:"jump",diff:u});var c=A(n.pos+i.skew);performance.now()-x>150&&(x=performance.now(),L(c));return}E.push(u);if(!(E.length>=3))return;var h=0;for(var p=0;p1?(E=[],e.playbackRate=d(1,u*1.3),K({type:"vpbr",level:"coarse",rate:e.playbackRate}),y+=4):Math.abs(u)>.5?(E=[],e.playbackRate=d(.5,u*.75),K({type:"vpbr",level:"mid",rate:e.playbackRate}),y+=2):Math.abs(u)>.1?(E=[],e.playbackRate=d(.4,u*.75),K({type:"vpbr",level:"midfine",rate:e.playbackRate}),y+=1):Math.abs(u)>.025?(E=[],e.playbackRate=d(.3,u*.6),K({type:"vpbr",level:"fine",rate:e.playbackRate})):(S||(y=Math.max(0,y-20),b++,b>5&&(S=!0,localStorage&&i.remember&&(K("Variable Playback Rate capability stored"),localStorage.mediascape_vpbr=JSON.stringify({appVersion:navigator.appVersion,vpbr:!0})))),N||(N=!0,V("sync",{event:"sync",sync:!0})),e.playbackRate=d(.02,u*.07)),i.automute&&(!e.muted&&(e.playbackRate>1.05||e.playbackRate<.95)?(s=!0,e.muted=!0,V("muted",{event:"muted",muted:!0}),K({type:"mute",muted:!0})):e.muted&&s&&(s=!1,e.muted=!1,K({type:"mute",muted:!1}),V("muted",{event:"muted",muted:!1})))}catch(v){i.automute&&(e.muted=!1),C=null,localStorage&&i.remember&&(K("Variable Playback Rate NOT SUPPORTED, remembering this "),localStorage.mediascape_vpbr=JSON.stringify({appVersion:navigator.appVersion,vpbr:!1})),console.log("Error setting variable playback speed - seems broken",v),F(D)}},M,_,D=function(t){if(a||f)return;var n=I();n.vel>0?e.paused&&e.play():e.paused||e.pause();if(n.vel!=1){if(A(n.pos)==M)return;M=n.pos,K("Jump, playback speed is not :",n.vel);var r=A(n.pos+i.skew);e.currentTime!=r&&L(r,"jump");return}var s=n.pos+i.skew,o=s-e.currentTime;if(t!=undefined&&t.pos!=undefined){K("MOTION JUMP");var r=n.pos+i.skew;L(r);return}E.push(o);if(!(E.length>=3))return;var u=0;for(var c=0;c15&&(K("Feels better"),i.target==i.original_target&&(N||(N=!0,V("sync",{event:"sync",sync:!0}))),i.target=Math.max(Math.abs(o)*.7,i.original_target),T-=8,V("target_change",{event:"target_change",target:i.target,reason:"improving"})),K({type:"dbg",diff:o,target:i.target,perfect:T});if(Math.abs(o)>i.target){T-=1;if(T>0)return;r=l.pos+i.skew,T+=8,L(r)}else Math.abs(o-_)=2){clearInterval(W);try{var t=new Event("canplay");e.dispatchEvent(t)}catch(n){var t=document.createEvent("Event");t.initEvent("canplay",!0,!1),e.dispatchEvent(t)}}},100),X={skip:[],mode_change:[],target_change:[],muted:[],sync:[]},V=function(e,t){if(!X.hasOwnProperty(e))throw"Unsupported event: "+e;for(var n=0;n-1&&X[e].splice(n,1),r},J=function(e,t,n){if(!X.hasOwnProperty(e))throw new Error("Unsupported event: "+e);if(!t||typeof t!="function")throw"Illegal handler";var i=X[e].indexOf(t);if(i!=-1)throw new Error("Already registered");return X[e].push(t),setTimeout(function(){e==="sync"&&V(e,{event:e,sync:N},t),e==="muted"&&V(e,{event:e,muted:s},t)},0),r};return r={setSkew:q,getSkew:R,setOption:U,getMethod:z,setMotion:u,stop:m,pause:v,on:J,off:$,init:H},r}var e,r=function(e,t,r){this._sync=n(e,t,r)};return r.prototype.setSkew=function(e){this._sync.setSkew(e)},r.prototype.getSkew=function(){this._sync.getSkew()},r.prototype.setOption=function(e,t){this._sync.setOption(e,t)},r.prototype.getMethod=function(){this._sync.getMethod()},Object.defineProperty(r.prototype,"timingsrc",{get:function(){return this._sync._motion},set:function(e){this._sync.setMotion(e)}}),r.prototype.stop=function(){this._sync.stop()},r.prototype.pause=function(e){this._sync.pause(e)},r.prototype.on=function(e,t,n){this._sync.on(e,t,n)},r.prototype.off=function(e,t){this._sync.off(e,t)},{mediaSync:n,MediaSync:r,mediaNeedKick:t}}),n("timingsrc",["./timingobject/main","./sequencing/main","./mediasync/mediasync"],function(e,t,n){return{version:"v1",inherit:e.inherit,TimingObject:e.TimingObject,TimingProviderState:e.TimingProviderState,ConverterBase:e.ConverterBase,SkewConverter:e.SkewConverter,DelayConverter:e.DelayConverter,ScaleConverter:e.ScaleConverter,LoopConverter:e.LoopConverter,RangeConverter:e.RangeConverter,TimeShiftConverter:e.TimeShiftConverter,LocalConverter:e.LocalConverter,DerivativeConverter:e.DerivativeConverter,Interval:t.Interval,Sequencer:t.Sequencer,setPointCallback:t.setPointCallback,setIntervalCallback:t.setIntervalCallback,JerkyInterval:t.JerkyInterval,MediaSync:n.MediaSync,mediaNeedKick:n.needKick}}),t("timingsrc")});
\ No newline at end of file
+(function(e,t){typeof define=="function"&&define.amd?define([],t):e.TIMINGSRC=t()})(this,function(){var e,t,n;return function(r){function v(e,t){return h.call(e,t)}function m(e,t){var n,r,i,s,o,u,a,f,c,h,p,v=t&&t.split("/"),m=l.map,g=m&&m["*"]||{};if(e&&e.charAt(0)===".")if(t){e=e.split("/"),o=e.length-1,l.nodeIdCompat&&d.test(e[o])&&(e[o]=e[o].replace(d,"")),e=v.slice(0,v.length-1).concat(e);for(c=0;c0&&(e.splice(c-1,2),c-=2)}}e=e.join("/")}else e.indexOf("./")===0&&(e=e.substring(2));if((v||g)&&m){n=e.split("/");for(c=n.length;c>0;c-=1){r=n.slice(0,c).join("/");if(v)for(h=v.length;h>0;h-=1){i=m[v.slice(0,h).join("/")];if(i){i=i[r];if(i){s=i,u=c;break}}}if(s)break;!a&&g&&g[r]&&(a=g[r],f=c)}!s&&a&&(s=a,u=f),s&&(n.splice(0,u,s),e=n.join("/"))}return e}function g(e,t){return function(){var n=p.call(arguments,0);return typeof n[0]!="string"&&n.length===1&&n.push(null),s.apply(r,n.concat([e,t]))}}function y(e){return function(t){return m(t,e)}}function b(e){return function(t){a[e]=t}}function w(e){if(v(f,e)){var t=f[e];delete f[e],c[e]=!0,i.apply(r,t)}if(!v(a,e)&&!v(c,e))throw new Error("No "+e);return a[e]}function E(e){var t,n=e?e.indexOf("!"):-1;return n>-1&&(t=e.substring(0,n),e=e.substring(n+1,e.length)),[t,e]}function S(e){return function(){return l&&l.config&&l.config[e]||{}}}var i,s,o,u,a={},f={},l={},c={},h=Object.prototype.hasOwnProperty,p=[].slice,d=/\.js$/;o=function(e,t){var n,r=E(e),i=r[0];return e=r[1],i&&(i=m(i,t),n=w(i)),i?n&&n.normalize?e=n.normalize(e,y(t)):e=m(e,t):(e=m(e,t),r=E(e),i=r[0],e=r[1],i&&(n=w(i))),{f:i?i+"!"+e:e,n:e,pr:i,p:n}},u={require:function(e){return g(e)},exports:function(e){var t=a[e];return typeof t!="undefined"?t:a[e]={}},module:function(e){return{id:e,uri:"",exports:a[e],config:S(e)}}},i=function(e,t,n,i){var s,l,h,p,d,m=[],y=typeof n,E;i=i||e;if(y==="undefined"||y==="function"){t=!t.length&&n.length?["require","exports","module"]:t;for(d=0;d0?n[0]:-1},t.prototype.getItem=function(e){return this._map[e]},t.prototype.register=function(e,t){var n=this._getID(e);if(n>-1)throw new Error("handler already registered");return n=this._newID(),this._map[n]={ID:n,handler:e,ctx:t,count:0,pending:!1},n},t.prototype.unregister=function(e){var t=this._getID(e);t!==-1&&delete this._map[t]},t.prototype.getItems=function(){return Object.keys(this._map).map(function(e){return this.getItem(e)},this)};var n=function(n,r){return n._ID=e(4),n._callbacks={},n._callbacks.events=new t,n._callbacks.events._options={init:!0},r.eventifyDefineEvent=function(e,n){if(e==="events")throw new Error("Illegal event type : 'events' is protected");n=n||{},n.init=n.init===undefined?!1:n.init,this._callbacks[e]=new t,this._callbacks[e]._options=n},r._eventifyMakeInitEvents=function(e){var t=this.eventifyMakeInitEvents||function(e){return[]},n;return e!=="events"?n=[e]:n=Object.keys(this._callbacks).filter(function(e){return e!=="events"&&this._callbacks[e]._options.init===!0},this),n.concatMap(function(e){return t.call(this,e)},this)},r._eventifyEventFormatter=function(e,t){var n=this.eventifyEventFormatter||function(e,t){return t};return e==="events"&&(t=t.map(function(e){return n.call(this,e.type,e.e)})),n(e,t)},r._eventifyCallbackFormatter=function(e,t,n){var r=this.eventifyCallbackFormatter||function(e,t,n){return[t]};return r.call(this,e,t,n)},r.eventifyTriggerEvents=function(e){e.forEach(function(e){if(e.type===undefined)throw new Error("Illegal event type; undefined");if(e.type==="events")throw new Error("Illegal event type; triggering of events on protocted event type 'events'")},this);if(e.length===0)return;return this._eventifyTriggerProtectedEvents(e),this._eventifyTriggerRegularEvents(e),this},r.eventifyTriggerEvent=function(e,t){return this.eventifyTriggerEvents([{type:e,e:t}])},r._eventifyTriggerProtectedEvents=function(e,t){this._eventifyTriggerEvent("events",{type:"events",e:e},t)},r._eventifyTriggerRegularEvents=function(e,t){e.forEach(function(e){this._eventifyTriggerEvent(e.type,e,t)},this)},r._eventifyTriggerEvent=function(e,t,n){var r,i,s={};if(!this._callbacks.hasOwnProperty(e))throw new Error("Unsupported event type "+e);var o=this._callbacks[e],u=o._options.init;return o.getItems().forEach(function(o){if(n===undefined){if(o.pending)return!1}else{if(o.ID!==n)return!1;s.init=!0,o.pending=!1}u&&(s.init=o.ID===n?!0:!1),s.count=o.count,s.src=this,i=this._eventifyEventFormatter(t.type,t.e),r=this._eventifyCallbackFormatter(e,i,s);try{return o.handler.apply(o.ctx,r),o.count+=1,!0}catch(a){console.log("Error in "+e+": "+o.handler+" "+o.ctx+": ",a)}},this),!1},r.on=function(e,t,n){if(!t||typeof t!="function")throw new Error("Illegal handler");if(!this._callbacks.hasOwnProperty(e))throw new Error("Unsupported event type "+e);var r=this._callbacks[e];n=n||this;var i=r.register(t,n);if(r._options.init){var s=r.getItem(i);s.pending=!0;var o=this;setTimeout(function(){var t=o._eventifyMakeInitEvents(e);t.length>0?e==="events"?o._eventifyTriggerProtectedEvents(t,i):o._eventifyTriggerRegularEvents(t,i):s.pending=!1},0)}return this},r.off=function(e,t){if(this._callbacks[e]!==undefined){var n=this._callbacks[e];n.unregister(t)}return this},n};return{eventify:n}}),n("util/motionutils",[],function(){"use strict";var e=function(e,t){if(t===undefined)throw new Error("no ts provided for calculateVector");var n=t-e.timestamp;return{position:e.position+e.velocity*n+.5*e.acceleration*n*n,velocity:e.velocity+e.acceleration*n,acceleration:e.acceleration,timestamp:t}},t=Object.freeze({INIT:"init",INSIDE:"inside",OUTSIDE_LOW:"outsidelow",OUTSIDE_HIGH:"outsidehigh"}),n=function(e,n){var r=e.position,i=e.velocity,s=e.acceleration;if(r>n[1])return t.OUTSIDE_HIGH;if(r0)return t.OUTSIDE_HIGH;if(i===0&&s>0)return t.OUTSIDE_HIGH}else if(r===n[0]){if(i<0)return t.OUTSIDE_LOW;if(i==0&&s<0)return t.OUTSIDE_HIGH}return t.INSIDE},r=function(e,r){var i=n(e,r);return i!==t.INSIDE&&(e.velocity=0,e.acceleration=0,i===t.OUTSIDE_HIGH?e.position=r[1]:e.position=r[0]),e},i=function(e,t){if(e>t)return 1;if(e===t)return 0;if(e=0?!0:!1},u=function(e,t,n,r){if(n===0&&t===0)return e!=r?[]:[0];if(n===0)return[(r-e)/t];if(o(e,t,n,r)===!1)return[];var i=t*t-2*n*(e-r);if(i===0)return[-t/n];var s=Math.sqrt(Math.pow(t,2)-2*n*(e-r)),u=(-t+s)/n,a=(-t-s)/n;return[Math.min(u,a),Math.max(u,a)]},a=function(e,t,n,r){var i=u(e,t,n,r);return i.length===0?[]:i.length==1?i[0]>0?[i[0]]:[]:i.length==2?i[1]<0?[]:i[0]>0?[i[0],i[1]]:i[1]>0?[i[1]]:[]:[]},f=function(e,t){var n=e.position,r=e.velocity,i=e.acceleration,s=a(n,r,i,t);return s.length===0?null:s[0]},l=function(e,t){var n=f(e,t[0]),r=f(e,t[1]);return n!==null&&r!==null?n0?[u,Math.max(n,s)]:[Math.min(n,s),u]}}return[Math.min(n,s),Math.max(n,s)]};return{calculateVector:e,calculateDirection:s,calculateMinPositiveRealSolution:f,calculateDelta:l,calculateInterval:p,calculateSolutionsInInterval:h,getCorrectRangeState:n,checkRange:r,RangeState:t}}),n("timingobject/timingbase",["util/eventutils","util/motionutils"],function(e,t){"use strict";var n=function(e,t){var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.uber=t.prototype,e.prototype.constructor=e},r=function(t){this._version=3,this._options=t||{},this._options.hasOwnProperty("timeout")||(this._options.timeout=!1),this._vector=null,this._range=null,this._timeout=null,this._tid=null,this._ready=!1,e.eventify(this,r.prototype),this.eventifyDefineEvent("ready",{init:!0}),this.eventifyDefineEvent("change",{init:!0}),this.eventifyDefineEvent("timeupdate",{init:!0})};Object.defineProperty(r.prototype,"version",{get:function(){return this._version}}),Object.defineProperty(r.prototype,"range",{get:function(){return this._range===null?null:[this._range[0],this._range[1]]}}),Object.defineProperty(r.prototype,"vector",{get:function(){return this._vector===null?null:{position:this._vector.position,velocity:this._vector.velocity,acceleration:this._vector.acceleration,timestamp:this._vector.timestamp}}}),Object.defineProperty(r.prototype,"ready",{get:function(){return this._ready}}),Object.defineProperty(r.prototype,"readyPromise",{get:function(){var e=this;return new Promise(function(t,n){if(e._ready)t();else{var r=function(){e.off("ready",r),t()};e.on("ready",r)}})}}),Object.defineProperty(r.prototype,"pos",{get:function(){return this.query().position}}),Object.defineProperty(r.prototype,"vel",{get:function(){return this.query().velocity}}),Object.defineProperty(r.prototype,"acc",{get:function(){return this.query().acceleration}}),r.prototype.eventifyMakeInitEvents=function(e){return e==="change"?this._ready?[{type:e,e:undefined}]:[]:e==="timeupdate"?this._ready?[{type:e,e:undefined}]:[]:e==="ready"?this._ready?[{type:e,e:undefined}]:[]:[]},r.prototype.query=function(){return this.vector===null?{position:undefined,velocity:undefined,acceleration:undefined}:t.calculateVector(this.vector,this.clock.now())},r.prototype.update=function(e){},r.prototype._getRange=function(){return null},r.prototype._preProcess=function(e){this._range===null&&(this._range=this._getRange());var e=this._onChange(e);this._process(e)},r.prototype._onChange=function(e){return e},r.prototype._renewTimeout=function(){if(this._options.timeout===!0){this._clearTimeout();var e=this._calculateTimeoutVector();if(e===null)return;var t=this.clock.now(),n=e.timestamp-t,r=this;this._timeout=this.clock.setTimeout(function(){r._process(r._onTimeout(e))},n,{anchor:t,early:.005})}},r.prototype._calculateTimeoutVector=function(){return null},r.prototype._clearTimeout=function(){this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)},r.prototype._onTimeout=function(e){return e},r.prototype._process=function(e){if(e!==null){var t=this._vector;this._vector=e,t===null&&(this._ready=!0,this.eventifyTriggerEvent("ready")),this._postProcess(this.vector)}this._renewTimeout()},r.prototype._postProcess=function(e){this.eventifyTriggerEvent("change"),this.eventifyTriggerEvent("timeupdate");var t=e.velocity!==0||e.acceleration!==0;if(t&&this._tid===null){var n=this;this._tid=setInterval(function(){n.eventifyTriggerEvent("timeupdate")},200)}else!t&&this._tid!==null&&(clearTimeout(this._tid),this._tid=null)};var i=function(e,t){r.call(this,t),this._timingsrc=null;var n=this;this._internalOnChange=function(){var e=n.timingsrc.vector;n._preProcess(e)},this.timingsrc=e};return n(i,r),Object.defineProperty(i.prototype,"clock",{get:function(){return this.timingsrc.clock}}),Object.defineProperty(i.prototype,"timingsrc",{get:function(){return this._timingsrc},set:function(e){this._timingsrc&&this._timingsrc.off("change",this._internalOnChange,this),this._range=null,this._vector=null,this._clearTimeout(),clearTimeout(this._tid),this._timingsrc=e,this._timingsrc.on("change",this._internalOnChange,this)}}),i.prototype.update=function(e){return this.timingsrc.update(e)},i.prototype._getRange=function(){return this.timingsrc.range},{TimingBase:r,ConverterBase:i,inherit:n,motionutils:t}}),n("timingobject/skewconverter",["./timingbase"],function(e){"use strict";var t=e.ConverterBase,n=e.inherit,r=function(e,n){this._skew=n,t.call(this,e)};return n(r,t),r.prototype._getRange=function(){var e=this.timingsrc.range;return e[0]=e[0]===-Infinity?e[0]:e[0]+this._skew,e[1]=e[1]===Infinity?e[1]:e[1]+this._skew,e},r.prototype._onChange=function(e){return e.position+=this._skew,e},r.prototype.update=function(e){return e.position!==undefined&&e.position!==null&&(e.position=e.position-this._skew),this.timingsrc.update(e)},Object.defineProperty(r.prototype,"skew",{get:function(){return this._skew}}),r.prototype.setSkew=function(e){this._skew=e;var t=this.timingsrc.vector;this._preProcess(t)},r}),n("timingobject/delayconverter",["./timingbase"],function(e){"use strict";var t=e.ConverterBase,n=e.inherit,r=function(e,n){if(n<0)throw new Error("negative delay not supported");if(n===0)throw new Error("zero delay makes delayconverter pointless");t.call(this,e),this._delay=n};return n(r,t),r.prototype._onChange=function(e){var t=this.clock.now()-e.timestamp;e.timestamp+=this._delay;if(tthis._range[1])this._process(this._calculateInitialVector());else{if(!(e.position10?this._tid=setTimeout(function(){s._ontimeout()},o-3e3):this._tid=setTimeout(function(){s._ontimeout()},(o-s._options.early)*1e3)};return Object.defineProperty(e.prototype,"target",{get:function(){return this._target}}),e.prototype._ontimeout=function(){if(this._tid!==null){var e=this._target-this._clock.now();if(e<=0)this.cancel(),this._callback();else if(e>this._options.early){var t=this;this._tid=setTimeout(function(){t._ontimeout()},(e-this._options.early)*1e3)}else this._smalldelay()}},e.prototype.handleEvent=function(e){if(e.source===window&&e.data.indexOf("smalldelaymsg_")===0){e.stopPropagation();var t=parseInt(e.data.split("_")[1]);this._tid!==null&&this._tid===t&&this._ontimeout()}},e.prototype._smalldelay=function(){this._delay_counter++;var e=this;window.postMessage("smalldelaymsg_"+e._tid,"*")},e.prototype.cancel=function(){if(this._tid!==null){clearTimeout(this._tid),this._tid=null;var e=this;window.removeEventListener("message",this,!0)}},{setTimeout:function(t,n,r,i){return new e(t,n,r,i)}}}),n("util/masterclock",["./eventutils","./timeoututils"],function(e,t){"use strict";(function(){"performance"in window==0&&(window.performance={},window.performance.offset=(new Date).getTime()),"now"in window.performance==0&&(window.performance.now=function(){return(new Date).getTime()-window.performance.offset})})();var n={now:function(){return performance.now()/1e3}},r=function(e,t){t===undefined&&(t=n.now());var r=t-e.timestamp;return{position:e.position+e.velocity*r,velocity:e.velocity,timestamp:t}},i=function(t){var r=n.now();t=t||{},this._vector={position:r,velocity:1,timestamp:r},e.eventify(this,i.prototype),this.eventifyDefineEvent("change"),this.adjust(t)};return i.prototype.adjust=function(e){e=e||{};var t=n.now(),r=this.query(t);if(e.skew===undefined&&e.rate===undefined)return;this._vector={position:e.skew!==undefined?t+e.skew:r.position,velocity:e.rate!==undefined?e.rate:r.velocity,timestamp:r.timestamp},this.eventifyTriggerEvent("change")},i.prototype.now=function(){return r(this._vector,n.now()).position},i.prototype.query=function(e){return r(this._vector,e)},i.prototype.setTimeout=function(e,n,r){return t.setTimeout(this,e,n,r)},i}),n("timingobject/timingobject",["./timingbase","./timingprovider","util/masterclock"],function(e,t,n){"use strict";var r=e.motionutils,i=e.TimingBase,s=e.inherit,o=t.LocalTimingProvider,u=t.TimingProviderState,a=function(e){e=e||{},i.call(this,{timeout:!0}),this._clock=null,this._range=null,this._vector=null;var t=this;this._provider=e.provider||new o(e),this._onSkewChangeWrapper=function(){t._onSkewChange()},this._onVectorChangeWrapper=function(){t._onVectorChange()},this._onReadystateChangeWrapper=function(){t._onReadystateChange()},this._provider.on("readystatechange",this._onReadystateChangeWrapper,this),this._initialise()};return s(a,i),a.prototype._initialise=function(){if(this._provider.readyState!==u.OPEN)return;this._clock===null&&(this._range=this._provider.range,this._clock=new n({skew:this._provider.skew}),this._preProcess(this._provider.vector),this._provider.on("vectorchange",this._onVectorChangeWrapper,this),this._provider.on("skewchange",this._onSkewChangeWrapper,this))},a.prototype._onReadystateChange=function(){this._initialise()},a.prototype._onSkewChange=function(){this._clock.adjust({skew:this._provider.skew})},a.prototype._onVectorChange=function(){this._preProcess(this._provider.vector)},Object.defineProperty(a.prototype,"clock",{get:function(){return this._clock}}),Object.defineProperty(a.prototype,"provider",{get:function(){return this._provider}}),a.prototype.query=function(){if(this.vector===null)return{position:undefined,velocity:undefined,acceleration:undefined};var e=r.calculateVector(this.vector,this.clock.now()),t=r.getCorrectRangeState(e,this._range);return t!==r.RangeState.INSIDE&&this._preProcess(e),r.calculateVector(this.vector,this.clock.now())},a.prototype.update=function(e){return this._provider.update(e)},a.prototype._onChange=function(e){return r.checkRange(e,this._range)},a.prototype._calculateTimeoutVector=function(){var e=this.query(),t=r.calculateDelta(e,this.range),n=t[0];if(n===null)return null;if(n===Infinity)return null;var i=t[1],s=r.calculateVector(e,e.timestamp+n);return s.position=i,s},a.prototype._onTimeout=function(e){return r.checkRange(e,this._range)},a}),n("timingobject/main",["./timingbase","./skewconverter","./delayconverter","./scaleconverter","./loopconverter","./rangeconverter","./timeshiftconverter","./derivativeconverter","./timingobject","./timingprovider"],function(e,t,n,r,i,s,o,u,a,f){"use strict";return{inherit:e.inherit,ConverterBase:e.ConverterBase,SkewConverter:t,DelayConverter:n,ScaleConverter:r,LoopConverter:i,RangeConverter:s,TimeShiftConverter:o,DerivativeConverter:u,TimingObject:a,TimingProviderState:f.TimingProviderState}}),n("util/interval",[],function(){"use strict";var e=function(e){var t=parseFloat(e);return e===t&&!isNaN(t)},t=function(e){this.name="IntervalError",this.message=e||""};t.prototype=Error.prototype;var n=function(n,r,i,s){var o=e(n),u=e(r);o&&r===undefined&&(r=n);if(!e(n))throw new t("low not a number");if(!e(r))throw new t("high not a number");if(n>r)throw new t("low > high");n===r&&(i=!0,s=!0),n===-Infinity&&(i=!0),r===Infinity&&(s=!0),i===undefined&&(i=!0),s===undefined&&(s=!1);if(typeof i!="boolean")throw new t("lowInclude not boolean");if(typeof s!="boolean")throw new t("highInclude not boolean");this.__defineGetter__("length",function(){return r-n}),this.__defineGetter__("low",function(){return n}),this.__defineGetter__("high",function(){return r}),this.__defineGetter__("lowInclude",function(){return i}),this.__defineGetter__("highInclude",function(){return s})};return n.prototype.toString=function(){var e=this.lowInclude?"[":"<",t=this.highInclude?"]":">",n=this.low===-Infinity?"<--":this.low.toFixed(2),r=this.high===Infinity?"-->":this.high.toFixed(2);return this.isSingular()?e+n+t:e+n+","+r+t},n.prototype.isFinite=function(){return isFinite(this.low)&&isFinite(this.high)},n.prototype.isSingular=function(){return this.low===this.high},n.prototype.coversPoint=function(e){return this.lowe.high?!1:this.low===e.high?this.coversPoint(e.high)&&e.coversPoint(this.low):!0},n.prototype.coversInterval=function(e){if(e instanceof n==0)throw new t("paramenter not instance of Interval");return e.lowe))return r;n=r-1}}return~n},r.prototype.insert=function(e){var t=this.binaryIndexOf(e);(t<0||t===0&&this.array[0]!==e)&&this.array.splice(Math.abs(t),0,e)},r.prototype.indexOf=function(e){var t=this.binaryIndexOf(e);return t<0||t===0&&this.array[0]!==e?-1:t},r.prototype.hasElement=function(e){var t=this.binaryIndexOf(e);return t<0||t===0&&this.array[0]!==e?!1:!0},r.prototype.remove=function(e){var t=this.binaryIndexOf(e);if(t<0||t===0&&this.array[0]!==e)return;this.array.splice(t,1)},r.prototype.getMinimum=function(){return this.array.length>0?this.array[0]:null},r.prototype.getMaximum=function(){return this.array.length>0?this.array[this.array.length-1]:null},r.prototype.ltIndexOf=function(e){var t=this.binaryIndexOf(e);return t=t<0?Math.abs(t)-1:t-1,t>=0?t:-1},r.prototype.leIndexOf=function(e){var t=this.binaryIndexOf(e);return t>0||t===0&&this.array[0]===e?t:(t=Math.abs(t)-1,t>=0?t:-1)},r.prototype.gtIndexOf=function(e){var t=this.binaryIndexOf(e);return t===0?this.array[0]===e&&(t=1):t=t<0?Math.abs(t):t+1,t0||t===0&&this.array[0]===e?t:(t=Math.abs(t),t-1&&(n.splice(t,1),r.push(e),n.length===0&&delete this._map[e.key]))},this),r},e.prototype.hasKey=function(e){return this._map.hasOwnProperty(e)},e.prototype.keys=function(){return Object.keys(this._map)},e.prototype.getItemsByKey=function(e){var t=[];return this.hasKey(e)&&this._map[e].forEach(function(n){t.push({key:e,value:n})}),t},e.prototype.getItemsByKeys=function(e){e===undefined&&(e=this.keys());var t=[];return e.forEach(function(e){t=t.concat(this.getItemsByKey(e))},this),t},e.prototype.list=e.prototype.getItemsByKeys,e}),n("sequencing/axis",["util/interval","./sortedarraybinary","./multimap"],function(e,t,n){"use strict";var r=function(e){this.name="AxisError",this.message=e||""};r.prototype=Error.prototype;var i=Object.freeze({NOOP:"noop",CREATE:"create",UPDATE:"update",REMOVE:"remove"}),s=Object.freeze({LOW:"low",SINGULAR:"singular",HIGH:"high",INSIDE:"inside",OUTSIDE:"outside",toInteger:function(e){if(e===s.LOW)return-1;if(e===s.HIGH)return 1;if(e===s.INSIDE)return 2;if(e===s.OUTSIDE)return 3;if(e===s.SINGULAR)return 0;throw new r("illegal string value for point type")},fromInteger:function(e){if(e===-1)return s.LOW;if(e===0)return s.SINGULAR;if(e===1)return s.HIGH;if(e===2)return s.INSIDE;if(e===3)return s.OUTSIDE;throw new r("illegal integer value for point type")}}),o=function(){this._map={},this._reverse=new n,this._index=new t,this._callbacks={change:[]}};return o.prototype._insert=function(e,t){this._map[e]=t,this._reverse.hasKey(t.low)||this._index.insert(t.low),this._reverse.hasKey(t.high)||this._index.insert(t.high),this._reverse.insert(t.low,e),this._reverse.insert(t.high,e)},o.prototype._remove=function(e){if(!this._map.hasOwnProperty(e))throw new r("attempt to remove non-existing key");var t=this._map[e];return delete this._map[e],this._reverse.remove(t.low,e),this._reverse.remove(t.high,e),this._reverse.hasKey(t.low)||this._index.remove(t.low),this._reverse.hasKey(t.high)||this._index.remove(t.high),t},o.prototype.updateAll=function(t){var n,s=[],o,u,a;return t.forEach(function(t){u=t.key;if(typeof u!="string")throw new r("key is "+typeof u+" - must be string");a=t.interval;if(a===undefined)this._map.hasOwnProperty(u)?(o=this._remove(u),n={type:i.REMOVE,key:u,interval:o,data:t.data}):n={type:i.NOOP,key:u,interval:undefined,data:undefined};else{if(a instanceof e==0)throw new r("parameter must be instanceof Interval");this._map.hasOwnProperty(u)?(o=this._map[u],a.equals(o)?n={type:i.NOOP,key:u,interval:o,data:t.data}:(this._remove(u),this._insert(u,a),n={type:i.UPDATE,key:u,interval:a,data:t.data})):(this._insert(u,a),n={type:i.CREATE,key:u,interval:a,data:t.data})}s.push(n)},this),this._doCallbacks("change",s),s},o.prototype.update=function(e,t){return this.updateAll([{key:e,interval:t}])},o.prototype.on=function(e,t,n){if(!t||typeof t!="function")throw new r("Illegal handler");if(!this._callbacks.hasOwnProperty(e))throw new r("Unsupported event "+e);var i=this._callbacks[e].indexOf(t);return i===-1&&(t._ctx_=n||this,this._callbacks[e].push(t)),this},o.prototype.off=function(e,t){if(this._callbacks[e]!==undefined){var n=this._callbacks[e].indexOf(t);n>-1&&this._callbacks[e].splice(n,1)}return this},o.prototype._doCallbacks=function(e,t){var n;this._callbacks[e].forEach(function(n){try{n.call(n._ctx_,t)}catch(r){console.log("Error in "+e+": "+n+": "+r)}},this)},o.prototype.lookupByPoint=function(e){var t,n=[];return Object.keys(this._map).forEach(function(r){t=this._map[r],(e===undefined||t.coversPoint(e))&&n.push({key:r,interval:t})},this),n},o.prototype.lookupByInterval=function(e){var t=this._index.lookup(e),n=[],r,i;return this._index.lookup(e).forEach(function(t){this._reverse.getItemsByKey(t).forEach(function(r){t=r.key,e=this._map[r.value],n.push({key:r.value,interval:e,point:t,pointType:this.getPointType(t,e)})},this)},this),n},o.prototype.items=function(){return this.lookupByPoint()},o.prototype.keys=function(){return Object.keys(this._map)},o.prototype.getPointType=function(e,t){return t.isSingular()&&e===t.low?s.SINGULAR:e===t.low?s.LOW:e===t.high?s.HIGH:t.low=e)return this.queue.push(r),this.queue.sort(this.sortFunc),!0;console.log("Schedule : task pushed a bit too late, ts < now ",t-e)}return!1},a.prototype.pop=function(e){var t=[];while(this.queue.length>0&&this.queue[0].ts<=e){var n=this.queue.shift(),r={task:n.task,pop_ts:e,push_ts:n.push_ts,ts:n.ts};t.push(r)}return t},a.prototype.invalidate=function(e){var t,n,r,i=[];for(t=0;t-1&&this.queue.splice(n,1)},a.prototype.advance=function(e){ethis.timeInterval.high},a.prototype.getDelayNextTs=function(e){return this.queue.length>0?Math.max(0,this.queue[0].ts-e):Math.max(0,this.timeInterval.high-e)},a.prototype.getNextTaskPoint=function(){return this.queue.length>0?this.queue[0].task.point:null};var f=function(e){this._argOrder=[],this._argMap={},this._sequencer=e};f.prototype.addCue=function(e,t,n){return this._argOrder.push(e),this._argMap[e]={key:e,interval:t,data:n},this},f.prototype.removeCue=function(e,t){return this.addCue(e,undefined,t)},f.prototype.submit=function(){var e=[];return this._argOrder.forEach(function(t){e.push(this._argMap[t])},this),this._argMap={},this._argOrder=[],e.length>0?this._sequencer.updateAll(e):[]};var l=function(e){this.name="SequencerError",this.message=e||""};l.prototype=Error.prototype;var c=function(e,t,n,r,i,s,o,u,a,f){this.src=e,this.key=t,this.interval=n,this.point=i,this.pointType=s,this.dueTs=u,this.delay=o-u,this.directionType=a,this.type=f,this.data=r};c.prototype.toString=function(){var e="["+this.point.toFixed(2)+"]";return e+=" "+this.key,e+=" "+this.interval.toString(),e+=" "+this.type,e+=" "+this.directionType,e+=" "+this.pointType,e+=" delay:"+this.delay.toFixed(4),this.data&&(e+=" "+JSON.stringify(this.data)),e};var h=function(e,t,n){this.key=e,this.interval=t,this.data=n};h.prototype.toString=function(){var e=this.key+" "+this.interval.toString();return this.data&&(e+=" "+JSON.stringify(this.data)),e};var p=function(e,n){this._to=e,this._clock=e.clock,this._axis=n||new r.Axis,this._schedule=null,this._timeout=null,this._currentTimeoutPoint=null,this._activeKeys=[],t.eventify(this,p.prototype),this.eventifyDefineEvent("enter",{init:!0}),this.eventifyDefineEvent("exit"),this.eventifyDefineEvent("change"),this._wrappedOnTimingChange=function(){this._onTimingChange()},this._wrappedOnAxisChange=function(e){this._onAxisChange(e)},this._to.on("change",this._wrappedOnTimingChange,this),this.loadData()};Object.defineProperty(p.prototype,"Interval",{get:function(){return n}}),p.prototype.eventifyMakeInitEvents=function(e){return e==="enter"?this._processInitialEvents():[]},p.prototype.loadData=function(){},p.prototype.getData=function(e){},p.prototype._isReady=function(){return this._schedule!==null},p.prototype._onTimingChange=function(t){var o=this._clock.now(),f=this._to.vector;this._isReady()===!1?(this._schedule=new a(o),this._axis.on("change",this._wrappedOnAxisChange,this)):(o=f.timestamp,this._schedule.advance(o));var l=e.calculateVector(f,o),c=this._activeKeys,h=this._axis.lookupByPoint(l.position).map(function(e){return e.key}),p=s(c,h),d=s(h,c),v=i(f);if(v){var m=l.position,g=this._axis.lookupByInterval(new n(m,m,!0,!0));g.forEach(function(t){if(t.pointType===r.PointType.SINGULAR)p.push(t.key);else{var n=t.interval,i=!1;t.pointType===r.PointType.LOW&&n.lowInclude?i=!0:t.pointType===r.PointType.HIGH&&n.highInclude&&(i=!0);var s=u.fromInteger(e.calculateDirection(f,o)),a=!0;t.pointType===r.PointType.LOW&&s===u.BACKWARDS&&(a=!1),t.pointType===r.PointType.HIGH&&s===u.FORWARDS&&(a=!1),!a&&i&&p.push(t.key),a&&!i&&d.push(t.key)}},this)}var y=p.map(function(e){return{key:e,interval:this._axis.getIntervalByKey(e),data:this.getData(e)}},this),b=d.map(function(e){return{key:e,interval:this._axis.getIntervalByKey(e),data:this.getData(e)}},this);this._processIntervalEvents(o,y,b,[]),this._load(o),this._main(o)},p.prototype.updateAll=function(e){this._axis.updateAll(e)},p.prototype._onAxisChange=function(t){var n=this,s,o,u,a,f,l=t.filter(function(e){return e.type!==r.OpType.NOOP}),c=this._clock.now(),h=e.calculateVector(this._to.vector,c),p=h.position,d=[],v=[],m,g;l.forEach(function(e){a=e.interval,u=e.key,m=this.isActive(u),g=!1,(e.type===r.OpType.CREATE||e.type===r.OpType.UPDATE)&&a.coversPoint(p)&&(g=!0),e.type===r.OpType.REMOVE?f=e.data:f=e.data||this.getData(u),m&&!g?v.push({key:u,interval:a,data:f}):!m&&g&&d.push({key:u,interval:a,data:f})},this);var y=v.map(function(e){return e.key}),b=t.filter(function(e){return this.isActive(e.key)&&y.indexOf(e.key)===-1},this).map(function(e){return{key:e.key,interval:e.interval,data:e.data}},this);if(l.length===0){b.length>0&&setTimeout(function(){n._processIntervalEvents(c,[],[],b)},0);return}var w=i(h);if(!w){setTimeout(function(){n._processIntervalEvents(c,v,d,b)},0);return}if(!w)this._schedule.advance(c);else{l.forEach(function(e){this._schedule.invalidate(e.key)},this);var E,S=[];l.forEach(function(e){a=e.interval,u=e.key;if(e.type===r.OpType.REMOVE)return;if(w){var t={key:u,interval:a},n=this._schedule.getPosInterval();n!==null&&(n.coversPoint(a.low)&&(t.point=a.low),n.coversPoint(a.high)&&(t.point=a.high),t.pointType=this._axis.getPointType(t.point,t.interval),S.push(t))}},this),S.length>0&&this._load(c,S)}setTimeout(function(){n._processIntervalEvents(c,v,d,b),n._main(c)},0)},p.prototype._main=function(e){var t;e=e||this._clock.now(),t=this._processScheduleEvents(e,this._schedule.pop(e)),this.eventifyTriggerEvents(t);var n=i(this._to.vector);n&&this._schedule.isExpired(e)&&(e=this._schedule.getTimeInterval().high,this._schedule.advance(e),this._load(e),t=this._processScheduleEvents(e,this._schedule.pop(e)),this.eventifyTriggerEvents(t));if(n){var r=!1;if(this._timeout===null)r=!0;else{var s=this._schedule.getNextTaskPoint();s!==null&&s!==this._currentTimeoutPoint&&(r=!0)}if(r){this._clearTimeout();var o=this._clock.now(),u=this._schedule.getDelayNextTs(o);this._currentTimeoutPoint=s;var a=this;this._timeout=this._clock.setTimeout(function(){a._clearTimeout(),a._main()},u,{anchor:o,early:.005})}}},p.prototype._clearTimeout=function(){this._currentTimeoutPoint=null,this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)},p.prototype._load=function(t,s){var o=this._to.vector;if(!i(o))return;var u=this._schedule.getTimeInterval(),a=u.low,f=u.high,l=f-a,c=this._to.range,h=e.calculateVector(o,a),p=s;if(!p){var d=e.calculateInterval(h,l),v=Math.max(d[0],c[0]),m=Math.min(d[1],c[1]),g=new n(v,m,!0,!0);this._schedule.setPosInterval(g),p=this._axis.lookupByInterval(g)}p.forEach(function(e){e.data=this.getData(e.key)},this);var y=e.calculateSolutionsInInterval(h,l,p),b=e.calculateDelta(h,c)[0];y.forEach(function(n){var i=n[0],s=n[1],u=!0;i===0&&(u=!1),i>b&&(u=!1),i===b&&(u=!1);if(s.pointType===r.PointType.LOW||s.pointType===r.PointType.HIGH){var f=e.calculateVector(o,a+i);f.velocity===0&&(u=!1)}u&&this._schedule.push(t,a+i,s)},this)},p.prototype._makeEArgs=function(e,t,n,i,s,a,f,l){var h=u.fromInteger(i),p=this._axis.getPointType(a,t);if(s===undefined){var d=r.PointType.toInteger(p),v=d*i*-1;s=o.fromInteger(v)}return new c(this,e,t,n,a,p,f,l,h,s)},p.prototype._processScheduleEvents=function(t,n){var r,i=[],s=e.calculateVector(this._to.vector,t),u=e.calculateDirection(s,t),a=this._clock.now();return n.forEach(function(e){e.task.interval.isSingular()?(r=this._makeEArgs(e.task.key,e.task.interval,e.task.data,u,o.ENTER,e.task.point,a,e.ts),i.push(r),r=this._makeEArgs(e.task.key,e.task.interval,e.task.data,u,o.EXIT,e.task.point,a,e.ts),i.push(r)):(r=this._makeEArgs(e.task.key,e.task.interval,e.task.data,u,undefined,e.task.point,a,e.ts),i.push(r))},this),this._makeEvents(t,i)},p.prototype._processIntervalEvents=function(t,n,r,i){if(n.length+r.length+i.length===0)return;var s=e.calculateVector(this._to.vector,t),u=e.calculateDirection(s,t),a=this._clock.now(),f=[];n.forEach(function(e){f.push(this._makeEArgs(e.key,e.interval,e.data,u,o.EXIT,s.position,a,t))},this),r.forEach(function(e){f.push(this._makeEArgs(e.key,e.interval,e.data,u,o.ENTER,s.position,a,t))},this),i.forEach(function(e){f.push(this._makeEArgs(e.key,e.interval,e.data,u,o.CHANGE,s.position,a,t))},this),this.eventifyTriggerEvents(this._makeEvents(t,f))},p.prototype._processInitialEvents=function(){var t,n,r,i=this._clock.now(),s=e.calculateVector(this._to.vector,i),u=e.calculateDirection(s,i),a=this._clock.now();return this._activeKeys.map(function(e){return t=this._axis.getIntervalByKey(e),n=this.getData(e),r=this._makeEArgs(e,t,n,u,o.ENTER,s.position,a,i),{type:o.ENTER,e:r}},this)},p.prototype._makeEvents=function(e,t){if(t.length===0)return[];var n,r=[];return t.forEach(function(e){e.type===o.EXIT&&(n=this._activeKeys.indexOf(e.key),n>-1&&this._activeKeys.splice(n,1)),e.type===o.ENTER&&(n=this._activeKeys.indexOf(e.key),n===-1&&this._activeKeys.push(e.key)),r.push(e)},this),r=this._reorderEventList(r),r.map(function(e){return{type:e.type,e:e}})},p.prototype._reorderEventList=function(e){if(e.length<2)return e;var t,n,i=[],s={a:[],x:[],b:[],c:[],y:[],d:[]};return e.forEach(function(e){if(e.point!==t||e.dueTs!==n)i=i.concat(s.a).concat(s.x).concat(s.b).concat(s.c).concat(s.y).concat(s.d),s={a:[],x:[],b:[],c:[],y:[],d:[]},t=e.point,n=e.dueTs;if(e.pointType===r.PointType.SINGULAR)e.type===o.ENTER?s.b.push(e):s.c.push(e);else{var u=!1;e.pointType===r.PointType.LOW&&e.interval.lowInclude?u=!0:e.pointType===r.PointType.HIGH&&e.interval.highInclude&&(u=!0),e.type===o.ENTER?u?s.x.push(e):s.d.push(e):u?s.y.push(e):s.a.push(e)}},this),i.concat(s.a).concat(s.x).concat(s.b).concat(s.c).concat(s.y).concat(s.d)},p.prototype.request=function(){return new f(this)},p.prototype.addCue=function(e,t,n){return this.updateAll([{key:e,interval:t,data:n}])},p.prototype.removeCue=function(e,t){return this.updateAll([{key:e,interval:undefined,data:t}])},p.prototype.hasCue=function(e){return this._axis.hasKey(e)},p.prototype.keys=function(){return this._axis.keys()},p.prototype.getCue=function(e){if(this._axis.hasKey(e))return new h(e,this._axis.getIntervalByKey(e),this.getData(e))},p.prototype.getCues=function(){return this.keys().map(function(e){return this.getCue(e)},this)},p.prototype.isActive=function(e){return this._activeKeys.indexOf(e)>-1},p.prototype.getActiveKeys=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(t)},this),e},p.prototype.getActiveCues=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(this.getCue(t))},this),e},p.prototype.getCuesByPoint=function(e){return this._axis.lookupByPoint(e).map(function(e){return this.getCue(e.key)},this)},p.prototype.getCuesByInterval=function(e){var t={};return this._axis.lookupByInterval(e).forEach(function(e){t[e.key]=e.interval}),Object.keys(t).map(function(e){return this.getCue(e)},this).filter(function(t){return e.overlapsInterval(t.interval)},this)},p.prototype.getCuesCoveredByInterval=function(e){return this.getCuesByInterval(e).filter(function(t){return e.coversInterval(t.interval)?!0:!1},this)},p.prototype.close=function(){this._to.off("change",this._wrappedOnTimingChange,this),this._axis.off("change",this._wrappedOnAxisChange,this),this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)};var d=function(e,t){var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.uber=t.prototype,e.prototype.constructor=e};return{inherit:d,Interval:n,DefaultSequencer:p,Axis:r.Axis,SequencerError:l}}),n("sequencing/windowsequencer",["util/eventutils","util/motionutils","./axis","./sequencer"],function(e,t,n,r){"use strict";var i=function(e,t){var n=[];for(var r=0;r-1&&s.indexOf(e.key)>-1&&a.push(e.key)}),this._activeKeys=s;var f=[],l=o.forEach(function(t){var r=this._getOpFromAxisOpList(e,t),i,s;r.type===n.OpType.REMOVE?(i=r.interval,s=r.data):(i=this._axis.getIntervalByKey(t),s=this.getData(t)),f.push({type:"exit",e:{key:t,interval:i,type:"exit",data:s}})},this),c=u.forEach(function(e){f.push({type:"enter",e:{key:e,interval:this._axis.getIntervalByKey(e),type:"enter",data:this.getData(e)}})},this),h=a.forEach(function(e){f.push({type:"change",e:{key:e,interval:this._axis.getIntervalByKey(e),type:"change",data:this.getData(e)}})},this);return this.eventifyTriggerEvents(f),this._activeKeys.map(function(e){return{type:"enter",e:{key:e,interval:this._axis.getIntervalByKey(e),type:"enter"}}},this)},o.prototype.request=function(){return this._seqA.request()},o.prototype.addCue=function(e,t,n){return this._seqA.addCue(e,t,n)},o.prototype.removeCue=function(e,t){return this._seqA.removeCue(e,t)},o.prototype.hasCue=function(e){return this._seqA.hasCue(e)},o.prototype.keys=function(){return this._seqA.keys()},o.prototype.getCue=function(e){return this._seqA.getCue(e)},o.prototype.getCues=function(){return this._seqA.getCues()},o.prototype.isActive=function(e){return this._activeKeys.indexOf(e)>-1},o.prototype.getActiveKeys=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(t)},this),e},o.prototype.getActiveCues=function(){var e=[];return this._activeKeys.forEach(function(t){e.push(this.getCue(t))},this),e},o.prototype.getCuesByPoint=function(e){return this._seqA.getCuesByPoint(e)},o.prototype.getCuesByInterval=function(e){return this._seqA.getCuesByInterval(e)},o.prototype.getCuesCoveredByInterval=function(e){return this._seqA.getCuesCoveredByInterval(e)},o.prototype.close=function(){this._axis.off("change",this._wrappedOnAxisChange),this._toA.off("change",this._wrappedOnTimingChangeA),this._toB.off("change",this._wrappedOnTimingChangeB),this._seqA.off("events",this._wrappedOnSequencerChangeA),this._seqB.off("events",this._wrappedOnSequencerChangeB),this._seqA.close(),this._seqB.close()},o.prototype.loadData=function(){},o.prototype.getData=function(e){},o}),n("sequencing/timingcallbacks",["util/motionutils"],function(e){"use strict";var t=function(e,t){var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.uber=t.prototype,e.prototype.constructor=e},n=function(e,t){this._timingsrc=e,this._handler=t,this._timeout=null,this._wrappedOnChange=function(){this._onChange()},this.timingsrc=e};n.prototype._renewTimeout=function(){this._clearTimeout();var e=this._calculateTimeout();if(e.delay===null)return null;var t=this;this._timeout=this._timingsrc.clock.setTimeout(function(){t._onTimeout()},e.delay,{anchor:e.anchor,early:.005})},n.prototype._clearTimeout=function(){this._timeout!==null&&(this._timeout.cancel(),this._timeout=null)},n.prototype.cancel=function(){this._clearTimeout(),this._timingsrc.off("change",this._wrappedOnChange,this)},Object.defineProperty(n.prototype,"timingsrc",{get:function(){return this._timingsrc},set:function(e){this._timingsrc&&this._timingsrc.off("change",this._wrappedOnChange,this),clearTimeout(this._tid),this._timingsrc=e,this._timingsrc.on("change",this._wrappedOnChange,this)}});var r=function(e,t,r,i){n.call(this,e,t),this._options=i||{},this._options.repeat=this._options.repeat!==undefined?this._options.repeat:!1,this._point=r};t(r,n),r.prototype._onChange=function(){this._timingsrc.query().position===this._point&&this._handler(),this._renewTimeout()},r.prototype._onTimeout=function(){this._options.repeat||this.cancel(),this._handler(),this._renewTimeout()},r.prototype._calculateTimeout=function(){var t=this._timingsrc.query(),n=e.calculateMinPositiveRealSolution(t,this._point);return{anchor:t.timestamp,delay:n}};var i=function(e,t,r,i){n.call(this,e,t),this._options=i||{},this._options.offset=this._options.offset!==undefined?this._options.offset:0,this._length=r};return t(i,n),i.prototype._mod=function(e,t){return(e%t+t)%t},i.prototype._getPoint=function(e){var t=this._options.offset;return{n:Math.floor((e-t)/this._length),offset:this._mod(e-t,this._length)}},i.prototype._getFloat=function(e){var t=this._options.offset;return t+e.n*this._length+e.offset},i.prototype._onChange=function(){var e=this._calculatePoints(this._timingsrc.query().position);e.isTarget&&this._handler(),this._renewTimeout()},i.prototype._onTimeout=function(){this._handler(),this._renewTimeout()},i.prototype._calculatePoints=function(e){var t={},n={},r,i=this._getPoint(e);return i.offset===0?(r=!0,t.n=i.n-1,t.offset=i.offset,n.n=i.n+1,n.offset=i.offset):(r=!1,t.n=i.n,t.offset=0,n.n=i.n+1,n.offset=0),{isTarget:r,before:this._getFloat(t),after:this._getFloat(n)}},i.prototype._calculateTimeout=function(){var t=this._timingsrc.query(),n=this._calculatePoints(t.position),r=e.calculateDelta(t,[n.before,n.after])[0];return{anchor:t.timestamp,delay:r}},{setPointCallback:function(e,t,n,i){return new r(e,t,n,i)},setIntervalCallback:function(e,t,n,r){return new i(e,t,n,r)}}}),n("sequencing/jerkyinterval",["util/eventutils","util/motionutils"],function(e,t){var n=function(t,r,i){this._toA=t,this._toB=r,this._toList=[this._toA],this._toB&&this._toList.push(this._toB),this._timeout=null,i=i||{},this._left=i.left||5,this._right=i.right||5,this._low,this._high,this._ready=!1,e.eventify(this,n.prototype),this.eventifyDefineEvent("ready",{init:!0}),this.eventifyDefineEvent("change",{init:!0});var s=this,o=this._toList.map(function(e){return e.readyPromise});Promise.all(o).then(function(e){s._initialise()}),this._toList.forEach(function(e){e.on("change",this._onChange,this)},this)};return n.prototype._initialise=function(){this._ready=!0,this.eventifyTriggerEvent("ready")},n.prototype.eventifyMakeInitEvents=function(e){return e==="change"?[{type:e,e:undefined}]:e==="ready"?this._ready?[{type:e,e:undefined}]:[]:[]},Object.defineProperty(n.prototype,"ready",{get:function(){return this._ready}}),Object.defineProperty(n.prototype,"low",{get:function(){return this._low}}),Object.defineProperty(n.prototype,"high",{get:function(){return this._high}}),Object.defineProperty(n.prototype,"readyPromise",{get:function(){var e=this;return new Promise(function(t,n){if(e._ready)t();else{var r=function(){e.off("ready",r),t()};e.on("ready",r)}})}}),Object.defineProperty(n.prototype,"range",{get:function(){return[this._low,this._high]}}),n.prototype._onChange=function(){this._refresh()},n.prototype._onTimeout=function(){this._refresh()},n.prototype._refresh=function(){var e=this,t=this._toList.map(function(e){return e.query()}),n=this._checkRange(t);n||this._update(t),this._resetTimeout()},n.prototype._update=function(e){var t=e.reduce(function(e,t){return Math.min(e,t.position)},Infinity)-this._left,n=e.reduce(function(e,t){return Math.max(e,t.position)},-Infinity)+this._right,r=!1;t!==this._low&&(this._low=t,r=!0),n!==this._high&&(this._high=n,r=!0),r&&this.eventifyTriggerEvent("change")},n.prototype._checkRange=function(e){return e.map(function(e){var n=t.calculateDirection(e,e.timestamp),r=!0;return this._low===undefined||this._high===undefined?r=!1:e.position3&&(K("Lost all confidence (thrashing)"),i.target=Math.min(1,i.target*2),V("target_change",{event:"target_change",target:i.target,reason:"thrashing"}),k=0)):k=0;var s=(r-C.ts)/1e3,o=e.currentTime,u=A(C.pos+s)-o;n=C.adjust+u,Math.abs(n)>5&&(n=0)}e.playbackRate=1,K({type:"skip",pos:t+n,target:A(l.pos),adjust:n}),T=Math.min(5,T+5),l.vel!=1?e.currentTime=t:(e.currentTime=t+n,C={ts:r,pos:t,adjust:n}),N&&(N=!1,V("sync",{event:"sync",sync:!1})),V("skip",{event:"skip",pos:t+n,target:l.pos,adjust:n})},O=function(t){if(a||f)return;var n=I();if(A(n.pos)==w)return;w=A(n.pos);var r=A(n.pos+i.skew),o=e.duration;if(o)if(r<0||r>o){e.paused||e.pause();return}n.vel!=0?e.paused&&e.play():e.paused||e.pause();try{if(!S&&y>40)throw s&&(e.muted=!1,s=!1),V("muted",{event:"muted",muted:!1}),new Error("Variable playback rate seems broken - "+y+" bad");var u=r-e.currentTime;if(u<-1||n.vel==0||Math.abs(u)>1){K({type:"jump",diff:u});var c=A(n.pos+i.skew);performance.now()-x>150&&(x=performance.now(),L(c));return}E.push(u);if(!(E.length>=3))return;var h=0;for(var p=0;p1?(E=[],e.playbackRate=d(1,u*1.3),K({type:"vpbr",level:"coarse",rate:e.playbackRate}),y+=4):Math.abs(u)>.5?(E=[],e.playbackRate=d(.5,u*.75),K({type:"vpbr",level:"mid",rate:e.playbackRate}),y+=2):Math.abs(u)>.1?(E=[],e.playbackRate=d(.4,u*.75),K({type:"vpbr",level:"midfine",rate:e.playbackRate}),y+=1):Math.abs(u)>.025?(E=[],e.playbackRate=d(.3,u*.6),K({type:"vpbr",level:"fine",rate:e.playbackRate})):(S||(y=Math.max(0,y-20),b++,b>5&&(S=!0,localStorage&&i.remember&&(K("Variable Playback Rate capability stored"),localStorage.mediascape_vpbr=JSON.stringify({appVersion:navigator.appVersion,vpbr:!0})))),N||(N=!0,V("sync",{event:"sync",sync:!0})),e.playbackRate=d(.02,u*.07)),i.automute&&(!e.muted&&(e.playbackRate>1.05||e.playbackRate<.95)?(s=!0,e.muted=!0,V("muted",{event:"muted",muted:!0}),K({type:"mute",muted:!0})):e.muted&&s&&(s=!1,e.muted=!1,K({type:"mute",muted:!1}),V("muted",{event:"muted",muted:!1})))}catch(v){i.automute&&(e.muted=!1),C=null,localStorage&&i.remember&&(K("Variable Playback Rate NOT SUPPORTED, remembering this "),localStorage.mediascape_vpbr=JSON.stringify({appVersion:navigator.appVersion,vpbr:!1})),console.log("Error setting variable playback speed - seems broken",v),F(D)}},M,_,D=function(t){if(a||f)return;var n=I();n.vel>0?e.paused&&e.play():e.paused||e.pause();if(n.vel!=1){if(A(n.pos)==M)return;M=n.pos,K("Jump, playback speed is not :",n.vel);var r=A(n.pos+i.skew);e.currentTime!=r&&L(r,"jump");return}var s=n.pos+i.skew,o=s-e.currentTime;if(t!=undefined&&t.pos!=undefined){K("MOTION JUMP");var r=n.pos+i.skew;L(r);return}E.push(o);if(!(E.length>=3))return;var u=0;for(var c=0;c15&&(K("Feels better"),i.target==i.original_target&&(N||(N=!0,V("sync",{event:"sync",sync:!0}))),i.target=Math.max(Math.abs(o)*.7,i.original_target),T-=8,V("target_change",{event:"target_change",target:i.target,reason:"improving"})),K({type:"dbg",diff:o,target:i.target,perfect:T});if(Math.abs(o)>i.target){T-=1;if(T>0)return;r=l.pos+i.skew,T+=8,L(r)}else Math.abs(o-_)=2){clearInterval(W);try{var t=new Event("canplay");e.dispatchEvent(t)}catch(n){var t=document.createEvent("Event");t.initEvent("canplay",!0,!1),e.dispatchEvent(t)}}},100),X={skip:[],mode_change:[],target_change:[],muted:[],sync:[]},V=function(e,t){if(!X.hasOwnProperty(e))throw"Unsupported event: "+e;for(var n=0;n-1&&X[e].splice(n,1),r},J=function(e,t,n){if(!X.hasOwnProperty(e))throw new Error("Unsupported event: "+e);if(!t||typeof t!="function")throw"Illegal handler";var i=X[e].indexOf(t);if(i!=-1)throw new Error("Already registered");return X[e].push(t),setTimeout(function(){e==="sync"&&V(e,{event:e,sync:N},t),e==="muted"&&V(e,{event:e,muted:s},t)},0),r};return r={setSkew:q,getSkew:R,setOption:U,getMethod:z,setMotion:u,stop:m,pause:v,on:J,off:$,init:H},r}var e,r=function(e,t,r){this._sync=n(e,t,r)};return r.prototype.setSkew=function(e){this._sync.setSkew(e)},r.prototype.getSkew=function(){this._sync.getSkew()},r.prototype.setOption=function(e,t){this._sync.setOption(e,t)},r.prototype.getMethod=function(){this._sync.getMethod()},Object.defineProperty(r.prototype,"timingsrc",{get:function(){return this._sync._motion},set:function(e){this._sync.setMotion(e)}}),r.prototype.stop=function(){this._sync.stop()},r.prototype.pause=function(e){this._sync.pause(e)},r.prototype.on=function(e,t,n){this._sync.on(e,t,n)},r.prototype.off=function(e,t){this._sync.off(e,t)},{mediaSync:n,MediaSync:r,mediaNeedKick:t}}),n("timingsrc",["./timingobject/main","./sequencing/main","./mediasync/mediasync"],function(e,t,n){return{version:"v1",inherit:e.inherit,TimingObject:e.TimingObject,TimingProviderState:e.TimingProviderState,ConverterBase:e.ConverterBase,SkewConverter:e.SkewConverter,DelayConverter:e.DelayConverter,ScaleConverter:e.ScaleConverter,LoopConverter:e.LoopConverter,RangeConverter:e.RangeConverter,TimeShiftConverter:e.TimeShiftConverter,LocalConverter:e.LocalConverter,DerivativeConverter:e.DerivativeConverter,Interval:t.Interval,Sequencer:t.Sequencer,setPointCallback:t.setPointCallback,setIntervalCallback:t.setIntervalCallback,JerkyInterval:t.JerkyInterval,MediaSync:n.MediaSync,mediaNeedKick:n.needKick}}),t("timingsrc")});
\ No newline at end of file
diff --git a/docs/lib/timingsrc-min-v2.1.js b/docs/lib/timingsrc-min-v2.1.js
deleted file mode 100644
index a8c0e55..0000000
--- a/docs/lib/timingsrc-min-v2.1.js
+++ /dev/null
@@ -1,7155 +0,0 @@
-(function (root, factory) {
- if (typeof define === 'function' && define.amd) {
- //Allow using this built library as an AMD module
- //in another project. That other project will only
- //see this AMD call, not the internal modules in
- //the closure below.
- define([], factory);
- } else {
- //Browser globals case. Just assign the
- //result to a property on the global.
- root.TIMINGSRC = factory();
- }
-}(this, function () {
- //almond, and your modules will be inlined here
- /**
- * @license almond 0.3.1 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
- * Available via the MIT or new BSD license.
- * see: http://github.com/jrburke/almond for details
- */
-//Going sloppy to avoid 'use strict' string cost, but strict practices should
-//be followed.
-/*jslint sloppy: true */
-/*global setTimeout: false */
-
-var requirejs, require, define;
-(function (undef) {
- var main, req, makeMap, handlers,
- defined = {},
- waiting = {},
- config = {},
- defining = {},
- hasOwn = Object.prototype.hasOwnProperty,
- aps = [].slice,
- jsSuffixRegExp = /\.js$/;
-
- function hasProp(obj, prop) {
- return hasOwn.call(obj, prop);
- }
-
- /**
- * Given a relative module name, like ./something, normalize it to
- * a real name that can be mapped to a path.
- * @param {String} name the relative name
- * @param {String} baseName a real name that the name arg is relative
- * to.
- * @returns {String} normalized name
- */
- function normalize(name, baseName) {
- var nameParts, nameSegment, mapValue, foundMap, lastIndex,
- foundI, foundStarMap, starI, i, j, part,
- baseParts = baseName && baseName.split("/"),
- map = config.map,
- starMap = (map && map['*']) || {};
-
- //Adjust any relative paths.
- if (name && name.charAt(0) === ".") {
- //If have a base name, try to normalize against it,
- //otherwise, assume it is a top-level require that will
- //be relative to baseUrl in the end.
- if (baseName) {
- name = name.split('/');
- lastIndex = name.length - 1;
-
- // Node .js allowance:
- if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
- name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
- }
-
- //Lop off the last part of baseParts, so that . matches the
- //"directory" and not name of the baseName's module. For instance,
- //baseName of "one/two/three", maps to "one/two/three.js", but we
- //want the directory, "one/two" for this normalization.
- name = baseParts.slice(0, baseParts.length - 1).concat(name);
-
- //start trimDots
- for (i = 0; i < name.length; i += 1) {
- part = name[i];
- if (part === ".") {
- name.splice(i, 1);
- i -= 1;
- } else if (part === "..") {
- if (i === 1 && (name[2] === '..' || name[0] === '..')) {
- //End of the line. Keep at least one non-dot
- //path segment at the front so it can be mapped
- //correctly to disk. Otherwise, there is likely
- //no path mapping for a path starting with '..'.
- //This can still fail, but catches the most reasonable
- //uses of ..
- break;
- } else if (i > 0) {
- name.splice(i - 1, 2);
- i -= 2;
- }
- }
- }
- //end trimDots
-
- name = name.join("/");
- } else if (name.indexOf('./') === 0) {
- // No baseName, so this is ID is resolved relative
- // to baseUrl, pull off the leading dot.
- name = name.substring(2);
- }
- }
-
- //Apply map config if available.
- if ((baseParts || starMap) && map) {
- nameParts = name.split('/');
-
- for (i = nameParts.length; i > 0; i -= 1) {
- nameSegment = nameParts.slice(0, i).join("/");
-
- if (baseParts) {
- //Find the longest baseName segment match in the config.
- //So, do joins on the biggest to smallest lengths of baseParts.
- for (j = baseParts.length; j > 0; j -= 1) {
- mapValue = map[baseParts.slice(0, j).join('/')];
-
- //baseName segment has config, find if it has one for
- //this name.
- if (mapValue) {
- mapValue = mapValue[nameSegment];
- if (mapValue) {
- //Match, update name to the new value.
- foundMap = mapValue;
- foundI = i;
- break;
- }
- }
- }
- }
-
- if (foundMap) {
- break;
- }
-
- //Check for a star map match, but just hold on to it,
- //if there is a shorter segment match later in a matching
- //config, then favor over this star map.
- if (!foundStarMap && starMap && starMap[nameSegment]) {
- foundStarMap = starMap[nameSegment];
- starI = i;
- }
- }
-
- if (!foundMap && foundStarMap) {
- foundMap = foundStarMap;
- foundI = starI;
- }
-
- if (foundMap) {
- nameParts.splice(0, foundI, foundMap);
- name = nameParts.join('/');
- }
- }
-
- return name;
- }
-
- function makeRequire(relName, forceSync) {
- return function () {
- //A version of a require function that passes a moduleName
- //value for items that may need to
- //look up paths relative to the moduleName
- var args = aps.call(arguments, 0);
-
- //If first arg is not require('string'), and there is only
- //one arg, it is the array form without a callback. Insert
- //a null so that the following concat is correct.
- if (typeof args[0] !== 'string' && args.length === 1) {
- args.push(null);
- }
- return req.apply(undef, args.concat([relName, forceSync]));
- };
- }
-
- function makeNormalize(relName) {
- return function (name) {
- return normalize(name, relName);
- };
- }
-
- function makeLoad(depName) {
- return function (value) {
- defined[depName] = value;
- };
- }
-
- function callDep(name) {
- if (hasProp(waiting, name)) {
- var args = waiting[name];
- delete waiting[name];
- defining[name] = true;
- main.apply(undef, args);
- }
-
- if (!hasProp(defined, name) && !hasProp(defining, name)) {
- throw new Error('No ' + name);
- }
- return defined[name];
- }
-
- //Turns a plugin!resource to [plugin, resource]
- //with the plugin being undefined if the name
- //did not have a plugin prefix.
- function splitPrefix(name) {
- var prefix,
- index = name ? name.indexOf('!') : -1;
- if (index > -1) {
- prefix = name.substring(0, index);
- name = name.substring(index + 1, name.length);
- }
- return [prefix, name];
- }
-
- /**
- * Makes a name map, normalizing the name, and using a plugin
- * for normalization if necessary. Grabs a ref to plugin
- * too, as an optimization.
- */
- makeMap = function (name, relName) {
- var plugin,
- parts = splitPrefix(name),
- prefix = parts[0];
-
- name = parts[1];
-
- if (prefix) {
- prefix = normalize(prefix, relName);
- plugin = callDep(prefix);
- }
-
- //Normalize according
- if (prefix) {
- if (plugin && plugin.normalize) {
- name = plugin.normalize(name, makeNormalize(relName));
- } else {
- name = normalize(name, relName);
- }
- } else {
- name = normalize(name, relName);
- parts = splitPrefix(name);
- prefix = parts[0];
- name = parts[1];
- if (prefix) {
- plugin = callDep(prefix);
- }
- }
-
- //Using ridiculous property names for space reasons
- return {
- f: prefix ? prefix + '!' + name : name, //fullName
- n: name,
- pr: prefix,
- p: plugin
- };
- };
-
- function makeConfig(name) {
- return function () {
- return (config && config.config && config.config[name]) || {};
- };
- }
-
- handlers = {
- require: function (name) {
- return makeRequire(name);
- },
- exports: function (name) {
- var e = defined[name];
- if (typeof e !== 'undefined') {
- return e;
- } else {
- return (defined[name] = {});
- }
- },
- module: function (name) {
- return {
- id: name,
- uri: '',
- exports: defined[name],
- config: makeConfig(name)
- };
- }
- };
-
- main = function (name, deps, callback, relName) {
- var cjsModule, depName, ret, map, i,
- args = [],
- callbackType = typeof callback,
- usingExports;
-
- //Use name if no relName
- relName = relName || name;
-
- //Call the callback to define the module, if necessary.
- if (callbackType === 'undefined' || callbackType === 'function') {
- //Pull out the defined dependencies and pass the ordered
- //values to the callback.
- //Default to [require, exports, module] if no deps
- deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
- for (i = 0; i < deps.length; i += 1) {
- map = makeMap(deps[i], relName);
- depName = map.f;
-
- //Fast path CommonJS standard dependencies.
- if (depName === "require") {
- args[i] = handlers.require(name);
- } else if (depName === "exports") {
- //CommonJS module spec 1.1
- args[i] = handlers.exports(name);
- usingExports = true;
- } else if (depName === "module") {
- //CommonJS module spec 1.1
- cjsModule = args[i] = handlers.module(name);
- } else if (hasProp(defined, depName) ||
- hasProp(waiting, depName) ||
- hasProp(defining, depName)) {
- args[i] = callDep(depName);
- } else if (map.p) {
- map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
- args[i] = defined[depName];
- } else {
- throw new Error(name + ' missing ' + depName);
- }
- }
-
- ret = callback ? callback.apply(defined[name], args) : undefined;
-
- if (name) {
- //If setting exports via "module" is in play,
- //favor that over return value and exports. After that,
- //favor a non-undefined return value over exports use.
- if (cjsModule && cjsModule.exports !== undef &&
- cjsModule.exports !== defined[name]) {
- defined[name] = cjsModule.exports;
- } else if (ret !== undef || !usingExports) {
- //Use the return value from the function.
- defined[name] = ret;
- }
- }
- } else if (name) {
- //May just be an object definition for the module. Only
- //worry about defining if have a module name.
- defined[name] = callback;
- }
- };
-
- requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
- if (typeof deps === "string") {
- if (handlers[deps]) {
- //callback in this case is really relName
- return handlers[deps](callback);
- }
- //Just return the module wanted. In this scenario, the
- //deps arg is the module name, and second arg (if passed)
- //is just the relName.
- //Normalize module name, if it contains . or ..
- return callDep(makeMap(deps, callback).f);
- } else if (!deps.splice) {
- //deps is a config object, not an array.
- config = deps;
- if (config.deps) {
- req(config.deps, config.callback);
- }
- if (!callback) {
- return;
- }
-
- if (callback.splice) {
- //callback is an array, which means it is a dependency list.
- //Adjust args if there are dependencies
- deps = callback;
- callback = relName;
- relName = null;
- } else {
- deps = undef;
- }
- }
-
- //Support require(['a'])
- callback = callback || function () {};
-
- //If relName is a function, it is an errback handler,
- //so remove it.
- if (typeof relName === 'function') {
- relName = forceSync;
- forceSync = alt;
- }
-
- //Simulate async callback;
- if (forceSync) {
- main(undef, deps, callback, relName);
- } else {
- //Using a non-zero value because of concern for what old browsers
- //do, and latest browsers "upgrade" to 4 if lower value is used:
- //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
- //If want a value immediately, use require('id') instead -- something
- //that works in almond on the global level, but not guaranteed and
- //unlikely to work in other AMD implementations.
- setTimeout(function () {
- main(undef, deps, callback, relName);
- }, 4);
- }
-
- return req;
- };
-
- /**
- * Just drops the config on the floor, but returns req in case
- * the config return value is used.
- */
- req.config = function (cfg) {
- return req(cfg);
- };
-
- /**
- * Expose module registry for debugging and tooling
- */
- requirejs._defined = defined;
-
- define = function (name, deps, callback) {
- if (typeof name !== 'string') {
- throw new Error('See almond README: incorrect module build, no module name');
- }
-
- //This module may not have dependencies
- if (!deps.splice) {
- //deps is not an array, so probably means
- //an object literal or factory function for
- //the value. Adjust args.
- callback = deps;
- deps = [];
- }
-
- if (!hasProp(defined, name) && !hasProp(waiting, name)) {
- waiting[name] = [name, deps, callback];
- }
- };
-
- define.amd = {
- jQuery: true
- };
-}());
-
-define("../build/almond", function(){});
-
-/*
- Copyright 2015 Norut Northern Research Institute
- Author : Ingar Mæhlum Arntzen
-
- This file is part of the Timingsrc module.
-
- Timingsrc is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Timingsrc is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with Timingsrc. If not, see 0 => p_turning minimum
- // a0 < 0 => p_turning maximum
- if (a0 > 0.0) {
- return [p_turning, Math.max(p0, p1)];
- }
- else {
- return [Math.min(p0,p1), p_turning];
- }
- }
- }
- // no turning point or turning point was not reached
- return [Math.min(p0,p1), Math.max(p0,p1)];
- };
-
-
- // return module object
- return {
- calculateVector : calculateVector,
- calculateDirection : calculateDirection,
- calculateMinPositiveRealSolution : calculateMinPositiveRealSolution,
- calculateDelta : calculateDelta,
- calculateInterval : calculateInterval,
- calculateSolutionsInInterval : calculateSolutionsInInterval,
- calculateSolutionsInInterval2 : calculateSolutionsInInterval2,
- getCorrectRangeState : getCorrectRangeState,
- checkRange : checkRange,
- RangeState : RangeState
- };
-});
-
-
-
-/*
- Copyright 2015 Norut Northern Research Institute
- Author : Ingar Mæhlum Arntzen
-
- This file is part of the Timingsrc module.
-
- Timingsrc is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Timingsrc is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with Timingsrc. If not, see -1) {
- indexes.push(index);
- }
- }
- return indexes;
- };
-
- /*
- element exists with value
- */
- BinarySearch.prototype.has = function (x) {
- return (this.indexOf(x) > -1) ? true : false;
- };
-
- BinarySearch.prototype.get = function (index) {
- return this.array[index];
- };
-
- /*
- utility function for protecting against duplicates
-
- removing duplicates using Set is natural,
- but in objectModes Set equality will not work with the value callback function.
- In this case use map instead - this is slower
- due to repeated use of the custom value() function
-
- Note. If duplicates exists, this function preserves the last duplicate given
- that both Map and Set replaces on insert, and that iteration is guaranteed to
- be insert ordered.
- */
- BinarySearch.prototype._unique = function (A) {
- return [...new Set(A)];
- };
-
-
- /*
- REMOVE
- Removes all elements with given values
- search for each one and splice remove them individually
- (reverse order)
-
- INSERT
- binarysearch and splice
- insert - binarysearch and splice
-
- WARNING - there should be no need to insert elements that are already
- present in the array. This function drops such duplicates
- */
- BinarySearch.prototype._update_splice = function (to_remove, to_insert, options) {
-
- // REMOVE
- if (this.array.length > 0) {
- let indexes = this.indexOfElements(to_remove);
- /*
- sort indexes to make sure we are removing elements
- in backwards order
- optimization
- - if elements were sorted in the first place this should not be necessary
- */
- indexes.sort(function(a,b){return a-b;});
- for (let i=indexes.length-1; i > -1; i--) {
- this.array.splice(indexes[i], 1);
- }
- }
-
- // INSERT
- let x, index;
- let len = to_insert.length;
- for (let i=0; i 0 && to_remove.length > 0) {
- // visit all elements and set their value to undefined
- // undefined values will be sorted to the end of the array
- let indexes = this.indexOfElements(to_remove);
- for (let i=0; i 0) {
- let index = this.array.indexOf(undefined);
- if (index > -1) {
- this.array.splice(index, this.array.length-index);
- }
- }
- // remove duplicates
- this.array = this._unique(this.array);
- };
-
-
- /*
- Update - removing and inserting elements in one operation
-
- a single element should only be present once in the list, thus avoiding
- multiple operations to one element. This is presumed solved externally.
- - also objects must not be members of both lists.
-
- - internally selects the best method - searchsplice or concatsort
- - selection based on relative sizes of existing elements and new elements
-
- */
- BinarySearch.prototype.update = function (to_remove, to_insert, options) {
- let size = to_remove.length + to_insert.length;
- if (size == 0) {
- return;
- }
-
- // regular case
- let approach = resolve_approach(this.array.length, size);
- if (approach == "splice") {
- this._update_splice(to_remove, to_insert, options);
- } else if (approach == "sort"){
- this._update_sort(to_remove, to_insert, options);
- }
- };
-
-
- /*
- Accessors
- */
-
- BinarySearch.prototype.getMinimum = function () {
- return (this.array.length > 0) ? this.array[0] : undefined;
- };
-
- BinarySearch.prototype.getMaximum = function () {
- return (this.array.length > 0) ? this.array[this.array.length - 1] : undefined;
- };
-
-
- /*
- Internal search functions
- */
-
- /*
- Find index of largest value less than x
- Returns -1 if noe values exist that are less than x
- */
- BinarySearch.prototype.ltIndexOf = function(x) {
- var i = this.binaryIndexOf(x);
- if (this.isFound(i, x)) {
- /*
- found - x is found on index i
- consider element to the left
- if we are at the left end of the array nothing is found
- return -1
- */
- if (i > 0) {
- return i-1;
- } else {
- return -1;
- }
- } else {
- /*
- not found - Math.abs(i) is index where x should be inserted
- => Math.abs(i) - 1 is the largest value less than x
- */
- return Math.abs(i)-1;
- }
- };
-
- /*
- Find index of rightmost value less than x or equal to x
- Returns -1 if noe values exist that are less than x or equal to x
- */
- BinarySearch.prototype.leIndexOf = function(x) {
- var i = this.binaryIndexOf(x);
- if (this.isFound(i, x)) {
- /*
- element found
- */
- return i;
- } else {
- // not found - consider element to the left
- i = Math.abs(i) - 1;
- return (i >= 0) ? i : -1;
- }
- };
-
- /*
- Find index of leftmost value greater than x
- Returns -1 if no values exist that are greater than x
- */
-
- BinarySearch.prototype.gtIndexOf = function (x) {
- var i = this.binaryIndexOf(x);
- if (this.isFound(i, x)) {
- /*
- found - x is found on index i
- if there are no elements to the right return -1
- */
- if (i < this.array.length -1) {
- return i+1;
- } else {
- return -1;
- }
- } else {
- /*
- not found - Math.abs(i) is index where x should be inserted
- => Math.abs(i) is the smallest value greater than x
- unless we hit the end of the array, in which cas no smalles value
- exist which is greater than x
- */
- let idx = Math.abs(i);
- return (idx < this.array.length) ? idx : -1;
- }
- };
-
-
- /*
- Find index of leftmost value which is greater than x or equal to x
- Returns -1 if noe values exist that are greater than x or equal to x
- */
-
- BinarySearch.prototype.geIndexOf = function(x) {
- var i = this.binaryIndexOf(x);
- if (this.isFound(i, x)) {
- /*
- found element
- */
- return i;
- } else {
- // not found - consider the element where x would be inserted
- i = Math.abs(i);
- return (i -1) {
- return [index, index + 1];
- } else {
- return [undefined, undefined];
- }
- }
-
- // regular non-singular interval
- var start_index = -1, end_index = -1;
- if (interval.lowInclude) {
- start_index = this.geIndexOf(interval.low);
- } else {
- start_index = this.gtIndexOf(interval.low);
- }
- if (start_index === -1) {
- return [undefined, undefined];
- }
- if (interval.highInclude) {
- end_index = this.leIndexOf(interval.high);
- } else {
- end_index = this.ltIndexOf(interval.high);
- }
- if (end_index === -1) { // not reachable - I think
- return [undefined, undefined];
- }
- return [start_index, end_index + 1];
- };
-
-
- /*
- lookup by interval
- */
- BinarySearch.prototype.lookup = function (interval) {
- let [start, end] = this.lookupIndexes(interval);
- return (start != undefined) ? this.array.slice(start, end) : [];
- };
-
- /*
- remove by interval
- */
- BinarySearch.prototype.remove = function (interval) {
- let [start, end] = this.lookupIndexes(interval);
- return (start != undefined) ? this.array.splice(start, end-start) : [];
- };
-
-
- BinarySearch.prototype.slice = function (start, end) {
- return this.array.slice(start, end);
- };
-
- BinarySearch.prototype.splice = function (start, length) {
- return this.array.splice(start, length);
- };
-
-
-
- /*
- method for removing multiple closely placed elements in place
- - removeList is sorted
- - changes only affect the part of the index between first and last element
- - move remaining elements to the left, remove elements with a single splice
- - efficent if removelist references elements that are close to eachother
- */
-
- BinarySearch.prototype.removeInSlice = function (removeList) {
- if (removeList.length == 0){
- return;
- }
- const low = removeList[0];
- const high = removeList[removeList.length-1];
- let [start, end] = this.lookupIndexes(new Interval(low, high, true, true));
-
- let rd_ptr = start;
- let wr_ptr = start;
- let rm_ptr = 0;
-
- while (rd_ptr < end) {
- let rd_elem = this.array[rd_ptr];
- let rm_elem = removeList[rm_ptr];
- if (rd_elem < rm_elem) {
- this.array[wr_ptr] = this.array[rd_ptr];
- wr_ptr++;
- rd_ptr++;
- } else if (rd_elem == rm_elem) {
- rd_ptr++;
- rm_ptr++;
- } else {
- // rd_elem > rm_elem
- rm_ptr++;
- }
- if (rm_ptr == removeList.length) {
- break
- }
- }
- this.array.splice(wr_ptr, rd_ptr-wr_ptr);
- };
-
-
-
- BinarySearch.prototype.values = function () {
- return this.array.values();
- };
-
- BinarySearch.prototype.clear = function () {
- this.array = [];
- };
-
- Object.defineProperty(BinarySearch.prototype, "length", {
- get: function () {
- return this.array.length;
- }
- });
-
- return BinarySearch;
-});
-
-
-
-
-define ('sequencing/axis',['../util/binarysearch', '../util/interval', '../util/eventify'],
- function (BinarySearch, Interval, eventify) {
-
- 'use strict';
-
- /*
- UTILITY
- */
-
-
- /*
- concat two arrays without creating a copy
- push elements from the shortest into the longest
- return the longest
- */
- const mergeArrays = function(arr1, arr2) {
- const [shortest, longest] = (arr1.length <= arr2.length) ? [arr1, arr2] : [arr2, arr1];
- let len = shortest.length;
- for (let i=0; i -1) {
- arr.splice(idx, 1);
- }
- return arr.length == 0;
- }
- };
-
-
- /*
- returns true if interval b has at least one endpoint inside interval a
-
- There are some subtleties if interval B shares one or two endpoints with A
-
- 4 ways for intervals to share an endpoint
- - a.high == b.low :
- >< (b.low outside a)
- >[ (b.low outside a)
- ]< (b.low outside a)
- ][ (b.low inside a)
- - b.high == a.low :
- >< (b.high outside a)
- >[ (b.high outside a)
- ]< (b.high outside a )
- ][ (b.high inside a)
- - a.high == b.high:
- >> (b.high inside a)
- >] (b.high outside a)
- ]> (b.high inside a)
- ]] (b.high inside a)
- - a.low == b.low :
- << (b.low inside a)
- <[ (b.low outside a)
- [< (b.low inside a)
- [[ (b.low inside a)
- */
-
- var endpointInside = function (a, b) {
- // check if b is to the right of a
- if (a.high < b.low) return false;
- // check if b is to the left of a
- if (b.high < a.low) return false;
- // check if b.low is inside a
- if (a.low < b.low && b.low < a.high) return true;
- // check if b.high is inside a
- if (a.low < b.high && b.high < a.high) return true;
- // special consideration if a and b happens to share one or two endpoints
- if (a.high == b.low) {
- if (a.highInclude && b.lowInclude) return true;
- }
- if (b.high == a.low) {
- if (b.highInclude && a.lowInclude) return true;
- }
- if (a.high == b.high) {
- if (!(!a.highInclude && b.highInclude)) return true;
- }
- if (a.low == b.low) {
- if (!(!a.lowInclude && b.lowInclude)) return true;
- }
- return false;
- };
-
-
- /*
- Setup for cue buckets.
- */
- const CueBucketIds = [0,10,100,1000,10000,100000, Infinity];
- var getCueBucketId = function (length) {
- for (let i=0; i cue
- */
- this._cueMap = new Map();
-
- /*
- Initialise set of CueBuckets
- Each CueBucket is responsible for cues of a certain length
- */
- this._cueBuckets = new Map(); // CueBucketId -> CueBucket
- for (let i=0; i {new: new_cue, old: old_cue}
-
- BatchMap is generated during initial batch processing,
- representing the effects of the entire cue batch,
- thus making cue batch processing into an atomic operation.
-
- - If operation applies to cue that already exists, the old cue
- will be included.
-
- - If multiple operations in a batch apply to the same
- cue, items will effectively be collapsed into one operation.
-
- - If a cue was available before cue processing started,
- this will be reported as old value (if this cue has been modified
- in any way), even if the cue has been modified multiple times
- during the batch. The last cue modification on a given key defines the new
- cue.
-
- - If a cue is both added and removed in the same batch,
- it will not be included in items.
- */
-
-
- Axis.prototype._update = function(cues) {
-
- /*
- process cue batch to make batchMap
- - distinguish add from modify by including old values from cueMap
- - collapse if same cue is mentioned multiple times
- */
- let batchMap = new Map(); // key -> {new:new_cue, old:old_cue}
- let len = cues.length;
- let init = this._cueMap.size == 0;
- for (let i=0; i 0) {
- res.push(cues);
- }
- }
- return [].concat(...res);
- };
-
- /*
- GET CUEPOINTS BY INTERVAL
-
- returns (point, cue) for all points covered by given interval
-
- returns:
- - list of cuepoints, from cue endpoints within interval
- - [{point: point, cue:cue}]
- */
- Axis.prototype.getCuePointsByInterval = function (interval) {
- return this._execute(Method.LOOKUP_CUEPOINTS, interval);
- };
-
- /*
- GET CUES BY INTERVAL
-
- semantic - "inside" | "partial" | "overlap"
-
- */
- Axis.prototype.getCuesByInterval = function (interval, semantic=Semantic.OVERLAP) {
- return this._execute(Method.LOOKUP_CUES, interval, semantic);
- };
-
-
- /*
- REMOVE CUES BY INTERVAL
- */
- Axis.prototype.removeCuesByInterval = function (interval, semantic=Semantic.INSIDE) {
- const cues = this._execute(Method.REMOVE_CUES, interval, semantic);
- // remove from cueMap and make events
- const eventMap = new Map();
- for (let i=0; i [cue, ....]
- */
- this._pointMap = new Map();
-
-
- /*
- pointIndex maintains a sorted list of numbers for efficient lookup.
- A large volume of insert and remove operations may be problematic
- with respect to performance, so the implementation seeks to
- do a single bulk update on this structure, for each batch of cue
- operations (i.e. each invocations of addCues). In order to do this
- all cue operations are processed to calculate a single batch
- of deletes and a single batch of inserts which then will be applied to
- the pointIndex in one atomic operation.
-
- [1.2, 3, 4, 8.1, ....]
- */
- this._pointIndex = new BinarySearch();
-
- // bookeeping during batch processing
- this._created = new Set(); // point
- this._dirty = new Set(); // point
- };
-
-
- /*
-
- CUE BATCH PROCESSING
-
- Needs to translates cue operations into a minimum set of
- operations on the pointIndex.
-
- To do this, we need to record points that are created and
- points which are modified.
-
- The total difference that the batch of cue operations
- amounts to is expressed as one list of values to be
- deleted, and and one list of values to be inserted.
- The update operation of the pointIndex will process both
- in one atomic operation.
-
- On flush both the pointMap and the pointIndex will brought
- up to speed
-
- created and dirty are used for bookeeping during
- processing of a cue batch. They are needed to
- create the correct diff operation to be applied on pointIndex.
-
- created : includes values that were not in pointMap
- before current batch was processed
-
- dirty : includes values that were in pointMap
- before curent batch was processed, and that
- have been become empty at least at one point during cue
- processing.
-
- created and dirty are used as temporary alternatives to pointMap.
- after the cue processing, pointmap will updated based on the
- contents of these two.
-
- operation add or remove for given cue
-
- this method may be invoked at most two times for the same key.
- - first "remove" on the old cue
- - second "add" on the new cue
-
-
- "add" means point to be added to point
- "remove" means cue to be removed from point
-
- process buffers operations for pointMap and index so that
- all operations may be applied in one batch. This happens in flush
- */
-
- CueBucket.prototype.processCue = function (op, cue) {
-
- let points, point, cues;
- if (cue.singular) {
- points = [cue.interval.low]
- } else {
- points = [cue.interval.low, cue.interval.high];
- }
-
- let init = (this._pointMap.size == 0);
-
- for (let i=0; i 0) {
- to_insert.push(point);
- } else {
- this._pointMap.delete(point);
- }
- }
- for (let point of this._dirty.values()) {
- let cues = this._pointMap.get(point);
- if (cues.length == 0) {
- to_remove.push(point);
- this._pointMap.delete(point);
- }
- }
- this._pointIndex.update(to_remove, to_insert);
- // cleanup
- this._created.clear();
- this._dirty.clear();
- };
-
-
-
- /*
- _getCuesFromInterval
-
- internal utility function to find cues from endpoints in interval
-
- getCuesByInterval will find points in interval in pointIndex and
- find the associated cues from pointMap.
-
- Cues may be reported more than once
- Any specific order of cues is not defined.
-
- (at least one cue endpoint will be equal to point)
-
- Note: This function returns only cues with endpoints covered by the interval.
- It does not return cues that cover the interval (i.e. one endpoint at each
- side of the interval).
-
- option cuepoint signals to include both the cue and its point
- {point:point, cue:cue}
- if not - a list of cues is returned
-
- the order is defined by point values (ascending), whether points are included or not.
- each point value is reported once, yet one cue
- may be reference by 1 or 2 points.
-
- returns list of cues, or list of cuepoints, based on options
- */
- CueBucket.prototype._lookupCuesFromInterval = function(interval, options={}) {
- const cuepoint = (options.cuepoint != undefined) ? options.cuepoint : false;
- /*
- search for points in pointIndex using interval
- if search interval is endpoints a and b will not be included
- this means that at cue [a,b] will not be picked up - as its enpoints are outside the search interval
- however, this also means that a cue will not be picked up - which is not correct - as these endpoints are inside the search interval
- solution is to broaden the search and filter away
- */
- const broadInterval = new Interval(interval.low, interval.high, true, true);
- const points = this._pointIndex.lookup(broadInterval);
- const res = [];
- const len = points.length;
- const cueSet = new Set();
- for (let i=0; i maxLength, then there can be no overlapping intervals in this bucket
-
- Endpoints must not overlap with endpoints of
- - if interval.lowInclude, then leftInterval.highInclude must be false,
- and vice versa.
- - the same consideration applies to interval.highInclude
- */
- CueBucket.prototype._lookupOutsideCuesFromInterval = function(interval){
- if (interval.length > this._maxLength) {
- return [];
- }
-
- const highIncludeOfLeftInterval = !interval.lowInclude;
- const leftInterval = new Interval(interval.high - this._maxLength, interval.low, true, highIncludeOfLeftInterval);
-
- const lowIncludeOfRightInterval = !interval.highInclude;
- const rightInterval = new Interval(interval.high, interval.low + this._maxLength, lowIncludeOfRightInterval, true);
-
- // iterate leftInterval to find cues that have endpoints covered by rightInterval
- return this._lookupCuesFromInterval(leftInterval)
- .filter(function (cue) {
- // fast test
- if (interval.high < cue.interval.low) {
- return true;
- }
- // more expensive test that will pick up cornercase
- // where [a,b] will actually be an outside covering interval for
- return rightInterval.coversPoint(cue.interval.high);
- });
- };
-
-
- /*
- execute dispatches request to given method.
-
- CUEPOINTS - look up all (point, cue) tuples in search interval
-
- INSIDE - look up all cues with both endpoints INSIDE the search interval
- PARTIAL - look up all INSIDE cues, plus cues with one endpoint inside the search interval
- ALL - look up all PARTIAL cues, plus cues with one cue at each side of search interval
-
- */
- CueBucket.prototype.execute = function (method, interval, semantic) {
- if (this._pointIndex.length == 0) {
- return [];
- }
- if (method == Method.LOOKUP_CUEPOINTS) {
- return this.lookupCuePoints(interval);
- } else if (method == Method.LOOKUP_CUES) {
- return this.lookupCues(interval, semantic);
- } else if (method == Method.REMOVE_CUES) {
- return this.removeCues(interval, semantic);
- } else if (method == Method.INTEGRITY) {
- return this._integrity();
- } else {
- throw new Error("method or semantic not supported " + method + " " + semantic);
- }
- };
-
-
- /*
- LOOKUP CUEPOINTS - look up all (point, cue) tuples in search interval
- */
- CueBucket.prototype.lookupCuePoints = function (interval) {
- return this._lookupCuesFromInterval(interval, {cuepoint:true});
- };
-
-
- /*
- LOOKUP CUES
- */
- CueBucket.prototype.lookupCues = function (interval, semantic=Semantic.OVERLAP) {
- const partial_cues = this._lookupCuesFromInterval(interval, {cuepoint:false});
- if (semantic == Semantic.PARTIAL) {
- return partial_cues;
- } else if (semantic == Semantic.INSIDE) {
- return partial_cues.filter(function (cue) {
- return interval.coversInterval(cue.interval);
- });
- } else if (semantic == Semantic.OVERLAP) {
- const outside_cues = this._lookupOutsideCuesFromInterval(interval);
- return mergeArrays(partial_cues, outside_cues);
- } else {
- throw new Error("illegal semantic " + semantic);
- }
- }
-
-
- /*
- REMOVE CUES
- */
- CueBucket.prototype.removeCues = function (interval, semantic) {
- /*
- update pointMap
- - remove all cues from pointMap
- - remove empty entries in pointMap
- - record points that became empty, as these need to be deleted in pointIndex
- - separate into two bucketes, inside and outside
- */
- const cues = this.execute(Method.LOOKUP_CUES, interval, semantic);
- const to_remove = [];
- let cue, point, points;
- for (let i=0; i 0) {
- throw new Error("differences in points " + [...missing]);
- }
-
- // collect all cues
- let cues = [];
- for (let _cues of this._pointMap.values()) {
- for (let cue of _cues.values()) {
- cues.push(cue);
- }
- }
- // remove duplicates
- cues = [...new Map(cues.map(function(cue){
- return [cue.key, cue];
- })).values()];
-
- // check all cues
- for (let cue of cues.values()) {
- if (cue.interval.length > this._maxLength) {
- throw new Error("cue interval violates maxLength ", cue);
- }
- let points;
- if (cue.singular) {
- points = [cue.interval.low];
- } else {
- points = [cue.interval.low, cue.interval.high];
- }
- for (let point of points.values()) {
- if (!this._pointIndex.has(point)) {
- throw new Error("point from pointMap cue not found in pointIndex ", point);
- }
- }
- }
-
- return [{
- maxLength: this._maxLength,
- points: [...this._pointMap.keys()],
- cues: cues
- }];
- };
-
-
-
-
- // module definition
- return Axis;
-});
-
-/*
- Copyright 2015 Norut Northern Research Institute
- Author : Ingar Mæhlum Arntzen
-
- This file is part of the Timingsrc module.
-
- Timingsrc is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Timingsrc is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with Timingsrc. If not, see and timestamps defines the time
- interval covered by the schedule - the . The
- idea is to move this interval stepwise, to eventually cover the
- entire time-line. The length of this interval is defined by the
- option . The default value is 5 seconds.
-
- The operation moves the interval so that the next
- interval matches the previous interval . If
- lookahead is 5 seconds, the general idea is to advance the
- covering interval every 5 seconds. However, it is safe to
- advance it more often. It is also safe to advance it less
- often. In this case the covering interval will grow in length to
- cover otherwise lost parts of the timeline - but events will be
- delivered too late.
-
- The push(ts,task) operation allows tasks to be added to the
- schedule, provided their due-times fall within the covering
- interval. The push_immediate(task) will assign === now.
- Push maintains time ordering.
-
- The pop() operation is used to get all tasks that are due for
- execution. The schedule should be popped regularly/frequently to
- keep tasks from being delayed in execution. The delay_next()
- operation returns the time (milliseconds) until the next task is
- due. This can be used with setTimeout() to arrange timely
- popping. However, note that this timeout may have to be
- re-evealuated as new tasks are pushed onto the schedule.
-
- Associated with the (time), there is also a
- "covering interval" with respect to timing object(position). Eg. In real-time
- (epoch) interval [1434891233.407, 1434891235.407] movement of timing object covers
- positions [23.0, 25.0]. All tasks are associated with a position on a
- dimension. This is set by the advance() operation. The position
- interval is used (externally) to quickly evaluate relevance of tasks, essentially to
- avoid calculating the due-times of a task only to find that it falls
- outside the time convering interval. Position interval is only managed
- externally.
-
- */
-
- var Schedule = function (now, options) {
- this.queue = [];
- // options
- this.options = options || {};
- this.options.lookahead = this.options.lookahead || 5.0;
- // time-interval
- var start = now;
- var end = now + this.options.lookahead;
-
- this.timeInterval = new Interval(start, end, true, true);
- // position-interval
- this.posInterval = null;
- };
-
- Schedule.prototype.getTimeInterval = function (){return this.timeInterval;};
- Schedule.prototype.getPosInterval = function (){return this.posInterval;};
- Schedule.prototype.setPosInterval = function (interval) {this.posInterval = interval;};
- Schedule.prototype.sortFunc = function(a,b) {return a.ts - b.ts;};
-
- // push
- // task assumed to have a key -- se usage by Sequencer
- Schedule.prototype.push = function (now, ts, task) {
- if (this.timeInterval.coversPoint(ts)) {
- var entry = {
- ts: ts,
- task: task,
- push_ts: now
- };
- if (ts >= now) {
- this.queue.push(entry);
- this.queue.sort(this.sortFunc); // maintain ordering
- return true;
- } else {
- console.log("Schedule : task pushed a bit too late, ts < now ", (ts-now));
- }
- }
- return false;
- };
-
- // pop
- Schedule.prototype.pop = function (now) {
- var res = [];
- while (this.queue.length > 0 && this.queue[0].ts <= now) {
- var entry = this.queue.shift();
- var info = {
- task: entry.task,
- pop_ts: now, // fresh timestamp?
- push_ts: entry.push_ts,
- ts: entry.ts
- };
- res.push(info);
- }
- return res;
- };
-
-
- /* Invalidate task with given key */
- Schedule.prototype.invalidate = function (key) {
- var i, index, entry, remove = [];
- // Find
- for (i=0; i -1) {
- this.queue.splice(index, 1);
- }
- }
- };
-
-
- /*
-
- ADVANCE
-
- The covering time interval is defined by [start,end>
- The covering interval should be advanced so that it always
- contains real-time, e.g., now.
-
- Advancing the covering interval assumes task queues to be empty.
- Therefore, make sure to pop all task before calling advance.
-
- Also, the time-sequence of covering intervals should ideally
- lay back-to-back on the time-line. To achive this the end of
- one interval becomes the start of the next. The end of the interval is
- now + lookahead.
-
- If advance is called before the current interval is expired,
- the current interval is cut short.
-
- If advance is not called for an extended time, the next
- invocation will cause the covering interval to stretch long
- into the past.
-
- If parameter start is supplied, this is used as starting point
- for covering interval.
-
- */
-
- Schedule.prototype.advance = function(now) {
- if (now < this.timeInterval.low) {
- console.log("Schedule : Advancing backwards " + (now - this.timeInterval.low));
- }
- var start = now;
- var end = now + this.options.lookahead;
- this.queue = []; // drop tasks (time interval cut off)
- this.timeInterval = new Interval(start, end, false, true);
- this.posInterval = null; // reset
- };
-
- /*
- Current schedule is expired (at given time)
- */
- Schedule.prototype.isExpired = function(now) {
- return (now > this.timeInterval.high);
- };
-
- /*
- delay until the next due task in schedule, or until the
- current time_interval expires
- */
- Schedule.prototype.getDelayNextTs = function (ts) {
- // ts should be fresh timestamp in seconds
- if (this.queue.length > 0) {
- return Math.max(0.0, this.queue[0].ts - ts);
- }
- return Math.max(0.0, this.timeInterval.high - ts);
- };
-
- Schedule.prototype.getNextTaskPoint = function () {
- return (this.queue.length > 0) ? this.queue[0].task.point : null;
- };
-
-
-
- /*
-
- SEQUENCER
-
- */
- var Sequencer = function (timingObject, _axis) {
- if (!(this instanceof Sequencer)) {
- throw new Error("Contructor function called without new operation");
- }
-
- // core resources
- this._to = timingObject;
- this._axis = _axis || new Axis();
-
- // timeout stuff
- this._schedule = null;
- this._timeout = null; // timeout
- this._currentTimeoutPoint = null; // point associated with current timeout
-
- // ready
- this._ready = new eventify.EventBoolean(false, {init:true});
-
- // active cues
- this._activeCues = new Map(); // (key -> cue)
- this._activeCuesList = [];
-
- // event stuff
- eventify.eventifyInstance(this);
- this.eventifyDefineEvent("change", {init:true}); // define enter event (supporting init-event)
- this.eventifyDefineEvent("remove");
-
- // wrap prototype handlers and store ref on instance
- this._wrappedOnTimingChange = function (eArg) {
- this._onTimingChange();
- // ready after processing the first onTimingChange
- if (this._ready.value == false) {
- this._ready.value = true;
- }
- };
- this._wrappedOnAxisChange = function (eArg) {
- if (this._ready.value == true) {
- this._onAxisChange(eArg);
- }
- };
-
- // connect to timing object and axis
- this._to.on("change", this._wrappedOnTimingChange, this);
- this._axis.on("change", this._wrappedOnAxisChange, this);
- };
- eventify.eventifyPrototype(Sequencer.prototype);
-
-
-
- Sequencer.prototype.isReady = function () {
- return this._ready.value;
- };
-
- // ready promise
- Object.defineProperty(Sequencer.prototype, 'ready', {
- get : function () {
- var self = this;
- return new Promise (function (resolve, reject) {
- if (self._ready.value === true) {
- resolve();
- } else {
- var onReady = function () {
- if (self._ready.value === true) {
- self._ready.off("change", onReady);
- resolve();
- }
- };
- self._ready.on("change", onReady);
- }
- });
- }
- });
-
- /*
- overrides how immediate events are constructed
- */
- Sequencer.prototype.eventifyMakeInitEvents = function (type) {
- if (type === "change") {
- if (this._ready.value == false) {
- return [];
- } else {
- // prepare initial events based on active cues
- const nowVector = this._to.query();
- const directionInt = motionutils.calculateDirection(this._to.vector, nowVector.timestamp);
- const eArgList = [];
- for (let cue of this._activeCues.values()) {
- eArgList.push(makeEArg(nowVector.timestamp, nowVector.position, cue, directionInt, Cause.INIT, VerbType.ENTER));
- }
- return eArgList;
- }
- }
- return [];
- };
-
- /*
-
- ON TIMING OBJECT CHANGE
-
- Whenever the timingobject position changes abruptly we need to
- re-evaluate intervals.
-
- A) Abrupt changes in position occur
- 1) after certain timing object changes or
- 2) when the timing object is initially loaded.
-
- B) Non-abrupts changes occur when velocity or acceleration is
- changed without immediately affecting the position
-
- In all cases - the schedule and timeout need to be re-evaluated.
-
- In case A. 1) the timing object change is possibly late due to network
- latency. To include effects of singulars/intervals from the small "lost"
- time interval, make sure to advance according to the timestamp of the
- timing object vector. 2) is not delayed.
-
-
- Furthermore in a small time-interval just before timing object updates
- the previous vector incorrectly drove the sequencer instead of the new
- updated vector. This may have caused the sequencer to falsely
- report some events, and to not report other events. This time
- interval is (initVector[T], now). For non-singular Intervals this will be
- corrected by the general re-evalution of Intervals. For singular Intervals
- explicit action is required to signal incorrect events. This implementation
- does not support this.
-
- */
-
- Sequencer.prototype._onTimingChange = function (eArg) {
- const nowVector = this._to.query();
- this._reevaluate(nowVector, Cause.TIMINGCHANGE);
- };
-
- Sequencer.prototype._onAxisChange = function (eventMap) {
- const nowVector = this._to.query();
- this._reevaluate(nowVector, Cause.CUECHANGE, eventMap);
- };
-
- /*
- Reevaluate active cues on a given point in time
- modifiedCues are given from onAxisChange
-
- could have used modifiedCues from axis change to change activeCues
- instead, simply reevaluate active cues with axis. This is likely
- more effective for large batches.
-
- Possible optimization:
- Consider the size of eventMap. If the eventMap is quite small,
- it may be quicker adjust activeCues by iterating eventMap and
- considering if each cue interval is covering the timing object position.
-
- For larger event batch, calls to getCuesByInterval will
- be quicker.
-
- */
- Sequencer.prototype._reevaluate = function (nowVector, cause, eventMap) {
- const now = nowVector.timestamp;
- const pos = nowVector.position;
-
- /*
- find new active cues
- */
- const activeCues = new Map(this._axis.getCuesByInterval(new Interval(pos)).map(function(cue) {
- return [cue.key, cue];
- }));
- /*
- find exit cues
- were in old active cues - but not in new
- */
- let exitCues = map_difference(this._activeCues, activeCues);
- /*
- find enter cues
- were not in old active cues - but are in new
- */
- let enterCues = map_difference(activeCues, this._activeCues);
- /*
- find change cues
- those cues that were modified and also remain within the set of active cues
- */
- let changeCues = new Map();
- if (cause == Cause.CUECHANGE) {
- const modifiedCues = new Map([...eventMap].filter(function ([key, eItem]) {
- return eItem.new && eItem.old;
- }).map(function([key, eItem]) {
- return [key, eItem.new];
- }));
- changeCues = map_intersect(modifiedCues, activeCues);
- }
-
- // update active cues
- this._activeCues = activeCues;
-
- // make events
- const eList = this._makeChangeEvents(now, nowVector.position, cause, exitCues, enterCues, changeCues);
- this.eventifyTriggerEvents(eList);
-
- /*
- Crazy Corner Case
-
- If reevaluate is executed with the timing object at position P and there is a cue C which has P as closed endpoint.
- For instance:
-
- C.interval : [P] |
-
- Since timing object position P is covered by cue C, an enter event will be generated by the code above.
-
- However, if the timing object additionally has velocity in the direction away from cue C, a playback exit event will
- immediately be needed. However, this will not be picked up by load/schedule, as this will only consider cue endpoints
- within the next segment on the timeline, which does not include point P, i.e. , depending
- on direction.
-
- Entering open intervals should be covered by schedule/load on next timeline segment.
-
- To solve this we will generate the needed playback events here. Active cues will be adjusted as part of that process.
-
- This issue is not likely to be easily reproducible, because for instance setting the timing object to
- {position:0, velocity:1} with yield a nowVector sampled a little bit later, which gives a position which is 0+delta, which
- means that cues that are tied to endpoint 0 will be detected by code above. So one really needs to be precise to a large
- number of decimal places for a cueendpoint to match the position exactly.
-
- */
- const directionInt = motionutils.calculateDirection(nowVector, now);
-
- if (isMoving(nowVector)) {
- const cuepoints = this._axis.getCuePointsByInterval(new Interval(pos));
- const direction = DirectionType.fromInteger(directionInt);
- exitCues = new Map();
- for (let cp of cuepoints.values()) {
- if (cp.cue.interval.singular) {
- exitCues.set(cp.cue.key, cp.cue);
- } else {
- // closed interval ?
- const interval = cp.cue.interval;
- const pointType = getPointType(pos, interval);
- let closed = false;
- if (pointType === PointType.LOW && interval.lowInclude) {
- closed = true;
- } else if (pointType === PointType.HIGH && interval.highInclude) {
- closed = true;
- }
- // exiting or entering interval?
- var entering = true;
- if (pointType === PointType.LOW && direction === DirectionType.BACKWARDS) {
- entering = false;
- } else if (pointType === PointType.HIGH && direction === DirectionType.FORWARDS) {
- entering = false;
- }
- // exiting closed interval
- if (!entering && closed) {
- exitCues.set(cp.cue.key, cp.cue);
- }
- }
- }
- // make events
- const _now = this._to.clock.now();
- const eList = [];
- for (let cue of exitCues.values()) {
- let eArg = makeEArg(_now, pos, cue, directionInt, Cause.PLAYBACK, VerbType.EXIT, now);
- eList.push({type: eArg.type, e:eArg});
- this._activeCues.delete(cue.key);
- }
- this.eventifyTriggerEvents(eList);
- }
-
- // update list version of activeCues
- this._activeCuesList = [...this._activeCues.values()];
-
- // clear schedule
- if (this._schedule == undefined) {
- this._schedule = new Schedule(now);
- } else {
- this._schedule.advance(now);
- }
-
- // kick off main loop
- if (isMoving(nowVector)) {
- this._load(now);
- this._main(now);
- } else {
- // stop main loop
- this._clearTimeout();
- }
- };
-
-
- /*
- Make events triggered by changes, either timing object changes or cue changes
- */
- Sequencer.prototype._makeChangeEvents = function (now, point, cause, exitCues, enterCues, changeCues) {
- const directionInt = motionutils.calculateDirection(this._to.vector, now);
- let eArgList = [];
- for (let cue of exitCues.values()) {
- eArgList.push(makeEArg(now, point, cue, directionInt, cause, VerbType.EXIT));
- }
- for (let cue of enterCues.values()) {
- eArgList.push(makeEArg(now, point, cue, directionInt, cause, VerbType.ENTER));
- }
-
- for (let cue of changeCues.values()) {
- eArgList.push(makeEArg(now, point, cue, directionInt, cause, VerbType.UPDATE))
- }
- // make sure events are correctly ordered
- eArgList = this._reorderEventList(eArgList, directionInt);
- return eArgList.map(function (eArg) {
- return {type: eArg.type, e:eArg};
- });
- };
-
-
- /*
- Make events during playback, from schedule task list
- */
- Sequencer.prototype._makePlaybackEvents = function (now, scheduleEntries) {
- const directionInt = motionutils.calculateDirection(this._to.vector, now);
- let eArgList = [];
- let entry, task;
- let dirty = false;
- for (let i=0; i 0) {
- let eList = this._makePlaybackEvents(now, tasks);
- this.eventifyTriggerEvents(eList);
- }
-
- // advance schedule window if end is reached
- var _isMoving = isMoving(this._to.vector);
- if (_isMoving && this._schedule.isExpired(now)) {
- // advance schedule to end of current window
- now = this._schedule.getTimeInterval().high;
- this._schedule.advance(now);
- this._load(now);
- // process tasks again in case some are due immediately
- let tasks = this._schedule.pop(now);
- if (tasks.length > 0) {
- let eList = this._makePlaybackEvents(now, tasks);
- this.eventifyTriggerEvents(eList);
- }
- }
- // adjust timeout if needed
- if (_isMoving) {
- let newTimeoutRequired = (this._timeout === null);
- if (!newTimeoutRequired) {
- // timeout exist - modify?
- // avoid modifying timeout if new timeout is equal to existing timeout
- // i.e. if task point is the same as last time
- var nextTimeoutPoint = this._schedule.getNextTaskPoint();
- if (nextTimeoutPoint === null) {
- // timeout is set for schedule window - no tasks in schedule
- // do not modify timeout
- } else {
- // nextTimeoutPoint defined - tasks in the schedule
- if (nextTimeoutPoint === this._currentTimeoutPoint) {
- // do not modify timeout
- } else {
- // modify timeout
- newTimeoutRequired = true
- }
- }
- }
- if (newTimeoutRequired) {
- // clear timeout
- this._clearTimeout();
- // update timeout
- var secAnchor = this._to.clock.now();
- var secDelay = this._schedule.getDelayNextTs(secAnchor); // seconds
- this._currentTimeoutPoint = nextTimeoutPoint;
- var self = this;
- this._timeout = this._to.clock.setTimeout(function () {
- self._clearTimeout();
- self._main(undefined, true);
- }, secDelay, {anchor: secAnchor, early: 0.005});
- }
- }
- };
-
-
- Sequencer.prototype._clearTimeout = function () {
- this._currentTimeoutPoint = null;
- if (this._timeout !== null) {
- this._timeout.cancel();
- this._timeout = null;
- }
- };
-
- /*
- LOAD
-
- Sequencer loads a new batch of points from axis into
- the schedule
-
- If given_points is specified, this implies that the
- points to load are known in advance. This is the case when
- axis is being updated dynamically during execution. If
- points are not known the load function fetches points from
- the axis by means of the time cover of the schedule.
-
- load only makes sense when timing object is moving
- */
-
- Sequencer.prototype._load = function (now, givenPoints) {
-
- /*
- MOVING
- Load events from time interval
- */
- var timeInterval = this._schedule.getTimeInterval();
- var tStart = timeInterval.low;
- var tEnd = timeInterval.high;
- var tDelta = timeInterval.length;
- // range
- var range = this._to.range;
- var vectorStart = motionutils.calculateVector(this._to.vector, tStart);
- var points = givenPoints;
-
- // Calculate points if not provided
- if (!points) {
-
- // 1) find the interval covered by the movement of timing object during the time delta
- var posRange = motionutils.calculateInterval(vectorStart, tDelta);
- var pStart = Math.round10(Math.max(posRange[0], range[0]), -10);
- var pEnd = Math.round10(Math.min(posRange[1], range[1]), -10);
-
- /*
- posInterval always <,]
- */
- const posInterval = new Interval(pStart, pEnd, false, true);
- this._schedule.setPosInterval(posInterval);
-
- // 2) find all points in this interval
- points = this._axis.getCuePointsByInterval(posInterval);
- }
-
- // create ordered list of all events for time interval t_delta
- var eventList = motionutils.calculateSolutionsInInterval(vectorStart, tDelta, points);
- if (points.length !== eventList.length) {
- console.log("warning : mismatch points and events", points.length, eventList.length);
- }
-
- /*
- SUBTLE 1 : adjust for range restrictions within
- time-interval tasks with larger delta will not be
- pushed to schedule it is not necessary to truncate the
- time interval of schedule similarly - just drop all
- events after prospective range violations. is
- time to (first) range violation
- */
- var rDelta = motionutils.calculateDelta(vectorStart, range)[0];
-
- /*
- SUBTLE 2: avoid tasks exactly at start of time-interval
- assume that this point should already be processed by the
- previous covering interval.
- */
-
- // filter and push events on sched
- eventList.forEach(function (e) {
-
- var d = e[0];
- var task = e[1];
- const pointType = getPointType(task.point, task.cue.interval);
- var push = true;
-
- /*
- events from within the time interval may still be too late,
- if they are before now .
- this may happen when new items are added dynamically
- even though we drop them here, they already had their
- effect in calculation of enter/exit events.
- */
- if (tStart + d < now) {
- push = false;
- }
-
- /*
- drop events exactly at the start of the time covering
- interval.
- likely obsolete since we are fetching points [low, high]
- */
- if (d === 0) {
- console.log("drop - exactly at start of time covering");
- push = false;
- }
- /*
- drop all events scheduled after (in time) range
- violation should occur
- */
- if (d > rDelta) {
- console.log("drop - events after range violations");
- push = false;
- }
- /*
- event scheduled exactly at range point.
- - interval :
- Exiting/entering a interval should not happen at range point - drop
- */
- if (d === rDelta) {
- console.log("drop - events exactly at range point")
- push = false;
- }
-
- /*
- check if we are touching an interval without
- entering or exiting. Note that direction will
- not be zero at this point, because direction
- includes acceleration, which is not zero in
- this case.
- drop all interval events that have zero velocity
- at the time it is supposed to fire
- */
- if (pointType === PointType.LOW || pointType === PointType.HIGH) {
- var v = motionutils.calculateVector(this._to.vector, tStart + d);
- if (v.velocity === 0){
- console.log("drop - touch endpoint during acceleration");
- push = false;
- }
- }
- // push
- if (push) {
- this._schedule.push(now, tStart + d, task);
- }
- }, this);
- };
-
-
- /*
- Event list is sorted by time.
- There can be multiple events on the same time.
- Events with the same point (thus time) need to be sorted according to the following precedence
- a. exit interval > (interval does not include exit-point)
- x. enter interval [ (interval includes enter-point)
- b. enter singular
- c. exit singular
- y. exit intervals ] (interval includes exit-point)
- d. enter intervals < (interval does not include enter-point)
- */
- Sequencer.prototype._reorderEventList = function (eArgList, directionInt) {
- if (eArgList.length < 2) return eArgList;
- // stack events per point
- var point, dueTs, newList = [];
- var s = {"a": [], "x": [], "b": [], "c": [], "y": [], "d": []};
- eArgList.sort(function (a, b) {
- return a.interval.low - b.interval.low;
- }).forEach(function(eArg) {
- // new point - pop from stack
- if (eArg.point !== point || eArg.dueTs !== dueTs) {
- // pop last from stack
- if (directionInt >= 0) {
- newList = newList.concat(s["a"], s["x"], s["b"], s["c"], s["y"], s["d"]);
- } else {
- newList = newList.concat(s["d"], s["y"], s["c"], s["b"], s["x"], s["a"]);
- }
- s = {"a": [], "x": [], "b": [], "c": [], "y": [], "d": []};
- point = eArg.point;
- dueTs = eArg.dueTs;
- }
- // push on stack
- if (eArg.pointType === PointType.SINGULAR) {
- if (eArg.type === VerbType.ENTER) {
- // enter singular
- s["b"].push(eArg);
- } else {
- // exit singular
- s["c"].push(eArg);
- }
- } else {
- /*
- Interval
- special ordering when we enter or exit interval
- through endpoint (low or high) and this endpoint is CLOSED ] as opposed to OPEN >
- */
- var closed = false;
- if ((eArg.pointType === PointType.LOW) && eArg.interval.lowInclude) {
- closed = true;
- } else if ((eArg.pointType === PointType.HIGH) && eArg.interval.highInclude) {
- closed = true;
- }
- if (eArg.type === VerbType.ENTER) {
- // enter interval
- if (closed) s["x"].push(eArg);
- else s["d"].push(eArg);
- } else {
- // exit interval
- if (closed) s["y"].push(eArg);
- else s["a"].push(eArg);
- }
- }
- }, this);
-
- // pop last from stack
- if (directionInt >= 0) {
- return newList.concat(s["a"], s["x"], s["b"], s["c"], s["y"], s["d"]);
- } else {
- return newList.concat(s["d"], s["y"], s["c"], s["b"], s["x"], s["a"]);
- }
- };
-
-
- /*
- Active Cues API
- */
-
- // return true if cue of given key is currently active
- Sequencer.prototype.isActive = function (key) {
- return (this._activeCues.has(key));
- };
-
- // Get keys of active cues
- Sequencer.prototype.getActiveKeys = function () {
- return [...this._activeCues.keys()];
- };
-
- Sequencer.prototype.getActiveCues = function () {
- return this._activeCuesList;
- };
-
- /*
- Export Axis API
-
- Alternative - expose Axis object itself with .getAxis()
- */
-
- Sequencer.prototype.update = function (cues) {
- return this._axis.update(cues);
- };
-
- Sequencer.prototype.addCue = function (key, interval, data) {
- return this._axis.addCue(key, interval, data)
- };
-
- Sequencer.prototype.removeCue = function (key) {
- return this._axis.removeCue(key);
- };
-
- // true if cues exists with given key
- Sequencer.prototype.hasCue = function (key) {
- return this._axis.has(key);
- };
-
- // get specific cue {key: key, interval:interva} given key
- Sequencer.prototype.getCue = function (key) {
- return this._axis.get(key);
- };
-
- // get all keys
- Sequencer.prototype.keys = function () {
- return this._axis.keys();
- };
-
- // get all cues
- Sequencer.prototype.getCues = function () {
- return this._axis.cues();
- };
-
- Sequencer.prototype.getCuesByInterval = function (interval, semantic) {
- return this._axis.getCuesByInterval(interval, semantic);
- };
-
- Sequencer.prototype.removeCuesByInterval = function (interval, semantic) {
- return this._axis.removeCuesByInterval(interval, semantic);
- };
-
-
- // shutdown
- Sequencer.prototype.close = function () {
- this._to.off("change", this._wrappedOnTimingChange, this);
- this._axis.off("change", this._wrappedOnAxisChange, this);
- if (this._timeout !== null) {
- this._timeout.cancel();
- this._timeout = null;
- }
- };
-
- /*
- utility - print event
- */
- Sequencer.prototype.eventToString = function (e) {
- var s = "[" + e.point.toFixed(2) + "]";
- s += " " + e.key;
- s += " " + e.interval.toString();
- s += " " + e.type;
- var verb = "none";
- if (e.enter) verb = "enter";
- else if (e.exit) verb = "exit";
- s += " (" + e.cause + "," + verb + ")";
- s += " " + e.directionType;
- s += " " + e.pointType;
- s += " delay:" + e.delay.toFixed(4);
- if (e.data) s += " " + JSON.stringify(e.data);
- return s;
- };;
-
- return Sequencer;
-});
-
-
-
-
-/*
- Copyright 2015 Norut Northern Research Institute
- Author : Ingar Mæhlum Arntzen
-
- This file is part of the Timingsrc module.
-
- Timingsrc is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Timingsrc is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with Timingsrc. If not, see !e.has(t)))}const o=function(t,e){return 0==t.size?new Map:0==e.size?t:new Map([...t].filter((function([t,i]){return!e.has(t)})))},l=function(t,e){return[t,e]=t.size<=e.size?[t,e]:[e,t],0==t.size?new Map:new Map([...t].filter((function([t,i]){return e.has(t)})))};function a(t){return null!=t&&"function"==typeof t[Symbol.iterator]}function h(t,e={}){let{copy:i=!1,order:n=!1}=e;if(0==t.length)return[];if(1==t.length)return t[0];let r=t.reduce((t,e)=>t+e.length,0);n||t.sort((t,e)=>e.length-t.length);let s,o,l=i?[]:t.shift(),a=l.length;l.length=r;for(let e of t){o=e.length,s=a+o;for(let t=0;tt instanceof Map).every(t=>1==t))throw new Error("some object in array_of_maps is not a Map",t);n||t.sort((t,e)=>e.size-t.size);let r=i?new Map:t.shift();for(let e of t)for(let[t,i]of e.entries())r.set(t,i);return r},divmod:function(t,e){let i=t%e;return[(t-i)/e,i]},isIterable:a,array_concat:h,object_equals:c,docready:u});const d=function(t){let e=parseFloat(t);return t===e&&!isNaN(e)};function p(t,e,i,n){if(t==1/0&&(0==e||0==i))throw new Error("Infinity endpoint must be right-closed or singular");if(t==-1/0&&(1==e||0==i))throw new Error("-Infinity endpoint must be left-closed or singular");return[t,e,i,n]}function f(t){let[e,i,n,r]=t;return r||null==i?2:i?n?3:0:n?1:4}function v(t,e){if(void 0===t.length){if(!d(t))throw new Error("e1 not a number",t);t=p(t,void 0,void 0,!0)}if(void 0===e.length){if(!d(e))throw new Error("e2 not a number",e);e=p(e,void 0,void 0,!0)}return t[0]!=e[0]?[t[0],e[0]]:[f(t),f(e)]}function g(t,e){let[i,n]=v(t,e),r=i-n;return 0==r?0:r>0?1:-1}var m={cmp:g,toString:function(t){if(void 0===t.length)return t.toString();{let e=f(t),i=t[0];if(i!=1/0&&i!=-1/0||(i="--"),0==e)return i+")";if(1==e)return"["+i;if(2==e)return`[${i}]`;if(3==e)return i+"]";if(4==e)return"("+i}},equals:function(t,e){let[i,n]=v(t,e);return i==n},rightof:function(t,e){let[i,n]=v(t,e);return i>n},leftof:function(t,e){let[i,n]=v(t,e);return ie)throw new w(`low > high, ${t}, ${e}`);if(t===e&&(i=!0,n=!0),t===-1/0&&(i=!0),e===1/0&&(n=!0),void 0===i&&(i=!0),void 0===n&&(n=!1),"boolean"!=typeof i)throw new w("lowInclude not boolean, "+i);if("boolean"!=typeof n)throw new w("highInclude not boolean, "+n);this._low=t,this._high=e,this._lowInclude=i,this._highInclude=n,this._length=this._high-this._low,this._singular=this._low===this._high,this._finite=isFinite(this._low)&&isFinite(this._high),this._endpointLow=m.create(this._low,!1,this._lowInclude,this._singular),this._endpointHigh=m.create(this._high,!0,this._highInclude,this._singular)}get low(){return this._low}get high(){return this._high}get lowInclude(){return this._lowInclude}get highInclude(){return this._highInclude}get length(){return this._length}get singular(){return this._singular}get finite(){return this._finite}get endpointLow(){return this._endpointLow}get endpointHigh(){return this._endpointHigh}toString(){if(this._singular){return`[${this._endpointLow[0]}]`}return`${m.toString(this._endpointLow)},${m.toString(this._endpointHigh)}`}asArray(){return[this._low,this._high,this._lowInclude,this._highInclude]}covers_endpoint(t){let e=m.leftof(t,this._endpointLow),i=m.rightof(t,this._endpointHigh);return!e&&!i}compare(t){return M(this,t)}equals(t){return M(this,t)==k.EQUALS}match(t,e=O){let i=M(this,t);return Boolean(e&i)}}R.Relation=k,R.Match=S,R.cmpLow=A(!0),R.cmpHigh=A(!1),R.fromEndpoints=function(t,e){let[i,n,r,s]=t,[o,l,a,h]=e;if(n)throw new w("illegal endpointLow - bracket must be left");if(!l)throw new w("illegal endpointHigh - bracket must be right");return new R(i,o,r,a)},R.intersect=function(t,e){let i=M(t,e);return i==k.OUTSIDE_LEFT?[]:i==k.OVERLAP_LEFT?[R.fromEndpoints(e.endpointLow,t.endpointHigh)]:i==k.COVERS?[e]:i==k.EQUALS||i==k.COVERED?[t]:i==k.OVERLAP_RIGHT?[R.fromEndpoints(t.endpointLow,e.endpointHigh)]:i==k.OUTSIDE_RIGHT?[]:void 0},R.union=function(t,e){let i=M(t,e);return i==k.OUTSIDE_LEFT?t.high!=e.low||!t.highInclude&&!e.lowInclude?[t,e]:[R.fromEndpoints(t.endpointLow,e.endpointHigh)]:i==k.OVERLAP_LEFT?[R.fromEndpoints(t.endpointLow,e.endpointHigh)]:i==k.COVERS||i==k.EQUALS?[t]:i==k.COVERED?[e]:i==k.OVERLAP_RIGHT?[R.fromEndpoints(e.endpointLow,t.endpointHigh)]:i==k.OUTSIDE_RIGHT?e.high!=t.low||!e.highInclude&&!t.lowInclude?[e,t]:[R.fromEndpoints(e.endpointLow,t.endpointHigh)]:void 0},R.intersectAll=function(t){if(t.sort(R.cmpLow),t.length<=1)return t;const e=[t.shift()];for(;t.length>0;){let i=e.pop(),n=t.shift();e.push(...R.intersect(i,n))}return e},R.unionAll=function(t){if(t.sort(R.cmpLow),t.length<=1)return t;const e=[t.shift()];for(;t.length>0;){let i=e.pop(),n=t.shift();e.push(...R.union(i,n))}return e},function(){function t(t,e,i){return void 0===i||0==+i?Math[t](e):(e=+e,i=+i,isNaN(e)||"number"!=typeof i||i%1!=0?NaN:(e=e.toString().split("e"),+((e=(e=Math[t](+(e[0]+"e"+(e[1]?+e[1]-i:-i)))).toString().split("e"))[0]+"e"+(e[1]?+e[1]+i:i))))}Math.round10||(Math.round10=function(e,i){return t("round",e,i)}),Math.floor10||(Math.floor10=function(e,i){return t("floor",e,i)}),Math.ceil10||(Math.ceil10=function(e,i){return t("ceil",e,i)})}();const L=function(t,e){return t-e};function D(t,e){let i=t.position==e.position,n=t.velocity==e.velocity,r=t.acceleration==e.acceleration,s=t.timestamp==e.timestamp;return i&&n&&r&&s}function C(t,e){if(void 0===e)throw new Error("no ts provided for calculateVector");const i=e-t.timestamp;return{position:t.position+t.velocity*i+.5*t.acceleration*i*i,velocity:t.velocity+t.acceleration*i,acceleration:t.acceleration,timestamp:e}}function N(t,e){let i;i=null==e?t:C(t,e);let n=L(i.velocity,0);return 0===n&&(n=L(t.acceleration,0)),n}function x(t){return 0!==t.velocity||0!==t.acceleration}const P=Object.freeze({INIT:"init",INSIDE:"inside",OUTSIDE_LOW:"outsidelow",OUTSIDE_HIGH:"outsidehigh"});function H(t,e){const{position:i,velocity:n,acceleration:r}=t;if(i>e[1])return P.OUTSIDE_HIGH;if(i0)return P.OUTSIDE_HIGH;if(0===n&&r>0)return P.OUTSIDE_HIGH}else if(i===e[0]){if(n<0)return P.OUTSIDE_LOW;if(0==n&&r<0)return P.OUTSIDE_HIGH}return P.INSIDE}function V(t,e){return H(t,e)!=P.INSIDE}function z(t,e){const i=H(t,e);return i!==P.INSIDE&&(t.velocity=0,t.acceleration=0,i===P.OUTSIDE_HIGH?t.position=e[1]:t.position=e[0]),t}function U(t,e){let i=t.timestamp,n=G(t,e[0]),r=G(t,e[1]);return void 0!==n&&void 0!==r?n=0}function q(t,e,i,n){if(0===i&&0===e)return t!=n?[]:[0];if(0===i)return[(n-t)/e];if(!1===B(t,e,i,n))return[];if(0===e*e-2*i*(t-n))return[-e/i];const r=Math.sqrt(Math.pow(e,2)-2*i*(t-n)),s=(-e+r)/i,o=(-e-r)/i;return[Math.min(s,o),Math.max(s,o)]}function G(t,e){const{position:i,velocity:n,acceleration:r}=t,s=function(t,e,i,n){const r=q(t,e,i,n);return 0===r.length?[]:1==r.length?r[0]>0?[r[0]]:[]:2==r.length?r[1]<0?[]:r[0]>0?[r[0],r[1]]:r[1]>0?[r[1]]:[]:[]}(i,n,r,e);return 0===s.length?void 0:s[0]}function j(t,e){let i=G(t,e[0]),n=G(t,e[1]);return i==1/0&&(i=void 0),n==1/0&&(n=void 0),void 0!==i&&void 0!==n?i0?lt))return e;r=e-1}return~r}isFound(t,e){return t>0||0==t&&this.array.length>0&&this.array[0]==e}indexOf(t){var e=this.binaryIndexOf(t);return this.isFound(e,t)?e:-1}indexOfElements(t){let e,i,n=[];for(let r=0;r-1&&n.push(i);return n}has(t){return this.indexOf(t)>-1}get(t){return this.array[t]}_update_splice(t,e,i){if(this.array.length>0){let e=this.indexOfElements(t);e.sort((function(t,e){return t-e}));for(let t=e.length-1;t>-1;t--)this.array.splice(e[t],1)}let n,r,s=e.length;for(let t=0;t0&&t.length>0){let e=this.indexOfElements(t);for(let t=0;t0){let t=this.array.indexOf(void 0);t>-1&&this.array.splice(t,this.array.length-t)}var n;this.array=(n=this.array,[...new Set(n)])}update(t,e,i){let n=t.length+e.length;if(0==n)return;let r=(s=this.array.length,o=n,0==s?"sort":o<=100?"splice":"sort");var s,o;"splice"==r?this._update_splice(t,e,i):"sort"==r&&this._update_sort(t,e,i)}getMinimum(){return this.array.length>0?this.array[0]:void 0}getMaximum=function(){return this.array.length>0?this.array[this.array.length-1]:void 0};ltIndexOf(t){var e=this.binaryIndexOf(t);return this.isFound(e,t)?e>0?e-1:-1:Math.abs(e)-1}leIndexOf(t){var e=this.binaryIndexOf(t);return this.isFound(e,t)||(e=Math.abs(e)-1)>=0?e:-1}gtIndexOf(t){var e=this.binaryIndexOf(t);if(this.isFound(e,t))return e-1?[e,e+1]:[void 0,void 0]}var e=-1,i=-1;return-1===(e=t.lowInclude?this.geIndexOf(t.low):this.gtIndexOf(t.low))||-1===(i=t.highInclude?this.leIndexOf(t.high):this.ltIndexOf(t.high))?[void 0,void 0]:[e,i+1]}lookup(t){let[e,i]=this.lookupIndexes(t);return null!=e?this.array.slice(e,i):[]}remove(t){let[e,i]=this.lookupIndexes(t);return null!=e?this.array.splice(e,i-e):[]}slice(t,e){return this.array.slice(t,e)}splice(t,e){return this.array.splice(t,e)}removeInSlice(t){if(0==t.length)return;const e=t[0],i=t[t.length-1];let[n,r]=this.lookupIndexes(new R(e,i,!0,!0)),s=n,o=n,l=0;for(;s-1&&(this.subscriptions.splice(e,1),t.terminate())}}class it{constructor(t,e,i){i=i||{},this.event=t,this.name=t.name,this.callback=e,this.init=void 0===i.init?this.event.init:i.init,this.init_pending=!1,this.terminated=!1,this.ctx=i.ctx}terminate(){this.terminated=!0,this.callback=void 0,this.event.unsubscribe(this)}}function nt(t){return t.__eventify_eventMap=new Map,t.__eventify_buffer=[],t}function rt(t){function e(t,e){const i=t.__eventify_eventMap.get(e);if(null==i)throw new Error("Event undefined",e);return i}t.eventifyDefine=function(t,e){if(this.__eventify_eventMap.has(t))throw new Error("Event already defined",t);this.__eventify_eventMap.set(t,new et(this,t,e))},t.eventifyTrigger=function(t,e){return this.eventifyTriggerAll([{name:t,eArg:e}])},t.eventifyTriggerAlike=function(t,e){return this.eventifyTriggerAll(e.map(e=>({name:t,eArg:e})))},t.eventifyTriggerAll=function(t){if(0==t.length)return;let i=t.map(t=>{let{name:i,eArg:n}=t,r=e(this,i),s=r.subscriptions.filter(t=>0==t.init_pending);return[r,n,s]},this);const n=i.length,r=this.__eventify_buffer,s=this.__eventify_buffer.length;this.__eventify_buffer.length=s+n;for(let t=0;t({key:t,new:e,old:void 0}));return this.sortItems(e),"batch"==t?[e]:e}}_notifyEvents(t){if(0==t.length)return;const e=this.eventifySubscriptions("batch").length>0,i=this.eventifySubscriptions("remove").length>0,n=this.eventifySubscriptions("change").length>0;if(e&&this.eventifyTrigger("batch",t),i||n)for(let e of t)null==e.new&&null!=e.old?i&&this.eventifyTrigger("remove",e):n&&this.eventifyTrigger("change",e)}get size(){return this.datasource.size}has(t){return this.datasource.has(t)}get(t){return this.datasource.get(t)}keys(){return this.datasource.keys()}values(){return this.datasource.values()}entries(){return this.datasource.entries()}set(t,e){let i=void 0;return this.datasource.has(t)&&(i=this.datasource.get(t)),this.datasource.set(t,e),this._notifyEvents([{key:t,new:e,old:i}]),this}delete(t){let e=!1,i=void 0;return this.datasource.has(t)&&(i=this.datasource.get(t),this.datasource.delete(t),e=!0),this._notifyEvents([{key:t,new:void 0,old:i}]),e}clear(){const t=[...this.datasource.entries()].map(([t,e])=>({key:t,new:void 0,old:e}));this.datasource.clear(),this._notifyEvents(t)}}ot.eventifyPrototype(lt.prototype);class at extends lt{static cmpLow(t,e){return R.cmpLow(t.interval,e.interval)}static cmpHigh(t,e){return R.cmpHigh(t.interval,e.interval)}sortOrder(t={}){let e=t.order||super.sortOrder(t);return"low"==e?at.cmpLow:"high"==e?at.cmpHigh:"function"==typeof e?e:void 0}cues(t={}){let e=this.sortValues(this.values(),t);return Array.isArray(e)?e:[...e]}}class ht{constructor(t,e){this.tid=void 0,this.to=t,this.callback=e}isSet(){return null!=this.tid}setTimeout(t,e){if(null!=this.tid)throw new Error("at most on timeout");let i=this.to.clock.now(),n=1e3*Math.max(t-i,0);this.tid=setTimeout(this.onTimeout.bind(this),n,t,e)}onTimeout(t,e){if(null!=this.tid){this.tid=void 0;let i=this.to.clock.now();inull!=t);return this.__update(t),n}__handleEvent(t){let{range:e,live:i=!0,...n}=t;null!=e&&(e=[e[0],e[1]]);let r={range:e,live:i,...n};if(r=this.onUpdateStart(r),null!=r)return this.__process(r)}__handleTimeout(t,e){this.__process({...e})}__process(t){let{range:e,position:i,velocity:n,acceleration:r,timestamp:s,live:o=!0,...l}=t,a=!1;if(null!=e){let[t,i]=e;t-1&&t.splice(i,1),0==t.length}}const Ot=[0,10,100,1e3,1e4,1e5,1/0];var Tt=function(t){for(let e=0;ethis._submit.bind(this)())}_push(t){let e=this._cues.length,i=0==e,n=t.length;this._cues.length+=n;for(let i=0;i0&&(this._done.value=!0)}_submit(){let t=[];return this._cues.length>0&&(t=this._ds.update(this._cues,this._options)),this._reset(),t}addCue(t,e,i){let n={key:t};return n.interval=e,arguments.length>2&&(n.data=i),n=At(n),this._push([n]),this}removeCue(t){return this._push([{key:t}]),this}update(t){t=t.map(t=>At(t)),this._push(t)}clear(){return this._cues=[],this}submit(){if(this._options.autosubmit)throw new Error("manual submit while options.autosubmit is true");this._done.value=!0}}class Lt extends at{constructor(t){super(t),this._map=new Map,this._builder=new Rt(this),this._cueBuckets=new Map;for(let t=0;t-1&&this._update_callbacks.splice(e,1)}_notify_callbacks(t,e){this._update_callbacks.forEach((function(i){i.handler(t,e)}))}set(t,e){throw new Error("not implemented")}delete(t){throw new Error("not implemented")}makeBuilder(t){return new Rt(this,t)}get builder(){return this._builder}addCue(t,e,i){return arguments.length>2?this._builder.addCue(t,e,i):this._builder.addCue(t,e),this}removeCue(t){return this._builder.removeCue(t),this}get updateDone(){return this._builder.updateDone}_addCue(t,e,i,n){let r={key:t,interval:e,data:i};return r=At(r),this.update(r,n)}_removeCue(t,e){return this.update({key:t},e)}update(t,e={}){const i=new Map;let n,r,s,{debug:o=!1,equals:l,check_needed:h=!0}=e;a(t)||(t=[t]);const c={ts:Et(),author:e.author};for(let o of t){if(h)try{o=At(o)}catch(t){console.log(t,o);continue}r=o.hasOwnProperty("interval"),s=o.hasOwnProperty("data"),n=this._map.get(o.key),null==n?(r||(o.interval=void 0),s||(o.data=void 0)):null!=n&&(r||s?s?r||(o.interval=n.interval):o.data=n.data:(o.interval=void 0,o.data=void 0)),this._update_cue(i,n,o,c,e)}if(this._call_buckets("flush"),i.size>0){let t={low:1/0,high:-1/0},e=[...i.values()].map(e=>(e.new&&e.new.interval&&(t.low=m.min(t.low,e.new.interval.endpointLow),t.high=m.max(t.high,e.new.interval.endpointHigh)),e.old&&e.old.interval&&(t.low=m.min(t.low,e.old.interval.endpointLow),t.high=m.max(t.high,e.old.interval.endpointHigh)),{key:e.key,new:e.new,old:e.old,info:e.info})),n=e.filter(t=>{let e=Mt(t.new,t.old,l);return e.interval!=St.NOOP||e.data!=St.NOOP});this._notifyEvents(n);let r=void 0;return t.low!=1/0&&(r=R.fromEndpoints(t.low,t.high)),this._notify_callbacks(i,r),o&&this.integrity(),e}return o&&this.integrity(),[]}_update_cue(t,e,i,n,r){let s,o,l,a,h,c,u,_,d,p,{chaining:f=!0,safe:v=!1,equals:g}=r;if(e===i)throw Error("illegal cue arg: same object as current cue");let m=Mt(e,i,g);if(m.interval==St.NOOP&&m.data==St.NOOP)return l={key:i.key,new:e,old:e,delta:m},void t.set(i.key,l);if(null==e)null==i.info&&(i.info={ts:n.ts,change_ts:n.ts,change_id:0}),s=void 0,o=v?Object.freeze(i):i,this._map.set(i.key,o);else if(null==i.interval&&null==i.data)s=e,o=void 0,this._map.delete(i.key);else if(null==i.info&&(i.info={ts:e.info.ts,change_ts:n.ts,change_id:e.info.change_id+1}),s=e,o={key:i.key,interval:i.interval,data:i.data,info:i.info},v&&(o=Object.freeze(o)),this._map.set(i.key,o),s.interval){let t=Tt(s.interval.length),e=this._cueBuckets.get(t);e.replace_endpoint(s.interval.low,o),s.singular||e.replace_endpoint(s.interval.high,o)}if(l={key:i.key,new:o,old:s,delta:m,info:n},f&&(a=t.get(i.key),null!=a&&(l.old=a.old,l.delta=Mt(o,l.old,g))),t.set(i.key,l),m.interval!=St.NOOP){if(m.interval==St.INSERT?(d=!1,p=!0,u=!0,_=!0):m.interval==St.DELETE?(d=!0,p=!1,u=!0,_=!0):m.interval==St.REPLACE&&(d=!0,p=!0,u=o.interval.low!=s.interval.low,_=o.interval.high!=s.interval.high),d){let t=Tt(s.interval.length);h=this._cueBuckets.get(t)}if(p){let t=Tt(o.interval.length);c=this._cueBuckets.get(t)}h&&c&&h!=c&&(d=!0,p=!0,u=!0,_=!0),u&&(d&&h.del_endpoint(s.interval.low,s),p&&c.add_endpoint(o.interval.low,o)),_&&(d&&!s.interval.singular&&h.del_endpoint(s.interval.high,s),p&&!o.interval.singular&&c.add_endpoint(o.interval.high,o))}}_call_buckets(t,...e){const i=[];for(let n of this._cueBuckets.values()){let r=n[t](...e);null!=r&&r.length>0&&i.push(r)}return h(i)}lookup_endpoints(t){return t=bt(t),this._call_buckets("lookup_endpoints",t)}lookup(t,e){return t=bt(t),this._call_buckets("lookup",t,e)}lookup_delete(t,e,i={}){t=bt(t);const n=this._call_buckets("lookup_delete",t,e),r=[],s={ts:Et(),author:i.author};let o;for(let t=0;tnull==t.interval),r=e.length,s=n.length,l=this._map.size,a=l-r-s;if(0!=a)throw console.log("count buckets",r),console.log("count no intervals",s),console.log("count map",l),console.log("count diff",a),new Error("inconsistent cue count");let h=new Map(e.map(t=>[t.key,t])),c=new Map([...this._map.entries()].filter(([t,e])=>null!=e.interval)),u=o(h,c);if(u.size>0)throw console.log("buckets missing cues:"),console.log([...u.keys()]),new Error("buckets missing cues: "+[...u.keys()]);if(u=o(c,h),u.size>0)throw new Error("buckets too many cues: "+[...u.keys()]);return{cues:e.length,points:i.length}}}Lt.Delta=St,Lt.cue_delta=Mt,Lt.cue_equals=function(t,e){let i=Mt(t,e);return i.interval==St.NOOP&&i.data==St.NOOP};class Dt{constructor(t){this._maxLength=t,this._pointMap=new Map,this._pointIndex=new tt,this._created=new Set,this._dirty=new Set}add_endpoint(t,e){let i=0==this._pointMap.size?void 0:this._pointMap.get(t);null==i?(this._pointMap.set(t,[e]),this._created.add(t)):i.push(e)}del_endpoint(t,e){let i=0==this._pointMap.size?void 0:this._pointMap.get(t);if(null!=i){It(i,e)&&this._dirty.add(t)}}replace_endpoint(t,e){let i=0==this._pointMap.size?void 0:this._pointMap.get(t);if(null!=i){(function(t,e){if(0==t.length)return!1;if(1==t.length){if(t[0].key==e.key)return t[0]=e,!0}else{let i=t.findIndex((function(t){return t.key==e.key}));if(i>-1)return t[i]=e,!0}return!1})(i,e)||console.log("WARNING: attempt to replace non-existent cue in pointMap")}}flush(){if(0==this._created.size&&0==this._dirty.size)return;let t=[],e=[];for(let t of this._created.values()){this._pointMap.get(t).length>0?e.push(t):this._pointMap.delete(t)}for(let e of this._dirty.values()){let i=this._pointMap.get(e);null!=i&&(0==i.length&&(t.push(e),this._pointMap.delete(e)))}this._pointIndex.update(t,e),this._created.clear(),this._dirty.clear()}lookup_endpoints(t){if(0==this._pointMap.size)return[];const e=new R(t.low,t.high,!0,!0),i=this._pointIndex.lookup(e),n=[],r=i.length;let s,o;for(let l=0;lthis._maxLength)return i;if(e&kt.COVERS){let e;if(this._maxLength==1/0)e=new R(-1/0,t.low);else{let i=t.high-this._maxLength,n=t.low;[i,n]=[Math.min(i,n),Math.max(i,n)],e=new R(i,n,!0,!0)}this._lookup_cues(e).forEach((function(e){e.interval.match(t,kt.COVERS)&&i.push(e)}))}return i}lookup_delete(t,e){const i=this.lookup(t,e),n=[];let r,s,o;for(let t=0;t0)throw new Error("pointMap missing points: "+[...i]);if(i=s(e,t),i.size>0)throw new Error("pointIndex missing points: "+[...i])}let n=[...this._pointIndex.values()];if(n.length!=t.size)throw new Error("pointIndex include duplicate points");for(let t=1;t=n[t])throw new Error("pointIndex not ordered");for(let t of n){let e=this._pointMap.get(t);for(let i of e)if(t!=i.interval.low&&t!=i.interval.high)throw console.log("POINT:",t),console.log("CUE:",i.interval.toString()),new Error("pointMap: wrong cue")}for(let t of[...this._pointMap.values()])for(let e of t)for(let t of[e.interval.low,e.interval.high])if(!this._pointMap.has(t))throw new Error(`cue found with low or high point not in pointMap ${t} -> ${e.interval.toString()} `);let r=[];for(let t of this._pointMap.values())for(let e of t)r.push(e);let o=new Map;for(let t of r){let e=o.get(t.key);if(null==e)o.set(t.key,t);else if(t!==e)throw new Error("pointMap: different cue objects for same key")}let l=[...o.values()];for(let t of l.values())if(t.interval.length>this._maxLength)throw new Error(`cue in wrong cue bucket ${this._maxLength}, ${t.interval.toString()}`);return[{maxLength:this._maxLength,points:[...this._pointMap.keys()],cues:l}]}}const Ct=$;function Nt(t,e){return m.cmp(t.tsEndpoint,e.tsEndpoint)}class xt{constructor(t,e,i){this.to=e,this.timeout=new ht(e,this.run.bind(this)),this.vector,this.timeInterval,this.posInterval,this.dataset=t,this.queue=[],this.callbacks=[],(i=i||{}).lookahead=i.lookahead||5,this.options=i}add_callback(t){let e={handler:t};return this.callbacks.push(e),e}del_callback(t){let e=this.callbacks.indexof(t);e>-1&&this.callbacks.splice(e,1)}_notify_callbacks(...t){this.callbacks.forEach((function(e){e.handler(...t)}))}setVector(t){let e=t.timestamp;this.vector;null!=this.vector&&(this.timeout.clear(),this.timeInterval=void 0,this.posInterval=void 0,this.queue=[]),this.vector=t,x(this.vector)&&this.run(e)}push(t){t.forEach((function(t){this.timeInterval.covers_endpoint(t.tsEndpoint)&&this.queue.push(t)}),this),this.queue.sort(Nt)}pop(t){let e=[];this.queue.length;for(;this.queue.length>0&&this.queue[0].tsEndpoint[0]<=t;)e.push(this.queue.shift());return e}next(){return this.queue.length>0?this.queue[0].tsEndpoint[0]:void 0}advance(t){let e,i=this.options.lookahead,n=!1;return null==this.timeInterval?(e=t,n=!0):m.leftof(this.timeInterval.endpointHigh,t)&&(e=this.timeInterval.high,n=!0),n&&(this.timeInterval=new R(e,e+i,!0,!1),this.posInterval=Ct(this.timeInterval,this.vector),this.queue=[]),n}load(t,e){let i=X(this.timeInterval,this.posInterval,this.vector,t),n=U(this.vector,this.to.range)[0];return null==e&&(e=this.timeInterval.endpointLow),i.filter((function(t){if(n<=t.tsEndpoint[0])return!1;if(m.leftof(t.tsEndpoint,e))return!1;if(0!=this.vector.acceleration){let e=t.tsEndpoint[0];if(e>this.timeInterval.endpointLow[0]){let i=C(this.vector,e);if(i.position==t.endpoint[0]&&0==i.velocity)return!1}}return!0}),this)}run(t){let e=this.pop(t);if(this.advance(t)){let i=this.dataset.lookup_endpoints(this.posInterval),n=this.load(i);this.push(n);let r=this.pop(t);e.push(...r)}e.length>0&&this._notify_callbacks(t,e,this);let i=this.next()||this.timeInterval.high;this.timeout.setTimeout(Math.min(i,this.timeInterval.high))}}function Pt(t){return t.interval==Lt.Delta.NOOP&&t.data==Lt.Delta.NOOP}const Ht=Object.freeze({ENTER:1,STAY:0,EXIT:-1,ENTER_EXIT:2}),Vt=new Map([["LRL",Ht.STAY],["LRR",Ht.EXIT],["LRS",Ht.EXIT],["LLL",Ht.STAY],["LLR",Ht.ENTER],["LLS",Ht.ENTER],["RRL",Ht.ENTER],["RRR",Ht.STAY],["RRS",Ht.ENTER],["RLL",Ht.EXIT],["RLR",Ht.STAY],["RLS",Ht.EXIT],["SRL",Ht.ENTER],["SRR",Ht.EXIT],["SRS",Ht.ENTER_EXIT],["SLL",Ht.EXIT],["SLR",Ht.ENTER],["SLS",Ht.ENTER_EXIT]]);function zt(t,e){return R.cmpLow(t.interval,e.interval)}function Ut(t,e){return-1*R.cmpHigh(t.interval,e.interval)}function Bt(t,e){return zt(t.new?t.new:t.old,e.new?e.new:e.old)}function qt(t,e){return Ut(t.new?t.new:t.old,e.new?e.new:e.old)}class Gt extends at{constructor(t,e){super(e),this._map=new Map,this._ds=t;let i=this._onDatasetCallback.bind(this);this._ds_cb=this._ds.add_callback(i)}get datasource(){return this._map}get dataset(){return this._ds}_movementDirection(){throw new Error("not implemented")}sortValues(t,e={}){if("function"==typeof this.sortOrder(e))return super.sortValues(t,e);{let e=Array.isArray(t)?t:[...t];return this._movementDirection()>=0?e.sort(zt):e.sort(Ut),e}}sortItems(t,e){let i=this.sortOrder();if("function"==typeof i)return super.sortItems(t);null==i&&(null==e&&(e=this._movementDirection()),e>=0?t.sort(Bt):t.sort(qt))}set(t,e){throw new Error("not implemented")}delete(t){throw new Error("not implemented")}clear(t){throw new Error("not implemented")}_onDatasetCallback(t,e){throw new Error("not implemented")}_items_from_dataset_events(t,e){const i=[],n=[],r=[],s=0==this._map.size;let o,l,a;for(let h of t.values())Pt(h.delta)||(o=!s&&this._map.has(h.key),l=!1,null!=h.new&&h.new.interval.match(e)&&(l=!0),o&&!l?(a={key:h.key,new:void 0,old:h.old,info:h.info},r.push(a)):!o&&l?(a={key:h.key,new:h.new,old:void 0,info:h.info},i.push(a)):o&&l&&(a={key:h.key,new:h.new,old:h.old,info:h.info},n.push(a)));return[r,n,i]}_items_from_dataset_lookup(t,e){const i=new Map(this._ds.lookup(e).map((function(t){return[t.key,t]})));let n,r=[],s=[],a=0==this._map.size;if(!a){let e=l(this._map,i);if(e.size>0){let i,n;for(let s of t.values())i=e.get(s.key),null==i||Pt(s.delta)||(n={key:s.key,new:s.new,old:s.old},r.push(n))}s=[...o(this._map,i).values()].map(t=>({key:t.key,new:void 0,old:t}))}n=a?i:o(i,this._map);let h=[...n.values()].map(t=>({key:t.key,new:t,old:void 0}));for(let e in[s,r,h])for(let i of e){let e=t.get(i.key);null!=e&&(i.info=e.info)}return[s,r,h]}get builder(){return this.dataset.builder}addCue(t,e,i){return this.dataset.addCue(t,e,i)}removeCue(t){return this.dataset.removeCue(t)}_addCue(t,e,i){return this.dataset._addCue(t,e,i)}_removeCue(t){return this.dataset._removeCue(t)}update(t,e){return this.dataset.update(t,e)}clear(){return this.dataset.clear()}hasCue(t){return this.dataset.has(t)}getCue(t){return this.dataset.get(t)}getCues(){return this.dataset.cues()}getActiveKeys(){return[...this.keys()]}getActiveCues(){return this.cues()}isActive(t){return this.has(t)}}Gt.Active=Ht,Gt.ActiveMap=Vt;const jt=Y.PosDelta,$t=Y.MoveDelta,Ft=Gt.Active,Xt=Gt.ActiveMap;class Qt extends Gt{constructor(t,e,i){super(t,i),this._to=e,this._sub=this._to.on("timingsrc",this._onTimingCallback.bind(this)),this._sched=new xt(this._ds,e);let n=this._onScheduleCallback.bind(this);this._sched_cb=this._sched.add_callback(n)}_movementDirection(){const t=this._to.clock.now();return N(this._to.vector,t)}_onDatasetCallback(t,e){if(!this._to.isReady())return;if(null==e)return;const i=this._to.clock.now(),n=C(this._to.vector,i),r=new R(n.position);if(!r.match(e,R.Match.OUTSIDE)){let e=this._items_from_dataset_events.bind(this);5e3{this._map.delete(t.key)}),s.forEach(t=>{this._map.set(t.key,t.new)}),o.forEach(t=>{this._map.set(t.key,t.new)});let l=N(n);this.sortItems(i,l),this.sortItems(s,l),this.sortItems(o,l);const a=h([i,s,o],{copy:!0,order:!0});this._notifyEvents(a)}this._sched.posInterval&&(this._sched.posInterval.match(e,R.Match.OUTSIDE)||this._sched.setVector(n))}_onTimingCallback(t){let e=C(t,this._to.clock.now()),i=new Y(this._to.old_vector,e);if(i.posDelta==jt.CHANGE||i.moveDelta==$t.STOP){let t=e.position,i=e.position,n=new R(t,i,!0,!0),r=new Map(this._ds.lookup(n).map(t=>[t.key,t])),s=o(this._map,r),l=o(r,this._map);this._map=r;let a=[...s.values()].map(t=>({key:t.key,new:void 0,old:t})),c=[...l.values()].map(t=>({key:t.key,new:t,old:void 0})),u=N(e);this.sortItems(a,u),this.sortItems(c,u);const _=h([a,c],{copy:!0,order:!0});this._notifyEvents(_)}this._sched.setVector(e)}_onScheduleCallback=function(t,e,i){if(!this._to.isReady())return;const n=[];e.forEach((function(t){let e=t.cue,i=this._map.has(e.key),[r,s,o,l]=t.endpoint,a=t.direction>0?"R":"L",h=l?"S":s?"R":"L",c=Xt.get(`S${a}${h}`);c==Ft.ENTER_EXIT?i?(n.push({key:e.key,new:void 0,old:e}),this._map.delete(e.key)):(n.push({key:e.key,new:e,old:void 0}),n.push({key:e.key,new:void 0,old:e})):c==Ft.ENTER?i||(n.push({key:e.key,new:e,old:void 0}),this._map.set(e.key,e)):c==Ft.EXIT&&i&&(n.push({key:e.key,new:void 0,old:e}),this._map.delete(e.key))}),this),this._notifyEvents(n)}}const Wt=Y.PosDelta,Yt=Y.MoveDelta,Jt=Gt.Active,Kt=Gt.ActiveMap;function Zt(t,e){let i=N(t)+N(e);return i>0?1:i<0?-1:0}class te extends Gt{constructor(t,e,i,n){super(t,n),this._toA=e,this._toA_ready=!1,this._toB=i,this._toB_ready=!1;let r=this._onTimingCallback.bind(this);this._subA=this._toA.on("timingsrc",r),this._subB=this._toB.on("timingsrc",r);let s=this._onScheduleCallback.bind(this);this._schedA=new xt(this._ds,e),this._schedA_cb=this._schedA.add_callback(s),this._schedB=new xt(this._ds,i),this._schedB_cb=this._schedB.add_callback(s),this._toA_vector,this._toB_vector}_isReady(){return this._toA_ready&&this._toB_ready}_movementDirection(){const t=this._toA.clock.now();return Zt(C(this._toA.vector,t),C(this._toB.vector,t))}_onDatasetCallback(t,e){if(!this._isReady())return;if(null==e)return;const i=this._toA.clock.now(),n=C(this._toA_vector,i),r=C(this._toB_vector,i);let[s,o]=[n.position,r.position],[l,a]=s<=o?[s,o]:[o,s];const c=new R(l,a,!0,!0);if(!c.match(e,R.Match.OUTSIDE)){let e=this._items_from_dataset_events.bind(this);5e3{this._map.delete(t.key)}),s.forEach(t=>{this._map.set(t.key,t.new)}),o.forEach(t=>{this._map.set(t.key,t.new)});let l=Zt(n,r);this.sortItems(i,l),this.sortItems(s,l),this.sortItems(o,l);const a=h([i,s,o],{copy:!0,order:!0});this._notifyEvents(a,l)}this._schedA.posInterval&&(this._schedA.posInterval.match(e,R.Match.OUTSIDE)||this._schedA.setVector(n)),this._schedB.posInterval&&(this._schedB.posInterval.match(e,R.Match.OUTSIDE)||this._schedB.setVector(r))}_onTimingCallback(t,e){let i=!1;if(!this._isReady()){if(e.src==this._toA?this._toA_ready=!0:this._toB_ready=!0,!this._isReady())return;i=!0}this._toA_vector=this._toA.vector,this._toB_vector=this._toB.vector;const n=e.src,r=n==this._toA?this._toB:this._toA;let s=C(n.vector,n.clock.now());const l=new Y(n.old_vector,s);let a=s.timestamp,c=C(r.vector,a);if(l.posDelta==Wt.CHANGE||l.MoveDelta==Yt.STOP){let t=Math.min(s.position,c.position),e=Math.max(s.position,c.position),i=new R(t,e,!0,!0),n=new Map(this._ds.lookup(i).map(t=>[t.key,t])),r=o(this._map,n),l=o(n,this._map);this._map=n;let a=[...r.values()].map(t=>({key:t.key,new:void 0,old:t})),u=[...l.values()].map(t=>({key:t.key,new:t,old:void 0})),_=Zt(s,c);this.sortItems(a,_),this.sortItems(u,_);const d=h([a,u],{copy:!0,order:!0});this._notifyEvents(d)}n==this._toA?this._schedA.setVector(s):n==this._toB&&this._schedB.setVector(s),i&&(r==this._toA?this._schedA.setVector(c):r==this._toB&&this._schedB.setVector(c))}_onScheduleCallback=function(t,e,i){if(!this._isReady())return;const n=i.to==this._toA?this._toB:this._toA,r=[];e.forEach((function(t){let[e,i,s,o]=t.endpoint,l=t.tsEndpoint[0],a=C(n.vector,l),h=a.position,c=e0?"R":"L",_=o?"S":i?"R":"L",d=Kt.get(`${c}${u}${_}`),p=t.cue,f=this._map.has(p.key);if(d==Jt.ENTER_EXIT){if(x(a)){d=N(a)!=t.direction?Jt.ENTER:Jt.EXIT}else d=Jt.ENTER}d==Jt.STAY&&(d=Jt.ENTER),d==Jt.ENTER&&f||(d!=Jt.EXIT||f)&&(d==Jt.ENTER?(r.push({key:p.key,new:p,old:void 0}),this._map.set(p.key,p)):d==Jt.EXIT&&(r.push({key:p.key,new:void 0,old:p}),this._map.delete(p.key)))}),this),this._notifyEvents(r)}}class ee{static position2percent(t,e){let[i,n]=e;return 100*(t-i)/(n-i)}static percent2position(t,e){let[i,n]=e;return t=Math.max(0,t),i+(n-i)*(t=Math.min(100,t))/100}constructor(t,e,i={}){this._to=t,this._sampler=i.sampler,this._progress_elem=e,this._lock=!1,this._options=i,this._range=i.range||this._to.range;let[n,r]=this._range;if(n==-1/0||r==1/0)throw new Error("illegal range",this._range);this._progress_elem.addEventListener("input",function(){this._lock_value=!0}.bind(this)),this._progress_elem.addEventListener("change",function(){this._lock_value=!1;let t=parseInt(this._progress_elem.value),e=ee.percent2position(t,this._range);this._to.update({position:e})}.bind(this)),this._sampler&&this._sampler.on("change",this.refresh.bind(this))}refresh(){let t=this._to.pos;if(!this._lock_value){let e=ee.position2percent(t,this._range);if(this._options.thumb){if(e<0||100t instanceof Lt),e=t.length>0?t[0]:new Lt,i=[...arguments].filter(t=>t instanceof ft),n=[...arguments].filter(t=>Object.getPrototypeOf(t)===Object.prototype),r=n.length>0?n[0]:{};if(0==i.length)throw new Error("no timingobject in arguments");return 1==i.length?new Qt(e,i[0],r):new te(e,i[0],i[1],r)}Qt.prototype.clone=function(){let t=[this.dataset];return t.push.apply(t,[...arguments]),ie(...t)},te.prototype.clone=function(){let t=[this.dataset];return t.push.apply(t,[...arguments]),ie(...t)};return t.BinarySearch=tt,t.CueCollection=at,t.Dataset=Lt,t.DatasetViewer=class{constructor(t,i){this.ds=t,this.elem=i,this.nonce=e(4),this.ds.on("change",this.onchange.bind(this)),this.ds.on("remove",this.onremove.bind(this))}cue2string(t){let e=t.interval?t.interval.toString():"undefined",i=JSON.stringify(t.data);return`${t.key}, ${e}, ${i}`}onchange(t){let e=`${this.nonce}-${t.key}`,i=this.elem.querySelector("#"+e);if(i)i.innerHTML=this.cue2string(t.new);else{let i=document.createElement("div");i.innerHTML=this.cue2string(t.new),i.setAttribute("id",e),this.elem.appendChild(i)}}onremove(t){let e=`${this.nonce}-${t.key}`,i=document.getElementById(e);i&&i.parentNode.removeChild(i)}},t.DelayConverter=class extends ft{constructor(t,e){if(e<0)throw new Error("negative delay not supported");if(0===e)throw new Error("zero delay makes delayconverter pointless");super(t),this._delay=e,this._buffer=[],this._timeout=new ht(this,this.__handleDelayed.bind(this)),this.eventifyDefine("delaychange",{init:!0})}eventifyInitEventArgs(t){return"delaychange"==t?[this._delay]:super.eventifyInitEventArgs(t)}onUpdateStart(t){this._buffer.push(t),this._timeout.isSet()||this.__handleDelayed()}__handleDelayed(){let t,e,i=this.clock.now();for(;this._buffer.length>0&&(e=this._buffer[0].timestamp+this._delay,!(i0&&(e=this._buffer[0].timestamp+this._delay,this._timeout.setTimeout(e))}update(t){throw new Error("update is not legal on delayed (non-live) timingobject")}get delay(){return this._delay}set delay(t){t!=this._delay&&(this._delay=t,this._timeout.clear(),this.__handleDelayed(),this.eventifyTrigger("delaychange",t))}},t.Interval=R,t.LoopConverter=class extends ft{constructor(t,e){if(super(t,{timeout:!0}),!Array.isArray(e)||2!=e.length)throw new Error("range must be array [low, high], "+e);this.__range=e}update(t){if(null!=t.range){let[e,i]=t.range;if(e>=i)throw new Error("illegal range",t.range);if(e!=this.__range[0]||i!=this.__range[1]){this.__range=[e,i];let t=this.__get_timingsrc().query();t.position=vt(t.position,this.__range),this.__vector=t;let n={range:this.__range,...this.__vector,live:!0};this.__dispatchEvents(n,!0,!0)}delete t.range}if(null!=t.position){let e=this.clock.now(),i=C(this.vector,e).position-t.position,n=C(this.__get_timingsrc().vector,e);t.position=n.position-i}return super.update(t)}onRangeViolation(t){return t.position=vt(t.position,this.__range),t}onUpdateStart(t){return null!=t.range&&(t.range=this.__range),null!=t.position&&(t.position=vt(t.position,this.__range)),t}},t.PositionCallback=class{constructor(t,e,i={}){this._to=t;let{stride:n=1,offset:r=0}=i;this._offset=r,this._stride=n,this._callback=e,this._timeout=new ht(this._to,this._handleTimeout.bind(this)),this._to.on("timingsrc",this._onChange.bind(this))}_onChange(t,e){let i=t.live?t.position:this._to.pos;this._renewTimeout(i)}_calculateTimeout(t,e){let i=this._to.query(),[n,r]=j(i,[t,e]);if(null==n)return;let[s,o]=this._to.range;return r-1&&this._callbacks.splice(e,1)}_notify_callbacks(t,e){this._callbacks.forEach((function(i){i.handler(t,e)}))}_cue_keep(t){return null!=t&&(!(this._interval&&!this._interval.match(t.interval))&&(!(this._key_filter&&!this._key_filter(t.key))&&!(this._data_filter&&!this._data_filter(t.data))))}_cue_convert(t){return null!=t&&this._data_convert?{key:t.key,interval:t.interval,data:this._data_convert(t.data)}:t}_items_filter_convert(t){let e=[];for(let i of t){if(null==i.new&&null==i.old)continue;let t=this._cue_keep(i.old)?i.old:void 0,n=this._cue_keep(i.new)?i.new:void 0;null==t&&null==n||(t=this._cue_convert(t),n=this._cue_convert(n),e.push({key:i.key,new:n,old:t}))}return e}_check_interval(t){if(this._interval)if(t){let e=R.intersect(t,this._interval);if(0==e.length)return console.log(`warning - lookup interval ${t.toString()} outside the subset interval ${this._interval.toString()}`),[];t=e[0]}else t=this._interval;return t}lookup(t,e){let i,n=this._check_interval(t);return i=n?this.datasource.lookup(n,e):[...this.datasource.values()],i.filter(this._cue_keep,this).map(this._cue_convert,this)}lookup_endpoints(t){let e=this._check_interval(t);return this.datasource.lookup_endpoints(e).filter(t=>this._cue_keep(t.cue),this).map(t=>({endpoint:t.endpoint,cue:this._cue_convert(t.cue)}),this)}eventifyInitEventArgs(t){if("batch"==t||"change"==t){let e=this.lookup().map(t=>({key:t.key,new:t,old:void 0}));return this.sortItems(e),"batch"==t?[e]:e}}_onDatasetCallback(t,e){let i=[...t.values()];i=this._items_filter_convert(i);for(let t of i)null!=t.new&&null==t.old?this._size+=1:null==t.new&&null!=t.old&&(this._size-=1);super._notifyEvents(i);let n=new Map(i.map(t=>[t.key,t]));this._interval&&(e=R.intersect(this._inverval,e)),this._notify_callbacks(n,e)}_setInterval(t){if(!t instanceof R)throw new Error("must be interval",t.toString());if(!this._interval||!this._interval.equals(t)){let e=this.lookup();this._interval=t;let i=this.datasource.lookup(t);i=i.filter(this._cue_keep,this).map(this._cue_convert,this);let n=new Map([...e].map(t=>[t.key,t])),r=new Map([...i].map(t=>[t.key,t])),s=o(n,r),l=o(r,n),a=[...s.values()].map(t=>({key:t.key,new:void 0,old:t})),c=[...l.values()].map(t=>({key:t.key,new:t,old:void 0}));this._size-=a.length,this._size+=c.length;const u=h([a,c],{copy:!1,order:!0});this._notifyEvents(u)}}get size(){return this._size}has(t){return null!=this.get(t)}get(t){let e=super.get(t);if(null!=e&&this._cue_keep(e))return this._cue_convert(e)}keys(){return this.values().map(t=>t.key)}values(){return[...super.values()].filter(t=>this._cue_keep(t),this).map(t=>this._cue_convert(t),this)}entries(){return this.values().map(t=>[t.key,t])}update(t,e){throw new Error("not implemented")}set(t,e){throw new Error("not implemented")}delete(t){throw new Error("not implemented")}clear(t){throw new Error("not implemented")}},t.Timeout=ht,t.TimeshiftConverter=class extends ft{constructor(t,e){super(t),this._offset=e,this.eventifyDefine("offsetchange",{init:!0})}eventifyInitEventArgs(t){return"offsetchange"==t?[this._offset]:super.eventifyInitEventArgs(t)}onUpdateStart(t){if(null!=t.range&&(t.range=[-1/0,1/0]),null!=t.position){let e=t.timestamp,i=C(t,e+this._offset);t.position=i.position,t.velocity=i.velocity,t.acceleration=i.acceleration,t.timestamp=e}return t}get offset(){return this._offset}set offset(t){t!=this._offset&&(this._offset=t,this.__handleEvent({...this.__get_timingsrc().vector,range:this.__get_timingsrc().range}),this.eventifyTrigger("offsetchange",t))}},t.TimingObject=ft,t.TimingProgress=ee,t.TimingSampler=mt,t.endpoint=m,t.eventify=ot,t.motionutils=J,t.utils=_,t.version="v3.0",t}({});
+//# sourceMappingURL=timingsrc-min-v3.js.map
diff --git a/docs/lib/timingsrc-min-v3.js.map b/docs/lib/timingsrc-min-v3.js.map
new file mode 100644
index 0000000..be7b787
--- /dev/null
+++ b/docs/lib/timingsrc-min-v3.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"timingsrc-min-v3.js","sources":["../../v3/util/utils.js","../../v3/util/endpoint.js","../../v3/util/interval.js","../../v3/util/motionutils.js","../../v3/util/binarysearch.js","../../v3/util/eventify.js","../../v3/util/observablemap.js","../../v3/dataset/cuecollection.js","../../v3/util/timeout.js","../../v3/timingobject/masterclock.js","../../v3/timingobject/internalprovider.js","../../v3/timingobject/externalprovider.js","../../v3/timingobject/timingobject.js","../../v3/timingobject/loopconverter.js","../../v3/timingobject/rangeconverter.js","../../v3/timingobject/timingsampler.js","../../v3/timingobject/positioncallback.js","../../v3/dataset/dataset.js","../../v3/sequencing/schedule.js","../../v3/sequencing/basesequencer.js","../../v3/sequencing/pointsequencer.js","../../v3/sequencing/intervalsequencer.js","../../v3/ui/timingprogress.js","../../v3/index.js","../../v3/ui/datasetviewer.js","../../v3/timingobject/delayconverter.js","../../v3/timingobject/scaleconverter.js","../../v3/timingobject/skewconverter.js","../../v3/dataset/subset.js","../../v3/timingobject/timeshiftconverter.js"],"sourcesContent":["/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see not equal\n if (aProps.length != bProps.length) {\n return false;\n }\n for (let i=0; i not equal\n if (a[propName] !== b[propName]) {\n return false;\n }\n }\n // equal\n return true;\n}\n\n\n/* document readypromise */\nexport const docready = new Promise(function(resolve) {\n if (document.readyState === 'complete') {\n resolve();\n } else {\n let onReady = function () {\n resolve();\n document.removeEventListener('DOMContentLoaded', onReady, true);\n window.removeEventListener('load', onReady, true);\n };\n document.addEventListener('DOMContentLoaded', onReady, true);\n window.addEventListener('load', onReady, true);\n }\n});\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see -1) {\n indexes.push(index);\n }\n }\n return indexes;\n };\n\n /*\n element exists with value\n */\n has(x) {\n return (this.indexOf(x) > -1) ? true : false;\n };\n\n get(index) {\n return this.array[index];\n };\n\n\n\n /*\n REMOVE\n Removes all elements with given values\n search for each one and splice remove them individually\n (reverse order)\n\n INSERT\n binarysearch and splice\n insert - binarysearch and splice\n\n WARNING - there should be no need to insert elements that are already\n present in the array. This function drops such duplicates\n */\n _update_splice(to_remove, to_insert, options) {\n\n // REMOVE\n if (this.array.length > 0) {\n let indexes = this.indexOfElements(to_remove);\n /*\n sort indexes to make sure we are removing elements\n in backwards order\n optimization\n - if elements were sorted in the first place this should not be necessary\n */\n indexes.sort(function(a,b){return a-b;});\n for (let i=indexes.length-1; i > -1; i--) {\n this.array.splice(indexes[i], 1);\n }\n }\n\n // INSERT\n let x, index;\n let len = to_insert.length;\n for (let i=0; i 0 && to_remove.length > 0) {\n // visit all elements and set their value to undefined\n // undefined values will be sorted to the end of the array\n let indexes = this.indexOfElements(to_remove);\n for (let i=0; i 0) {\n let index = this.array.indexOf(undefined);\n if (index > -1) {\n this.array.splice(index, this.array.length-index);\n }\n }\n // remove duplicates\n this.array = unique(this.array);\n };\n\n\n /*\n Update - removing and inserting elements in one operation\n\n a single element should only be present once in the list, thus avoiding\n multiple operations to one element. This is presumed solved externally.\n - also objects must not be members of both lists.\n\n - internally selects the best method - searchsplice or concatsort\n - selection based on relative sizes of existing elements and new elements\n\n */\n update(to_remove, to_insert, options) {\n let size = to_remove.length + to_insert.length;\n if (size == 0) {\n return;\n }\n\n // regular case\n let approach = resolve_approach(this.array.length, size);\n if (approach == \"splice\") {\n this._update_splice(to_remove, to_insert, options);\n } else if (approach == \"sort\"){\n this._update_sort(to_remove, to_insert, options);\n }\n };\n\n\n /*\n Accessors\n */\n\n getMinimum() {\n return (this.array.length > 0) ? this.array[0] : undefined;\n };\n\n getMaximum = function () {\n return (this.array.length > 0) ? this.array[this.array.length - 1] : undefined;\n };\n\n\n /*\n Internal search functions\n */\n\n /*\n Find index of largest value less than x\n Returns -1 if noe values exist that are less than x\n */\n ltIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n consider element to the left\n if we are at the left end of the array nothing is found\n return -1\n */\n if (i > 0) {\n return i-1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) - 1 is the largest value less than x\n */\n return Math.abs(i)-1;\n }\n };\n\n /*\n Find index of rightmost value less than x or equal to x\n Returns -1 if noe values exist that are less than x or equal to x\n */\n leIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n element found\n */\n return i;\n } else {\n // not found - consider element to the left\n i = Math.abs(i) - 1;\n return (i >= 0) ? i : -1;\n }\n };\n\n /*\n \tFind index of leftmost value greater than x\n \tReturns -1 if no values exist that are greater than x\n */\n\n gtIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n if there are no elements to the right return -1\n */\n if (i < this.array.length -1) {\n return i+1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) is the smallest value greater than x\n unless we hit the end of the array, in which cas no smalles value\n exist which is greater than x\n */\n let idx = Math.abs(i);\n return (idx < this.array.length) ? idx : -1;\n }\n };\n\n\n /*\n Find index of leftmost value which is greater than x or equal to x\n Returns -1 if noe values exist that are greater than x or equal to x\n */\n\n geIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found element\n */\n return i;\n } else {\n // not found - consider the element where x would be inserted\n i = Math.abs(i);\n return (i -1) {\n return [index, index + 1];\n } else {\n return [undefined, undefined];\n }\n }\n\n // regular non-singular interval\n var start_index = -1, end_index = -1;\n if (interval.lowInclude) {\n start_index = this.geIndexOf(interval.low);\n } else {\n start_index = this.gtIndexOf(interval.low);\n }\n if (start_index === -1) {\n return [undefined, undefined];\n }\n if (interval.highInclude) {\n end_index = this.leIndexOf(interval.high);\n } else {\n end_index = this.ltIndexOf(interval.high);\n }\n if (end_index === -1) { // not reachable - I think\n return [undefined, undefined];\n }\n return [start_index, end_index + 1];\n };\n\n\n /*\n lookup by interval\n */\n lookup(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.slice(start, end) : [];\n };\n\n /*\n remove by interval\n */\n remove(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.splice(start, end-start) : [];\n };\n\n\n slice(start, end) {\n return this.array.slice(start, end);\n };\n\n splice(start, length) {\n return this.array.splice(start, length);\n };\n\n\n\n /*\n method for removing multiple closely placed elements in place\n - removeList is sorted\n - changes only affect the part of the index between first and last element\n - move remaining elements to the left, remove elements with a single splice\n - efficent if removelist references elements that are close to eachother\n */\n\n removeInSlice(removeList) {\n if (removeList.length == 0){\n return;\n }\n const low = removeList[0];\n const high = removeList[removeList.length-1];\n let [start, end] = this.lookupIndexes(new Interval(low, high, true, true));\n\n let rd_ptr = start;\n let wr_ptr = start;\n let rm_ptr = 0;\n\n while (rd_ptr < end) {\n let rd_elem = this.array[rd_ptr];\n let rm_elem = removeList[rm_ptr];\n if (rd_elem < rm_elem) {\n this.array[wr_ptr] = this.array[rd_ptr];\n wr_ptr++;\n rd_ptr++;\n } else if (rd_elem == rm_elem) {\n rd_ptr++;\n rm_ptr++;\n } else {\n // rd_elem > rm_elem\n rm_ptr++;\n }\n if (rm_ptr == removeList.length) {\n break\n }\n }\n this.array.splice(wr_ptr, rd_ptr-wr_ptr);\n };\n\n\n values() {\n return this.array.values();\n };\n\n clear() {\n this.array = [];\n };\n\n get length () {\n return this.array.length;\n }\n\n}\n\nexport default BinarySearch;\n\n\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see {\n\t\t\treturn {name, eArg};\n\t\t}));\n\t}\n\n\t/*\n\t\tTrigger single event\n\t*/\n\tfunction eventifyTrigger(name, eArg) {\n\t\treturn this.eventifyTriggerAll([{name, eArg}]);\n\t}\n\n\t_prototype.eventifyDefine = eventifyDefine;\n\t_prototype.eventifyTrigger = eventifyTrigger;\n\t_prototype.eventifyTriggerAlike = eventifyTriggerAlike;\n\t_prototype.eventifyTriggerAll = eventifyTriggerAll;\n\t_prototype.eventifySubscriptions = eventifySubscriptions;\n\t_prototype.on = on;\n\t_prototype.off = off;\n};\n\n\n/*\n\tEvent Variable\n\n\tObjects with a single \"change\" event\n*/\n\nexport class EventVariable {\n\n\tconstructor (value) {\n\t\teventifyInstance(this);\n\t\tthis._value = value;\n\t\tthis.eventifyDefine(\"change\", {init:true});\n\t}\n\n\teventifyInitEventArgs(name) {\n\t\tif (name == \"change\") {\n\t\t\treturn [this._value];\n\t\t}\n\t}\n\n\tget value () {return this._value};\n\tset value (value) {\n\t\tif (value != this._value) {\n\t\t\tthis._value = value;\n\t\t\tthis.eventifyTrigger(\"change\", value);\n\t\t}\n\t}\n}\neventifyPrototype(EventVariable.prototype);\n\n/*\n\tEvent Boolean\n\n\n\tNote : implementation uses falsiness of input parameter to constructor and set() operation,\n\tso eventBoolean(-1) will actually set it to true because\n\t(-1) ? true : false -> true !\n*/\n\nexport class EventBoolean extends EventVariable {\n\tconstructor(value) {\n\t\tsuper(Boolean(value));\n\t}\n\n\tset value (value) {\n\t\tsuper.value = Boolean(value);\n\t}\n\tget value () {return super.value};\n}\n\n\n/*\n\tmake a promise which is resolved when EventBoolean changes\n\tvalue.\n*/\nexport function makePromise(eventObject, conditionFunc) {\n\tconditionFunc = conditionFunc || function(val) {return val == true};\n\treturn new Promise (function (resolve, reject) {\n\t\tlet sub = eventObject.on(\"change\", function (value) {\n\t\t\tif (conditionFunc(value)) {\n\t\t\t\tresolve(value);\n\t\t\t\teventObject.off(sub);\n\t\t\t}\n\t\t});\n\t});\n};\n\n// module api\nexport default {\n\teventifyPrototype,\n\teventifyInstance,\n\tEventVariable,\n\tEventBoolean,\n\tmakePromise\n};\n\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n fallback to order from constructor\n noop if no ordering is defined\n */\n sortValues(iter, options={}) {\n let order = this.sortOrder(options);\n if (typeof order == \"function\") {\n // sort\n // if iterable not array - convert into array ahead of sorting\n let arr = (Array.isArray(iter)) ? iter : [...iter];\n return arr.sort(order);\n } else {\n // noop\n return iter;\n }\n }\n\n /* \n Sort items (in-place) by value {new:value, old:value} using\n ordering function for values\n */\n sortItems(items) {\n let order = this.sortOrder(); \n if (typeof order == \"function\") {\n items.sort(function(item_a, item_b) {\n let cue_a = (item_a.new) ? item_a.new : item_a.old;\n let cue_b = (item_b.new) ? item_b.new : item_b.old;\n return order(cue_a, cue_b);\n });\n }\n }\n\n /***************************************************************\n EVENTS\n ***************************************************************/\n\n /*\n Eventify: immediate events\n */\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n let items = [...this.datasource.entries()].map(([key, val]) => {\n return {key:key, new:val, old:undefined};\n });\n // sort init items (if order defined)\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /*\n Event Notification\n */\n _notifyEvents(items) {\n // event notification\n if (items.length == 0) {\n return;\n }\n const has_update_subs = this.eventifySubscriptions(\"batch\").length > 0;\n const has_remove_subs = this.eventifySubscriptions(\"remove\").length > 0;\n const has_change_subs = this.eventifySubscriptions(\"change\").length > 0;\n // update\n if (has_update_subs) {\n this.eventifyTrigger(\"batch\", items);\n }\n // change, remove\n if (has_remove_subs || has_change_subs) {\n for (let item of items) {\n if (item.new == undefined && item.old != undefined) {\n if (has_remove_subs) {\n this.eventifyTrigger(\"remove\", item);\n }\n } else {\n if (has_change_subs) {\n this.eventifyTrigger(\"change\", item);\n }\n }\n }\n }\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get size () {\n return this.datasource.size;\n }\n\n has(key) {\n return this.datasource.has(key);\n };\n\n get(key) {\n return this.datasource.get(key);\n };\n\n keys() {\n return this.datasource.keys();\n };\n\n values() {\n return this.datasource.values();\n };\n\n entries() {\n return this.datasource.entries();\n }\n\n\n /***************************************************************\n MODIFY\n ***************************************************************/\n\n set(key, value) {\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n }\n this.datasource.set(key, value);\n this._notifyEvents([{key: key, new:value, old: old}]);\n return this;\n }\n\n delete(key) {\n let result = false;\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n this.datasource.delete(key);\n result = true;\n }\n this._notifyEvents([{key: key, new:undefined, old: old}]);\n return result;\n }\n\n clear() {\n // create change events for all cues\n const items = [...this.datasource.entries()].map(([key, val]) => {\n return {key: key, new: undefined, old: val};\n })\n // clear _map\n this.datasource.clear();\n // event notification\n this._notifyEvents(items);\n }\n\n}\n\neventify.eventifyPrototype(ObservableMap.prototype);\n\nexport default ObservableMap;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see {\n return this._submit.bind(this)();\n });\n }\n\n _push(cue_args) {\n // append cue args\n let m = this._cues.length;\n let was_empty = m == 0;\n let n = cue_args.length;\n this._cues.length += n;\n for (let i=0; i 0) {\n // batch done immediately \n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n }\n\n _submit() {\n let result = [];\n // carry out update if necessary\n if (this._cues.length > 0) {\n result = this._ds.update(this._cues, this._options); \n }\n // reset cue arg builder\n this._reset();\n // update result\n return result;\n } \n \n /*\n add or change single cue\n \n if both interval and data are undefined\n this is not interpreted as remove,\n but as a cue with no interval and a data value set\n to undefined\n */\n addCue(key, interval, data) {\n let cue_arg = {key:key};\n cue_arg.interval = interval; \n if (arguments.length > 2) {\n cue_arg.data = data;\n }\n cue_arg = cue_check(cue_arg)\n this._push([cue_arg]);\n return this;\n }\n\n /* remove single cue */\n removeCue(key) {\n this._push([{key:key}]);\n return this;\n }\n\n /* load array of cue args into argbuilder */\n update(cue_args) {\n cue_args = cue_args.map((cue_arg) => cue_check(cue_arg));\n this._push(cue_args);\n }\n\n /* clear args currently in argbuilder */\n clear() {\n this._cues = [];\n return this;\n }\n\n /* manually submit cue args from cue arg builder */\n submit() {\n if (this._options.autosubmit) {\n throw new Error(\"manual submit while options.autosubmit is true\");\n }\n // mark batch as done\n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n}\n\n\n/*\n this implements Dataset, a data collection supporting\n efficient lookup of cues tied to intervals on the timeline\n\n - cues may be tied to one or two points on the timeline, this\n is expressed by an Interval.\n - cues are indexed both by key and by intervals\n - the interval index is divided into a set of CueBuckets,\n based on cue interval length, for efficient lookup\n*/\n\nclass Dataset extends CueCollection {\n\n constructor(options) {\n super(options);\n\n this._map = new Map();\n this._builder = new CueArgBuilder(this);\n\n /*\n Initialise set of CueBuckets\n Each CueBucket is responsible for cues of a certain length\n */\n this._cueBuckets = new Map(); // CueBucketId -> CueBucket\n for (let i=0; i -1) {\n this._update_callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._update_callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n /***************************************************************\n MAP METHODS\n */\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n\n /***************************************************************\n CUE ARG BUILDER\n */\n \n makeBuilder(options) {\n return new CueArgBuilder(this, options);\n }\n\n // not really useful (v2 complience)\n get builder () {return this._builder;};\n\n \n /***************************************************************\n ADD CUE, REMOVE CUE\n\n - COMPATIBILTY WITH V2\n - SAFE TO USE repeatedly (batched using promise)\n */\n\n addCue(key, interval, data) {\n if (arguments.length > 2) {\n this._builder.addCue(key, interval, data);\n } else {\n this._builder.addCue(key, interval);\n }\n return this;\n }\n\n removeCue(key) {\n this._builder.removeCue(key);\n return this;\n }\n\n get updateDone() {return this._builder.updateDone};\n\n /***************************************************************\n ADD CUE, REMOVE CUE - INTERACTIVE USE\n\n - CONVENIENCE for interactive use\n - COMPATIBILTY WITH V2\n - NOT RECOMMENDED TO USE repeatedly (batched using promise)\n */\n\n _addCue(key, interval, data, options) {\n let cue = {key:key, interval:interval, data:data};\n cue = cue_check(cue);\n return this.update(cue, options);\n }\n\n _removeCue(key, options) {\n return this.update({key:key}, options);\n }\n\n /***************************************************************\n UPDATE\n\n - insert, replace or delete cues\n\n update(cues, equals, check)\n\n ordered list of cues to be updated\n - equality function for data objects\n\n cue = {\n key:key,\n interval: Interval,\n data: data\n }\n\n required\n - cue.key property is defined and value is != undefined\n - if cue.interval != undefined, it must be instance of Interval\n\n EXAMPLES\n\n // INSERT (no pre-existing cue)\n\n cue = {key:1, interval: new Interval(3,4), data: {}}\n // insert cue with only interval\n cue = {key:1, interval: new Interval(3,4)}\n // insert cue with only data\n cue = {key:1, data: {}}\n\n\n // REPLACE (pre-existing cue)\n preexisting_cue = {key:1, interval: new Interval(3,4), data: {}}\n\n cue = {key:1, interval: new Interval(3,5), data: {foo:\"bar\"}}\n // replace interval, keep data\n cue = {key:1, interval: new Interval(3,5)}\n // replace interval, delete data\n cue = {key:1, interval: new Interval(3,5), data: undefined\n // replace data, keep interval\n cue = {key:1, data: {foo:\"bar\"}}\n // replace data, delete interval\n cue = {key:1, interval: undefined, data: {foo:\"bar\"}}\n\n // DELETE (pre-existing)\n cue = {key:1}\n // delete interval, keep data\n cue = {key:1, interval: undefined}\n // delete data, keep interval\n cue = {key:1, data: undefined}\n\n\n Update returns a list of event items - describes the effects of an update.\n {\n new: new_cue,\n old: old_cue,\n delta: {\n interval: Delta,\n data: Delta\n }\n }\n\n with independent delta values for interval and data:\n Delta.NOOP: 0\n Delta.INSERT: 1\n Delta.REPLACE: 2\n Delta.DELETE: 3\n\n Duplicates\n - if there are multiple cue operations for the same key,\n within the same batch of cues,\n these will be processed in order.\n\n - The old cue will always be the state of the cue,\n before the batch started.\n\n - The returned delta values will be calcultated relative to\n the cue before the batch started (old).\n\n This way, external mirroring observers may will be able to\n replicate the effects of the update operation.\n\n ***************************************************************/\n\n\n\n\n update(cues, options = {}) {\n const batchMap = new Map();\n let current_cue;\n let has_interval, has_data;\n\n // options\n let {debug=false, equals, check_needed=true} = options;\n\n // support single cue arg for convenience\n if (!utils.isIterable(cues)) {\n cues = [cues];\n }\n\n /***********************************************************\n process all cues\n ***********************************************************/\n const epoch_ts = epoch();\n const info = {\n ts: epoch_ts,\n author: options.author\n };\n\n for (let cue of cues) {\n\n /*******************************************************\n check validity of cue argument\n *******************************************************/\n if (check_needed) {\n try {\n cue = cue_check(cue)\n } catch (err) {\n console.log(err, cue)\n continue;\n }\n }\n has_interval = cue.hasOwnProperty(\"interval\");\n has_data = cue.hasOwnProperty(\"data\");\n\n /*******************************************************\n adjust cue so that it correctly represents\n the new cue to replace the current cue\n - includes preservation of values from current cue\n *******************************************************/\n\n current_cue = this._map.get(cue.key);\n if (current_cue == undefined) {\n // make sure properties are defined\n if (!has_interval) {\n cue.interval = undefined;\n }\n if (!has_data) {\n cue.data = undefined;\n }\n } else if (current_cue != undefined) {\n if (!has_interval && !has_data) {\n // make sure properties are defined\n cue.interval = undefined;\n cue.data = undefined;\n } else if (!has_data) {\n // REPLACE_INTERVAL, preserve data\n cue.data = current_cue.data;\n } else if (!has_interval) {\n // REPLACE_DATA, preserve interval\n cue.interval = current_cue.interval;\n } else {\n // REPLACE CUE\n }\n }\n\n /*******************************************************\n update cue\n - update _map\n - update cueBuckets\n - create batchMap\n *******************************************************/\n this._update_cue(batchMap, current_cue, cue, info, options);\n }\n\n // flush all buckets so updates take effect\n this._call_buckets(\"flush\");\n\n if (batchMap.size > 0) {\n\n /*\n create events without delta property\n and accumulate relevance interval for batch\n */\n let relevance = {low: Infinity, high: -Infinity};\n\n // create list of events and remove delta property\n let items = [...batchMap.values()].map(item => {\n if (item.new && item.new.interval) {\n relevance.low = endpoint.min(relevance.low, item.new.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.new.interval.endpointHigh);\n }\n if (item.old && item.old.interval) {\n relevance.low = endpoint.min(relevance.low, item.old.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.old.interval.endpointHigh);\n }\n return {key:item.key, new:item.new, old:item.old, info: item.info};\n });\n\n // extra filter items to remove NOOP transitions\n let event_items = items.filter((item) => {\n let delta = cue_delta(item.new, item.old, equals);\n return (delta.interval != Delta.NOOP || delta.data != Delta.NOOP);\n });\n\n // event notification\n this._notifyEvents(event_items);\n\n // create relevance Interval\n let relevanceInterval = undefined;\n if (relevance.low != Infinity) {\n relevanceInterval = Interval.fromEndpoints(relevance.low, relevance.high);\n }\n\n /*\n notify sequencer last so that change event\n from the dataset will be applied before change\n events from sequencers.\n */\n this._notify_callbacks(batchMap, relevanceInterval);\n \n // debug\n if (debug) {this.integrity();}\n return items;\n }\n // debug\n if (debug) {this.integrity();}\n return [];\n };\n\n\n\n /***************************************************************\n UPDATE CUE\n\n update operation for a single cue\n\n - update _map\n - generate entry for batchMap\n - update CueBucket\n ***************************************************************/\n\n _update_cue(batchMap, current_cue, cue, info, options) {\n\n let old_cue, new_cue;\n let item, _item;\n let oldCueBucket, newCueBucket;\n let low_changed, high_changed;\n let remove_needed, add_needed;\n\n // options\n let {chaining=true, safe=false, equals} = options;\n \n if (current_cue === cue) {\n throw Error(\"illegal cue arg: same object as current cue\");\n }\n\n // check for equality\n let delta = cue_delta(current_cue, cue, equals);\n\n // (NOOP, NOOP)\n if (delta.interval == Delta.NOOP && delta.data == Delta.NOOP) {\n item = {\n key:cue.key, new:current_cue,\n old:current_cue, delta: delta\n }\n batchMap.set(cue.key, item);\n return;\n }\n\n\n /***********************************************************\n update _map and batchMap\n ***********************************************************/\n\n if (current_cue == undefined) {\n // INSERT - add cue object to _map\n\n // cue info: add if missing\n if (cue.info == undefined) {\n cue.info = {\n ts: info.ts,\n change_ts: info.ts,\n change_id: 0\n }\n }\n\n old_cue = undefined;\n new_cue = (safe)? Object.freeze(cue) : cue;\n this._map.set(cue.key, new_cue);\n\n\n } else if (cue.interval == undefined && cue.data == undefined) {\n // DELETE - remove cue object from _map\n old_cue = current_cue;\n new_cue = undefined;\n this._map.delete(cue.key);\n\n // cue info: noop\n\n } else {\n // REPLACE\n\n // cue info - update if missing\n // preserve ts from current cue, update update_ts\n if (cue.info == undefined) {\n cue.info = {\n ts: current_cue.info.ts,\n change_ts: info.ts,\n change_id: current_cue.info.change_id + 1\n };\n }\n\n /*\n Solution used to be in-place modification\n of current cue.\n Now we instead implement replace by inserting\n a new cue object as current cue.\n Since current cue is referenced both in\n _map and in pointMap - it must be replaced both\n places.\n\n Adjustments to pointMap as a result of interval\n changes are handled further down\n\n Another design option would be to let point map\n manage only keys of cues. This however would \n impose an extra map lookup per item in lookup - \n so better to pay this modest price in update\n */\n old_cue = current_cue;\n new_cue = {\n key: cue.key,\n interval: cue.interval,\n data: cue.data,\n info: cue.info\n }\n\n if (safe) {\n new_cue = Object.freeze(new_cue);\n }\n\n // replace in cue map\n this._map.set(cue.key, new_cue);\n\n // replace in point map\n // - only necessary if old cue is in pointMap\n // i.e. if old_cue has interval\n if (old_cue.interval) {\n let bid = getCueBucketId(old_cue.interval.length);\n let cueBucket = this._cueBuckets.get(bid);\n // replace for low\n cueBucket.replace_endpoint(old_cue.interval.low, new_cue);\n // replace for high\n if (!old_cue.singular) {\n cueBucket.replace_endpoint(old_cue.interval.high, new_cue);\n }\n }\n }\n item = {key:cue.key, new:new_cue, old:old_cue, delta:delta, info};\n\n /*\n if this item has been set earlier in batchMap\n restore the correct old_cue by getting it from\n the previous batchMap item\n\n recalculate delta relative to old_cue\n - continue processing with the original (delta, old_cue) defined\n above, as this is required to correctly change cueBuckets\n which have already been affected by previous item.\n */\n if (chaining) {\n _item = batchMap.get(cue.key);\n if (_item != undefined) {\n item.old = _item.old;\n item.delta = cue_delta(new_cue, item.old, equals);\n }\n }\n\n batchMap.set(cue.key, item)\n\n //console.log(\"OLD:\", cue_to_string(old_cue));\n //console.log(\"NEW:\", cue_to_string(new_cue));\n\n /***********************************************************\n update cueBuckets\n\n - use delta.interval to avoid unnessesary changes\n\n - interval may change in several ways:\n - low changed\n - high changed\n - low and high changed\n - changed intervals may stay in bucket or change bucket:\n - changing to/from singular may require special consideration\n with respect to how many endpoints are being updated\n - singular -> singular\n - singular -> regular\n - regular -> singular\n - regular -> regular\n - changes to interval.lowInclude and interval highInclude\n do not require any changes to CueBuckets, as long\n as interval.low and interval.high values stay unchanged.\n ***********************************************************/\n\n if (delta.interval == Delta.NOOP) {\n // no changes to interval - no change needed in pointMap \n return;\n } else if (delta.interval == Delta.INSERT) {\n remove_needed = false;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.DELETE) {\n remove_needed = true;\n add_needed = false;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.REPLACE) {\n remove_needed = true;\n add_needed = true;\n low_changed = new_cue.interval.low != old_cue.interval.low;\n high_changed = new_cue.interval.high != old_cue.interval.high;\n }\n\n /*\n old cue and new cue might not belong to the same cue bucket\n */\n if (remove_needed){\n let old_bid = getCueBucketId(old_cue.interval.length);\n oldCueBucket = this._cueBuckets.get(old_bid);\n }\n if (add_needed) {\n let new_bid = getCueBucketId(new_cue.interval.length);\n newCueBucket = this._cueBuckets.get(new_bid);\n }\n\n /*\n if old CueBucket is different from the new cue Buckets\n both low and high must be moved, even it one was not\n changed\n */\n if (oldCueBucket && newCueBucket) {\n if (oldCueBucket != newCueBucket) {\n remove_needed = true;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n }\n }\n\n /*\n dispatch add and remove operations for interval points\n\n cues in CueBucket may be removed using a copy of the cue,\n because remove is by key.\n\n cues added to CueBucket must be the correct object\n (current_cue), so that later in-place modifications become\n reflected in CueBucket.\n */\n\n // update low point - if changed\n if (low_changed) {\n if (remove_needed) {\n oldCueBucket.del_endpoint(old_cue.interval.low, old_cue);\n }\n if (add_needed) {\n newCueBucket.add_endpoint(new_cue.interval.low, new_cue);\n }\n }\n // update high point - if changed\n if (high_changed) {\n if (remove_needed && !old_cue.interval.singular) {\n oldCueBucket.del_endpoint(old_cue.interval.high, old_cue);\n }\n if (add_needed && !new_cue.interval.singular) {\n newCueBucket.add_endpoint(new_cue.interval.high, new_cue);\n }\n }\n }\n\n\n /*\n INTERNAL FUNCTION\n execute method across all cue buckets\n and aggregate results\n */\n _call_buckets(method, ...args) {\n const arrays = [];\n for (let cueBucket of this._cueBuckets.values()) {\n let cues = cueBucket[method](...args);\n if (cues != undefined && cues.length > 0) {\n arrays.push(cues);\n }\n }\n return utils.array_concat(arrays);\n };\n\n\n /*\n LOOKUP ENDPOINTS\n\n returns (endpoint, cue) for all endpoints covered by given interval\n\n returns:\n - [{endpoint: endpoint, cue:cue}]\n */\n\n lookup_endpoints(interval) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup_endpoints\", interval);\n };\n\n\n /*\n LOOKUP\n */\n\n lookup(interval, mask) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup\", interval, mask);\n };\n\n\n /*\n REMOVE CUES BY INTERVAL\n */\n lookup_delete(interval, mask, options={}) {\n interval = asInterval(interval);\n const cues = this._call_buckets(\"lookup_delete\", interval, mask);\n // remove from _map and make event items\n const items = [];\n const info = {\n ts: epoch(),\n author: options.author\n };\n let cue;\n for (let i=0; i cue.interval == undefined);\n\n let count_buckets = cues.length;\n let count_no_interval = no_interval_cues.length;\n let count_map = this._map.size;\n let diff = count_map - count_buckets - count_no_interval;\n if (diff != 0) {\n console.log(\"count buckets\", count_buckets);\n console.log(\"count no intervals\", count_no_interval);\n console.log(\"count map\", count_map);\n console.log(\"count diff\", diff);\n throw new Error(\"inconsistent cue count\");\n }\n\n // check that cue maps are non overlapping\n let bucket_map = new Map(cues.map(cue => [cue.key, cue]));\n let map_map = new Map([...this._map.entries()].filter(([key, cue]) => {\n return (cue.interval != undefined);\n }));\n\n let missing = utils.map_difference(bucket_map, map_map);\n if (missing.size > 0) {\n console.log(\"buckets missing cues:\")\n console.log([...missing.keys()])\n throw new Error(`buckets missing cues: ${[...missing.keys()]}`);\n }\n \n missing = utils.map_difference(map_map, bucket_map);\n if (missing.size > 0) {\n throw new Error(`buckets too many cues: ${[...missing.keys()]}`);\n }\n\n return {\n cues: cues.length,\n points: points.length\n };\n };\n\n}\n\n\nDataset.Delta = Delta;\nDataset.cue_delta = cue_delta;\nDataset.cue_equals = cue_equals;\n\n\n/*\n CueBucket is a bucket of cues limited to specific length\n*/\n\n\nclass CueBucket {\n\n\n constructor(maxLength) {\n\n // max length of cues in this bucket\n this._maxLength = maxLength;\n\n /*\n pointMap maintains the associations between values (points on\n the timeline) and cues that reference such points. A single point value may be\n referenced by multiple cues, so one point value maps to a list of cues.\n\n value -> [cue, ....]\n */\n this._pointMap = new Map();\n\n\n /*\n pointIndex maintains a sorted list of numbers for efficient lookup.\n A large volume of insert and remove operations may be problematic\n with respect to performance, so the implementation seeks to\n do a single bulk update on this structure, for each batch of cue\n operations (i.e. each invocations of addCues). In order to do this\n all cue operations are processed to calculate a single batch\n of deletes and a single batch of inserts which then will be applied to\n the pointIndex in one atomic operation.\n\n [1.2, 3, 4, 8.1, ....]\n */\n this._pointIndex = new BinarySearch();\n\n // bookeeping during batch processing\n this._created = new Set(); // point\n this._dirty = new Set(); // point\n\n };\n\n\n /*\n\n ENDPOINT BATCH PROCESSING\n\n Needs to translate endpoint operations into a minimum set of\n operations on the pointIndex.\n\n To do this, we need to record points that are created and\n points that are removed.\n\n The total difference that the batch of cue operations\n amounts to is expressed as one list of values to be\n deleted, and and one list of values to be inserted.\n The update operation of the pointIndex will process both\n in one atomic operation.\n\n On flush both the pointMap and the pointIndex will be brought\n up to speed\n\n created and dirty are used for bookeeping during\n processing of a cue batch. They are needed to\n create the correct diff operation to be applied on pointIndex.\n\n created : includes values that were not in pointMap\n before current batch was processed\n\n dirty : includes values that were in pointMap\n before current batch was processed, and that\n have been become empty at least at one point during cue\n processing.\n\n created and dirty are used as temporary alternatives to pointMap.\n after the cue processing, pointmap will updated based on the\n contents of these two.\n\n process buffers operations for pointMap and index so that\n all operations may be applied in one batch. This happens in flush\n */\n\n add_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues == undefined) {\n this._pointMap.set(point, [cue]);\n this._created.add(point);\n } else {\n cues.push(cue);\n //addCueToArray(cues, cue);\n }\n }\n\n del_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let empty = removeCueFromArray(cues, cue);\n if (empty) {\n this._dirty.add(point);\n }\n }\n };\n\n /* \n in case of data update without touching the interval\n the new cue needs to be insert in place of the old\n */\n replace_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let ok = replaceCueInArray (cues, cue);\n if (!ok) {\n console.log(\"WARNING: attempt to replace non-existent cue in pointMap\")\n }\n }\n }\n\n\n /*\n Batch processing is completed\n Commit changes to pointIndex and pointMap.\n\n pointMap\n - update with contents of created\n\n pointIndex\n - points to delete - dirty and empty\n - points to insert - created and non-empty\n\n it is possible that a cue ends up in both created and dirty\n\n */\n flush() {\n if (this._created.size == 0 && this._dirty.size == 0) {\n return;\n }\n\n // update pointIndex\n let to_remove = [];\n let to_insert = [];\n for (let point of this._created.values()) {\n let cues = this._pointMap.get(point);\n if (cues.length > 0) {\n to_insert.push(point);\n } else {\n this._pointMap.delete(point);\n }\n }\n for (let point of this._dirty.values()) {\n let cues = this._pointMap.get(point);\n if (cues == undefined) {\n // point already deleted from created set - ignore\n continue;\n }\n if (cues.length == 0) {\n to_remove.push(point);\n this._pointMap.delete(point);\n }\n }\n this._pointIndex.update(to_remove, to_insert);\n // cleanup\n this._created.clear();\n this._dirty.clear();\n };\n\n\n /*\n LOOKUP_ENDPOINTS\n\n returns all (endpoint, cue) pairs where\n - endpoint is a cue endpoint (cue.endpointLow or cue.endpointHigh)\n - endpoint is INSIDE search interval\n - [{endpoint:endpoint, cue: cue}]\n\n - a given endpoint may appear multiple times in the result,\n as multiple cues may be tied to the same endpoint\n - a given cue may appear two times in the result, if\n both cue.endpointLow and cue.endpointHigh are both INSIDE interval\n - a singular cue will appear only once\n - ordering: no specific order is guaranteed\n - results are concatenated from multiple CueBuckets\n - internally in a single CueBucket\n - no defined order for cues tied to the same endpoint\n - the natural order is endpoint order\n - but this can be added on the outside if needed\n - no order is defined if two cues have exactly the\n same endpoint\n\n */\n\n lookup_endpoints(interval) {\n if (this._pointMap.size == 0) {\n return [];\n }\n const broader_interval = new Interval(interval.low, interval.high, true, true);\n const points = this._pointIndex.lookup(broader_interval);\n const result = [];\n const len = points.length;\n let point, _endpoint;\n for (let i=0; i this._maxLength) {\n return cues;\n }\n\n /*\n handle match with COVERS separately\n\n search left of search interval for cues\n that covers the search interval\n search left is limited by CueBucket maxlength\n left_interval: [interval.high-maxLength, interval.low]\n\n it would be possible to search right too, but we\n have to choose one.\n */\n if (mask & Relation.COVERS) {\n\n let left_interval;\n if (this._maxLength == Infinity) {\n // no limitation on interval length\n // must search entire timeline to the left\n left_interval = new Interval(-Infinity, interval.low);\n } else {\n let low = interval.high - this._maxLength;\n let high = interval.low;\n // protect against float rounding effects creating\n // high < low by a very small margin\n [low, high] = [Math.min(low, high), Math.max(low, high)];\n left_interval = new Interval(low, high, true, true);\n }\n this._lookup_cues(left_interval)\n .forEach(function(cue){\n if (cue.interval.match(interval, Relation.COVERS)) {\n cues.push(cue);\n }\n });\n }\n\n return cues;\n }\n\n\n /*\n REMOVE CUES\n */\n lookup_delete(interval, mask) {\n /*\n update pointMap\n - remove all cues from pointMap\n - remove empty entries in pointMap\n - record points that became empty, as these need to be deleted in pointIndex\n - separate into two bucketes, inside and outside\n */\n const cues = this.lookup(interval, mask);\n const to_remove = [];\n let cue, point, points;\n for (let i=0; i 0) {\n throw new Error(`pointMap missing points: ${[...missing]}`);\n }\n \n missing = utils.set_difference(map_point_set, index_point_set);\n if (missing.size > 0) {\n throw new Error(`pointIndex missing points: ${[...missing]}`);\n }\n }\n\n /*\n invariable - pointIndex shall always be sorted and not contain duplicates\n */\n let points = [...this._pointIndex.values()];\n if (points.length != index_point_set.size) {\n throw new Error(\"pointIndex include duplicate points\");\n }\n for (let i=1; i= points[i]) {\n throw new Error(\"pointIndex not ordered\");\n } \n }\n\n /**\n * invariable - pointMap point -> cues \n * cues shall only include cues which are relevant to given point\n */\n for (let point of points) {\n let cues = this._pointMap.get(point);\n for (let cue of cues) {\n // figure out if point is endpoint low or high\n if (point == cue.interval.low) {\n continue;\n } else if (point == cue.interval.high) {\n continue;\n } else {\n console.log(\"POINT:\", point); \n console.log(\"CUE:\", cue.interval.toString());\n throw new Error(\"pointMap: wrong cue\");\n }\n } \n }\n\n\n /**\n * invariable - all endpoints from all cues from pointMap are found as points in pointMap\n */\n\n for (let _cue_list of [...this._pointMap.values()]) {\n for (let cue of _cue_list) {\n for (let p of [cue.interval.low, cue.interval.high]) {\n if (!this._pointMap.has(p)) {\n throw new Error(`cue found with low or high point not in pointMap ${p} -> ${cue.interval.toString()} `);\n }\n }\n }\n }\n\n\n /*\n invariable - all cues in pointMap with same key are same object\n */\n\n // collect all cues from pointMap\n let _cues = [];\n for (let _cue_list of this._pointMap.values()) {\n for (let cue of _cue_list) {\n _cues.push(cue);\n }\n }\n\n // remove and check duplicates\n let cueMap = new Map();\n for (let cue of _cues) {\n let _cue = cueMap.get(cue.key);\n if (_cue == undefined) {\n cueMap.set(cue.key, cue);\n } else {\n // duplicate\n if (cue !== _cue) {\n throw new Error(\"pointMap: different cue objects for same key\");\n }\n }\n }\n let cues = [...cueMap.values()];\n\n /**\n * invariable - all cues belong to this bucket\n */\n\n for (let cue of cues.values()) {\n // check that cue belongs to this bucket\n if (cue.interval.length > this._maxLength) {\n throw new Error(`cue in wrong cue bucket ${this._maxLength}, ${cue.interval.toString()}`);\n }\n }\n\n return [{\n maxLength: this._maxLength,\n points: [...this._pointMap.keys()],\n cues: cues\n }];\n };\n}\n\n// module definition\nexport default Dataset;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n - : if defined only include cues that match the interval\n - : filter by cue key\n function keep(key) returns boolena\n - : filter by cue data\n function keep(data) returns boolean\n - : change cue data\n function convert(data) returns data\n NOTE: filtering occurs BEFORE convert\n and only impacts the presentation of cues\n WARNING: it is possible to change the value\n in such a way that filtering appears incorrect\n\n This subset implementation is STATELESS\n It does not manage its own state, only implements a\n stateless frontend over its source dataset.\n\n*/\n\nclass Subset extends CueCollection {\n\n constructor(dataset, options={}) {\n super(options);\n this._key_filter = options.key_filter;\n this._data_filter = options.data_filter;\n this._interval = options.interval;\n this._data_convert = options.data_convert;\n this._size = 0;\n\n // Callbacks\n this._callbacks = [];\n\n // Source Dataset\n this._src_ds = dataset;\n let cb = this._onDatasetCallback.bind(this)\n this._src_ds_cb = this._src_ds.add_callback(cb);\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get datasource () {\n return this._src_ds;\n }\n\n get dataset () {\n return this._src_ds;\n }\n\n\n get interval () {\n return this._interval;\n }\n\n set interval (itv) {\n this._setInterval(itv);\n }\n\n\n /***************************************************************\n EVENT CALLBACKS - FOR SEQUENCERS\n ***************************************************************/\n\n add_callback (handler) {\n let handle = {\n handler: handler\n }\n this._callbacks.push(handle);\n return handle;\n };\n\n\n del_callback (handle) {\n let index = this._callbacks.indexof(handle);\n if (index > -1) {\n this._callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n\n /***************************************************************\n FILTER & CONVER\n ***************************************************************/\n\n /* \n Keep cue \n */\n\n _cue_keep(cue) {\n if (cue == undefined) {\n return false;\n }\n // check if cue matches interval\n if (this._interval) {\n if (!this._interval.match(cue.interval)) {\n return false;\n }\n }\n // check key filter\n if (this._key_filter) {\n if (!this._key_filter(cue.key)) {\n return false;\n }\n }\n // check data filter\n if (this._data_filter) {\n if (!this._data_filter(cue.data)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Convert cue\n */\n _cue_convert(cue) {\n if (cue != undefined && this._data_convert) {\n // copy\n return {\n key: cue.key,\n interval: cue.interval,\n data: this._data_convert(cue.data)\n }\n }\n return cue;\n }\n\n /**\n * Filter (and modify) event items based on key_filter and data_filter\n */\n\n _items_filter_convert(items) {\n let _items = [];\n for (let item of items) {\n if (item.new == undefined && item.old == undefined) {\n continue;\n }\n /* \n use cue filter function to check relevance of both old and new\n consider change of unrelevant cue into relevant cue.\n old cue would be non-relevant, new cue would be relevant\n Since old cue was not part of the subset before, it needs\n to be removed from the item - effectively turning the change\n operation into an add operation. \n */\n let _old = (this._cue_keep(item.old)) ? item.old : undefined;\n let _new = (this._cue_keep(item.new)) ? item.new : undefined;\n if (_old == undefined && _new == undefined) {\n continue;\n }\n // convert\n _old = this._cue_convert(_old);\n _new = this._cue_convert(_new);\n // push\n _items.push({key:item.key, new: _new, old: _old});\n }\n return _items;\n }\n\n\n /***************************************************************\n LOOKUP\n ***************************************************************/\n\n _check_interval(interval) {\n if (this._interval) {\n // subset interval\n if (interval) {\n // lookup interval - find intersection\n let intersects = Interval.intersect(interval, this._interval);\n if (intersects.length == 0) {\n console.log(`warning - lookup interval ${interval.toString()} outside the subset interval ${this._interval.toString()}`);\n return [];\n } else {\n interval = intersects[0];\n }\n } else {\n // no lookup interval - use subset interval \n interval = this._interval;\n }\n }\n return interval;\n }\n\n /** \n * lookup cues\n */\n\n lookup(interval, mask) {\n let _interval = this._check_interval(interval);\n let cues;\n if (_interval) {\n cues = this.datasource.lookup(_interval, mask);\n } else {\n cues = [...this.datasource.values()];\n }\n // filter & convert cues\n return cues.filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n }\n\n /* \n lookup endpoints\n used by sequencers\n */\n\n lookup_endpoints(interval) {\n let _interval = this._check_interval(interval);\n let items = this.datasource.lookup_endpoints(_interval);\n // filter and convert\n return items.filter((item) => {\n return this._cue_keep(item.cue);\n }, this).map((item) => {\n return {endpoint: item.endpoint, cue: this._cue_convert(item.cue)};\n }, this);\n }\n\n /***************************************************************\n INITIAL STATE\n ***************************************************************/\n\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n // find cues\n let cues = this.lookup();\n // make event items\n let items = cues.map((cue) => {\n return {key:cue.key, new:cue, old:undefined};\n });\n // sort\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /***************************************************************\n DATASET CALLBACK\n ***************************************************************/\n\n _onDatasetCallback(eventMap, relevanceInterval) {\n let items = [...eventMap.values()];\n items = this._items_filter_convert(items);\n // update size\n for (let item of items) {\n if (item.new != undefined && item.old == undefined) {\n // add\n this._size += 1;\n } else if (item.new == undefined && item.old != undefined) {\n // remove\n this._size -= 1;\n } \n } \n // forward as events\n super._notifyEvents(items);\n // forward as callbacks\n let batchMap = new Map(items.map((item) => {\n return [item.key, item];\n }));\n if (this._interval) {\n relevanceInterval = Interval.intersect(this._inverval, relevanceInterval);\n }\n this._notify_callbacks(batchMap, relevanceInterval);\n }\n\n\n /***************************************************************\n SET INTERVAL\n ***************************************************************/\n\n _setInterval (itv) {\n if (!itv instanceof Interval) {\n throw new Error(\"must be interval\", itv.toString());\n }\n if (!this._interval || !this._interval.equals(itv)) {\n // current cues (before interval update)\n let current_cues = this.lookup();\n // update interval\n this._interval = itv;\n // cues (after interval update)\n let new_cues = this.datasource.lookup(itv);\n // filter & convert cues\n new_cues = new_cues\n .filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n // switch to map representation\n let currentCueMap = new Map([...current_cues].map((cue) => {\n return [cue.key, cue];\n }));\n let newCueMap = new Map([...new_cues].map((cue) => {\n return [cue.key, cue];\n }));\n // exit and enter cues\n let exitCueMap = map_difference(currentCueMap, newCueMap);\n let enterCueMap = map_difference(newCueMap, currentCueMap);\n // make list of event items\n let exitItems = [...exitCueMap.values()].map((cue) => {\n return {key: cue.key, new:undefined, old: cue}\n });\n let enterItems = [...enterCueMap.values()].map((cue) => {\n return {key: cue.key, new:cue, old: undefined}\n });\n // update size\n this._size -= exitItems.length;\n this._size += enterItems.length; \n // event notification\n const items = array_concat([exitItems, enterItems], {copy:false, order:true});\n this._notifyEvents(items);\n }\n }\n\n /***************************************************************\n MAP ACCESSORS\n ***************************************************************/\n\n get size () {\n return this._size;\n }\n\n has(key) {\n return (this.get(key) != undefined);\n };\n\n get(key) {\n let cue = super.get(key);\n if (cue != undefined && this._cue_keep(cue)) {\n return this._cue_convert(cue);\n }\n };\n\n keys() {\n return this.values().map((cue => {\n return cue.key;\n }));\n };\n\n values() {\n return [...super.values()]\n .filter((cue) => {\n return this._cue_keep(cue);\n }, this)\n .map((cue) => {\n return this._cue_convert(cue);\n }, this);\n };\n\n entries() {\n return this.values().map((cue) => {\n return [cue.key, cue];\n });\n };\n\n\n /***************************************************************\n MAP MODIFICATION METHODS\n ***************************************************************/\n\n update(cues, options) {\n throw new Error(\"not implemented\");\n }\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n clear (key) {\n throw new Error(\"not implemented\");\n }\n\n}\n\n// module definition\nexport default Subset;","/*\n\tCopyright 2015 Norut Northern Research Institute\n\tAuthor : Ingar Mæhlum Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see not equal\n if (aProps.length != bProps.length) {\n return false;\n }\n for (let i=0; i not equal\n if (a[propName] !== b[propName]) {\n return false;\n }\n }\n // equal\n return true;\n}\n\n\n/* document readypromise */\nexport const docready = new Promise(function(resolve) {\n if (document.readyState === 'complete') {\n resolve();\n } else {\n let onReady = function () {\n resolve();\n document.removeEventListener('DOMContentLoaded', onReady, true);\n window.removeEventListener('load', onReady, true);\n };\n document.addEventListener('DOMContentLoaded', onReady, true);\n window.addEventListener('load', onReady, true);\n }\n});\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see -1) {\n indexes.push(index);\n }\n }\n return indexes;\n };\n\n /*\n element exists with value\n */\n has(x) {\n return (this.indexOf(x) > -1) ? true : false;\n };\n\n get(index) {\n return this.array[index];\n };\n\n\n\n /*\n REMOVE\n Removes all elements with given values\n search for each one and splice remove them individually\n (reverse order)\n\n INSERT\n binarysearch and splice\n insert - binarysearch and splice\n\n WARNING - there should be no need to insert elements that are already\n present in the array. This function drops such duplicates\n */\n _update_splice(to_remove, to_insert, options) {\n\n // REMOVE\n if (this.array.length > 0) {\n let indexes = this.indexOfElements(to_remove);\n /*\n sort indexes to make sure we are removing elements\n in backwards order\n optimization\n - if elements were sorted in the first place this should not be necessary\n */\n indexes.sort(function(a,b){return a-b;});\n for (let i=indexes.length-1; i > -1; i--) {\n this.array.splice(indexes[i], 1);\n }\n }\n\n // INSERT\n let x, index;\n let len = to_insert.length;\n for (let i=0; i 0 && to_remove.length > 0) {\n // visit all elements and set their value to undefined\n // undefined values will be sorted to the end of the array\n let indexes = this.indexOfElements(to_remove);\n for (let i=0; i 0) {\n let index = this.array.indexOf(undefined);\n if (index > -1) {\n this.array.splice(index, this.array.length-index);\n }\n }\n // remove duplicates\n this.array = unique(this.array);\n };\n\n\n /*\n Update - removing and inserting elements in one operation\n\n a single element should only be present once in the list, thus avoiding\n multiple operations to one element. This is presumed solved externally.\n - also objects must not be members of both lists.\n\n - internally selects the best method - searchsplice or concatsort\n - selection based on relative sizes of existing elements and new elements\n\n */\n update(to_remove, to_insert, options) {\n let size = to_remove.length + to_insert.length;\n if (size == 0) {\n return;\n }\n\n // regular case\n let approach = resolve_approach(this.array.length, size);\n if (approach == \"splice\") {\n this._update_splice(to_remove, to_insert, options);\n } else if (approach == \"sort\"){\n this._update_sort(to_remove, to_insert, options);\n }\n };\n\n\n /*\n Accessors\n */\n\n getMinimum() {\n return (this.array.length > 0) ? this.array[0] : undefined;\n };\n\n getMaximum = function () {\n return (this.array.length > 0) ? this.array[this.array.length - 1] : undefined;\n };\n\n\n /*\n Internal search functions\n */\n\n /*\n Find index of largest value less than x\n Returns -1 if noe values exist that are less than x\n */\n ltIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n consider element to the left\n if we are at the left end of the array nothing is found\n return -1\n */\n if (i > 0) {\n return i-1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) - 1 is the largest value less than x\n */\n return Math.abs(i)-1;\n }\n };\n\n /*\n Find index of rightmost value less than x or equal to x\n Returns -1 if noe values exist that are less than x or equal to x\n */\n leIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n element found\n */\n return i;\n } else {\n // not found - consider element to the left\n i = Math.abs(i) - 1;\n return (i >= 0) ? i : -1;\n }\n };\n\n /*\n \tFind index of leftmost value greater than x\n \tReturns -1 if no values exist that are greater than x\n */\n\n gtIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found - x is found on index i\n if there are no elements to the right return -1\n */\n if (i < this.array.length -1) {\n return i+1;\n } else {\n return -1;\n }\n } else {\n /*\n not found - Math.abs(i) is index where x should be inserted\n => Math.abs(i) is the smallest value greater than x\n unless we hit the end of the array, in which cas no smalles value\n exist which is greater than x\n */\n let idx = Math.abs(i);\n return (idx < this.array.length) ? idx : -1;\n }\n };\n\n\n /*\n Find index of leftmost value which is greater than x or equal to x\n Returns -1 if noe values exist that are greater than x or equal to x\n */\n\n geIndexOf(x) {\n var i = this.binaryIndexOf(x);\n if (this.isFound(i, x)) {\n /*\n found element\n */\n return i;\n } else {\n // not found - consider the element where x would be inserted\n i = Math.abs(i);\n return (i -1) {\n return [index, index + 1];\n } else {\n return [undefined, undefined];\n }\n }\n\n // regular non-singular interval\n var start_index = -1, end_index = -1;\n if (interval.lowInclude) {\n start_index = this.geIndexOf(interval.low);\n } else {\n start_index = this.gtIndexOf(interval.low);\n }\n if (start_index === -1) {\n return [undefined, undefined];\n }\n if (interval.highInclude) {\n end_index = this.leIndexOf(interval.high);\n } else {\n end_index = this.ltIndexOf(interval.high);\n }\n if (end_index === -1) { // not reachable - I think\n return [undefined, undefined];\n }\n return [start_index, end_index + 1];\n };\n\n\n /*\n lookup by interval\n */\n lookup(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.slice(start, end) : [];\n };\n\n /*\n remove by interval\n */\n remove(interval) {\n let [start, end] = this.lookupIndexes(interval);\n return (start != undefined) ? this.array.splice(start, end-start) : [];\n };\n\n\n slice(start, end) {\n return this.array.slice(start, end);\n };\n\n splice(start, length) {\n return this.array.splice(start, length);\n };\n\n\n\n /*\n method for removing multiple closely placed elements in place\n - removeList is sorted\n - changes only affect the part of the index between first and last element\n - move remaining elements to the left, remove elements with a single splice\n - efficent if removelist references elements that are close to eachother\n */\n\n removeInSlice(removeList) {\n if (removeList.length == 0){\n return;\n }\n const low = removeList[0];\n const high = removeList[removeList.length-1];\n let [start, end] = this.lookupIndexes(new Interval(low, high, true, true));\n\n let rd_ptr = start;\n let wr_ptr = start;\n let rm_ptr = 0;\n\n while (rd_ptr < end) {\n let rd_elem = this.array[rd_ptr];\n let rm_elem = removeList[rm_ptr];\n if (rd_elem < rm_elem) {\n this.array[wr_ptr] = this.array[rd_ptr];\n wr_ptr++;\n rd_ptr++;\n } else if (rd_elem == rm_elem) {\n rd_ptr++;\n rm_ptr++;\n } else {\n // rd_elem > rm_elem\n rm_ptr++;\n }\n if (rm_ptr == removeList.length) {\n break\n }\n }\n this.array.splice(wr_ptr, rd_ptr-wr_ptr);\n };\n\n\n values() {\n return this.array.values();\n };\n\n clear() {\n this.array = [];\n };\n\n get length () {\n return this.array.length;\n }\n\n}\n\nexport default BinarySearch;\n\n\n\n","/*\n\tCopyright 2020\n\tAuthor : Ingar Arntzen\n\n\tThis file is part of the Timingsrc module.\n\n\tTimingsrc is free software: you can redistribute it and/or modify\n\tit under the terms of the GNU Lesser General Public License as published by\n\tthe Free Software Foundation, either version 3 of the License, or\n\t(at your option) any later version.\n\n\tTimingsrc is distributed in the hope that it will be useful,\n\tbut WITHOUT ANY WARRANTY; without even the implied warranty of\n\tMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n\tGNU Lesser General Public License for more details.\n\n\tYou should have received a copy of the GNU Lesser General Public License\n\talong with Timingsrc. If not, see {\n\t\t\treturn {name, eArg};\n\t\t}));\n\t}\n\n\t/*\n\t\tTrigger single event\n\t*/\n\tfunction eventifyTrigger(name, eArg) {\n\t\treturn this.eventifyTriggerAll([{name, eArg}]);\n\t}\n\n\t_prototype.eventifyDefine = eventifyDefine;\n\t_prototype.eventifyTrigger = eventifyTrigger;\n\t_prototype.eventifyTriggerAlike = eventifyTriggerAlike;\n\t_prototype.eventifyTriggerAll = eventifyTriggerAll;\n\t_prototype.eventifySubscriptions = eventifySubscriptions;\n\t_prototype.on = on;\n\t_prototype.off = off;\n};\n\n\n/*\n\tEvent Variable\n\n\tObjects with a single \"change\" event\n*/\n\nexport class EventVariable {\n\n\tconstructor (value) {\n\t\teventifyInstance(this);\n\t\tthis._value = value;\n\t\tthis.eventifyDefine(\"change\", {init:true});\n\t}\n\n\teventifyInitEventArgs(name) {\n\t\tif (name == \"change\") {\n\t\t\treturn [this._value];\n\t\t}\n\t}\n\n\tget value () {return this._value};\n\tset value (value) {\n\t\tif (value != this._value) {\n\t\t\tthis._value = value;\n\t\t\tthis.eventifyTrigger(\"change\", value);\n\t\t}\n\t}\n}\neventifyPrototype(EventVariable.prototype);\n\n/*\n\tEvent Boolean\n\n\n\tNote : implementation uses falsiness of input parameter to constructor and set() operation,\n\tso eventBoolean(-1) will actually set it to true because\n\t(-1) ? true : false -> true !\n*/\n\nexport class EventBoolean extends EventVariable {\n\tconstructor(value) {\n\t\tsuper(Boolean(value));\n\t}\n\n\tset value (value) {\n\t\tsuper.value = Boolean(value);\n\t}\n\tget value () {return super.value};\n}\n\n\n/*\n\tmake a promise which is resolved when EventBoolean changes\n\tvalue.\n*/\nexport function makePromise(eventObject, conditionFunc) {\n\tconditionFunc = conditionFunc || function(val) {return val == true};\n\treturn new Promise (function (resolve, reject) {\n\t\tlet sub = eventObject.on(\"change\", function (value) {\n\t\t\tif (conditionFunc(value)) {\n\t\t\t\tresolve(value);\n\t\t\t\teventObject.off(sub);\n\t\t\t}\n\t\t});\n\t});\n};\n\n// module api\nexport default {\n\teventifyPrototype,\n\teventifyInstance,\n\tEventVariable,\n\tEventBoolean,\n\tmakePromise\n};\n\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n fallback to order from constructor\n noop if no ordering is defined\n */\n sortValues(iter, options={}) {\n let order = this.sortOrder(options);\n if (typeof order == \"function\") {\n // sort\n // if iterable not array - convert into array ahead of sorting\n let arr = (Array.isArray(iter)) ? iter : [...iter];\n return arr.sort(order);\n } else {\n // noop\n return iter;\n }\n }\n\n /* \n Sort items (in-place) by value {new:value, old:value} using\n ordering function for values\n */\n sortItems(items) {\n let order = this.sortOrder(); \n if (typeof order == \"function\") {\n items.sort(function(item_a, item_b) {\n let cue_a = (item_a.new) ? item_a.new : item_a.old;\n let cue_b = (item_b.new) ? item_b.new : item_b.old;\n return order(cue_a, cue_b);\n });\n }\n }\n\n /***************************************************************\n EVENTS\n ***************************************************************/\n\n /*\n Eventify: immediate events\n */\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n let items = [...this.datasource.entries()].map(([key, val]) => {\n return {key:key, new:val, old:undefined};\n });\n // sort init items (if order defined)\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /*\n Event Notification\n */\n _notifyEvents(items) {\n // event notification\n if (items.length == 0) {\n return;\n }\n const has_update_subs = this.eventifySubscriptions(\"batch\").length > 0;\n const has_remove_subs = this.eventifySubscriptions(\"remove\").length > 0;\n const has_change_subs = this.eventifySubscriptions(\"change\").length > 0;\n // update\n if (has_update_subs) {\n this.eventifyTrigger(\"batch\", items);\n }\n // change, remove\n if (has_remove_subs || has_change_subs) {\n for (let item of items) {\n if (item.new == undefined && item.old != undefined) {\n if (has_remove_subs) {\n this.eventifyTrigger(\"remove\", item);\n }\n } else {\n if (has_change_subs) {\n this.eventifyTrigger(\"change\", item);\n }\n }\n }\n }\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get size () {\n return this.datasource.size;\n }\n\n has(key) {\n return this.datasource.has(key);\n };\n\n get(key) {\n return this.datasource.get(key);\n };\n\n keys() {\n return this.datasource.keys();\n };\n\n values() {\n return this.datasource.values();\n };\n\n entries() {\n return this.datasource.entries();\n }\n\n\n /***************************************************************\n MODIFY\n ***************************************************************/\n\n set(key, value) {\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n }\n this.datasource.set(key, value);\n this._notifyEvents([{key: key, new:value, old: old}]);\n return this;\n }\n\n delete(key) {\n let result = false;\n let old = undefined;\n if (this.datasource.has(key)) {\n old = this.datasource.get(key);\n this.datasource.delete(key);\n result = true;\n }\n this._notifyEvents([{key: key, new:undefined, old: old}]);\n return result;\n }\n\n clear() {\n // create change events for all cues\n const items = [...this.datasource.entries()].map(([key, val]) => {\n return {key: key, new: undefined, old: val};\n })\n // clear _map\n this.datasource.clear();\n // event notification\n this._notifyEvents(items);\n }\n\n}\n\neventify.eventifyPrototype(ObservableMap.prototype);\n\nexport default ObservableMap;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see {\n return this._submit.bind(this)();\n });\n }\n\n _push(cue_args) {\n // append cue args\n let m = this._cues.length;\n let was_empty = m == 0;\n let n = cue_args.length;\n this._cues.length += n;\n for (let i=0; i 0) {\n // batch done immediately \n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n }\n\n _submit() {\n let result = [];\n // carry out update if necessary\n if (this._cues.length > 0) {\n result = this._ds.update(this._cues, this._options); \n }\n // reset cue arg builder\n this._reset();\n // update result\n return result;\n } \n \n /*\n add or change single cue\n \n if both interval and data are undefined\n this is not interpreted as remove,\n but as a cue with no interval and a data value set\n to undefined\n */\n addCue(key, interval, data) {\n let cue_arg = {key:key};\n cue_arg.interval = interval; \n if (arguments.length > 2) {\n cue_arg.data = data;\n }\n this._push([cue_arg]);\n return this;\n }\n\n /* remove single cue */\n removeCue(key) {\n this._push([{key:key}]);\n return this;\n }\n\n /* load array of cue args into argbuilder */\n update(cue_args) {\n this._push(cue_args);\n }\n\n /* clear args currently in argbuilder */\n clear() {\n this._cues = [];\n return this;\n }\n\n /* manually submit cue args from cue arg builder */\n submit() {\n if (this._options.autosubmit) {\n throw new Error(\"manual submit while options.autosubmit is true\");\n }\n // mark batch as done\n // will be submitted by donePromise in next microtask\n this._done.value = true;\n }\n}\n\n\n/*\n this implements Dataset, a data collection supporting\n efficient lookup of cues tied to intervals on the timeline\n\n - cues may be tied to one or two points on the timeline, this\n is expressed by an Interval.\n - cues are indexed both by key and by intervals\n - the interval index is divided into a set of CueBuckets,\n based on cue interval length, for efficient lookup\n*/\n\nclass Dataset extends CueCollection {\n\n constructor(options) {\n super(options);\n\n this._map = new Map();\n this._builder = new CueArgBuilder(this);\n\n /*\n Initialise set of CueBuckets\n Each CueBucket is responsible for cues of a certain length\n */\n this._cueBuckets = new Map(); // CueBucketId -> CueBucket\n for (let i=0; i -1) {\n this._update_callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._update_callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n /***************************************************************\n MAP METHODS\n */\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n\n /***************************************************************\n CUE ARG BUILDER\n */\n \n makeBuilder(options) {\n return new CueArgBuilder(this, options);\n }\n\n // not really useful (v2 complience)\n get builder () {return this._builder;};\n\n \n /***************************************************************\n ADD CUE, REMOVE CUE\n\n - COMPATIBILTY WITH V2\n - SAFE TO USE repeatedly (batched using promise)\n */\n\n addCue(key, interval, data) {\n if (arguments.length > 2) {\n this._builder.addCue(key, interval, data);\n } else {\n this._builder.addCue(key, interval);\n }\n return this;\n }\n\n removeCue(key) {\n this._builder.removeCue(key);\n return this;\n }\n\n get updateDone() {return this._builder.updateDone};\n\n /***************************************************************\n ADD CUE, REMOVE CUE - INTERACTIVE USE\n\n - CONVENIENCE for interactive use\n - COMPATIBILTY WITH V2\n - NOT RECOMMENDED TO USE repeatedly (batched using promise)\n */\n\n _addCue(key, interval, data, options) {\n return this.update({key:key, interval:interval, data:data}, options);\n }\n\n _removeCue(key, options) {\n return this.update({key:key}, options);\n }\n\n /***************************************************************\n UPDATE\n\n - insert, replace or delete cues\n\n update(cues, equals, check)\n\n ordered list of cues to be updated\n - equality function for data objects\n\n cue = {\n key:key,\n interval: Interval,\n data: data\n }\n\n required\n - cue.key property is defined and value is != undefined\n - if cue.interval != undefined, it must be instance of Interval\n\n EXAMPLES\n\n // INSERT (no pre-existing cue)\n\n cue = {key:1, interval: new Interval(3,4), data: {}}\n // insert cue with only interval\n cue = {key:1, interval: new Interval(3,4)}\n // insert cue with only data\n cue = {key:1, data: {}}\n\n\n // REPLACE (pre-existing cue)\n preexisting_cue = {key:1, interval: new Interval(3,4), data: {}}\n\n cue = {key:1, interval: new Interval(3,5), data: {foo:\"bar\"}}\n // replace interval, keep data\n cue = {key:1, interval: new Interval(3,5)}\n // replace interval, delete data\n cue = {key:1, interval: new Interval(3,5), data: undefined\n // replace data, keep interval\n cue = {key:1, data: {foo:\"bar\"}}\n // replace data, delete interval\n cue = {key:1, interval: undefined, data: {foo:\"bar\"}}\n\n // DELETE (pre-existing)\n cue = {key:1}\n // delete interval, keep data\n cue = {key:1, interval: undefined}\n // delete data, keep interval\n cue = {key:1, data: undefined}\n\n\n Update returns a list of event items - describes the effects of an update.\n {\n new: new_cue,\n old: old_cue,\n delta: {\n interval: Delta,\n data: Delta\n }\n }\n\n with independent delta values for interval and data:\n Delta.NOOP: 0\n Delta.INSERT: 1\n Delta.REPLACE: 2\n Delta.DELETE: 3\n\n Duplicates\n - if there are multiple cue operations for the same key,\n within the same batch of cues,\n these will be processed in order.\n\n - The old cue will always be the state of the cue,\n before the batch started.\n\n - The returned delta values will be calcultated relative to\n the cue before the batch started (old).\n\n This way, external mirroring observers may will be able to\n replicate the effects of the update operation.\n\n ***************************************************************/\n\n update(cues, options = {}) {\n const batchMap = new Map();\n let current_cue;\n let has_interval, has_data;\n\n // options\n let {debug=false, equals} = options;\n\n // support single cue arg for convenience\n if (!utils.isIterable(cues)) {\n cues = [cues];\n }\n\n /***********************************************************\n process all cues\n ***********************************************************/\n const epoch_ts = epoch();\n const info = {\n ts: epoch_ts,\n author: options.author\n };\n\n for (let cue of cues) {\n\n /*******************************************************\n check validity of cue argument\n *******************************************************/\n\n if (cue == undefined || !cue.hasOwnProperty(\"key\") || cue.key == undefined) {\n\n if (cue == undefined) {\n throw new Error(\"cue is undefined\");\n } else if (!cue.hasOwnProperty(\"key\")) {\n throw new Error(\"cue missing key property\", cue);\n } else if (cue.key == undefined) {\n throw new Error(\"cue.key is undefined\", cue); \n }\n }\n\n has_interval = cue.hasOwnProperty(\"interval\");\n has_data = cue.hasOwnProperty(\"data\");\n if (has_interval) {\n cue.interval = asInterval(cue.interval);\n }\n\n\n /*******************************************************\n adjust cue so that it correctly represents\n the new cue to replace the current cue\n - includes preservation of values from current cue\n *******************************************************/\n\n current_cue = this._map.get(cue.key);\n if (current_cue == undefined) {\n // make sure properties are defined\n if (!has_interval) {\n cue.interval = undefined;\n }\n if (!has_data) {\n cue.data = undefined;\n }\n } else if (current_cue != undefined) {\n if (!has_interval && !has_data) {\n // make sure properties are defined\n cue.interval = undefined;\n cue.data = undefined;\n } else if (!has_data) {\n // REPLACE_INTERVAL, preserve data\n cue.data = current_cue.data;\n } else if (!has_interval) {\n // REPLACE_DATA, preserve interval\n cue.interval = current_cue.interval;\n } else {\n // REPLACE CUE\n }\n }\n\n /*******************************************************\n update cue\n - update _map\n - update cueBuckets\n - create batchMap\n *******************************************************/\n this._update_cue(batchMap, current_cue, cue, info, options);\n }\n\n // flush all buckets so updates take effect\n this._call_buckets(\"flush\");\n\n if (batchMap.size > 0) {\n\n /*\n create events without delta property\n and accumulate relevance interval for batch\n */\n let relevance = {low: Infinity, high: -Infinity};\n\n // create list of events and remove delta property\n let items = [...batchMap.values()].map(item => {\n if (item.new && item.new.interval) {\n relevance.low = endpoint.min(relevance.low, item.new.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.new.interval.endpointHigh);\n }\n if (item.old && item.old.interval) {\n relevance.low = endpoint.min(relevance.low, item.old.interval.endpointLow);\n relevance.high = endpoint.max(relevance.high, item.old.interval.endpointHigh);\n }\n return {key:item.key, new:item.new, old:item.old, info: item.info};\n });\n\n // extra filter items to remove NOOP transitions\n let event_items = items.filter((item) => {\n let delta = cue_delta(item.new, item.old, equals);\n return (delta.interval != Delta.NOOP || delta.data != Delta.NOOP);\n });\n\n // event notification\n this._notifyEvents(event_items);\n\n // create relevance Interval\n let relevanceInterval = undefined;\n if (relevance.low != Infinity) {\n relevanceInterval = Interval.fromEndpoints(relevance.low, relevance.high);\n }\n\n /*\n notify sequencer last so that change event\n from the dataset will be applied before change\n events from sequencers.\n */\n this._notify_callbacks(batchMap, relevanceInterval);\n \n // debug\n if (debug) {this.integrity();}\n return items;\n }\n // debug\n if (debug) {this.integrity();}\n return [];\n };\n\n\n\n /***************************************************************\n UPDATE CUE\n\n update operation for a single cue\n\n - update _map\n - generate entry for batchMap\n - update CueBucket\n ***************************************************************/\n\n _update_cue(batchMap, current_cue, cue, info, options) {\n\n let old_cue, new_cue;\n let item, _item;\n let oldCueBucket, newCueBucket;\n let low_changed, high_changed;\n let remove_needed, add_needed;\n\n // options\n let {chaining=true, safe=false, equals} = options;\n \n if (current_cue === cue) {\n throw Error(\"illegal cue arg: same object as current cue\");\n }\n\n // check for equality\n let delta = cue_delta(current_cue, cue, equals);\n\n // (NOOP, NOOP)\n if (delta.interval == Delta.NOOP && delta.data == Delta.NOOP) {\n item = {\n key:cue.key, new:current_cue,\n old:current_cue, delta: delta\n }\n batchMap.set(cue.key, item);\n return;\n }\n\n\n /***********************************************************\n update _map and batchMap\n ***********************************************************/\n\n if (current_cue == undefined) {\n // INSERT - add cue object to _map\n\n // cue info: add if missing\n if (cue.info == undefined) {\n cue.info = {\n ts: info.ts,\n change_ts: info.ts,\n change_id: 0\n }\n }\n\n old_cue = undefined;\n new_cue = (safe)? Object.freeze(cue) : cue;\n this._map.set(cue.key, new_cue);\n\n\n } else if (cue.interval == undefined && cue.data == undefined) {\n // DELETE - remove cue object from _map\n old_cue = current_cue;\n new_cue = undefined;\n this._map.delete(cue.key);\n\n // cue info: noop\n\n } else {\n // REPLACE\n\n // cue info - update if missing\n // preserve ts from current cue, update update_ts\n if (cue.info == undefined) {\n cue.info = {\n ts: current_cue.info.ts,\n change_ts: info.ts,\n change_id: current_cue.info.change_id + 1\n };\n }\n\n /*\n Solution used to be in-place modification\n of current cue.\n Now we instead implement replace by inserting\n a new cue object as current cue.\n Since current cue is referenced both in\n _map and in pointMap - it must be replaced both\n places.\n\n Adjustments to pointMap as a result of interval\n changes are handled further down\n\n Another design option would be to let point map\n manage only keys of cues. This however would \n impose an extra map lookup per item in lookup - \n so better to pay this modest price in update\n */\n old_cue = current_cue;\n new_cue = {\n key: cue.key,\n interval: cue.interval,\n data: cue.data,\n info: cue.info\n }\n\n if (safe) {\n new_cue = Object.freeze(new_cue);\n }\n\n // replace in cue map\n this._map.set(cue.key, new_cue);\n\n // replace in point map\n // - only necessary if old cue is in pointMap\n // i.e. if old_cue has interval\n if (old_cue.interval) {\n let bid = getCueBucketId(old_cue.interval.length);\n let cueBucket = this._cueBuckets.get(bid);\n // replace for low\n cueBucket.replace_endpoint(old_cue.interval.low, new_cue);\n // replace for high\n if (!old_cue.singular) {\n cueBucket.replace_endpoint(old_cue.interval.high, new_cue);\n }\n }\n }\n item = {key:cue.key, new:new_cue, old:old_cue, delta:delta, info};\n\n /*\n if this item has been set earlier in batchMap\n restore the correct old_cue by getting it from\n the previous batchMap item\n\n recalculate delta relative to old_cue\n - continue processing with the original (delta, old_cue) defined\n above, as this is required to correctly change cueBuckets\n which have already been affected by previous item.\n */\n if (chaining) {\n _item = batchMap.get(cue.key);\n if (_item != undefined) {\n item.old = _item.old;\n item.delta = cue_delta(new_cue, item.old, equals);\n }\n }\n\n batchMap.set(cue.key, item)\n\n //console.log(\"OLD:\", cue_to_string(old_cue));\n //console.log(\"NEW:\", cue_to_string(new_cue));\n\n /***********************************************************\n update cueBuckets\n\n - use delta.interval to avoid unnessesary changes\n\n - interval may change in several ways:\n - low changed\n - high changed\n - low and high changed\n - changed intervals may stay in bucket or change bucket:\n - changing to/from singular may require special consideration\n with respect to how many endpoints are being updated\n - singular -> singular\n - singular -> regular\n - regular -> singular\n - regular -> regular\n - changes to interval.lowInclude and interval highInclude\n do not require any changes to CueBuckets, as long\n as interval.low and interval.high values stay unchanged.\n ***********************************************************/\n\n if (delta.interval == Delta.NOOP) {\n // no changes to interval - no change needed in pointMap \n return;\n } else if (delta.interval == Delta.INSERT) {\n remove_needed = false;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.DELETE) {\n remove_needed = true;\n add_needed = false;\n low_changed = true;\n high_changed = true;\n } else if (delta.interval == Delta.REPLACE) {\n remove_needed = true;\n add_needed = true;\n low_changed = new_cue.interval.low != old_cue.interval.low;\n high_changed = new_cue.interval.high != old_cue.interval.high;\n }\n\n /*\n old cue and new cue might not belong to the same cue bucket\n */\n if (remove_needed){\n let old_bid = getCueBucketId(old_cue.interval.length);\n oldCueBucket = this._cueBuckets.get(old_bid);\n }\n if (add_needed) {\n let new_bid = getCueBucketId(new_cue.interval.length);\n newCueBucket = this._cueBuckets.get(new_bid);\n }\n\n /*\n if old CueBucket is different from the new cue Buckets\n both low and high must be moved, even it one was not\n changed\n */\n if (oldCueBucket && newCueBucket) {\n if (oldCueBucket != newCueBucket) {\n remove_needed = true;\n add_needed = true;\n low_changed = true;\n high_changed = true;\n }\n }\n\n /*\n dispatch add and remove operations for interval points\n\n cues in CueBucket may be removed using a copy of the cue,\n because remove is by key.\n\n cues added to CueBucket must be the correct object\n (current_cue), so that later in-place modifications become\n reflected in CueBucket.\n */\n\n // update low point - if changed\n if (low_changed) {\n if (remove_needed) {\n oldCueBucket.del_endpoint(old_cue.interval.low, old_cue);\n }\n if (add_needed) {\n newCueBucket.add_endpoint(new_cue.interval.low, new_cue);\n }\n }\n // update high point - if changed\n if (high_changed) {\n if (remove_needed && !old_cue.interval.singular) {\n oldCueBucket.del_endpoint(old_cue.interval.high, old_cue);\n }\n if (add_needed && !new_cue.interval.singular) {\n newCueBucket.add_endpoint(new_cue.interval.high, new_cue);\n }\n }\n }\n\n\n /*\n INTERNAL FUNCTION\n execute method across all cue buckets\n and aggregate results\n */\n _call_buckets(method, ...args) {\n const arrays = [];\n for (let cueBucket of this._cueBuckets.values()) {\n let cues = cueBucket[method](...args);\n if (cues != undefined && cues.length > 0) {\n arrays.push(cues);\n }\n }\n return utils.array_concat(arrays);\n };\n\n\n /*\n LOOKUP ENDPOINTS\n\n returns (endpoint, cue) for all endpoints covered by given interval\n\n returns:\n - [{endpoint: endpoint, cue:cue}]\n */\n\n lookup_endpoints(interval) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup_endpoints\", interval);\n };\n\n\n /*\n LOOKUP\n */\n\n lookup(interval, mask) {\n interval = asInterval(interval);\n return this._call_buckets(\"lookup\", interval, mask);\n };\n\n\n /*\n REMOVE CUES BY INTERVAL\n */\n lookup_delete(interval, mask, options={}) {\n interval = asInterval(interval);\n const cues = this._call_buckets(\"lookup_delete\", interval, mask);\n // remove from _map and make event items\n const items = [];\n const info = {\n ts: epoch(),\n author: options.author\n };\n let cue;\n for (let i=0; i cue.interval == undefined);\n\n let count_buckets = cues.length;\n let count_no_interval = no_interval_cues.length;\n let count_map = this._map.size;\n let diff = count_map - count_buckets - count_no_interval;\n if (diff != 0) {\n console.log(\"count buckets\", count_buckets);\n console.log(\"count no intervals\", count_no_interval);\n console.log(\"count map\", count_map);\n console.log(\"count diff\", diff);\n throw new Error(\"inconsistent cue count\");\n }\n\n // check that cue maps are non overlapping\n let bucket_map = new Map(cues.map(cue => [cue.key, cue]));\n let map_map = new Map([...this._map.entries()].filter(([key, cue]) => {\n return (cue.interval != undefined);\n }));\n\n let missing = utils.map_difference(bucket_map, map_map);\n if (missing.size > 0) {\n console.log(\"buckets missing cues:\")\n console.log([...missing.keys()])\n throw new Error(`buckets missing cues: ${[...missing.keys()]}`);\n }\n \n missing = utils.map_difference(map_map, bucket_map);\n if (missing.size > 0) {\n throw new Error(`buckets too many cues: ${[...missing.keys()]}`);\n }\n\n return {\n cues: cues.length,\n points: points.length\n };\n };\n\n}\n\n\nDataset.Delta = Delta;\nDataset.cue_delta = cue_delta;\nDataset.cue_equals = cue_equals;\n\n\n/*\n CueBucket is a bucket of cues limited to specific length\n*/\n\n\nclass CueBucket {\n\n\n constructor(maxLength) {\n\n // max length of cues in this bucket\n this._maxLength = maxLength;\n\n /*\n pointMap maintains the associations between values (points on\n the timeline) and cues that reference such points. A single point value may be\n referenced by multiple cues, so one point value maps to a list of cues.\n\n value -> [cue, ....]\n */\n this._pointMap = new Map();\n\n\n /*\n pointIndex maintains a sorted list of numbers for efficient lookup.\n A large volume of insert and remove operations may be problematic\n with respect to performance, so the implementation seeks to\n do a single bulk update on this structure, for each batch of cue\n operations (i.e. each invocations of addCues). In order to do this\n all cue operations are processed to calculate a single batch\n of deletes and a single batch of inserts which then will be applied to\n the pointIndex in one atomic operation.\n\n [1.2, 3, 4, 8.1, ....]\n */\n this._pointIndex = new BinarySearch();\n\n // bookeeping during batch processing\n this._created = new Set(); // point\n this._dirty = new Set(); // point\n\n };\n\n\n /*\n\n ENDPOINT BATCH PROCESSING\n\n Needs to translate endpoint operations into a minimum set of\n operations on the pointIndex.\n\n To do this, we need to record points that are created and\n points that are removed.\n\n The total difference that the batch of cue operations\n amounts to is expressed as one list of values to be\n deleted, and and one list of values to be inserted.\n The update operation of the pointIndex will process both\n in one atomic operation.\n\n On flush both the pointMap and the pointIndex will be brought\n up to speed\n\n created and dirty are used for bookeeping during\n processing of a cue batch. They are needed to\n create the correct diff operation to be applied on pointIndex.\n\n created : includes values that were not in pointMap\n before current batch was processed\n\n dirty : includes values that were in pointMap\n before current batch was processed, and that\n have been become empty at least at one point during cue\n processing.\n\n created and dirty are used as temporary alternatives to pointMap.\n after the cue processing, pointmap will updated based on the\n contents of these two.\n\n process buffers operations for pointMap and index so that\n all operations may be applied in one batch. This happens in flush\n */\n\n add_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues == undefined) {\n this._pointMap.set(point, [cue]);\n this._created.add(point);\n } else {\n cues.push(cue);\n //addCueToArray(cues, cue);\n }\n }\n\n del_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let empty = removeCueFromArray(cues, cue);\n if (empty) {\n this._dirty.add(point);\n }\n }\n };\n\n /* \n in case of data update without touching the interval\n the new cue needs to be insert in place of the old\n */\n replace_endpoint(point, cue) {\n let init = (this._pointMap.size == 0);\n let cues = (init) ? undefined : this._pointMap.get(point);\n if (cues != undefined) {\n let ok = replaceCueInArray (cues, cue);\n if (!ok) {\n console.log(\"WARNING: attempt to replace non-existent cue in pointMap\")\n }\n }\n }\n\n\n /*\n Batch processing is completed\n Commit changes to pointIndex and pointMap.\n\n pointMap\n - update with contents of created\n\n pointIndex\n - points to delete - dirty and empty\n - points to insert - created and non-empty\n\n it is possible that a cue ends up in both created and dirty\n\n */\n flush() {\n if (this._created.size == 0 && this._dirty.size == 0) {\n return;\n }\n\n // update pointIndex\n let to_remove = [];\n let to_insert = [];\n for (let point of this._created.values()) {\n let cues = this._pointMap.get(point);\n if (cues.length > 0) {\n to_insert.push(point);\n } else {\n this._pointMap.delete(point);\n }\n }\n for (let point of this._dirty.values()) {\n let cues = this._pointMap.get(point);\n if (cues == undefined) {\n // point already deleted from created set - ignore\n continue;\n }\n if (cues.length == 0) {\n to_remove.push(point);\n this._pointMap.delete(point);\n }\n }\n this._pointIndex.update(to_remove, to_insert);\n // cleanup\n this._created.clear();\n this._dirty.clear();\n };\n\n\n /*\n LOOKUP_ENDPOINTS\n\n returns all (endpoint, cue) pairs where\n - endpoint is a cue endpoint (cue.endpointLow or cue.endpointHigh)\n - endpoint is INSIDE search interval\n - [{endpoint:endpoint, cue: cue}]\n\n - a given endpoint may appear multiple times in the result,\n as multiple cues may be tied to the same endpoint\n - a given cue may appear two times in the result, if\n both cue.endpointLow and cue.endpointHigh are both INSIDE interval\n - a singular cue will appear only once\n - ordering: no specific order is guaranteed\n - results are concatenated from multiple CueBuckets\n - internally in a single CueBucket\n - no defined order for cues tied to the same endpoint\n - the natural order is endpoint order\n - but this can be added on the outside if needed\n - no order is defined if two cues have exactly the\n same endpoint\n\n */\n\n lookup_endpoints(interval) {\n if (this._pointMap.size == 0) {\n return [];\n }\n const broader_interval = new Interval(interval.low, interval.high, true, true);\n const points = this._pointIndex.lookup(broader_interval);\n const result = [];\n const len = points.length;\n let point, _endpoint;\n for (let i=0; i this._maxLength) {\n return cues;\n }\n\n /*\n handle match with COVERS separately\n\n search left of search interval for cues\n that covers the search interval\n search left is limited by CueBucket maxlength\n left_interval: [interval.high-maxLength, interval.low]\n\n it would be possible to search right too, but we\n have to choose one.\n */\n if (mask & Relation.COVERS) {\n\n\n let low = interval.high - this._maxLength;\n let high = interval.low;\n // protect against float rounding effects creating\n // high < low by a very small margin\n [low, high] = [Math.min(low, high), Math.max(low, high)];\n let left_interval = new Interval(low, high, true, true);\n this._lookup_cues(left_interval)\n .forEach(function(cue){\n if (cue.interval.match(interval, Relation.COVERS)) {\n cues.push(cue);\n }\n });\n }\n\n return cues;\n }\n\n\n /*\n REMOVE CUES\n */\n lookup_delete(interval, mask) {\n /*\n update pointMap\n - remove all cues from pointMap\n - remove empty entries in pointMap\n - record points that became empty, as these need to be deleted in pointIndex\n - separate into two bucketes, inside and outside\n */\n const cues = this.lookup(interval, mask);\n const to_remove = [];\n let cue, point, points;\n for (let i=0; i 0) {\n throw new Error(`pointMap missing points: ${[...missing]}`);\n }\n \n missing = utils.set_difference(map_point_set, index_point_set);\n if (missing.size > 0) {\n throw new Error(`pointIndex missing points: ${[...missing]}`);\n }\n }\n\n /*\n invariable - pointIndex shall always be sorted and not contain duplicates\n */\n let points = [...this._pointIndex.values()];\n if (points.length != index_point_set.size) {\n throw new Error(\"pointIndex include duplicate points\");\n }\n for (let i=1; i= points[i]) {\n throw new Error(\"pointIndex not ordered\");\n } \n }\n\n /**\n * invariable - pointMap point -> cues \n * cues shall only include cues which are relevant to given point\n */\n for (let point of points) {\n let cues = this._pointMap.get(point);\n for (let cue of cues) {\n // figure out if point is endpoint low or high\n if (point == cue.interval.low) {\n continue;\n } else if (point == cue.interval.high) {\n continue;\n } else {\n console.log(\"POINT:\", point); \n console.log(\"CUE:\", cue.interval.toString());\n throw new Error(\"pointMap: wrong cue\");\n }\n } \n }\n\n\n /**\n * invariable - all endpoints from all cues from pointMap are found as points in pointMap\n */\n\n for (let _cue_list of [...this._pointMap.values()]) {\n for (let cue of _cue_list) {\n for (let p of [cue.interval.low, cue.interval.high]) {\n if (!this._pointMap.has(p)) {\n throw new Error(`cue found with low or high point not in pointMap ${p} -> ${cue.interval.toString()} `);\n }\n }\n }\n }\n\n\n /*\n invariable - all cues in pointMap with same key are same object\n */\n\n // collect all cues from pointMap\n let _cues = [];\n for (let _cue_list of this._pointMap.values()) {\n for (let cue of _cue_list) {\n _cues.push(cue);\n }\n }\n\n // remove and check duplicates\n let cueMap = new Map();\n for (let cue of _cues) {\n let _cue = cueMap.get(cue.key);\n if (_cue == undefined) {\n cueMap.set(cue.key, cue);\n } else {\n // duplicate\n if (cue !== _cue) {\n throw new Error(\"pointMap: different cue objects for same key\");\n }\n }\n }\n let cues = [...cueMap.values()];\n\n /**\n * invariable - all cues belong to this bucket\n */\n\n for (let cue of cues.values()) {\n // check that cue belongs to this bucket\n if (cue.interval.length > this._maxLength) {\n throw new Error(`cue in wrong cue bucket ${this._maxLength}, ${cue.interval.toString()}`);\n }\n }\n\n return [{\n maxLength: this._maxLength,\n points: [...this._pointMap.keys()],\n cues: cues\n }];\n };\n}\n\n// module definition\nexport default Dataset;\n","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see \n - : if defined only include cues that match the interval\n - : filter by cue key\n function keep(key) returns boolena\n - : filter by cue data\n function keep(data) returns boolean\n - : change cue data\n function convert(data) returns data\n NOTE: filtering occurs BEFORE convert\n and only impacts the presentation of cues\n WARNING: it is possible to change the value\n in such a way that filtering appears incorrect\n\n This subset implementation is STATELESS\n It does not manage its own state, only implements a\n stateless frontend over its source dataset.\n\n*/\n\nclass Subset extends CueCollection {\n\n constructor(dataset, options={}) {\n super(options);\n this._key_filter = options.key_filter;\n this._data_filter = options.data_filter;\n this._interval = options.interval;\n this._data_convert = options.data_convert;\n this._size = 0;\n\n // Callbacks\n this._callbacks = [];\n\n // Source Dataset\n this._src_ds = dataset;\n let cb = this._onDatasetCallback.bind(this)\n this._src_ds_cb = this._src_ds.add_callback(cb);\n }\n\n\n /***************************************************************\n ACCESSORS\n ***************************************************************/\n\n get datasource () {\n return this._src_ds;\n }\n\n get dataset () {\n return this._src_ds;\n }\n\n\n get interval () {\n return this._interval;\n }\n\n set interval (itv) {\n this._setInterval(itv);\n }\n\n\n /***************************************************************\n EVENT CALLBACKS - FOR SEQUENCERS\n ***************************************************************/\n\n add_callback (handler) {\n let handle = {\n handler: handler\n }\n this._callbacks.push(handle);\n return handle;\n };\n\n\n del_callback (handle) {\n let index = this._callbacks.indexof(handle);\n if (index > -1) {\n this._callbacks.splice(index, 1);\n }\n };\n\n\n _notify_callbacks (batchMap, relevanceInterval) {\n this._callbacks.forEach(function(handle) {\n handle.handler(batchMap, relevanceInterval);\n });\n };\n\n\n /***************************************************************\n FILTER & CONVER\n ***************************************************************/\n\n /* \n Keep cue \n */\n\n _cue_keep(cue) {\n if (cue == undefined) {\n return false;\n }\n // check if cue matches interval\n if (this._interval) {\n if (!this._interval.match(cue.interval)) {\n return false;\n }\n }\n // check key filter\n if (this._key_filter) {\n if (!this._key_filter(cue.key)) {\n return false;\n }\n }\n // check data filter\n if (this._data_filter) {\n if (!this._data_filter(cue.data)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Convert cue\n */\n _cue_convert(cue) {\n if (cue != undefined && this._data_convert) {\n // copy\n return {\n key: cue.key,\n interval: cue.interval,\n data: this._data_convert(cue.data)\n }\n }\n return cue;\n }\n\n /**\n * Filter (and modify) event items based on key_filter and data_filter\n */\n\n _items_filter_convert(items) {\n let _items = [];\n for (let item of items) {\n if (item.new == undefined && item.old == undefined) {\n continue;\n }\n /* \n use cue filter function to check relevance of both old and new\n consider change of unrelevant cue into relevant cue.\n old cue would be non-relevant, new cue would be relevant\n Since old cue was not part of the subset before, it needs\n to be removed from the item - effectively turning the change\n operation into an add operation. \n */\n let _old = (this._cue_keep(item.old)) ? item.old : undefined;\n let _new = (this._cue_keep(item.new)) ? item.new : undefined;\n if (_old == undefined && _new == undefined) {\n continue;\n }\n // convert\n _old = this._cue_convert(_old);\n _new = this._cue_convert(_new);\n // push\n _items.push({key:item.key, new: _new, old: _old});\n }\n return _items;\n }\n\n\n /***************************************************************\n LOOKUP\n ***************************************************************/\n\n _check_interval(interval) {\n if (this._interval) {\n // subset interval\n if (interval) {\n // lookup interval - find intersection\n let intersects = Interval.intersect(interval, this._interval);\n if (intersects.length == 0) {\n console.log(`warning - lookup interval ${interval.toString()} outside the subset interval ${this._interval.toString()}`);\n return [];\n } else {\n interval = intersects[0];\n }\n } else {\n // no lookup interval - use subset interval \n interval = this._interval;\n }\n }\n return interval;\n }\n\n /** \n * lookup cues\n */\n\n lookup(interval, mask) {\n let _interval = this._check_interval(interval);\n let cues;\n if (_interval) {\n cues = this.datasource.lookup(_interval, mask);\n } else {\n cues = [...this.datasource.values()];\n }\n // filter & convert cues\n return cues.filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n }\n\n /* \n lookup endpoints\n used by sequencers\n */\n\n lookup_endpoints(interval) {\n let _interval = this._check_interval(interval);\n let items = this.datasource.lookup_endpoints(_interval);\n // filter and convert\n return items.filter((item) => {\n return this._cue_keep(item.cue);\n }, this).map((item) => {\n return {endpoint: item.endpoint, cue: this._cue_convert(item.cue)};\n }, this);\n }\n\n /***************************************************************\n INITIAL STATE\n ***************************************************************/\n\n eventifyInitEventArgs(name) {\n if (name == \"batch\" || name == \"change\") {\n // find cues\n let cues = this.lookup();\n // make event items\n let items = cues.map((cue) => {\n return {key:cue.key, new:cue, old:undefined};\n });\n // sort\n this.sortItems(items);\n return (name == \"batch\") ? [items] : items;\n }\n }\n\n /***************************************************************\n DATASET CALLBACK\n ***************************************************************/\n\n _onDatasetCallback(eventMap, relevanceInterval) {\n let items = [...eventMap.values()];\n items = this._items_filter_convert(items);\n // update size\n for (let item of items) {\n if (item.new != undefined && item.old == undefined) {\n // add\n this._size += 1;\n } else if (item.new == undefined && item.old != undefined) {\n // remove\n this._size -= 1;\n } \n } \n // forward as events\n super._notifyEvents(items);\n // forward as callbacks\n let batchMap = new Map(items.map((item) => {\n return [item.key, item];\n }));\n if (this._interval) {\n relevanceInterval = Interval.intersect(this._inverval, relevanceInterval);\n }\n this._notify_callbacks(batchMap, relevanceInterval);\n }\n\n\n /***************************************************************\n SET INTERVAL\n ***************************************************************/\n\n _setInterval (itv) {\n if (!itv instanceof Interval) {\n throw new Error(\"must be interval\", itv.toString());\n }\n if (!this._interval || !this._interval.equals(itv)) {\n // current cues (before interval update)\n let current_cues = this.lookup();\n // update interval\n this._interval = itv;\n // cues (after interval update)\n let new_cues = this.datasource.lookup(itv);\n // filter & convert cues\n new_cues = new_cues\n .filter(this._cue_keep, this)\n .map(this._cue_convert, this);\n // switch to map representation\n let currentCueMap = new Map([...current_cues].map((cue) => {\n return [cue.key, cue];\n }));\n let newCueMap = new Map([...new_cues].map((cue) => {\n return [cue.key, cue];\n }));\n // exit and enter cues\n let exitCueMap = map_difference(currentCueMap, newCueMap);\n let enterCueMap = map_difference(newCueMap, currentCueMap);\n // make list of event items\n let exitItems = [...exitCueMap.values()].map((cue) => {\n return {key: cue.key, new:undefined, old: cue}\n });\n let enterItems = [...enterCueMap.values()].map((cue) => {\n return {key: cue.key, new:cue, old: undefined}\n });\n // update size\n this._size -= exitItems.length;\n this._size += enterItems.length; \n // event notification\n const items = array_concat([exitItems, enterItems], {copy:false, order:true});\n this._notifyEvents(items);\n }\n }\n\n /***************************************************************\n MAP ACCESSORS\n ***************************************************************/\n\n get size () {\n return this._size;\n }\n\n has(key) {\n return (this.get(key) != undefined);\n };\n\n get(key) {\n let cue = super.get(key);\n if (cue != undefined && this._cue_keep(cue)) {\n return this._cue_convert(cue);\n }\n };\n\n keys() {\n return this.values().map((cue => {\n return cue.key;\n }));\n };\n\n values() {\n return [...super.values()]\n .filter((cue) => {\n return this._cue_keep(cue);\n }, this)\n .map((cue) => {\n return this._cue_convert(cue);\n }, this);\n };\n\n entries() {\n return this.values().map((cue) => {\n return [cue.key, cue];\n });\n };\n\n\n /***************************************************************\n MAP MODIFICATION METHODS\n ***************************************************************/\n\n update(cues, options) {\n throw new Error(\"not implemented\");\n }\n\n set (key, value) {\n throw new Error(\"not implemented\");\n }\n\n delete (key) {\n throw new Error(\"not implemented\");\n }\n\n clear (key) {\n throw new Error(\"not implemented\");\n }\n\n}\n\n// module definition\nexport default Subset;","/*\n Copyright 2020\n Author : Ingar Arntzen\n\n This file is part of the Timingsrc module.\n\n Timingsrc is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n Timingsrc is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with Timingsrc. If not, see 0 => p_turning minimum
- // a0 < 0 => p_turning maximum
- if (a0 > 0.0) {
- return [p_turning, Math.max(p0, p1)];
- }
- else {
- return [Math.min(p0,p1), p_turning];
- }
- }
- }
- // no turning point or turning point was not reached
- return [Math.min(p0,p1), Math.max(p0,p1)];
- };
-
-
- // return module object
- return {
- calculateVector : calculateVector,
- calculateDirection : calculateDirection,
- calculateMinPositiveRealSolution : calculateMinPositiveRealSolution,
- calculateDelta : calculateDelta,
- calculateInterval : calculateInterval,
- calculateSolutionsInInterval : calculateSolutionsInInterval,
- getCorrectRangeState : getCorrectRangeState,
- checkRange : checkRange,
- RangeState : RangeState
- };
-});
-
-
-/*
- Copyright 2015 Norut Northern Research Institute
- Author : Ingar Mæhlum Arntzen
-
- This file is part of the Timingsrc module.
-
- Timingsrc is free software: you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Timingsrc is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with Timingsrc. If not, see and timestamps defines the time
- interval covered by the schedule - the . The
- idea is to move this interval stepwise, to eventually cover the
- entire time-line. The length of this interval is defined by the
- option . The default value is 5 seconds.
-
- The operation moves the interval so that the next
- interval matches the previous interval