From c6ab58bce8c76e58388ce6d1c9042989df191a61 Mon Sep 17 00:00:00 2001 From: Jan Klaas Kollhof Date: Sun, 8 Nov 2020 20:36:26 +0100 Subject: [PATCH 1/2] feat(runtime): add experimental runtime support for async iterables --- src/runtime.js | 333 ++++++++++++++++++++++++++++++++++++++----- src/runtime.test.fnk | 182 +++++++++++++++++++++++ 2 files changed, 479 insertions(+), 36 deletions(-) diff --git a/src/runtime.js b/src/runtime.js index 2e97913..bbc8317 100644 --- a/src/runtime.js +++ b/src/runtime.js @@ -11,6 +11,19 @@ class Iterator { it = next_it } } + + async *[Symbol.asyncIterator]() { + let it = this; + let value, next_it, accu; + while (true) { + [value, next_it, accu] = await it.next(accu); + if (next_it.done) { + return; + } + yield value; + it = next_it + } + } } @@ -209,24 +222,22 @@ export const _iter_ = (iterable)=> { } - -class LoopIterator extends Iterator { - constructor(step_fn, num_args, async, spread_result, iterable, accu) { +class SpreadableIterator extends Iterator { + constructor(step_fn, num_args, spread_result, input, accu) { super(); - this.iterable = iterable; + this.input = input; this.step_fn = step_fn; this.num_args = num_args; - this.async = async; this.spread_result = spread_result; this.accu = accu; } } +class MappingIterator extends SpreadableIterator { -class MappingIterator extends LoopIterator { next(shared_accu) { - const {iterable, num_args, spread_result, step_fn, async} = this; + const {input: iterable, num_args, spread_result, step_fn} = this; const use_accu = num_args > 1; let value, next_shared_accu; let {accu} = this; @@ -248,28 +259,79 @@ class MappingIterator extends LoopIterator { return _next_( chain( _iter_(value), - new MappingIterator(step_fn, num_args, async, spread_result, next_it, accu), + new MappingIterator(step_fn, num_args, spread_result, next_it, accu), + ), + next_shared_accu + ); + } + return [ + value, + new MappingIterator(step_fn, num_args, spread_result, next_it, accu), + next_shared_accu + ]; + } +} + + +class AsyncMappingIterator extends SpreadableIterator { + async next(shared_accu) { + const {input: iterable, num_args, spread_result, step_fn} = this; + const use_accu = num_args > 1; + let value, next_shared_accu; + let {accu} = this; + + const [item, next_it, step_accu=shared_accu] = await _next_(iterable, shared_accu); + + if (is_done(next_it)) { + return [undefined, next_it, step_accu]; + } + + if (use_accu) { + [value, accu, next_shared_accu=step_accu] = await step_fn(item, accu, step_accu); + } else { + value = await step_fn(item); + next_shared_accu=step_accu; + } + + if (spread_result) { + return _next_( + chain_async( + _iter_(value), + new AsyncMappingIterator(step_fn, num_args, spread_result, next_it, accu), ), next_shared_accu ); } return [ value, - new MappingIterator(step_fn, num_args, async, spread_result, next_it, accu), + new AsyncMappingIterator(step_fn, num_args, spread_result, next_it, accu), next_shared_accu ]; } } export const _map_ = (step_fn, num_args, async, spread_result)=> (iterable)=> ( - new MappingIterator(step_fn, num_args, async, spread_result, _iter_(iterable), undefined) + async + ? new AsyncMappingIterator(step_fn, num_args, spread_result, _iter_(iterable), undefined) + : new MappingIterator(step_fn, num_args, spread_result, _iter_(iterable), undefined) ); +class LoopIterator extends Iterator { + constructor(step_fn, num_args, iterable, accu) { + super(); + this.iterable = iterable; + this.step_fn = step_fn; + this.num_args = num_args; + this.accu = accu; + } +} + + class FilteringIterator extends LoopIterator { next(shared_accu) { - const {num_args, spread_result, step_fn, async} = this; + const {num_args, step_fn} = this; const use_accu = num_args > 1; let value, step_accu, item; @@ -293,7 +355,7 @@ class FilteringIterator extends LoopIterator { if (value === true) { return [ item, - new FilteringIterator(step_fn, num_args, async, spread_result, it, accu), + new FilteringIterator(step_fn, num_args, it, accu), next_shared_accu ]; } @@ -301,15 +363,51 @@ class FilteringIterator extends LoopIterator { } } -export const _filter_ = (step_fn, num_args, async, spread_result)=> (iterable)=> ( - new FilteringIterator(step_fn, num_args, async, spread_result, _iter_(iterable), undefined) -); +class AsyncFilteringIterator extends LoopIterator { + async next(shared_accu) { + const {num_args, step_fn} = this; + const use_accu = num_args > 1; + + let value, step_accu, item; + let next_shared_accu = shared_accu; + let {accu, iterable: it} = this; + + while(true) { + [item, it, step_accu=next_shared_accu] = await _next_(it, next_shared_accu); + if (is_done(it)) { + return [undefined, it, step_accu]; + } + let value; + if (use_accu) { + [value, accu, next_shared_accu=step_accu] = await step_fn(item, accu, step_accu); + } else { + value = await step_fn(item); + next_shared_accu = step_accu + } + + if (value === true) { + return [ + item, + new AsyncFilteringIterator(step_fn, num_args, it, accu), + next_shared_accu + ]; + } + } + } +} + +export const _filter_ = (step_fn, num_args, async)=> (iterable)=> ( + async + ? new AsyncFilteringIterator(step_fn, num_args, _iter_(iterable), undefined) + : new FilteringIterator(step_fn, num_args, _iter_(iterable), undefined) +); +// TODO: same as filter, except we exit on first non True class WhileIterator extends LoopIterator { next(shared_accu) { - const {num_args, step_fn, async} = this; + const {num_args, step_fn} = this; const use_accu = num_args > 1; let value, step_accu, item; @@ -332,7 +430,40 @@ class WhileIterator extends LoopIterator { if (value === true) { return [ item, - new WhileIterator(step_fn, num_args, async, false, it, accu), + new WhileIterator(step_fn, num_args, it, accu), + next_shared_accu + ]; + } + return [undefined, emtpy_iter, next_shared_accu]; + } +} + +class AsyncWhileIterator extends LoopIterator { + async next(shared_accu) { + const {num_args, step_fn} = this; + const use_accu = num_args > 1; + + let value, step_accu, item; + let next_shared_accu = shared_accu; + let {accu, iterable: it} = this; + + [item, it, step_accu=next_shared_accu] = await _next_(it, next_shared_accu); + + if (is_done(it)) { + return [undefined, it, step_accu]; + } + + if (use_accu) { + [value, accu, next_shared_accu=step_accu] = await step_fn(item, accu, step_accu); + } else { + value = await step_fn(item); + next_shared_accu = step_accu; + } + + if (value === true) { + return [ + item, + new AsyncWhileIterator(step_fn, num_args, it, accu), next_shared_accu ]; } @@ -340,15 +471,18 @@ class WhileIterator extends LoopIterator { } } + export const _while_ = (step_fn, num_args, async)=> (iterable)=> ( - new WhileIterator(step_fn, num_args, async, false, _iter_(iterable), undefined) + async + ? new AsyncWhileIterator(step_fn, num_args, _iter_(iterable), undefined) + : new WhileIterator(step_fn, num_args, _iter_(iterable), undefined) ); class UntilIterator extends LoopIterator { next(shared_accu) { - const {num_args, step_fn, async} = this; + const {num_args, step_fn} = this; const use_accu = num_args > 1; let value, item, step_accu; @@ -378,31 +512,103 @@ class UntilIterator extends LoopIterator { return [ item, - new UntilIterator(step_fn, num_args, async, false, it, accu), + new UntilIterator(step_fn, num_args, it, accu), + next_shared_accu + ]; + } +} + +class AsyncUntilIterator extends LoopIterator { + async next(shared_accu) { + const {num_args, step_fn} = this; + const use_accu = num_args > 1; + + let value, item, step_accu; + let next_shared_accu = shared_accu; + let {accu, iterable: it} = this; + + [item, it, step_accu=next_shared_accu] = await _next_(it, next_shared_accu); + + if (is_done(it)) { + return [undefined, it, step_accu]; + } + + if (use_accu) { + [value, accu, next_shared_accu=step_accu] = await step_fn(item, accu, step_accu); + } else { + value = await step_fn(item); + next_shared_accu = step_accu + } + + if (value === true) { + return [ + item, + iterator((_, shared_accu)=> [undefined, emtpy_iter, shared_accu]), + next_shared_accu + ]; + } + + return [ + item, + new AsyncUntilIterator(step_fn, num_args, it, accu), next_shared_accu ]; } } export const _until_ = (step_fn, num_args, async)=> (iterable)=> ( - new UntilIterator(step_fn, num_args, async, false, _iter_(iterable), undefined) + async + ? new AsyncUntilIterator(step_fn, num_args, _iter_(iterable), undefined) + : new UntilIterator(step_fn, num_args, _iter_(iterable), undefined) ); -class UnfoldingIterator extends Iterator { - constructor(step_fn, num_args, async, spread_result, prev, accu) { +class UnfoldingIterator extends SpreadableIterator { + next(shared_accu) { + const {num_args, step_fn, spread_result, input: prev} = this; + const use_accu = num_args > 1; + + let value; + let next_shared_accu = shared_accu; + let {accu} = this; + + if (use_accu) { + [value, accu, next_shared_accu=shared_accu] = step_fn(prev, accu, shared_accu); + } else { + value = step_fn(prev); + next_shared_accu = shared_accu; + } + + if (spread_result) { + return _next_( + chain( + _iter_(value), + new UnfoldingIterator(step_fn, num_args, spread_result, value, accu), + ), + next_shared_accu + ); + } + return [ + value, + new UnfoldingIterator(step_fn, num_args, spread_result, value, accu), + next_shared_accu + ]; + } +} + +class AsyncUnfoldingIterator extends Iterator { + constructor(step_fn, num_args, spread_result, prev, accu) { super(); this.prev = prev; this.step_fn = step_fn; this.num_args = num_args; - this.async = async; this.spread_result = spread_result; this.accu = accu; } - next(shared_accu) { - const {num_args, step_fn, async, spread_result, prev} = this; + async next(shared_accu) { + const {num_args, step_fn, spread_result, prev} = this; const use_accu = num_args > 1; let value; @@ -410,24 +616,24 @@ class UnfoldingIterator extends Iterator { let {accu} = this; if (use_accu) { - [value, accu, next_shared_accu=shared_accu] = step_fn(prev, accu, shared_accu); + [value, accu, next_shared_accu=shared_accu] = await step_fn(prev, accu, shared_accu); } else { - value = step_fn(prev); + value = await step_fn(prev); next_shared_accu = shared_accu; } if (spread_result) { - return _next_( - chain( + return await _next_( + chain_async( _iter_(value), - new UnfoldingIterator(step_fn, num_args, async, spread_result, value, accu), + new UnfoldingIterator(step_fn, num_args, spread_result, value, accu), ), next_shared_accu ); } return [ value, - new UnfoldingIterator(step_fn, num_args, async, spread_result, value, accu), + new AsyncUnfoldingIterator(step_fn, num_args, spread_result, value, accu), next_shared_accu ]; } @@ -435,15 +641,17 @@ class UnfoldingIterator extends Iterator { export const _unfold_ = (step_fn, num_args, async, spread_result)=> (prev)=> ( - new UnfoldingIterator(step_fn, num_args, async, spread_result, prev, undefined) + async + ? new AsyncUnfoldingIterator(step_fn, num_args, spread_result, prev, undefined) + : new UnfoldingIterator(step_fn, num_args, spread_result, prev, undefined) ); -export const _fold_ = (reducer, num_args)=> (iterable)=> { +export const fold_sync = (reducer, num_args, result)=> (iterable)=> { const use_accu = num_args > 2; let it = _iter_(iterable); - let result, accu, item, shared_accu, step_accu; + let accu, item, shared_accu, step_accu; while (true) { [item, it, step_accu=shared_accu] = _next_(it, step_accu); @@ -457,7 +665,34 @@ export const _fold_ = (reducer, num_args)=> (iterable)=> { shared_accu = step_accu; } } -} +}; + + +export const fold_async = (reducer, num_args, result)=> async (iterable)=> { + const use_accu = num_args > 2; + let it = _iter_(iterable); + let accu, item, shared_accu, step_accu; + + while (true) { + [item, it, step_accu=shared_accu] = await _next_(it, step_accu); + if (is_done(it)) { + return result; + } + if (use_accu) { + [result, accu, shared_accu=step_accu] = await reducer(item, result, accu, step_accu); + } else { + result = await reducer(item, result); + shared_accu = step_accu; + } + } +}; + + +export const _fold_ = (reducer, num_args, is_async, initial)=> ( + is_async + ? fold_async(reducer, num_args, initial) + : fold_sync(reducer, num_args, initial) +); @@ -487,7 +722,33 @@ class ChainIterator extends Iterator { } } +class AsyncChainIterator extends Iterator { + constructor(iters) { + super(); + this.iters = iters; + } + + async next(shared_accu) { + let {iters} = this; + let it, item, next_shared_accu; + + while (true) { + [it, ...iters] = iters; + [item, it, next_shared_accu=shared_accu] = await _next_(it, shared_accu); + + if (is_done(it)) { + if (iters.length === 0) { + return [undefined, it, next_shared_accu]; + } + shared_accu = next_shared_accu; + } else { + return [item, new AsyncChainIterator([it, ...iters]), next_shared_accu]; + } + } + } +} const chain = (...iterables)=> new ChainIterator(iterables); +const chain_async = (...iterables)=> new AsyncChainIterator(iterables); diff --git a/src/runtime.test.fnk b/src/runtime.test.fnk index 00990ae..30c3a85 100644 --- a/src/runtime.test.fnk +++ b/src/runtime.test.fnk @@ -21,6 +21,14 @@ expect_iter = fn actual, expectation: expectation +expect_iter_a = fn actual, expectation: + expect + await pipe actual: + fold await item, items=[]: + [...items, item] + expectation + + describe _map_, fn: it 'maps items', fn: @@ -47,6 +55,31 @@ describe _map_, fn: ['1', '1', '2', '2', '3', '3'] + it 'maps items async', fn: + expect_iter_a + '123' | map await item: + await 'foo${item}' + to_equal + ['foo1', 'foo2', 'foo3'] + + + it 'maps items with accu async', fn: + expect_iter_a + 'abc' | map await item, acc=1: + ['${item}${acc}', await acc + 1] + to_equal + ['a1', 'b2', 'c3'] + + + it 'maps items with spread async', fn: + expect_iter_a + '123' | map await item: + ...[item, await item] + to_equal + ['1', '1', '2', '2', '3', '3'] + + + describe _filter_, fn: it 'keeps items', fn: @@ -56,6 +89,7 @@ describe _filter_, fn: to_equal [2, 4] + it 'keeps items with accu', fn: expect_iter [1, 2, 3, 4] | filter item, cntr=1: @@ -64,6 +98,22 @@ describe _filter_, fn: [2, 4] + it 'keeps items async', fn: + expect_iter_a + [1, 2, 3, 4] | filter await item: + await 0 == item % 2 + to_equal + [2, 4] + + + it 'keeps items with accu async', fn: + expect_iter_a + [1, 2, 3, 4] | filter await item, cntr=1: + [0 == (item * cntr) % 2, cntr + 1] + to_equal + [2, 4] + + describe _while_, fn: it 'keeps items while condition holds true', fn: @@ -73,6 +123,7 @@ describe _while_, fn: to_equal [1, 2, 3] + it 'keeps all', fn: expect_iter [1, 2, 3, 4, 5] | while item: @@ -80,6 +131,7 @@ describe _while_, fn: to_equal [1, 2, 3, 4, 5] + it 'keeps items with accu', fn: expect_iter [1, 2, 3, 4, 5] | while item, acc=5: @@ -88,6 +140,30 @@ describe _while_, fn: [1, 2] + it 'keeps items while condition holds true async', fn: + expect_iter_a + [1, 2, 3, 4, 5] | while await item: + await item < 4 + to_equal + [1, 2, 3] + + + it 'keeps all async', fn: + expect_iter_a + [1, 2, 3, 4, 5] | while await item: + await item > 0 + to_equal + [1, 2, 3, 4, 5] + + + it 'keeps items with accu async', fn: + expect_iter_a + [1, 2, 3, 4, 5] | while await item, acc=5: + [acc - item > 0, await acc - 1] + to_equal + [1, 2] + + describe _until_, fn: it 'keeps items until condition is true', fn: @@ -97,6 +173,7 @@ describe _until_, fn: to_equal [1, 2, 3, 4, 5] + it 'keeps all', fn: expect_iter [1, 2, 3, 4, 5] | until item: @@ -104,6 +181,7 @@ describe _until_, fn: to_equal [1, 2, 3, 4, 5] + it 'keeps items with accu', fn: expect_iter [1, 2, 3, 4, 5] | until item, acc=5: @@ -112,6 +190,30 @@ describe _until_, fn: [1, 2, 3] +it 'keeps items until condition is true async', fn: + expect_iter_a + [1, 2, 3, 4, 5] | until await item: + await item == 5 + to_equal + [1, 2, 3, 4, 5] + + + it 'keeps all async', fn: + expect_iter_a + [1, 2, 3, 4, 5] | until await item: + await item == 0 + to_equal + [1, 2, 3, 4, 5] + + + it 'keeps items with accu async', fn: + expect_iter_a + [1, 2, 3, 4, 5] | until await item, acc=5: + [acc - item == 0, await acc - 1] + to_equal + [1, 2, 3] + + describe _fold_, fn: it 'folds items', fn: @@ -121,6 +223,13 @@ describe _fold_, fn: to_equal '321' + it 'folds empty', fn: + expect + '' | fold item, prev='foobar': + '${item}${prev}' + to_equal + 'foobar' + it 'folds items with accu', fn: expect @@ -130,6 +239,22 @@ describe _fold_, fn: ',a0,b1,c2' + it 'folds items async ', fn: + expect + await '123' | fold await item, prev='': + '${item}${await prev}' + to_equal + '321' + + + it 'folds items with accu', fn: + expect + await 'abc' | fold await item, prev='', acc=0: + ['${prev},${item}${acc}', await acc + 1] + to_equal + ',a0,b1,c2' + + describe _unfold_, fn: it 'creates items from previous', fn: @@ -173,6 +298,47 @@ describe _unfold_, fn: [1, 2, 3, 1] + it 'creates items from previous async ', fn: + expect_iter_a + pipe 0: + unfold await prev: + await prev + 1 + while await item: + item < 5 + to_equal + [1, 2, 3, 4] + + it 'creates items with accu async', fn: + expect_iter_a + pipe 0: + unfold await prev, accu=1: + [prev + accu, await accu * 2] + while await item: + item < 20 + to_equal + [1, 3, 7, 15] + + + it 'creates items with spread async', fn: + expect_iter_a + pipe: + unfold await _: + ...[1, 2, 3] + + until await item, seen=false: + [item == 2 and seen, seen or item == 2] + + to_equal + [1, 2, 3, 1, 2] + + [foo, bar, spam, shrub] = [1, 2, 3] | unfold items: ...items + + expect_iter + [foo, bar, spam, shrub] + to_equal + [1, 2, 3, 1] + + describe _zip_, fn: it 'zips iterables into one', fn: @@ -369,6 +535,22 @@ describe 'other iterables', fn: +describe 'JS async iterable', fn: + it 'provides async iterable', fn: + [await item1, item2] = '1234' | filter await item: item != '1' + expect + [item1, item2] + to_equal ['2', '3'] + + + it 'exhausts async iterable', fn: + [await item] = '1234' | filter await item: item == '0' + expect + item + to_equal undefined + + + describe 'shared accu', fn: it 'shares accus across iterators', fn: expect From a07f4fe4a4a80e07f30807eec85e07f6c04dbe8a Mon Sep 17 00:00:00 2001 From: Jan Klaas Kollhof Date: Sun, 8 Nov 2020 21:01:48 +0100 Subject: [PATCH 2/2] build(deps): upgrade deps --- package-lock.json | 41 ++++++++++++++++++++++------------------- package.json | 2 +- 2 files changed, 23 insertions(+), 20 deletions(-) diff --git a/package-lock.json b/package-lock.json index 8814682..53ad76d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -13,7 +13,7 @@ "@babel/preset-env": "^7.11.5", "@fink/jest": "^7.0.0", "@fink/larix": "^15.2.0", - "@fink/loxia": "^18.2.0", + "@fink/loxia": "^19.0.0", "babel-jest": "^26.5.2", "commitizen": "^4.0.5", "cz-conventional-changelog": "^3.1.0", @@ -1457,9 +1457,9 @@ } }, "node_modules/@fink/js-interop": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/@fink/js-interop/-/js-interop-2.0.1.tgz", - "integrity": "sha512-WDjgBWf6hSS3aAP9lMM+OYJOQTOaWoPvWDgN+7IakSacplsX2omk6bdpE1sYBwSLEqfAQ0ZuyybfdGv83WM/WA==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@fink/js-interop/-/js-interop-2.1.0.tgz", + "integrity": "sha512-6yxsatYmTb/exBvItoZZYIWv0uIqyuvKW5AaOu/Un94uL5GNRVD6vJYbCX7V1xp4xG+asRTn6uQnzoIn7fTN+A==", "dev": true, "engines": { "node": ">=14.0.0" @@ -1479,9 +1479,9 @@ } }, "node_modules/@fink/loxia": { - "version": "18.3.0", - "resolved": "https://registry.npmjs.org/@fink/loxia/-/loxia-18.3.0.tgz", - "integrity": "sha512-kiMZ334cYMw7zAJLapWjb9MC3/u+mYz7UD9biD4P9YTdoHLQf+2JSZ4+PuAXjiE24RYrzU2nfZTkZx1kcfCtKg==", + "version": "19.0.0", + "resolved": "https://registry.npmjs.org/@fink/loxia/-/loxia-19.0.0.tgz", + "integrity": "sha512-5c/RwWzMRl5FhaSeqfe2Jl16aEaLpM0rDkD2GHfh+2TKszFeeBTqK5RJiE4RQ8iqQ744S2RjkcCHEQdnr6aymw==", "dev": true, "dependencies": { "@babel/core": "^7.10.5", @@ -1493,6 +1493,9 @@ }, "engines": { "node": ">=14.0.0" + }, + "peerDependencies": { + "@fink/js-interop": ">2.1" } }, "node_modules/@fink/prattler": { @@ -18935,9 +18938,9 @@ } }, "node_modules/ws": { - "version": "7.3.1", - "resolved": "https://registry.npmjs.org/ws/-/ws-7.3.1.tgz", - "integrity": "sha512-D3RuNkynyHmEJIpD2qrgVkc9DQ23OrN/moAwZX4L8DfvszsJxpjQuUq3LMx6HoYji9fbIOBY18XWBsAux1ZZUA==", + "version": "7.4.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.0.tgz", + "integrity": "sha512-kyFwXuV/5ymf+IXhS6f0+eAFvydbaBW3zjpT6hUdAh/hbVjTIB5EHBGi0bPoCLSK2wcuz3BrEkB9LrYv1Nm4NQ==", "dev": true, "engines": { "node": ">=8.3.0" @@ -20256,9 +20259,9 @@ } }, "@fink/js-interop": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/@fink/js-interop/-/js-interop-2.0.1.tgz", - "integrity": "sha512-WDjgBWf6hSS3aAP9lMM+OYJOQTOaWoPvWDgN+7IakSacplsX2omk6bdpE1sYBwSLEqfAQ0ZuyybfdGv83WM/WA==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@fink/js-interop/-/js-interop-2.1.0.tgz", + "integrity": "sha512-6yxsatYmTb/exBvItoZZYIWv0uIqyuvKW5AaOu/Un94uL5GNRVD6vJYbCX7V1xp4xG+asRTn6uQnzoIn7fTN+A==", "dev": true }, "@fink/larix": { @@ -20272,9 +20275,9 @@ } }, "@fink/loxia": { - "version": "18.3.0", - "resolved": "https://registry.npmjs.org/@fink/loxia/-/loxia-18.3.0.tgz", - "integrity": "sha512-kiMZ334cYMw7zAJLapWjb9MC3/u+mYz7UD9biD4P9YTdoHLQf+2JSZ4+PuAXjiE24RYrzU2nfZTkZx1kcfCtKg==", + "version": "19.0.0", + "resolved": "https://registry.npmjs.org/@fink/loxia/-/loxia-19.0.0.tgz", + "integrity": "sha512-5c/RwWzMRl5FhaSeqfe2Jl16aEaLpM0rDkD2GHfh+2TKszFeeBTqK5RJiE4RQ8iqQ744S2RjkcCHEQdnr6aymw==", "dev": true, "requires": { "@babel/core": "^7.10.5", @@ -34068,9 +34071,9 @@ } }, "ws": { - "version": "7.3.1", - "resolved": "https://registry.npmjs.org/ws/-/ws-7.3.1.tgz", - "integrity": "sha512-D3RuNkynyHmEJIpD2qrgVkc9DQ23OrN/moAwZX4L8DfvszsJxpjQuUq3LMx6HoYji9fbIOBY18XWBsAux1ZZUA==", + "version": "7.4.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.0.tgz", + "integrity": "sha512-kyFwXuV/5ymf+IXhS6f0+eAFvydbaBW3zjpT6hUdAh/hbVjTIB5EHBGi0bPoCLSK2wcuz3BrEkB9LrYv1Nm4NQ==", "dev": true, "requires": {} }, diff --git a/package.json b/package.json index 92cd591..44a8d5e 100644 --- a/package.json +++ b/package.json @@ -42,7 +42,7 @@ "@babel/preset-env": "^7.11.5", "@fink/jest": "^7.0.0", "@fink/larix": "^15.2.0", - "@fink/loxia": "^18.2.0", + "@fink/loxia": "^19.0.0", "babel-jest": "^26.5.2", "commitizen": "^4.0.5", "cz-conventional-changelog": "^3.1.0",