mol_crypto_lib 0.1.989 → 0.1.991

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.
Files changed (5) hide show
  1. package/node.test.js +41 -33
  2. package/node.test.js.map +1 -1
  3. package/package.json +1 -1
  4. package/web.test.js +41 -33
  5. package/web.test.js.map +1 -1
package/node.test.js CHANGED
@@ -1826,7 +1826,12 @@ var $;
1826
1826
  var $;
1827
1827
  (function ($) {
1828
1828
  function $mol_range2(item = index => index, size = () => Number.POSITIVE_INFINITY) {
1829
- return new Proxy(new $mol_range2_array(), {
1829
+ const source = typeof item === 'function' ? new $mol_range2_array() : item;
1830
+ if (typeof item !== 'function') {
1831
+ item = index => source[index];
1832
+ size = () => source.length;
1833
+ }
1834
+ return new Proxy(source, {
1830
1835
  get(target, field) {
1831
1836
  if (typeof field === 'string') {
1832
1837
  if (field === 'length')
@@ -1839,7 +1844,7 @@ var $;
1839
1844
  if (index === Math.trunc(index))
1840
1845
  return item(index);
1841
1846
  }
1842
- return target[field];
1847
+ return $mol_range2_array.prototype[field];
1843
1848
  },
1844
1849
  set(target, field) {
1845
1850
  return $mol_fail(new TypeError(`Lazy range is read only (trying to set field ${JSON.stringify(field)})`));
@@ -1880,13 +1885,16 @@ var $;
1880
1885
  return $mol_range2(index => index < this.length ? this[index] : tail[0][index - this.length], () => this.length + tail[0].length);
1881
1886
  }
1882
1887
  filter(check, context) {
1883
- const filtered = new $mol_range2_array();
1884
- for (let index = 0; index < this.length; ++index) {
1885
- const item = this[index];
1886
- if (check.call(context, item, index, this))
1887
- filtered.push(item);
1888
- }
1889
- return filtered;
1888
+ const filtered = [];
1889
+ let cursor = -1;
1890
+ return $mol_range2(index => {
1891
+ while (cursor < this.length && index >= filtered.length - 1) {
1892
+ const val = this[++cursor];
1893
+ if (check(val, cursor, this))
1894
+ filtered.push(val);
1895
+ }
1896
+ return filtered[index];
1897
+ }, () => cursor < this.length ? Number.POSITIVE_INFINITY : filtered.length);
1890
1898
  }
1891
1899
  forEach(proceed, context) {
1892
1900
  for (let [key, value] of this.entries())
@@ -1946,7 +1954,7 @@ var $;
1946
1954
  'lazy calls'() {
1947
1955
  let calls = 0;
1948
1956
  const list = $mol_range2(index => (++calls, index), () => 10);
1949
- $mol_assert_ok(list instanceof Array);
1957
+ $mol_assert_equal(true, list instanceof Array);
1950
1958
  $mol_assert_equal(list.length, 10);
1951
1959
  $mol_assert_equal(list[-1], undefined);
1952
1960
  $mol_assert_equal(list[0], 0);
@@ -1989,11 +1997,17 @@ var $;
1989
1997
  $mol_range2(i => i, () => 5).forEach(i => log += i);
1990
1998
  $mol_assert_equal(log, '01234');
1991
1999
  },
2000
+ 'reduce'() {
2001
+ let calls = 0;
2002
+ const list = $mol_range2().slice(1, 6);
2003
+ $mol_assert_equal(list.reduce((s, v) => s + v), 15);
2004
+ $mol_assert_equal(list.reduce((s, v) => s + v, 5), 20);
2005
+ },
1992
2006
  'lazy concat'() {
1993
2007
  let calls1 = 0;
1994
2008
  let calls2 = 0;
1995
2009
  const list = $mol_range2(index => (++calls1, index), () => 5).concat([0, 1, 2, 3, 4], $mol_range2(index => (++calls2, index), () => 5));
1996
- $mol_assert_ok(list instanceof Array);
2010
+ $mol_assert_equal(true, list instanceof Array);
1997
2011
  $mol_assert_equal(list.length, 15);
1998
2012
  $mol_assert_equal(list[0], 0);
1999
2013
  $mol_assert_equal(list[4], 4);
@@ -2005,32 +2019,26 @@ var $;
2005
2019
  $mol_assert_equal(calls1, 2);
2006
2020
  $mol_assert_equal(calls2, 2);
2007
2021
  },
2008
- 'filter'() {
2022
+ 'lazy filter'() {
2009
2023
  let calls = 0;
2010
- const list = $mol_range2(index => (++calls, index), () => 10).filter(v => v % 2).slice(0, 3);
2011
- $mol_assert_ok(list instanceof Array);
2024
+ const list = $mol_range2(index => (++calls, index), () => 15).filter(v => v % 2).slice(0, 3);
2025
+ $mol_assert_equal(true, list instanceof Array);
2012
2026
  $mol_assert_equal(list.length, 3);
2013
2027
  $mol_assert_equal(list[0], 1);
2014
2028
  $mol_assert_equal(list[2], 5);
2015
2029
  $mol_assert_equal(list[3], undefined);
2016
- $mol_assert_equal(calls, 10);
2030
+ $mol_assert_equal(calls, 8);
2017
2031
  },
2018
- 'reverse'() {
2032
+ 'lazy reverse'() {
2019
2033
  let calls = 0;
2020
2034
  const list = $mol_range2(index => (++calls, index), () => 10).toReversed().slice(0, 3);
2021
- $mol_assert_ok(list instanceof Array);
2035
+ $mol_assert_equal(true, list instanceof Array);
2022
2036
  $mol_assert_equal(list.length, 3);
2023
2037
  $mol_assert_equal(list[0], 9);
2024
2038
  $mol_assert_equal(list[2], 7);
2025
2039
  $mol_assert_equal(list[3], undefined);
2026
2040
  $mol_assert_equal(calls, 2);
2027
2041
  },
2028
- 'reduce'() {
2029
- let calls = 0;
2030
- const list = $mol_range2().slice(1, 6);
2031
- $mol_assert_equal(list.reduce((s, v) => s + v), 15);
2032
- $mol_assert_equal(list.reduce((s, v) => s + v, 5), 20);
2033
- },
2034
2042
  'lazy map'() {
2035
2043
  let calls1 = 0;
2036
2044
  let calls2 = 0;
@@ -2040,7 +2048,7 @@ var $;
2040
2048
  $mol_assert_equal(source, self);
2041
2049
  return index + 10;
2042
2050
  }, () => 5);
2043
- $mol_assert_ok(target instanceof Array);
2051
+ $mol_assert_equal(true, target instanceof Array);
2044
2052
  $mol_assert_equal(target.length, 5);
2045
2053
  $mol_assert_equal(target[0], 10);
2046
2054
  $mol_assert_equal(target[4], 14);
@@ -2051,7 +2059,7 @@ var $;
2051
2059
  'lazy slice'() {
2052
2060
  let calls = 0;
2053
2061
  const list = $mol_range2(index => (++calls, index), () => 10).slice(3, 7);
2054
- $mol_assert_ok(list instanceof Array);
2062
+ $mol_assert_equal(true, list instanceof Array);
2055
2063
  $mol_assert_equal(list.length, 4);
2056
2064
  $mol_assert_equal(list[0], 3);
2057
2065
  $mol_assert_equal(list[3], 6);
@@ -2060,22 +2068,22 @@ var $;
2060
2068
  },
2061
2069
  'lazy some'() {
2062
2070
  let calls = 0;
2063
- $mol_assert_ok($mol_range2(index => (++calls, index), () => 5).some(v => v >= 2));
2071
+ $mol_assert_equal(true, $mol_range2(index => (++calls, index), () => 5).some(v => v >= 2));
2064
2072
  $mol_assert_equal(calls, 3);
2065
- $mol_assert_not($mol_range2(i => i, () => 0).some(v => true));
2066
- $mol_assert_ok($mol_range2(i => i).some(v => v > 5));
2073
+ $mol_assert_equal(false, $mol_range2(i => i, () => 0).some(v => true));
2074
+ $mol_assert_equal(true, $mol_range2(i => i).some(v => v > 5));
2067
2075
  },
2068
2076
  'lazy every'() {
2069
2077
  let calls = 0;
2070
- $mol_assert_not($mol_range2(index => (++calls, index), () => 5).every(v => v < 2));
2078
+ $mol_assert_equal(false, $mol_range2(index => (++calls, index), () => 5).every(v => v < 2));
2071
2079
  $mol_assert_equal(calls, 3);
2072
- $mol_assert_ok($mol_range2(i => i, () => 0).every(v => false));
2073
- $mol_assert_not($mol_range2(i => i).every(v => v < 5));
2080
+ $mol_assert_equal(true, $mol_range2(i => i, () => 0).every(v => false));
2081
+ $mol_assert_equal(false, $mol_range2(i => i).every(v => v < 5));
2074
2082
  },
2075
2083
  'lazyfy'() {
2076
2084
  let calls = 0;
2077
- const list = new $mol_range2_array(...[0, 1, 2, 3, 4, 5]).map(i => (++calls, i + 10)).slice(2);
2078
- $mol_assert_ok(list instanceof Array);
2085
+ const list = $mol_range2([0, 1, 2, 3, 4, 5]).map(i => (++calls, i + 10)).slice(2);
2086
+ $mol_assert_equal(true, list instanceof Array);
2079
2087
  $mol_assert_equal(list.length, 4);
2080
2088
  $mol_assert_equal(calls, 0);
2081
2089
  $mol_assert_equal(list[0], 12);