camunda-bpmn-js 5.17.0 → 5.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -171,7 +171,7 @@
171
171
  * @return {T[]}
172
172
  */
173
173
 
174
- const nativeToString$d = Object.prototype.toString;
174
+ const nativeToString$c = Object.prototype.toString;
175
175
  const nativeHasOwnProperty$b = Object.prototype.hasOwnProperty;
176
176
 
177
177
  function isUndefined$b(obj) {
@@ -187,15 +187,15 @@
187
187
  }
188
188
 
189
189
  function isArray$c(obj) {
190
- return nativeToString$d.call(obj) === '[object Array]';
190
+ return nativeToString$c.call(obj) === '[object Array]';
191
191
  }
192
192
 
193
193
  function isObject$4(obj) {
194
- return nativeToString$d.call(obj) === '[object Object]';
194
+ return nativeToString$c.call(obj) === '[object Object]';
195
195
  }
196
196
 
197
197
  function isNumber$4(obj) {
198
- return nativeToString$d.call(obj) === '[object Number]';
198
+ return nativeToString$c.call(obj) === '[object Number]';
199
199
  }
200
200
 
201
201
  /**
@@ -204,7 +204,7 @@
204
204
  * @return {boolean}
205
205
  */
206
206
  function isFunction$5(obj) {
207
- const tag = nativeToString$d.call(obj);
207
+ const tag = nativeToString$c.call(obj);
208
208
 
209
209
  return (
210
210
  tag === '[object Function]' ||
@@ -216,7 +216,7 @@
216
216
  }
217
217
 
218
218
  function isString$6(obj) {
219
- return nativeToString$d.call(obj) === '[object String]';
219
+ return nativeToString$c.call(obj) === '[object String]';
220
220
  }
221
221
 
222
222
  /**
@@ -698,7 +698,7 @@
698
698
  * @return {T[]}
699
699
  */
700
700
 
701
- const nativeToString$c = Object.prototype.toString;
701
+ const nativeToString$b = Object.prototype.toString;
702
702
  const nativeHasOwnProperty$a = Object.prototype.hasOwnProperty;
703
703
 
704
704
  function isUndefined$a(obj) {
@@ -706,7 +706,7 @@
706
706
  }
707
707
 
708
708
  function isArray$b(obj) {
709
- return nativeToString$c.call(obj) === '[object Array]';
709
+ return nativeToString$b.call(obj) === '[object Array]';
710
710
  }
711
711
 
712
712
  /**
@@ -2417,7 +2417,7 @@
2417
2417
  return Array.prototype.concat.apply([], arr);
2418
2418
  }
2419
2419
 
2420
- const nativeToString$b = Object.prototype.toString;
2420
+ const nativeToString$a = Object.prototype.toString;
2421
2421
  const nativeHasOwnProperty$9 = Object.prototype.hasOwnProperty;
2422
2422
 
2423
2423
  function isUndefined$9(obj) {
@@ -2433,15 +2433,15 @@
2433
2433
  }
2434
2434
 
2435
2435
  function isArray$9(obj) {
2436
- return nativeToString$b.call(obj) === '[object Array]';
2436
+ return nativeToString$a.call(obj) === '[object Array]';
2437
2437
  }
2438
2438
 
2439
2439
  function isObject$3(obj) {
2440
- return nativeToString$b.call(obj) === '[object Object]';
2440
+ return nativeToString$a.call(obj) === '[object Object]';
2441
2441
  }
2442
2442
 
2443
2443
  function isNumber$3(obj) {
2444
- return nativeToString$b.call(obj) === '[object Number]';
2444
+ return nativeToString$a.call(obj) === '[object Number]';
2445
2445
  }
2446
2446
 
2447
2447
  /**
@@ -2450,7 +2450,7 @@
2450
2450
  * @return {boolean}
2451
2451
  */
2452
2452
  function isFunction$4(obj) {
2453
- const tag = nativeToString$b.call(obj);
2453
+ const tag = nativeToString$a.call(obj);
2454
2454
 
2455
2455
  return (
2456
2456
  tag === '[object Function]' ||
@@ -2462,7 +2462,7 @@
2462
2462
  }
2463
2463
 
2464
2464
  function isString$5(obj) {
2465
- return nativeToString$b.call(obj) === '[object String]';
2465
+ return nativeToString$a.call(obj) === '[object String]';
2466
2466
  }
2467
2467
 
2468
2468
 
@@ -3835,7 +3835,7 @@
3835
3835
  * @return {T[]}
3836
3836
  */
3837
3837
 
3838
- const nativeToString$a = Object.prototype.toString;
3838
+ const nativeToString$9 = Object.prototype.toString;
3839
3839
  const nativeHasOwnProperty$8 = Object.prototype.hasOwnProperty;
3840
3840
 
3841
3841
  function isUndefined$8(obj) {
@@ -3843,7 +3843,7 @@
3843
3843
  }
3844
3844
 
3845
3845
  function isArray$8(obj) {
3846
- return nativeToString$a.call(obj) === '[object Array]';
3846
+ return nativeToString$9.call(obj) === '[object Array]';
3847
3847
  }
3848
3848
 
3849
3849
  /**
@@ -9603,10 +9603,10 @@
9603
9603
  * @return {T[]}
9604
9604
  */
9605
9605
 
9606
- const nativeToString$9 = Object.prototype.toString;
9606
+ const nativeToString$8 = Object.prototype.toString;
9607
9607
 
9608
9608
  function isString$4(obj) {
9609
- return nativeToString$9.call(obj) === '[object String]';
9609
+ return nativeToString$8.call(obj) === '[object String]';
9610
9610
  }
9611
9611
 
9612
9612
  /**
@@ -9631,7 +9631,7 @@
9631
9631
  * @return {T[]}
9632
9632
  */
9633
9633
 
9634
- const nativeToString$8 = Object.prototype.toString;
9634
+ const nativeToString$7 = Object.prototype.toString;
9635
9635
  const nativeHasOwnProperty$7 = Object.prototype.hasOwnProperty;
9636
9636
 
9637
9637
  function isUndefined$7(obj) {
@@ -9647,15 +9647,15 @@
9647
9647
  }
9648
9648
 
9649
9649
  function isArray$6(obj) {
9650
- return nativeToString$8.call(obj) === '[object Array]';
9650
+ return nativeToString$7.call(obj) === '[object Array]';
9651
9651
  }
9652
9652
 
9653
9653
  function isObject$2(obj) {
9654
- return nativeToString$8.call(obj) === '[object Object]';
9654
+ return nativeToString$7.call(obj) === '[object Object]';
9655
9655
  }
9656
9656
 
9657
9657
  function isString$3(obj) {
9658
- return nativeToString$8.call(obj) === '[object String]';
9658
+ return nativeToString$7.call(obj) === '[object String]';
9659
9659
  }
9660
9660
 
9661
9661
  /**
@@ -10824,7 +10824,7 @@
10824
10824
  * @return {T[]}
10825
10825
  */
10826
10826
 
10827
- const nativeToString$7 = Object.prototype.toString;
10827
+ const nativeToString$6 = Object.prototype.toString;
10828
10828
  const nativeHasOwnProperty$6 = Object.prototype.hasOwnProperty;
10829
10829
 
10830
10830
  function isUndefined$5(obj) {
@@ -10836,7 +10836,7 @@
10836
10836
  }
10837
10837
 
10838
10838
  function isArray$5(obj) {
10839
- return nativeToString$7.call(obj) === '[object Array]';
10839
+ return nativeToString$6.call(obj) === '[object Array]';
10840
10840
  }
10841
10841
 
10842
10842
  /**
@@ -10845,7 +10845,7 @@
10845
10845
  * @return {boolean}
10846
10846
  */
10847
10847
  function isFunction$3(obj) {
10848
- const tag = nativeToString$7.call(obj);
10848
+ const tag = nativeToString$6.call(obj);
10849
10849
 
10850
10850
  return (
10851
10851
  tag === '[object Function]' ||
@@ -10857,7 +10857,7 @@
10857
10857
  }
10858
10858
 
10859
10859
  function isString$2(obj) {
10860
- return nativeToString$7.call(obj) === '[object String]';
10860
+ return nativeToString$6.call(obj) === '[object String]';
10861
10861
  }
10862
10862
 
10863
10863
  /**
@@ -56375,7 +56375,7 @@
56375
56375
  * @return {T[]}
56376
56376
  */
56377
56377
 
56378
- const nativeToString$6 = Object.prototype.toString;
56378
+ const nativeToString$5 = Object.prototype.toString;
56379
56379
  const nativeHasOwnProperty$5 = Object.prototype.hasOwnProperty;
56380
56380
 
56381
56381
  function isUndefined$4(obj) {
@@ -56387,7 +56387,7 @@
56387
56387
  }
56388
56388
 
56389
56389
  function isArray$4(obj) {
56390
- return nativeToString$6.call(obj) === '[object Array]';
56390
+ return nativeToString$5.call(obj) === '[object Array]';
56391
56391
  }
56392
56392
 
56393
56393
  /**
@@ -56396,7 +56396,7 @@
56396
56396
  * @return {boolean}
56397
56397
  */
56398
56398
  function isFunction$2(obj) {
56399
- const tag = nativeToString$6.call(obj);
56399
+ const tag = nativeToString$5.call(obj);
56400
56400
 
56401
56401
  return (
56402
56402
  tag === '[object Function]' ||
@@ -68903,7 +68903,7 @@
68903
68903
  * @return {T[]}
68904
68904
  */
68905
68905
 
68906
- const nativeToString$5 = Object.prototype.toString;
68906
+ const nativeToString$4 = Object.prototype.toString;
68907
68907
  const nativeHasOwnProperty$4 = Object.prototype.hasOwnProperty;
68908
68908
 
68909
68909
  function isUndefined$3(obj) {
@@ -68915,15 +68915,15 @@
68915
68915
  }
68916
68916
 
68917
68917
  function isArray$3(obj) {
68918
- return nativeToString$5.call(obj) === '[object Array]';
68918
+ return nativeToString$4.call(obj) === '[object Array]';
68919
68919
  }
68920
68920
 
68921
68921
  function isObject$1(obj) {
68922
- return nativeToString$5.call(obj) === '[object Object]';
68922
+ return nativeToString$4.call(obj) === '[object Object]';
68923
68923
  }
68924
68924
 
68925
68925
  function isNumber$2(obj) {
68926
- return nativeToString$5.call(obj) === '[object Number]';
68926
+ return nativeToString$4.call(obj) === '[object Number]';
68927
68927
  }
68928
68928
 
68929
68929
  /**
@@ -70723,10 +70723,331 @@
70723
70723
  * @return {T[]}
70724
70724
  */
70725
70725
 
70726
- const nativeToString$4 = Object.prototype.toString;
70726
+ const nativeToString$3 = Object.prototype.toString;
70727
+ const nativeHasOwnProperty$3 = Object.prototype.hasOwnProperty;
70728
+
70729
+ function isUndefined$2(obj) {
70730
+ return obj === undefined;
70731
+ }
70732
+
70733
+ function isNil$3(obj) {
70734
+ return obj == null;
70735
+ }
70736
+
70737
+ function isArray$2(obj) {
70738
+ return nativeToString$3.call(obj) === '[object Array]';
70739
+ }
70727
70740
 
70728
70741
  function isNumber$1(obj) {
70729
- return nativeToString$4.call(obj) === '[object Number]';
70742
+ return nativeToString$3.call(obj) === '[object Number]';
70743
+ }
70744
+
70745
+ /**
70746
+ * @param {any} obj
70747
+ *
70748
+ * @return {boolean}
70749
+ */
70750
+ function isFunction$1(obj) {
70751
+ const tag = nativeToString$3.call(obj);
70752
+
70753
+ return (
70754
+ tag === '[object Function]' ||
70755
+ tag === '[object AsyncFunction]' ||
70756
+ tag === '[object GeneratorFunction]' ||
70757
+ tag === '[object AsyncGeneratorFunction]' ||
70758
+ tag === '[object Proxy]'
70759
+ );
70760
+ }
70761
+
70762
+
70763
+ /**
70764
+ * Ensure collection is an array.
70765
+ *
70766
+ * @param {Object} obj
70767
+ */
70768
+ function ensureArray(obj) {
70769
+
70770
+ if (isArray$2(obj)) {
70771
+ return;
70772
+ }
70773
+
70774
+ throw new Error('must supply array');
70775
+ }
70776
+
70777
+ /**
70778
+ * Return true, if target owns a property with the given key.
70779
+ *
70780
+ * @param {Object} target
70781
+ * @param {String} key
70782
+ *
70783
+ * @return {Boolean}
70784
+ */
70785
+ function has$3(target, key) {
70786
+ return !isNil$3(target) && nativeHasOwnProperty$3.call(target, key);
70787
+ }
70788
+
70789
+ /**
70790
+ * @template T
70791
+ * @typedef { (
70792
+ * ((e: T) => boolean) |
70793
+ * ((e: T, idx: number) => boolean) |
70794
+ * ((e: T, key: string) => boolean) |
70795
+ * string |
70796
+ * number
70797
+ * ) } Matcher
70798
+ */
70799
+
70800
+ /**
70801
+ * @template T
70802
+ * @template U
70803
+ *
70804
+ * @typedef { (
70805
+ * ((e: T) => U) | string | number
70806
+ * ) } Extractor
70807
+ */
70808
+
70809
+
70810
+ /**
70811
+ * @template T
70812
+ * @typedef { (val: T, key: any) => boolean } MatchFn
70813
+ */
70814
+
70815
+ /**
70816
+ * @template T
70817
+ * @typedef { T[] } ArrayCollection
70818
+ */
70819
+
70820
+ /**
70821
+ * @template T
70822
+ * @typedef { { [key: string]: T } } StringKeyValueCollection
70823
+ */
70824
+
70825
+ /**
70826
+ * @template T
70827
+ * @typedef { { [key: number]: T } } NumberKeyValueCollection
70828
+ */
70829
+
70830
+ /**
70831
+ * @template T
70832
+ * @typedef { StringKeyValueCollection<T> | NumberKeyValueCollection<T> } KeyValueCollection
70833
+ */
70834
+
70835
+ /**
70836
+ * @template T
70837
+ * @typedef { KeyValueCollection<T> | ArrayCollection<T> } Collection
70838
+ */
70839
+
70840
+ /**
70841
+ * Find element in collection.
70842
+ *
70843
+ * @template T
70844
+ * @param {Collection<T>} collection
70845
+ * @param {Matcher<T>} matcher
70846
+ *
70847
+ * @return {Object}
70848
+ */
70849
+ function find$1(collection, matcher) {
70850
+
70851
+ const matchFn = toMatcher(matcher);
70852
+
70853
+ let match;
70854
+
70855
+ forEach$2(collection, function(val, key) {
70856
+ if (matchFn(val, key)) {
70857
+ match = val;
70858
+
70859
+ return false;
70860
+ }
70861
+ });
70862
+
70863
+ return match;
70864
+
70865
+ }
70866
+
70867
+
70868
+ /**
70869
+ * Iterate over collection; returning something
70870
+ * (non-undefined) will stop iteration.
70871
+ *
70872
+ * @template T
70873
+ * @param {Collection<T>} collection
70874
+ * @param { ((item: T, idx: number) => (boolean|void)) | ((item: T, key: string) => (boolean|void)) } iterator
70875
+ *
70876
+ * @return {T} return result that stopped the iteration
70877
+ */
70878
+ function forEach$2(collection, iterator) {
70879
+
70880
+ let val,
70881
+ result;
70882
+
70883
+ if (isUndefined$2(collection)) {
70884
+ return;
70885
+ }
70886
+
70887
+ const convertKey = isArray$2(collection) ? toNum$2 : identity$2;
70888
+
70889
+ for (let key in collection) {
70890
+
70891
+ if (has$3(collection, key)) {
70892
+ val = collection[key];
70893
+
70894
+ result = iterator(val, convertKey(key));
70895
+
70896
+ if (result === false) {
70897
+ return val;
70898
+ }
70899
+ }
70900
+ }
70901
+ }
70902
+
70903
+ /**
70904
+ * Return collection without element.
70905
+ *
70906
+ * @template T
70907
+ * @param {ArrayCollection<T>} arr
70908
+ * @param {Matcher<T>} matcher
70909
+ *
70910
+ * @return {T[]}
70911
+ */
70912
+ function without(arr, matcher) {
70913
+
70914
+ if (isUndefined$2(arr)) {
70915
+ return [];
70916
+ }
70917
+
70918
+ ensureArray(arr);
70919
+
70920
+ const matchFn = toMatcher(matcher);
70921
+
70922
+ return arr.filter(function(el, idx) {
70923
+ return !matchFn(el, idx);
70924
+ });
70925
+
70926
+ }
70927
+
70928
+
70929
+ /**
70930
+ * Reduce collection, returning a single result.
70931
+ *
70932
+ * @template T
70933
+ * @template V
70934
+ *
70935
+ * @param {Collection<T>} collection
70936
+ * @param {(result: V, entry: T, index: any) => V} iterator
70937
+ * @param {V} result
70938
+ *
70939
+ * @return {V} result returned from last iterator
70940
+ */
70941
+ function reduce$1(collection, iterator, result) {
70942
+
70943
+ forEach$2(collection, function(value, idx) {
70944
+ result = iterator(result, value, idx);
70945
+ });
70946
+
70947
+ return result;
70948
+ }
70949
+
70950
+
70951
+ /**
70952
+ * Transform a collection into another collection
70953
+ * by piping each member through the given fn.
70954
+ *
70955
+ * @param {Object|Array} collection
70956
+ * @param {Function} fn
70957
+ *
70958
+ * @return {Array} transformed collection
70959
+ */
70960
+ function map$2(collection, fn) {
70961
+
70962
+ let result = [];
70963
+
70964
+ forEach$2(collection, function(val, key) {
70965
+ result.push(fn(val, key));
70966
+ });
70967
+
70968
+ return result;
70969
+ }
70970
+
70971
+
70972
+
70973
+ /**
70974
+ * Sort collection by criteria.
70975
+ *
70976
+ * @template T
70977
+ *
70978
+ * @param {Collection<T>} collection
70979
+ * @param {Extractor<T, number | string>} extractor
70980
+ *
70981
+ * @return {Array}
70982
+ */
70983
+ function sortBy(collection, extractor) {
70984
+
70985
+ extractor = toExtractor(extractor);
70986
+
70987
+ let sorted = [];
70988
+
70989
+ forEach$2(collection, function(value, key) {
70990
+ let disc = extractor(value, key);
70991
+
70992
+ let entry = {
70993
+ d: disc,
70994
+ v: value
70995
+ };
70996
+
70997
+ for (var idx = 0; idx < sorted.length; idx++) {
70998
+ let { d } = sorted[idx];
70999
+
71000
+ if (disc < d) {
71001
+ sorted.splice(idx, 0, entry);
71002
+ return;
71003
+ }
71004
+ }
71005
+
71006
+ // not inserted, append (!)
71007
+ sorted.push(entry);
71008
+ });
71009
+
71010
+ return map$2(sorted, (e) => e.v);
71011
+ }
71012
+
71013
+
71014
+ /**
71015
+ * @param {string | ((e: any) => any) } extractor
71016
+ *
71017
+ * @return { (e: any) => any }
71018
+ */
71019
+ function toExtractor(extractor) {
71020
+
71021
+ /**
71022
+ * @satisfies { (e: any) => any }
71023
+ */
71024
+ return isFunction$1(extractor) ? extractor : (e) => {
71025
+
71026
+ // @ts-ignore: just works
71027
+ return e[extractor];
71028
+ };
71029
+ }
71030
+
71031
+
71032
+ /**
71033
+ * @template T
71034
+ * @param {Matcher<T>} matcher
71035
+ *
71036
+ * @return {MatchFn<T>}
71037
+ */
71038
+ function toMatcher(matcher) {
71039
+ return isFunction$1(matcher) ? matcher : (e) => {
71040
+ return e === matcher;
71041
+ };
71042
+ }
71043
+
71044
+
71045
+ function identity$2(arg) {
71046
+ return arg;
71047
+ }
71048
+
71049
+ function toNum$2(arg) {
71050
+ return Number(arg);
70730
71051
  }
70731
71052
 
70732
71053
  /**
@@ -71015,14 +71336,14 @@
71015
71336
  * @return {T[]}
71016
71337
  */
71017
71338
 
71018
- const nativeToString$3 = Object.prototype.toString;
71339
+ const nativeToString$2 = Object.prototype.toString;
71019
71340
 
71020
71341
  function isObject(obj) {
71021
- return nativeToString$3.call(obj) === '[object Object]';
71342
+ return nativeToString$2.call(obj) === '[object Object]';
71022
71343
  }
71023
71344
 
71024
71345
  function isString$1(obj) {
71025
- return nativeToString$3.call(obj) === '[object String]';
71346
+ return nativeToString$2.call(obj) === '[object String]';
71026
71347
  }
71027
71348
 
71028
71349
  /**
@@ -71173,339 +71494,6 @@
71173
71494
 
71174
71495
  var t$1,r,u$1,i$1,o=0,f$1=[],c=[],e=l$1.__b,a=l$1.__r,v=l$1.diffed,l=l$1.__c,m=l$1.unmount;function d(t,u){l$1.__h&&l$1.__h(r,t,o||u),o=0;var i=r.__H||(r.__H={__:[],__h:[]});return t>=i.__.length&&i.__.push({__V:c}),i.__[t]}function h(n){return o=1,s(B$1,n)}function s(n,u,i){var o=d(t$1++,2);if(o.t=n,!o.__c&&(o.__=[i?i(u):B$1(void 0,u),function(n){var t=o.__N?o.__N[0]:o.__[0],r=o.t(t,n);t!==r&&(o.__N=[r,o.__[1]],o.__c.setState({}));}],o.__c=r,!r.u)){var f=function(n,t,r){if(!o.__c.__H)return true;var u=o.__c.__H.__.filter(function(n){return n.__c});if(u.every(function(n){return !n.__N}))return !c||c.call(this,n,t,r);var i=false;return u.forEach(function(n){if(n.__N){var t=n.__[0];n.__=n.__N,n.__N=void 0,t!==n.__[0]&&(i=true);}}),!(!i&&o.__c.props===n)&&(!c||c.call(this,n,t,r))};r.u=true;var c=r.shouldComponentUpdate,e=r.componentWillUpdate;r.componentWillUpdate=function(n,t,r){if(this.__e){var u=c;c=void 0,f(n,t,r),c=u;}e&&e.call(this,n,t,r);},r.shouldComponentUpdate=f;}return o.__N||o.__}function p(u,i){var o=d(t$1++,3);!l$1.__s&&z$1(o.__H,i)&&(o.__=u,o.i=i,r.__H.__h.push(o));}function y(u,i){var o=d(t$1++,4);!l$1.__s&&z$1(o.__H,i)&&(o.__=u,o.i=i,r.__h.push(o));}function _(n){return o=5,F$1(function(){return {current:n}},[])}function A$1(n,t,r){o=6,y(function(){return "function"==typeof n?(n(t()),function(){return n(null)}):n?(n.current=t(),function(){return n.current=null}):void 0},null==r?r:r.concat(n));}function F$1(n,r){var u=d(t$1++,7);return z$1(u.__H,r)?(u.__V=n(),u.i=r,u.__h=n,u.__V):u.__}function T$1(n,t){return o=8,F$1(function(){return n},t)}function q$1(n){var u=r.context[n.__c],i=d(t$1++,9);return i.c=n,u?(null==i.__&&(i.__=true,u.sub(r)),u.props.value):n.__}function x$1(t,r){l$1.useDebugValue&&l$1.useDebugValue(r?r(t):t);}function V$1(){var n=d(t$1++,11);if(!n.__){for(var u=r.__v;null!==u&&!u.__m&&null!==u.__;)u=u.__;var i=u.__m||(u.__m=[0,0]);n.__="P"+i[0]+"-"+i[1]++;}return n.__}function b(){for(var t;t=f$1.shift();)if(t.__P&&t.__H)try{t.__H.__h.forEach(k$1),t.__H.__h.forEach(w$1),t.__H.__h=[];}catch(r){t.__H.__h=[],l$1.__e(r,t.__v);}}l$1.__b=function(n){r=null,e&&e(n);},l$1.__r=function(n){a&&a(n),t$1=0;var i=(r=n.__c).__H;i&&(u$1===r?(i.__h=[],r.__h=[],i.__.forEach(function(n){n.__N&&(n.__=n.__N),n.__V=c,n.__N=n.i=void 0;})):(i.__h.forEach(k$1),i.__h.forEach(w$1),i.__h=[],t$1=0)),u$1=r;},l$1.diffed=function(t){v&&v(t);var o=t.__c;o&&o.__H&&(o.__H.__h.length&&(1!==f$1.push(o)&&i$1===l$1.requestAnimationFrame||((i$1=l$1.requestAnimationFrame)||j$1)(b)),o.__H.__.forEach(function(n){n.i&&(n.__H=n.i),n.__V!==c&&(n.__=n.__V),n.i=void 0,n.__V=c;})),u$1=r=null;},l$1.__c=function(t,r){r.some(function(t){try{t.__h.forEach(k$1),t.__h=t.__h.filter(function(n){return !n.__||w$1(n)});}catch(u){r.some(function(n){n.__h&&(n.__h=[]);}),r=[],l$1.__e(u,t.__v);}}),l&&l(t,r);},l$1.unmount=function(t){m&&m(t);var r,u=t.__c;u&&u.__H&&(u.__H.__.forEach(function(n){try{k$1(n);}catch(n){r=n;}}),u.__H=void 0,r&&l$1.__e(r,u.__v));};var g$1="function"==typeof requestAnimationFrame;function j$1(n){var t,r=function(){clearTimeout(u),g$1&&cancelAnimationFrame(t),setTimeout(n);},u=setTimeout(r,100);g$1&&(t=requestAnimationFrame(r));}function k$1(n){var t=r,u=n.__c;"function"==typeof u&&(n.__c=void 0,u()),r=t;}function w$1(n){var t=r;n.__c=n.__(),r=t;}function z$1(n,t){return !n||n.length!==t.length||t.some(function(t,r){return t!==n[r]})}function B$1(n,t){return "function"==typeof t?t(n):t}
71175
71496
 
71176
- /**
71177
- * Flatten array, one level deep.
71178
- *
71179
- * @template T
71180
- *
71181
- * @param {T[][] | T[] | null} [arr]
71182
- *
71183
- * @return {T[]}
71184
- */
71185
-
71186
- const nativeToString$2 = Object.prototype.toString;
71187
- const nativeHasOwnProperty$3 = Object.prototype.hasOwnProperty;
71188
-
71189
- function isUndefined$2(obj) {
71190
- return obj === undefined;
71191
- }
71192
-
71193
- function isNil$3(obj) {
71194
- return obj == null;
71195
- }
71196
-
71197
- function isArray$2(obj) {
71198
- return nativeToString$2.call(obj) === '[object Array]';
71199
- }
71200
-
71201
- /**
71202
- * @param {any} obj
71203
- *
71204
- * @return {boolean}
71205
- */
71206
- function isFunction$1(obj) {
71207
- const tag = nativeToString$2.call(obj);
71208
-
71209
- return (
71210
- tag === '[object Function]' ||
71211
- tag === '[object AsyncFunction]' ||
71212
- tag === '[object GeneratorFunction]' ||
71213
- tag === '[object AsyncGeneratorFunction]' ||
71214
- tag === '[object Proxy]'
71215
- );
71216
- }
71217
-
71218
-
71219
- /**
71220
- * Ensure collection is an array.
71221
- *
71222
- * @param {Object} obj
71223
- */
71224
- function ensureArray(obj) {
71225
-
71226
- if (isArray$2(obj)) {
71227
- return;
71228
- }
71229
-
71230
- throw new Error('must supply array');
71231
- }
71232
-
71233
- /**
71234
- * Return true, if target owns a property with the given key.
71235
- *
71236
- * @param {Object} target
71237
- * @param {String} key
71238
- *
71239
- * @return {Boolean}
71240
- */
71241
- function has$3(target, key) {
71242
- return !isNil$3(target) && nativeHasOwnProperty$3.call(target, key);
71243
- }
71244
-
71245
- /**
71246
- * @template T
71247
- * @typedef { (
71248
- * ((e: T) => boolean) |
71249
- * ((e: T, idx: number) => boolean) |
71250
- * ((e: T, key: string) => boolean) |
71251
- * string |
71252
- * number
71253
- * ) } Matcher
71254
- */
71255
-
71256
- /**
71257
- * @template T
71258
- * @template U
71259
- *
71260
- * @typedef { (
71261
- * ((e: T) => U) | string | number
71262
- * ) } Extractor
71263
- */
71264
-
71265
-
71266
- /**
71267
- * @template T
71268
- * @typedef { (val: T, key: any) => boolean } MatchFn
71269
- */
71270
-
71271
- /**
71272
- * @template T
71273
- * @typedef { T[] } ArrayCollection
71274
- */
71275
-
71276
- /**
71277
- * @template T
71278
- * @typedef { { [key: string]: T } } StringKeyValueCollection
71279
- */
71280
-
71281
- /**
71282
- * @template T
71283
- * @typedef { { [key: number]: T } } NumberKeyValueCollection
71284
- */
71285
-
71286
- /**
71287
- * @template T
71288
- * @typedef { StringKeyValueCollection<T> | NumberKeyValueCollection<T> } KeyValueCollection
71289
- */
71290
-
71291
- /**
71292
- * @template T
71293
- * @typedef { KeyValueCollection<T> | ArrayCollection<T> } Collection
71294
- */
71295
-
71296
- /**
71297
- * Find element in collection.
71298
- *
71299
- * @template T
71300
- * @param {Collection<T>} collection
71301
- * @param {Matcher<T>} matcher
71302
- *
71303
- * @return {Object}
71304
- */
71305
- function find$1(collection, matcher) {
71306
-
71307
- const matchFn = toMatcher(matcher);
71308
-
71309
- let match;
71310
-
71311
- forEach$2(collection, function(val, key) {
71312
- if (matchFn(val, key)) {
71313
- match = val;
71314
-
71315
- return false;
71316
- }
71317
- });
71318
-
71319
- return match;
71320
-
71321
- }
71322
-
71323
-
71324
- /**
71325
- * Iterate over collection; returning something
71326
- * (non-undefined) will stop iteration.
71327
- *
71328
- * @template T
71329
- * @param {Collection<T>} collection
71330
- * @param { ((item: T, idx: number) => (boolean|void)) | ((item: T, key: string) => (boolean|void)) } iterator
71331
- *
71332
- * @return {T} return result that stopped the iteration
71333
- */
71334
- function forEach$2(collection, iterator) {
71335
-
71336
- let val,
71337
- result;
71338
-
71339
- if (isUndefined$2(collection)) {
71340
- return;
71341
- }
71342
-
71343
- const convertKey = isArray$2(collection) ? toNum$2 : identity$2;
71344
-
71345
- for (let key in collection) {
71346
-
71347
- if (has$3(collection, key)) {
71348
- val = collection[key];
71349
-
71350
- result = iterator(val, convertKey(key));
71351
-
71352
- if (result === false) {
71353
- return val;
71354
- }
71355
- }
71356
- }
71357
- }
71358
-
71359
- /**
71360
- * Return collection without element.
71361
- *
71362
- * @template T
71363
- * @param {ArrayCollection<T>} arr
71364
- * @param {Matcher<T>} matcher
71365
- *
71366
- * @return {T[]}
71367
- */
71368
- function without(arr, matcher) {
71369
-
71370
- if (isUndefined$2(arr)) {
71371
- return [];
71372
- }
71373
-
71374
- ensureArray(arr);
71375
-
71376
- const matchFn = toMatcher(matcher);
71377
-
71378
- return arr.filter(function(el, idx) {
71379
- return !matchFn(el, idx);
71380
- });
71381
-
71382
- }
71383
-
71384
-
71385
- /**
71386
- * Reduce collection, returning a single result.
71387
- *
71388
- * @template T
71389
- * @template V
71390
- *
71391
- * @param {Collection<T>} collection
71392
- * @param {(result: V, entry: T, index: any) => V} iterator
71393
- * @param {V} result
71394
- *
71395
- * @return {V} result returned from last iterator
71396
- */
71397
- function reduce$1(collection, iterator, result) {
71398
-
71399
- forEach$2(collection, function(value, idx) {
71400
- result = iterator(result, value, idx);
71401
- });
71402
-
71403
- return result;
71404
- }
71405
-
71406
-
71407
- /**
71408
- * Transform a collection into another collection
71409
- * by piping each member through the given fn.
71410
- *
71411
- * @param {Object|Array} collection
71412
- * @param {Function} fn
71413
- *
71414
- * @return {Array} transformed collection
71415
- */
71416
- function map$2(collection, fn) {
71417
-
71418
- let result = [];
71419
-
71420
- forEach$2(collection, function(val, key) {
71421
- result.push(fn(val, key));
71422
- });
71423
-
71424
- return result;
71425
- }
71426
-
71427
-
71428
-
71429
- /**
71430
- * Sort collection by criteria.
71431
- *
71432
- * @template T
71433
- *
71434
- * @param {Collection<T>} collection
71435
- * @param {Extractor<T, number | string>} extractor
71436
- *
71437
- * @return {Array}
71438
- */
71439
- function sortBy(collection, extractor) {
71440
-
71441
- extractor = toExtractor(extractor);
71442
-
71443
- let sorted = [];
71444
-
71445
- forEach$2(collection, function(value, key) {
71446
- let disc = extractor(value, key);
71447
-
71448
- let entry = {
71449
- d: disc,
71450
- v: value
71451
- };
71452
-
71453
- for (var idx = 0; idx < sorted.length; idx++) {
71454
- let { d } = sorted[idx];
71455
-
71456
- if (disc < d) {
71457
- sorted.splice(idx, 0, entry);
71458
- return;
71459
- }
71460
- }
71461
-
71462
- // not inserted, append (!)
71463
- sorted.push(entry);
71464
- });
71465
-
71466
- return map$2(sorted, (e) => e.v);
71467
- }
71468
-
71469
-
71470
- /**
71471
- * @param {string | ((e: any) => any) } extractor
71472
- *
71473
- * @return { (e: any) => any }
71474
- */
71475
- function toExtractor(extractor) {
71476
-
71477
- /**
71478
- * @satisfies { (e: any) => any }
71479
- */
71480
- return isFunction$1(extractor) ? extractor : (e) => {
71481
-
71482
- // @ts-ignore: just works
71483
- return e[extractor];
71484
- };
71485
- }
71486
-
71487
-
71488
- /**
71489
- * @template T
71490
- * @param {Matcher<T>} matcher
71491
- *
71492
- * @return {MatchFn<T>}
71493
- */
71494
- function toMatcher(matcher) {
71495
- return isFunction$1(matcher) ? matcher : (e) => {
71496
- return e === matcher;
71497
- };
71498
- }
71499
-
71500
-
71501
- function identity$2(arg) {
71502
- return arg;
71503
- }
71504
-
71505
- function toNum$2(arg) {
71506
- return Number(arg);
71507
- }
71508
-
71509
71497
  /**
71510
71498
  * Flatten array, one level deep.
71511
71499
  *