@es-git/packfile - npm Package Compare versions

Comparing version 0.5.0 to 0.6.0

es/compose-packfile.d.ts

 import { Entry } from './types';
-export default function composePackfile(items: Entry[]): IterableIterator<Uint8Array>;
+export default function composePackfile(items: AsyncIterableIterator<Entry>, count: number): AsyncIterableIterator<Uint8Array>;

es/compose-packfile.js

@@ -0,1 +1,18 @@
+var __asyncValues = (this && this.__asyncIterator) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 import { packHash } from '@es-git/core';
@@ -5,11 +22,24 @@ import * as pako from 'pako';
 import { Type } from './types';
-export default function* composePackfile(items) {
-    const hash = sha1();
-    yield update(packHeader(items.length), hash);
-    for (const item of items) {
-        for (const chunk of packFrame(item)) {
-            yield update(chunk, hash);
+export default function composePackfile(items, count) {
+    return __asyncGenerator(this, arguments, function* composePackfile_1() {
+        const hash = sha1();
+        yield update(packHeader(count), hash);
+        try {
+            for (var items_1 = __asyncValues(items), items_1_1; items_1_1 = yield __await(items_1.next()), !items_1_1.done;) {
+                const item = yield __await(items_1_1.value);
+                for (const chunk of packFrame(item)) {
+                    yield update(chunk, hash);
+                }
+            }
         }
-    }
-    yield packHash(hash.digest());
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) yield __await(_a.call(items_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        yield packHash(hash.digest());
+        var e_1, _a;
+    });
 }
@@ -16,0 +46,0 @@ function update(chunk, hash) {

es/pack.d.ts

 export declare type HashBlob = [string, Uint8Array];
-export default function (objects: Iterable<HashBlob>): Uint8Array;
+export default function pack(objects: AsyncIterableIterator<HashBlob>, count: number): AsyncIterableIterator<Uint8Array>;

es/pack.js

@@ -1,29 +0,123 @@
-import { concat, decode } from '@es-git/core';
+var __asyncValues = (this && this.__asyncIterator) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { if (o[n]) i[n] = function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; }; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { decode } from '@es-git/core';
 import composePackfile from './compose-packfile';
 import { Type } from './types';
-export default function (objects) {
-    return concat(...composePackfile([...toEntry(toRawObject(objects))].sort(byType)));
+import pipe from './pipe';
+export default function pack(objects, count) {
+    return __asyncGenerator(this, arguments, function* pack_1() {
+        yield __await(yield* __asyncDelegator(__asyncValues(pipe(objects)
+            .pipe(toRawObject)
+            .pipe(toEntry)
+            .pipe(sortByType)
+            .pipe(x => composePackfile(x, count)))));
+    });
 }
-function* toRawObject(objects) {
-    for (const [hash, body] of objects) {
-        const space = body.indexOf(0x20);
-        const nil = body.indexOf(0x00, space);
-        yield {
-            body: body.subarray(nil + 1),
-            type: decode(body, 0, space),
-            hash: hash
-        };
-    }
+function toRawObject(objects) {
+    return __asyncGenerator(this, arguments, function* toRawObject_1() {
+        try {
+            for (var objects_1 = __asyncValues(objects), objects_1_1; objects_1_1 = yield __await(objects_1.next()), !objects_1_1.done;) {
+                const [hash, body] = yield __await(objects_1_1.value);
+                const space = body.indexOf(0x20);
+                const nil = body.indexOf(0x00, space);
+                yield {
+                    body: body.subarray(nil + 1),
+                    type: decode(body, 0, space),
+                    hash: hash
+                };
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (objects_1_1 && !objects_1_1.done && (_a = objects_1.return)) yield __await(_a.call(objects_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _a;
+    });
 }
-function* toEntry(objects) {
-    for (const object of objects) {
-        yield {
-            body: object.body,
-            type: object.type === 'commit' ? Type.commit
-                : object.type === 'tree' ? Type.tree
-                    : Type.blob,
-            offset: 0
-        };
-    }
+function toEntry(objects) {
+    return __asyncGenerator(this, arguments, function* toEntry_1() {
+        try {
+            for (var objects_2 = __asyncValues(objects), objects_2_1; objects_2_1 = yield __await(objects_2.next()), !objects_2_1.done;) {
+                const object = yield __await(objects_2_1.value);
+                yield {
+                    body: object.body,
+                    type: object.type === 'commit' ? Type.commit
+                        : object.type === 'tree' ? Type.tree
+                            : Type.blob,
+                    offset: 0
+                };
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (objects_2_1 && !objects_2_1.done && (_a = objects_2.return)) yield __await(_a.call(objects_2));
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var e_2, _a;
+    });
 }
+function sortByType(entries) {
+    return __asyncGenerator(this, arguments, function* sortByType_1() {
+        const commits = [];
+        const trees = [];
+        const blobs = [];
+        const others = [];
+        try {
+            for (var entries_1 = __asyncValues(entries), entries_1_1; entries_1_1 = yield __await(entries_1.next()), !entries_1_1.done;) {
+                const entry = yield __await(entries_1_1.value);
+                switch (entry.type) {
+                    case Type.commit:
+                        commits.push(entry);
+                        break;
+                    case Type.tree:
+                        trees.push(entry);
+                        break;
+                    case Type.blob:
+                        blobs.push(entry);
+                        break;
+                    default:
+                        others.push(entry);
+                        break;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) yield __await(_a.call(entries_1));
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        yield __await(yield* __asyncDelegator(__asyncValues(commits)));
+        yield __await(yield* __asyncDelegator(__asyncValues(trees)));
+        yield __await(yield* __asyncDelegator(__asyncValues(blobs)));
+        yield __await(yield* __asyncDelegator(__asyncValues(others)));
+        var e_3, _a;
+    });
+}
 function byType(a, b) {
@@ -30,0 +124,0 @@ return a.type - b.type;

es/unpack.js

@@ -0,6 +1,33 @@
+var __asyncValues = (this && this.__asyncIterator) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : o[Symbol.iterator]();
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { if (o[n]) i[n] = function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; }; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 import parsePackfile from './parse-packfile';
 import normalizeEntries from './normalize-entries';
+import pipe from './pipe';
 export default function unpack(chunks, progress) {
-    return normalizeEntries(parsePackfile(chunks, progress), progress);
+    return __asyncGenerator(this, arguments, function* unpack_1() {
+        yield __await(yield* __asyncDelegator(__asyncValues(pipe(chunks)
+            .pipe(c => parsePackfile(c, progress))
+            .pipe(c => normalizeEntries(c, progress)))));
+    });
 }
 //# sourceMappingURL=unpack.js.map

js/compose-packfile.js

@@ -1,2 +0,2 @@
-'use strict';
+"use strict";
 
@@ -7,23 +7,31 @@ Object.defineProperty(exports, "__esModule", {
 
-var _regenerator = require('babel-runtime/regenerator');
+var _regenerator = require("babel-runtime/regenerator");
 
 var _regenerator2 = _interopRequireDefault(_regenerator);
 
-var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+var _promise = require("babel-runtime/core-js/promise");
 
+var _promise2 = _interopRequireDefault(_promise);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
 var _getIterator3 = _interopRequireDefault(_getIterator2);
 
+var _symbol = require("babel-runtime/core-js/symbol");
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
 exports.default = composePackfile;
 
-var _core = require('@es-git/core');
+var _core = require("@es-git/core");
 
-var _pako = require('pako');
+var _pako = require("pako");
 
 var pako = _interopRequireWildcard(_pako);
 
-var _gitSha = require('git-sha1');
+var _gitSha = require("git-sha1");
 
 var _gitSha2 = _interopRequireDefault(_gitSha);
 
-var _types = require('./types');
+var _types = require("./types");
 
@@ -34,134 +42,187 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
 
-var _marked = /*#__PURE__*/_regenerator2.default.mark(composePackfile),
-    _marked2 = /*#__PURE__*/_regenerator2.default.mark(packFrame);
+var _marked = /*#__PURE__*/_regenerator2.default.mark(packFrame);
 
-function composePackfile(items) {
-    var hash, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, item, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, chunk;
+var __asyncValues = undefined && undefined.__asyncIterator || function (o) {
+    if (!_symbol2.default.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[_symbol2.default.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : (0, _getIterator3.default)(o);
+};
+var __await = undefined && undefined.__await || function (v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+var __asyncGenerator = undefined && undefined.__asyncGenerator || function (thisArg, _arguments, generator) {
+    if (!_symbol2.default.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []),
+        i,
+        q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[_symbol2.default.asyncIterator] = function () {
+        return this;
+    }, i;
+    function verb(n) {
+        if (g[n]) i[n] = function (v) {
+            return new _promise2.default(function (a, b) {
+                q.push([n, v, a, b]) > 1 || resume(n, v);
+            });
+        };
+    }
+    function resume(n, v) {
+        try {
+            step(g[n](v));
+        } catch (e) {
+            settle(q[0][3], e);
+        }
+    }
+    function step(r) {
+        r.value instanceof __await ? _promise2.default.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+        resume("next", value);
+    }
+    function reject(value) {
+        resume("throw", value);
+    }
+    function settle(f, v) {
+        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+    }
+};
+function composePackfile(items, count) {
+    return __asyncGenerator(this, arguments, /*#__PURE__*/_regenerator2.default.mark(function composePackfile_1() {
+        var hash, items_1, items_1_1, item, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, chunk, e_1, _a;
 
-    return _regenerator2.default.wrap(function composePackfile$(_context) {
-        while (1) {
-            switch (_context.prev = _context.next) {
-                case 0:
-                    hash = (0, _gitSha2.default)();
-                    _context.next = 3;
-                    return update(packHeader(items.length), hash);
+        return _regenerator2.default.wrap(function composePackfile_1$(_context) {
+            while (1) {
+                switch (_context.prev = _context.next) {
+                    case 0:
+                        hash = (0, _gitSha2.default)();
+                        _context.next = 3;
+                        return update(packHeader(count), hash);
 
-                case 3:
-                    _iteratorNormalCompletion = true;
-                    _didIteratorError = false;
-                    _iteratorError = undefined;
-                    _context.prev = 6;
-                    _iterator = (0, _getIterator3.default)(items);
+                    case 3:
+                        _context.prev = 3;
+                        items_1 = __asyncValues(items);
 
-                case 8:
-                    if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
-                        _context.next = 39;
-                        break;
-                    }
+                    case 5:
+                        _context.next = 7;
+                        return __await(items_1.next());
 
-                    item = _step.value;
-                    _iteratorNormalCompletion2 = true;
-                    _didIteratorError2 = false;
-                    _iteratorError2 = undefined;
-                    _context.prev = 13;
-                    _iterator2 = (0, _getIterator3.default)(packFrame(item));
+                    case 7:
+                        items_1_1 = _context.sent;
 
-                case 15:
-                    if (_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done) {
-                        _context.next = 22;
+                        if (items_1_1.done) {
+                            _context.next = 40;
+                            break;
+                        }
+
+                        _context.next = 11;
+                        return __await(items_1_1.value);
+
+                    case 11:
+                        item = _context.sent;
+                        _iteratorNormalCompletion = true;
+                        _didIteratorError = false;
+                        _iteratorError = undefined;
+                        _context.prev = 15;
+                        _iterator = (0, _getIterator3.default)(packFrame(item));
+
+                    case 17:
+                        if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
+                            _context.next = 24;
+                            break;
+                        }
+
+                        chunk = _step.value;
+                        _context.next = 21;
+                        return update(chunk, hash);
+
+                    case 21:
+                        _iteratorNormalCompletion = true;
+                        _context.next = 17;
                         break;
-                    }
 
-                    chunk = _step2.value;
-                    _context.next = 19;
-                    return update(chunk, hash);
+                    case 24:
+                        _context.next = 30;
+                        break;
 
-                case 19:
-                    _iteratorNormalCompletion2 = true;
-                    _context.next = 15;
-                    break;
+                    case 26:
+                        _context.prev = 26;
+                        _context.t0 = _context["catch"](15);
+                        _didIteratorError = true;
+                        _iteratorError = _context.t0;
 
-                case 22:
-                    _context.next = 28;
-                    break;
+                    case 30:
+                        _context.prev = 30;
+                        _context.prev = 31;
 
-                case 24:
-                    _context.prev = 24;
-                    _context.t0 = _context['catch'](13);
-                    _didIteratorError2 = true;
-                    _iteratorError2 = _context.t0;
+                        if (!_iteratorNormalCompletion && _iterator.return) {
+                            _iterator.return();
+                        }
 
-                case 28:
-                    _context.prev = 28;
-                    _context.prev = 29;
+                    case 33:
+                        _context.prev = 33;
 
-                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
-                        _iterator2.return();
-                    }
+                        if (!_didIteratorError) {
+                            _context.next = 36;
+                            break;
+                        }
 
-                case 31:
-                    _context.prev = 31;
+                        throw _iteratorError;
 
-                    if (!_didIteratorError2) {
-                        _context.next = 34;
-                        break;
-                    }
+                    case 36:
+                        return _context.finish(33);
 
-                    throw _iteratorError2;
+                    case 37:
+                        return _context.finish(30);
 
-                case 34:
-                    return _context.finish(31);
+                    case 38:
+                        _context.next = 5;
+                        break;
 
-                case 35:
-                    return _context.finish(28);
+                    case 40:
+                        _context.next = 45;
+                        break;
 
-                case 36:
-                    _iteratorNormalCompletion = true;
-                    _context.next = 8;
-                    break;
+                    case 42:
+                        _context.prev = 42;
+                        _context.t1 = _context["catch"](3);
+                        e_1 = { error: _context.t1 };
 
-                case 39:
-                    _context.next = 45;
-                    break;
+                    case 45:
+                        _context.prev = 45;
+                        _context.prev = 46;
 
-                case 41:
-                    _context.prev = 41;
-                    _context.t1 = _context['catch'](6);
-                    _didIteratorError = true;
-                    _iteratorError = _context.t1;
+                        if (!(items_1_1 && !items_1_1.done && (_a = items_1.return))) {
+                            _context.next = 50;
+                            break;
+                        }
 
-                case 45:
-                    _context.prev = 45;
-                    _context.prev = 46;
+                        _context.next = 50;
+                        return __await(_a.call(items_1));
 
-                    if (!_iteratorNormalCompletion && _iterator.return) {
-                        _iterator.return();
-                    }
+                    case 50:
+                        _context.prev = 50;
 
-                case 48:
-                    _context.prev = 48;
+                        if (!e_1) {
+                            _context.next = 53;
+                            break;
+                        }
 
-                    if (!_didIteratorError) {
-                        _context.next = 51;
-                        break;
-                    }
+                        throw e_1.error;
 
-                    throw _iteratorError;
+                    case 53:
+                        return _context.finish(50);
 
-                case 51:
-                    return _context.finish(48);
+                    case 54:
+                        return _context.finish(45);
 
-                case 52:
-                    return _context.finish(45);
+                    case 55:
+                        _context.next = 57;
+                        return (0, _core.packHash)(hash.digest());
 
-                case 53:
-                    _context.next = 55;
-                    return (0, _core.packHash)(hash.digest());
-
-                case 55:
-                case 'end':
-                    return _context.stop();
+                    case 57:
+                    case "end":
+                        return _context.stop();
+                }
             }
-        }
-    }, _marked, this, [[6, 41, 45, 53], [13, 24, 28, 36], [29,, 31, 35], [46,, 48, 52]]);
+        }, composePackfile_1, this, [[3, 42, 45, 55], [15, 26, 30, 38], [31,, 33, 37], [46,, 50, 54]]);
+    }));
 }
@@ -210,7 +271,7 @@ function update(chunk, hash) {
                 case 12:
-                case 'end':
+                case "end":
                     return _context2.stop();
             }
         }
-    }, _marked2, this);
+    }, _marked, this);
 }
@@ -217,0 +278,0 @@ // write TYPE_AND_BASE128_SIZE

js/pack.js

@@ -1,2 +0,2 @@
-'use strict';
+"use strict";
 
@@ -7,182 +7,438 @@ Object.defineProperty(exports, "__esModule", {
 
-var _regenerator = require('babel-runtime/regenerator');
+var _slicedToArray2 = require("babel-runtime/helpers/slicedToArray");
 
+var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+
+var _regenerator = require("babel-runtime/regenerator");
+
 var _regenerator2 = _interopRequireDefault(_regenerator);
 
-var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
+var _newArrowCheck2 = require("babel-runtime/helpers/newArrowCheck");
 
-var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
+var _newArrowCheck3 = _interopRequireDefault(_newArrowCheck2);
 
-var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+var _promise = require("babel-runtime/core-js/promise");
 
+var _promise2 = _interopRequireDefault(_promise);
+
+var _iterator = require("babel-runtime/core-js/symbol/iterator");
+
+var _iterator2 = _interopRequireDefault(_iterator);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
 var _getIterator3 = _interopRequireDefault(_getIterator2);
 
-var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+var _symbol = require("babel-runtime/core-js/symbol");
 
-var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+var _symbol2 = _interopRequireDefault(_symbol);
 
-exports.default = function (objects) {
-    return _core.concat.apply(undefined, (0, _toConsumableArray3.default)((0, _composePackfile2.default)([].concat((0, _toConsumableArray3.default)(toEntry(toRawObject(objects)))).sort(byType))));
-};
+exports.default = pack;
 
-var _core = require('@es-git/core');
+var _core = require("@es-git/core");
 
-var _composePackfile = require('./compose-packfile');
+var _composePackfile = require("./compose-packfile");
 
 var _composePackfile2 = _interopRequireDefault(_composePackfile);
 
-var _types = require('./types');
+var _types = require("./types");
 
+var _pipe = require("./pipe");
+
+var _pipe2 = _interopRequireDefault(_pipe);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var _marked = /*#__PURE__*/_regenerator2.default.mark(toRawObject),
-    _marked2 = /*#__PURE__*/_regenerator2.default.mark(toEntry);
+var __asyncValues = undefined && undefined.__asyncIterator || function (o) {
+    if (!_symbol2.default.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[_symbol2.default.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : (0, _getIterator3.default)(o);
+};
+var __await = undefined && undefined.__await || function (v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+var __asyncDelegator = undefined && undefined.__asyncDelegator || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) {
+        throw e;
+    }), verb("return"), i[_iterator2.default] = function () {
+        return this;
+    }, i;
+    function verb(n, f) {
+        if (o[n]) i[n] = function (v) {
+            return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
+        };
+    }
+};
+var __asyncGenerator = undefined && undefined.__asyncGenerator || function (thisArg, _arguments, generator) {
+    if (!_symbol2.default.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []),
+        i,
+        q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[_symbol2.default.asyncIterator] = function () {
+        return this;
+    }, i;
+    function verb(n) {
+        if (g[n]) i[n] = function (v) {
+            return new _promise2.default(function (a, b) {
+                q.push([n, v, a, b]) > 1 || resume(n, v);
+            });
+        };
+    }
+    function resume(n, v) {
+        try {
+            step(g[n](v));
+        } catch (e) {
+            settle(q[0][3], e);
+        }
+    }
+    function step(r) {
+        r.value instanceof __await ? _promise2.default.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+        resume("next", value);
+    }
+    function reject(value) {
+        resume("throw", value);
+    }
+    function settle(f, v) {
+        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+    }
+};
+function pack(objects, count) {
+    return __asyncGenerator(this, arguments, /*#__PURE__*/_regenerator2.default.mark(function pack_1() {
+        var _this = this;
 
+        return _regenerator2.default.wrap(function pack_1$(_context) {
+            while (1) {
+                switch (_context.prev = _context.next) {
+                    case 0:
+                        _context.t0 = __await;
+                        return _context.delegateYield(__asyncDelegator(__asyncValues((0, _pipe2.default)(objects).pipe(toRawObject).pipe(toEntry).pipe(sortByType).pipe(function (x) {
+                            (0, _newArrowCheck3.default)(this, _this);
+                            return (0, _composePackfile2.default)(x, count);
+                        }.bind(this)))), "t1", 2);
+
+                    case 2:
+                        _context.t2 = _context.t1;
+                        _context.next = 5;
+                        return (0, _context.t0)(_context.t2);
+
+                    case 5:
+                    case "end":
+                        return _context.stop();
+                }
+            }
+        }, pack_1, this);
+    }));
+}
 function toRawObject(objects) {
-    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step$value, hash, body, space, nil;
+    return __asyncGenerator(this, arguments, /*#__PURE__*/_regenerator2.default.mark(function toRawObject_1() {
+        var objects_1, objects_1_1, _ref, _ref2, hash, body, space, nil, e_1, _a;
 
-    return _regenerator2.default.wrap(function toRawObject$(_context) {
-        while (1) {
-            switch (_context.prev = _context.next) {
-                case 0:
-                    _iteratorNormalCompletion = true;
-                    _didIteratorError = false;
-                    _iteratorError = undefined;
-                    _context.prev = 3;
-                    _iterator = (0, _getIterator3.default)(objects);
+        return _regenerator2.default.wrap(function toRawObject_1$(_context2) {
+            while (1) {
+                switch (_context2.prev = _context2.next) {
+                    case 0:
+                        _context2.prev = 0;
+                        objects_1 = __asyncValues(objects);
 
-                case 5:
-                    if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
-                        _context.next = 14;
+                    case 2:
+                        _context2.next = 4;
+                        return __await(objects_1.next());
+
+                    case 4:
+                        objects_1_1 = _context2.sent;
+
+                        if (objects_1_1.done) {
+                            _context2.next = 18;
+                            break;
+                        }
+
+                        _context2.next = 8;
+                        return __await(objects_1_1.value);
+
+                    case 8:
+                        _ref = _context2.sent;
+                        _ref2 = (0, _slicedToArray3.default)(_ref, 2);
+                        hash = _ref2[0];
+                        body = _ref2[1];
+                        space = body.indexOf(0x20);
+                        nil = body.indexOf(0x00, space);
+                        _context2.next = 16;
+                        return {
+                            body: body.subarray(nil + 1),
+                            type: (0, _core.decode)(body, 0, space),
+                            hash: hash
+                        };
+
+                    case 16:
+                        _context2.next = 2;
                         break;
-                    }
 
-                    _step$value = (0, _slicedToArray3.default)(_step.value, 2), hash = _step$value[0], body = _step$value[1];
-                    space = body.indexOf(0x20);
-                    nil = body.indexOf(0x00, space);
-                    _context.next = 11;
-                    return {
-                        body: body.subarray(nil + 1),
-                        type: (0, _core.decode)(body, 0, space),
-                        hash: hash
-                    };
+                    case 18:
+                        _context2.next = 23;
+                        break;
 
-                case 11:
-                    _iteratorNormalCompletion = true;
-                    _context.next = 5;
-                    break;
+                    case 20:
+                        _context2.prev = 20;
+                        _context2.t0 = _context2["catch"](0);
+                        e_1 = { error: _context2.t0 };
 
-                case 14:
-                    _context.next = 20;
-                    break;
+                    case 23:
+                        _context2.prev = 23;
+                        _context2.prev = 24;
 
-                case 16:
-                    _context.prev = 16;
-                    _context.t0 = _context['catch'](3);
-                    _didIteratorError = true;
-                    _iteratorError = _context.t0;
+                        if (!(objects_1_1 && !objects_1_1.done && (_a = objects_1.return))) {
+                            _context2.next = 28;
+                            break;
+                        }
 
-                case 20:
-                    _context.prev = 20;
-                    _context.prev = 21;
+                        _context2.next = 28;
+                        return __await(_a.call(objects_1));
 
-                    if (!_iteratorNormalCompletion && _iterator.return) {
-                        _iterator.return();
-                    }
+                    case 28:
+                        _context2.prev = 28;
 
-                case 23:
-                    _context.prev = 23;
+                        if (!e_1) {
+                            _context2.next = 31;
+                            break;
+                        }
 
-                    if (!_didIteratorError) {
-                        _context.next = 26;
-                        break;
-                    }
+                        throw e_1.error;
 
-                    throw _iteratorError;
+                    case 31:
+                        return _context2.finish(28);
 
-                case 26:
-                    return _context.finish(23);
+                    case 32:
+                        return _context2.finish(23);
 
-                case 27:
-                    return _context.finish(20);
-
-                case 28:
-                case 'end':
-                    return _context.stop();
+                    case 33:
+                    case "end":
+                        return _context2.stop();
+                }
             }
-        }
-    }, _marked, this, [[3, 16, 20, 28], [21,, 23, 27]]);
+        }, toRawObject_1, this, [[0, 20, 23, 33], [24,, 28, 32]]);
+    }));
 }
 function toEntry(objects) {
-    var _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, object;
+    return __asyncGenerator(this, arguments, /*#__PURE__*/_regenerator2.default.mark(function toEntry_1() {
+        var objects_2, objects_2_1, object, e_2, _a;
 
-    return _regenerator2.default.wrap(function toEntry$(_context2) {
-        while (1) {
-            switch (_context2.prev = _context2.next) {
-                case 0:
-                    _iteratorNormalCompletion2 = true;
-                    _didIteratorError2 = false;
-                    _iteratorError2 = undefined;
-                    _context2.prev = 3;
-                    _iterator2 = (0, _getIterator3.default)(objects);
+        return _regenerator2.default.wrap(function toEntry_1$(_context3) {
+            while (1) {
+                switch (_context3.prev = _context3.next) {
+                    case 0:
+                        _context3.prev = 0;
+                        objects_2 = __asyncValues(objects);
 
-                case 5:
-                    if (_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done) {
-                        _context2.next = 12;
+                    case 2:
+                        _context3.next = 4;
+                        return __await(objects_2.next());
+
+                    case 4:
+                        objects_2_1 = _context3.sent;
+
+                        if (objects_2_1.done) {
+                            _context3.next = 13;
+                            break;
+                        }
+
+                        _context3.next = 8;
+                        return __await(objects_2_1.value);
+
+                    case 8:
+                        object = _context3.sent;
+                        _context3.next = 11;
+                        return {
+                            body: object.body,
+                            type: object.type === 'commit' ? _types.Type.commit : object.type === 'tree' ? _types.Type.tree : _types.Type.blob,
+                            offset: 0
+                        };
+
+                    case 11:
+                        _context3.next = 2;
                         break;
-                    }
 
-                    object = _step2.value;
-                    _context2.next = 9;
-                    return {
-                        body: object.body,
-                        type: object.type === 'commit' ? _types.Type.commit : object.type === 'tree' ? _types.Type.tree : _types.Type.blob,
-                        offset: 0
-                    };
+                    case 13:
+                        _context3.next = 18;
+                        break;
 
-                case 9:
-                    _iteratorNormalCompletion2 = true;
-                    _context2.next = 5;
-                    break;
+                    case 15:
+                        _context3.prev = 15;
+                        _context3.t0 = _context3["catch"](0);
+                        e_2 = { error: _context3.t0 };
 
-                case 12:
-                    _context2.next = 18;
-                    break;
+                    case 18:
+                        _context3.prev = 18;
+                        _context3.prev = 19;
 
-                case 14:
-                    _context2.prev = 14;
-                    _context2.t0 = _context2['catch'](3);
-                    _didIteratorError2 = true;
-                    _iteratorError2 = _context2.t0;
+                        if (!(objects_2_1 && !objects_2_1.done && (_a = objects_2.return))) {
+                            _context3.next = 23;
+                            break;
+                        }
 
-                case 18:
-                    _context2.prev = 18;
-                    _context2.prev = 19;
+                        _context3.next = 23;
+                        return __await(_a.call(objects_2));
 
-                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
-                        _iterator2.return();
-                    }
+                    case 23:
+                        _context3.prev = 23;
 
-                case 21:
-                    _context2.prev = 21;
+                        if (!e_2) {
+                            _context3.next = 26;
+                            break;
+                        }
 
-                    if (!_didIteratorError2) {
-                        _context2.next = 24;
+                        throw e_2.error;
+
+                    case 26:
+                        return _context3.finish(23);
+
+                    case 27:
+                        return _context3.finish(18);
+
+                    case 28:
+                    case "end":
+                        return _context3.stop();
+                }
+            }
+        }, toEntry_1, this, [[0, 15, 18, 28], [19,, 23, 27]]);
+    }));
+}
+function sortByType(entries) {
+    return __asyncGenerator(this, arguments, /*#__PURE__*/_regenerator2.default.mark(function sortByType_1() {
+        var commits, trees, blobs, others, entries_1, entries_1_1, entry, e_3, _a;
+
+        return _regenerator2.default.wrap(function sortByType_1$(_context4) {
+            while (1) {
+                switch (_context4.prev = _context4.next) {
+                    case 0:
+                        commits = [];
+                        trees = [];
+                        blobs = [];
+                        others = [];
+                        _context4.prev = 4;
+                        entries_1 = __asyncValues(entries);
+
+                    case 6:
+                        _context4.next = 8;
+                        return __await(entries_1.next());
+
+                    case 8:
+                        entries_1_1 = _context4.sent;
+
+                        if (entries_1_1.done) {
+                            _context4.next = 26;
+                            break;
+                        }
+
+                        _context4.next = 12;
+                        return __await(entries_1_1.value);
+
+                    case 12:
+                        entry = _context4.sent;
+                        _context4.t0 = entry.type;
+                        _context4.next = _context4.t0 === _types.Type.commit ? 16 : _context4.t0 === _types.Type.tree ? 18 : _context4.t0 === _types.Type.blob ? 20 : 22;
                         break;
-                    }
 
-                    throw _iteratorError2;
+                    case 16:
+                        commits.push(entry);
+                        return _context4.abrupt("break", 24);
 
-                case 24:
-                    return _context2.finish(21);
+                    case 18:
+                        trees.push(entry);
+                        return _context4.abrupt("break", 24);
 
-                case 25:
-                    return _context2.finish(18);
+                    case 20:
+                        blobs.push(entry);
+                        return _context4.abrupt("break", 24);
 
-                case 26:
-                case 'end':
-                    return _context2.stop();
+                    case 22:
+                        others.push(entry);
+                        return _context4.abrupt("break", 24);
+
+                    case 24:
+                        _context4.next = 6;
+                        break;
+
+                    case 26:
+                        _context4.next = 31;
+                        break;
+
+                    case 28:
+                        _context4.prev = 28;
+                        _context4.t1 = _context4["catch"](4);
+                        e_3 = { error: _context4.t1 };
+
+                    case 31:
+                        _context4.prev = 31;
+                        _context4.prev = 32;
+
+                        if (!(entries_1_1 && !entries_1_1.done && (_a = entries_1.return))) {
+                            _context4.next = 36;
+                            break;
+                        }
+
+                        _context4.next = 36;
+                        return __await(_a.call(entries_1));
+
+                    case 36:
+                        _context4.prev = 36;
+
+                        if (!e_3) {
+                            _context4.next = 39;
+                            break;
+                        }
+
+                        throw e_3.error;
+
+                    case 39:
+                        return _context4.finish(36);
+
+                    case 40:
+                        return _context4.finish(31);
+
+                    case 41:
+                        _context4.t2 = __await;
+                        return _context4.delegateYield(__asyncDelegator(__asyncValues(commits)), "t3", 43);
+
+                    case 43:
+                        _context4.t4 = _context4.t3;
+                        _context4.next = 46;
+                        return (0, _context4.t2)(_context4.t4);
+
+                    case 46:
+                        _context4.t5 = __await;
+                        return _context4.delegateYield(__asyncDelegator(__asyncValues(trees)), "t6", 48);
+
+                    case 48:
+                        _context4.t7 = _context4.t6;
+                        _context4.next = 51;
+                        return (0, _context4.t5)(_context4.t7);
+
+                    case 51:
+                        _context4.t8 = __await;
+                        return _context4.delegateYield(__asyncDelegator(__asyncValues(blobs)), "t9", 53);
+
+                    case 53:
+                        _context4.t10 = _context4.t9;
+                        _context4.next = 56;
+                        return (0, _context4.t8)(_context4.t10);
+
+                    case 56:
+                        _context4.t11 = __await;
+                        return _context4.delegateYield(__asyncDelegator(__asyncValues(others)), "t12", 58);
+
+                    case 58:
+                        _context4.t13 = _context4.t12;
+                        _context4.next = 61;
+                        return (0, _context4.t11)(_context4.t13);
+
+                    case 61:
+                    case "end":
+                        return _context4.stop();
+                }
             }
-        }
-    }, _marked2, this, [[3, 14, 18, 26], [19,, 21, 25]]);
+        }, sortByType_1, this, [[4, 28, 31, 41], [32,, 36, 40]]);
+    }));
 }
@@ -189,0 +445,0 @@ function byType(a, b) {

js/unpack.js

@@ -1,2 +0,2 @@
-'use strict';
+"use strict";
 
@@ -6,18 +6,130 @@ Object.defineProperty(exports, "__esModule", {
 });
+
+var _regenerator = require("babel-runtime/regenerator");
+
+var _regenerator2 = _interopRequireDefault(_regenerator);
+
+var _newArrowCheck2 = require("babel-runtime/helpers/newArrowCheck");
+
+var _newArrowCheck3 = _interopRequireDefault(_newArrowCheck2);
+
+var _promise = require("babel-runtime/core-js/promise");
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _iterator = require("babel-runtime/core-js/symbol/iterator");
+
+var _iterator2 = _interopRequireDefault(_iterator);
+
+var _getIterator2 = require("babel-runtime/core-js/get-iterator");
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _symbol = require("babel-runtime/core-js/symbol");
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
 exports.default = unpack;
 
-var _parsePackfile = require('./parse-packfile');
+var _parsePackfile = require("./parse-packfile");
 
 var _parsePackfile2 = _interopRequireDefault(_parsePackfile);
 
-var _normalizeEntries = require('./normalize-entries');
+var _normalizeEntries = require("./normalize-entries");
 
 var _normalizeEntries2 = _interopRequireDefault(_normalizeEntries);
 
+var _pipe = require("./pipe");
+
+var _pipe2 = _interopRequireDefault(_pipe);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+var __asyncValues = undefined && undefined.__asyncIterator || function (o) {
+    if (!_symbol2.default.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[_symbol2.default.asyncIterator];
+    return m ? m.call(o) : typeof __values === "function" ? __values(o) : (0, _getIterator3.default)(o);
+};
+var __await = undefined && undefined.__await || function (v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+};
+var __asyncDelegator = undefined && undefined.__asyncDelegator || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) {
+        throw e;
+    }), verb("return"), i[_iterator2.default] = function () {
+        return this;
+    }, i;
+    function verb(n, f) {
+        if (o[n]) i[n] = function (v) {
+            return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
+        };
+    }
+};
+var __asyncGenerator = undefined && undefined.__asyncGenerator || function (thisArg, _arguments, generator) {
+    if (!_symbol2.default.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []),
+        i,
+        q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[_symbol2.default.asyncIterator] = function () {
+        return this;
+    }, i;
+    function verb(n) {
+        if (g[n]) i[n] = function (v) {
+            return new _promise2.default(function (a, b) {
+                q.push([n, v, a, b]) > 1 || resume(n, v);
+            });
+        };
+    }
+    function resume(n, v) {
+        try {
+            step(g[n](v));
+        } catch (e) {
+            settle(q[0][3], e);
+        }
+    }
+    function step(r) {
+        r.value instanceof __await ? _promise2.default.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+        resume("next", value);
+    }
+    function reject(value) {
+        resume("throw", value);
+    }
+    function settle(f, v) {
+        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+    }
+};
 function unpack(chunks, progress) {
-    return (0, _normalizeEntries2.default)((0, _parsePackfile2.default)(chunks, progress), progress);
+    return __asyncGenerator(this, arguments, /*#__PURE__*/_regenerator2.default.mark(function unpack_1() {
+        var _this = this;
+
+        return _regenerator2.default.wrap(function unpack_1$(_context) {
+            while (1) {
+                switch (_context.prev = _context.next) {
+                    case 0:
+                        _context.t0 = __await;
+                        return _context.delegateYield(__asyncDelegator(__asyncValues((0, _pipe2.default)(chunks).pipe(function (c) {
+                            (0, _newArrowCheck3.default)(this, _this);
+                            return (0, _parsePackfile2.default)(c, progress);
+                        }.bind(this)).pipe(function (c) {
+                            (0, _newArrowCheck3.default)(this, _this);
+                            return (0, _normalizeEntries2.default)(c, progress);
+                        }.bind(this)))), "t1", 2);
+
+                    case 2:
+                        _context.t2 = _context.t1;
+                        _context.next = 5;
+                        return (0, _context.t0)(_context.t2);
+
+                    case 5:
+                    case "end":
+                        return _context.stop();
+                }
+            }
+        }, unpack_1, this);
+    }));
 }
 //# sourceMappingURL=unpack.js.map
 //# sourceMappingURL=unpack.js.map

package.json

 {
   "name": "@es-git/packfile",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "",
@@ -5,0 +5,0 @@ "main": "js/index.js",

ts/compose-packfile.ts

@@ -13,8 +13,8 @@ import {
 
-export default function *composePackfile(items : Entry[]) {
+export default async function *composePackfile(items : AsyncIterableIterator<Entry>, count : number) {
   const hash = sha1();
 
-  yield update(packHeader(items.length), hash);
+  yield update(packHeader(count), hash);
 
-  for(const item of items){
+  for await(const item of items){
     for(const chunk of packFrame(item)){
@@ -21,0 +21,0 @@ yield update(chunk, hash);

ts/pack.ts

@@ -13,11 +13,16 @@ import {
 } from './types';
+import pipe from './pipe';
 
 export type HashBlob = [string, Uint8Array];
 
-export default function(objects : Iterable<HashBlob>){
-  return concat(...composePackfile([...toEntry(toRawObject(objects))].sort(byType)));
+export default async function* pack(objects : AsyncIterableIterator<HashBlob>, count : number) : AsyncIterableIterator<Uint8Array> {
+  yield* pipe(objects)
+        .pipe(toRawObject)
+        .pipe(toEntry)
+        .pipe(sortByType)
+        .pipe(x => composePackfile(x, count));
 }
 
-function *toRawObject(objects : Iterable<HashBlob>) : IterableIterator<RawObject> {
-  for(const [hash, body] of objects){
+async function *toRawObject(objects : AsyncIterableIterator<HashBlob>) : AsyncIterableIterator<RawObject> {
+  for await(const [hash, body] of objects){
     const space = body.indexOf(0x20)
@@ -33,4 +38,4 @@ const nil = body.indexOf(0x00, space);
 
-function *toEntry(objects : IterableIterator<RawObject>) : IterableIterator<NormalEntry> {
-  for(const object of objects){
+async function *toEntry(objects : AsyncIterableIterator<RawObject>) : AsyncIterableIterator<NormalEntry> {
+  for await(const object of objects){
     yield {
@@ -46,4 +51,31 @@ body: object.body,
 
+async function* sortByType(entries : AsyncIterableIterator<NormalEntry>) {
+  const commits = [];
+  const trees = [];
+  const blobs = [];
+  const others = [];
+  for await(const entry of entries){
+    switch(entry.type){
+      case Type.commit:
+        commits.push(entry);
+        break;
+      case Type.tree:
+        trees.push(entry);
+        break;
+      case Type.blob:
+        blobs.push(entry);
+        break;
+      default:
+        others.push(entry);
+        break;
+    }
+  }
+  yield* commits;
+  yield* trees;
+  yield* blobs;
+  yield* others;
+}
+
 function byType(a : NormalEntry, b : NormalEntry) {
   return a.type - b.type;
 }

ts/unpack.ts

@@ -5,7 +5,10 @@ import { RawObject, Progress } from './types';
 import normalizeEntries from './normalize-entries';
+import pipe from './pipe';
 
 export { RawObject };
 
-export default function unpack(chunks : AsyncIterableIterator<Uint8Array>, progress? : Progress) : AsyncIterableIterator<RawObject> {
-  return normalizeEntries(parsePackfile(chunks, progress), progress);
+export default async function* unpack(chunks : AsyncIterableIterator<Uint8Array>, progress? : Progress) : AsyncIterableIterator<RawObject> {
+  yield* pipe(chunks)
+        .pipe(c => parsePackfile(c, progress))
+        .pipe(c => normalizeEntries(c, progress));
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

265370

increased by36.1%

Number of package files

75

increased by13.64%

Lines of code

3170

increased by31.32%

No dependency changes