discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@glimmer/program.js

@@ -1,405 +0,0 @@
-import '@glimmer/util';
-
-const UNRESOLVED = {};
-const WELL_KNOWN_EMPTY_ARRAY_POSITION = 0;
-const WELL_KNOW_EMPTY_ARRAY = Object.freeze([]);
-class WriteOnlyConstants {
-    constructor() {
-        // `0` means NULL
-        this.strings = [];
-        this.arrays = [WELL_KNOW_EMPTY_ARRAY];
-        this.tables = [];
-        this.handles = [];
-        this.resolved = [];
-        this.numbers = [];
-    }
-    string(value) {
-        let index = this.strings.indexOf(value);
-        if (index > -1) {
-            return index;
-        }
-        return this.strings.push(value) - 1;
-    }
-    stringArray(strings) {
-        let _strings = new Array(strings.length);
-        for (let i = 0; i < strings.length; i++) {
-            _strings[i] = this.string(strings[i]);
-        }
-        return this.array(_strings);
-    }
-    array(values) {
-        if (values.length === 0) {
-            return WELL_KNOWN_EMPTY_ARRAY_POSITION;
-        }
-        let index = this.arrays.indexOf(values);
-        if (index > -1) {
-            return index;
-        }
-        return this.arrays.push(values) - 1;
-    }
-    handle(handle) {
-        let index = this.handles.indexOf(handle);
-        if (index > -1) {
-            return index;
-        }
-        this.resolved.push(UNRESOLVED);
-        return this.handles.push(handle) - 1;
-    }
-    serializable(value) {
-        let str = JSON.stringify(value);
-        let index = this.strings.indexOf(str);
-        if (index > -1) {
-            return index;
-        }
-        return this.strings.push(str) - 1;
-    }
-    number(number) {
-        let index = this.numbers.indexOf(number);
-        if (index > -1) {
-            return index;
-        }
-        return this.numbers.push(number) - 1;
-    }
-    toPool() {
-        return {
-            strings: this.strings,
-            arrays: this.arrays,
-            handles: this.handles,
-            numbers: this.numbers
-        };
-    }
-}
-class RuntimeConstants {
-    constructor(resolver, pool) {
-        this.resolver = resolver;
-        this.strings = pool.strings;
-        this.arrays = pool.arrays;
-        this.handles = pool.handles;
-        this.resolved = this.handles.map(() => UNRESOLVED);
-        this.numbers = pool.numbers;
-    }
-    getString(value) {
-        return this.strings[value];
-    }
-    getNumber(value) {
-        return this.numbers[value];
-    }
-    getStringArray(value) {
-        let names = this.getArray(value);
-        let _names = new Array(names.length);
-        for (let i = 0; i < names.length; i++) {
-            let n = names[i];
-            _names[i] = this.getString(n);
-        }
-        return _names;
-    }
-    getArray(value) {
-        return this.arrays[value];
-    }
-    resolveHandle(index) {
-        let resolved = this.resolved[index];
-        if (resolved === UNRESOLVED) {
-            let handle = this.handles[index];
-            resolved = this.resolved[index] = this.resolver.resolve(handle);
-        }
-        return resolved;
-    }
-    getSerializable(s) {
-        return JSON.parse(this.strings[s]);
-    }
-}
-class Constants extends WriteOnlyConstants {
-    constructor(resolver, pool) {
-        super();
-        this.resolver = resolver;
-        if (pool) {
-            this.strings = pool.strings;
-            this.arrays = pool.arrays;
-            this.handles = pool.handles;
-            this.resolved = this.handles.map(() => UNRESOLVED);
-            this.numbers = pool.numbers;
-        }
-    }
-    getNumber(value) {
-        return this.numbers[value];
-    }
-    getString(value) {
-        return this.strings[value];
-    }
-    getStringArray(value) {
-        let names = this.getArray(value);
-        let _names = new Array(names.length);
-        for (let i = 0; i < names.length; i++) {
-            let n = names[i];
-            _names[i] = this.getString(n);
-        }
-        return _names;
-    }
-    getArray(value) {
-        return this.arrays[value];
-    }
-    resolveHandle(index) {
-        let resolved = this.resolved[index];
-        if (resolved === UNRESOLVED) {
-            let handle = this.handles[index];
-            resolved = this.resolved[index] = this.resolver.resolve(handle);
-        }
-        return resolved;
-    }
-    getSerializable(s) {
-        return JSON.parse(this.strings[s]);
-    }
-}
-class LazyConstants extends Constants {
-    constructor() {
-        super(...arguments);
-        this.others = [];
-        this.serializables = [];
-    }
-    serializable(value) {
-        let index = this.serializables.indexOf(value);
-        if (index > -1) {
-            return index;
-        }
-        return this.serializables.push(value) - 1;
-    }
-    getSerializable(s) {
-        return this.serializables[s];
-    }
-    getOther(value) {
-        return this.others[value - 1];
-    }
-    other(other) {
-        return this.others.push(other);
-    }
-}
-
-class Opcode {
-    constructor(heap) {
-        this.heap = heap;
-        this.offset = 0;
-    }
-    get size() {
-        let rawType = this.heap.getbyaddr(this.offset);
-        return ((rawType & 768 /* OPERAND_LEN_MASK */) >> 8 /* ARG_SHIFT */) + 1;
-    }
-    get isMachine() {
-        let rawType = this.heap.getbyaddr(this.offset);
-        return rawType & 1024 /* MACHINE_MASK */;
-    }
-    get type() {
-        return this.heap.getbyaddr(this.offset) & 255 /* TYPE_MASK */;
-    }
-    get op1() {
-        return this.heap.getbyaddr(this.offset + 1);
-    }
-    get op2() {
-        return this.heap.getbyaddr(this.offset + 2);
-    }
-    get op3() {
-        return this.heap.getbyaddr(this.offset + 3);
-    }
-}
-
-function encodeTableInfo(size, scopeSize, state) {
-    return size | scopeSize << 16 | state << 30;
-}
-function changeState(info, newState) {
-    return info | newState << 30;
-}
-const PAGE_SIZE = 0x100000;
-/**
- * The Heap is responsible for dynamically allocating
- * memory in which we read/write the VM's instructions
- * from/to. When we malloc we pass out a VMHandle, which
- * is used as an indirect way of accessing the memory during
- * execution of the VM. Internally we track the different
- * regions of the memory in an int array known as the table.
- *
- * The table 32-bit aligned and has the following layout:
- *
- * | ... | hp (u32) |       info (u32)          |
- * | ... |  Handle  | Size | Scope Size | State |
- * | ... | 32-bits  | 16b  |    14b     |  2b   |
- *
- * With this information we effectively have the ability to
- * control when we want to free memory. That being said you
- * can not free during execution as raw address are only
- * valid during the execution. This means you cannot close
- * over them as you will have a bad memory access exception.
- */
-class Heap {
-    constructor(serializedHeap) {
-        this.placeholders = [];
-        this.offset = 0;
-        this.handle = 0;
-        this.capacity = PAGE_SIZE;
-        if (serializedHeap) {
-            let { buffer, table, handle } = serializedHeap;
-            this.heap = new Uint16Array(buffer);
-            this.table = table;
-            this.offset = this.heap.length;
-            this.handle = handle;
-            this.capacity = 0;
-        } else {
-            this.heap = new Uint16Array(PAGE_SIZE);
-            this.table = [];
-        }
-    }
-    push(item) {
-        this.sizeCheck();
-        this.heap[this.offset++] = item;
-    }
-    sizeCheck() {
-        if (this.capacity === 0) {
-            let heap = slice(this.heap, 0, this.offset);
-            this.heap = new Uint16Array(heap.length + PAGE_SIZE);
-            this.heap.set(heap, 0);
-            this.capacity = PAGE_SIZE;
-        }
-        this.capacity--;
-    }
-    getbyaddr(address) {
-        return this.heap[address];
-    }
-    setbyaddr(address, value) {
-        this.heap[address] = value;
-    }
-    malloc() {
-        this.table.push(this.offset, 0);
-        let handle = this.handle;
-        this.handle += 2 /* ENTRY_SIZE */;
-        return handle;
-    }
-    finishMalloc(handle, scopeSize) {
-        let start = this.table[handle];
-        let finish = this.offset;
-        let instructionSize = finish - start;
-        let info = encodeTableInfo(instructionSize, scopeSize, 0 /* Allocated */);
-        this.table[handle + 1 /* INFO_OFFSET */] = info;
-    }
-    size() {
-        return this.offset;
-    }
-    // It is illegal to close over this address, as compaction
-    // may move it. However, it is legal to use this address
-    // multiple times between compactions.
-    getaddr(handle) {
-        return this.table[handle];
-    }
-    gethandle(address) {
-        this.table.push(address, encodeTableInfo(0, 0, 3 /* Pointer */));
-        let handle = this.handle;
-        this.handle += 2 /* ENTRY_SIZE */;
-        return handle;
-    }
-    sizeof(handle) {
-        return -1;
-    }
-    scopesizeof(handle) {
-        let info = this.table[handle + 1 /* INFO_OFFSET */];
-        return (info & 1073676288 /* SCOPE_MASK */) >> 16;
-    }
-    free(handle) {
-        let info = this.table[handle + 1 /* INFO_OFFSET */];
-        this.table[handle + 1 /* INFO_OFFSET */] = changeState(info, 1 /* Freed */);
-    }
-    /**
-     * The heap uses the [Mark-Compact Algorithm](https://en.wikipedia.org/wiki/Mark-compact_algorithm) to shift
-     * reachable memory to the bottom of the heap and freeable
-     * memory to the top of the heap. When we have shifted all
-     * the reachable memory to the top of the heap, we move the
-     * offset to the next free position.
-     */
-    compact() {
-        let compactedSize = 0;
-        let { table, table: { length }, heap } = this;
-        for (let i = 0; i < length; i += 2 /* ENTRY_SIZE */) {
-            let offset = table[i];
-            let info = table[i + 1 /* INFO_OFFSET */];
-            let size = info & 65535 /* SIZE_MASK */;
-            let state = info & 3221225472 /* STATE_MASK */ >> 30;
-            if (state === 2 /* Purged */) {
-                    continue;
-                } else if (state === 1 /* Freed */) {
-                    // transition to "already freed" aka "purged"
-                    // a good improvement would be to reuse
-                    // these slots
-                    table[i + 1 /* INFO_OFFSET */] = changeState(info, 2 /* Purged */);
-                    compactedSize += size;
-                } else if (state === 0 /* Allocated */) {
-                    for (let j = offset; j <= i + size; j++) {
-                        heap[j - compactedSize] = heap[j];
-                    }
-                    table[i] = offset - compactedSize;
-                } else if (state === 3 /* Pointer */) {
-                    table[i] = offset - compactedSize;
-                }
-        }
-        this.offset = this.offset - compactedSize;
-    }
-    pushPlaceholder(valueFunc) {
-        this.sizeCheck();
-        let address = this.offset++;
-        this.heap[address] = 65535 /* MAX_SIZE */;
-        this.placeholders.push([address, valueFunc]);
-    }
-    patchPlaceholders() {
-        let { placeholders } = this;
-        for (let i = 0; i < placeholders.length; i++) {
-            let [address, getValue] = placeholders[i];
-
-            this.setbyaddr(address, getValue());
-        }
-    }
-    capture(offset = this.offset) {
-        this.patchPlaceholders();
-        // Only called in eager mode
-        let buffer = slice(this.heap, 0, offset).buffer;
-        return {
-            handle: this.handle,
-            table: this.table,
-            buffer: buffer
-        };
-    }
-}
-class WriteOnlyProgram {
-    constructor(constants = new WriteOnlyConstants(), heap = new Heap()) {
-        this.constants = constants;
-        this.heap = heap;
-        this._opcode = new Opcode(this.heap);
-    }
-    opcode(offset) {
-        this._opcode.offset = offset;
-        return this._opcode;
-    }
-}
-class RuntimeProgram {
-    constructor(constants, heap) {
-        this.constants = constants;
-        this.heap = heap;
-        this._opcode = new Opcode(this.heap);
-    }
-    static hydrate(rawHeap, pool, resolver) {
-        let heap = new Heap(rawHeap);
-        let constants = new RuntimeConstants(resolver, pool);
-        return new RuntimeProgram(constants, heap);
-    }
-    opcode(offset) {
-        this._opcode.offset = offset;
-        return this._opcode;
-    }
-}
-class Program extends WriteOnlyProgram {}
-function slice(arr, start, end) {
-    if (arr.slice !== undefined) {
-        return arr.slice(start, end);
-    }
-    let ret = new Uint16Array(end);
-    for (; start < end; start++) {
-        ret[start] = arr[start];
-    }
-    return ret;
-}
-
-export { WELL_KNOWN_EMPTY_ARRAY_POSITION, WriteOnlyConstants, RuntimeConstants, Constants, LazyConstants, Heap, WriteOnlyProgram, RuntimeProgram, Program, Opcode };

data/dist/es/@glimmer/reference.js

@@ -1,478 +0,0 @@
-import { LinkedList, ListNode, dict } from '@glimmer/util';
-
-const CONSTANT = 0;
-const INITIAL = 1;
-const VOLATILE = NaN;
-class RevisionTag {
-    validate(snapshot) {
-        return this.value() === snapshot;
-    }
-}
-RevisionTag.id = 0;
-const VALUE = [];
-const VALIDATE = [];
-class TagWrapper {
-    constructor(type, inner) {
-        this.type = type;
-        this.inner = inner;
-    }
-    value() {
-        let func = VALUE[this.type];
-        return func(this.inner);
-    }
-    validate(snapshot) {
-        let func = VALIDATE[this.type];
-        return func(this.inner, snapshot);
-    }
-}
-function register(Type) {
-    let type = VALUE.length;
-    VALUE.push(tag => tag.value());
-    VALIDATE.push((tag, snapshot) => tag.validate(snapshot));
-    Type.id = type;
-}
-///
-// CONSTANT: 0
-VALUE.push(() => CONSTANT);
-VALIDATE.push((_tag, snapshot) => snapshot === CONSTANT);
-const CONSTANT_TAG = new TagWrapper(0, null);
-// VOLATILE: 1
-VALUE.push(() => VOLATILE);
-VALIDATE.push((_tag, snapshot) => snapshot === VOLATILE);
-const VOLATILE_TAG = new TagWrapper(1, null);
-// CURRENT: 2
-VALUE.push(() => $REVISION);
-VALIDATE.push((_tag, snapshot) => snapshot === $REVISION);
-const CURRENT_TAG = new TagWrapper(2, null);
-function isConst({ tag }) {
-    return tag === CONSTANT_TAG;
-}
-function isConstTag(tag) {
-    return tag === CONSTANT_TAG;
-}
-///
-let $REVISION = INITIAL;
-function bump() {
-    $REVISION++;
-}
-class DirtyableTag extends RevisionTag {
-    static create(revision = $REVISION) {
-        return new TagWrapper(this.id, new DirtyableTag(revision));
-    }
-    constructor(revision = $REVISION) {
-        super();
-        this.revision = revision;
-    }
-    value() {
-        return this.revision;
-    }
-    dirty() {
-        this.revision = ++$REVISION;
-    }
-}
-register(DirtyableTag);
-function combineTagged(tagged) {
-    let optimized = [];
-    for (let i = 0, l = tagged.length; i < l; i++) {
-        let tag = tagged[i].tag;
-        if (tag === VOLATILE_TAG) return VOLATILE_TAG;
-        if (tag === CONSTANT_TAG) continue;
-        optimized.push(tag);
-    }
-    return _combine(optimized);
-}
-function combineSlice(slice) {
-    let optimized = [];
-    let node = slice.head();
-    while (node !== null) {
-        let tag = node.tag;
-        if (tag === VOLATILE_TAG) return VOLATILE_TAG;
-        if (tag !== CONSTANT_TAG) optimized.push(tag);
-        node = slice.nextNode(node);
-    }
-    return _combine(optimized);
-}
-function combine(tags) {
-    let optimized = [];
-    for (let i = 0, l = tags.length; i < l; i++) {
-        let tag = tags[i];
-        if (tag === VOLATILE_TAG) return VOLATILE_TAG;
-        if (tag === CONSTANT_TAG) continue;
-        optimized.push(tag);
-    }
-    return _combine(optimized);
-}
-function _combine(tags) {
-    switch (tags.length) {
-        case 0:
-            return CONSTANT_TAG;
-        case 1:
-            return tags[0];
-        case 2:
-            return TagsPair.create(tags[0], tags[1]);
-        default:
-            return TagsCombinator.create(tags);
-    }
-}
-class CachedTag extends RevisionTag {
-    constructor() {
-        super(...arguments);
-        this.lastChecked = null;
-        this.lastValue = null;
-    }
-    value() {
-        let { lastChecked, lastValue } = this;
-        if (lastChecked !== $REVISION) {
-            this.lastChecked = $REVISION;
-            this.lastValue = lastValue = this.compute();
-        }
-        return this.lastValue;
-    }
-    invalidate() {
-        this.lastChecked = null;
-    }
-}
-class TagsPair extends CachedTag {
-    static create(first, second) {
-        return new TagWrapper(this.id, new TagsPair(first, second));
-    }
-    constructor(first, second) {
-        super();
-        this.first = first;
-        this.second = second;
-    }
-    compute() {
-        return Math.max(this.first.value(), this.second.value());
-    }
-}
-register(TagsPair);
-class TagsCombinator extends CachedTag {
-    static create(tags) {
-        return new TagWrapper(this.id, new TagsCombinator(tags));
-    }
-    constructor(tags) {
-        super();
-        this.tags = tags;
-    }
-    compute() {
-        let { tags } = this;
-        let max = -1;
-        for (let i = 0; i < tags.length; i++) {
-            let value = tags[i].value();
-            max = Math.max(value, max);
-        }
-        return max;
-    }
-}
-register(TagsCombinator);
-class UpdatableTag extends CachedTag {
-    static create(tag) {
-        return new TagWrapper(this.id, new UpdatableTag(tag));
-    }
-    constructor(tag) {
-        super();
-        this.tag = tag;
-        this.lastUpdated = INITIAL;
-    }
-    compute() {
-        return Math.max(this.lastUpdated, this.tag.value());
-    }
-    update(tag) {
-        if (tag !== this.tag) {
-            this.tag = tag;
-            this.lastUpdated = $REVISION;
-            this.invalidate();
-        }
-    }
-}
-register(UpdatableTag);
-class CachedReference {
-    constructor() {
-        this.lastRevision = null;
-        this.lastValue = null;
-    }
-    value() {
-        let { tag, lastRevision, lastValue } = this;
-        if (lastRevision === null || !tag.validate(lastRevision)) {
-            lastValue = this.lastValue = this.compute();
-            this.lastRevision = tag.value();
-        }
-        return lastValue;
-    }
-    invalidate() {
-        this.lastRevision = null;
-    }
-}
-class MapperReference extends CachedReference {
-    constructor(reference, mapper) {
-        super();
-        this.tag = reference.tag;
-        this.reference = reference;
-        this.mapper = mapper;
-    }
-    compute() {
-        let { reference, mapper } = this;
-        return mapper(reference.value());
-    }
-}
-function map(reference, mapper) {
-    return new MapperReference(reference, mapper);
-}
-//////////
-class ReferenceCache {
-    constructor(reference) {
-        this.lastValue = null;
-        this.lastRevision = null;
-        this.initialized = false;
-        this.tag = reference.tag;
-        this.reference = reference;
-    }
-    peek() {
-        if (!this.initialized) {
-            return this.initialize();
-        }
-        return this.lastValue;
-    }
-    revalidate() {
-        if (!this.initialized) {
-            return this.initialize();
-        }
-        let { reference, lastRevision } = this;
-        let tag = reference.tag;
-        if (tag.validate(lastRevision)) return NOT_MODIFIED;
-        this.lastRevision = tag.value();
-        let { lastValue } = this;
-        let value = reference.value();
-        if (value === lastValue) return NOT_MODIFIED;
-        this.lastValue = value;
-        return value;
-    }
-    initialize() {
-        let { reference } = this;
-        let value = this.lastValue = reference.value();
-        this.lastRevision = reference.tag.value();
-        this.initialized = true;
-        return value;
-    }
-}
-const NOT_MODIFIED = 'adb3b78e-3d22-4e4b-877a-6317c2c5c145';
-function isModified(value) {
-    return value !== NOT_MODIFIED;
-}
-
-class ConstReference {
-    constructor(inner) {
-        this.inner = inner;
-        this.tag = CONSTANT_TAG;
-    }
-    value() {
-        return this.inner;
-    }
-}
-
-class ListItem extends ListNode {
-    constructor(iterable, result) {
-        super(iterable.valueReferenceFor(result));
-        this.retained = false;
-        this.seen = false;
-        this.key = result.key;
-        this.iterable = iterable;
-        this.memo = iterable.memoReferenceFor(result);
-    }
-    update(item) {
-        this.retained = true;
-        this.iterable.updateValueReference(this.value, item);
-        this.iterable.updateMemoReference(this.memo, item);
-    }
-    shouldRemove() {
-        return !this.retained;
-    }
-    reset() {
-        this.retained = false;
-        this.seen = false;
-    }
-}
-class IterationArtifacts {
-    constructor(iterable) {
-        this.iterator = null;
-        this.map = dict();
-        this.list = new LinkedList();
-        this.tag = iterable.tag;
-        this.iterable = iterable;
-    }
-    isEmpty() {
-        let iterator = this.iterator = this.iterable.iterate();
-        return iterator.isEmpty();
-    }
-    iterate() {
-        let iterator;
-        if (this.iterator === null) {
-            iterator = this.iterable.iterate();
-        } else {
-            iterator = this.iterator;
-        }
-        this.iterator = null;
-        return iterator;
-    }
-    has(key) {
-        return !!this.map[key];
-    }
-    get(key) {
-        return this.map[key];
-    }
-    wasSeen(key) {
-        let node = this.map[key];
-        return node !== undefined && node.seen;
-    }
-    append(item) {
-        let { map, list, iterable } = this;
-        let node = map[item.key] = new ListItem(iterable, item);
-        list.append(node);
-        return node;
-    }
-    insertBefore(item, reference) {
-        let { map, list, iterable } = this;
-        let node = map[item.key] = new ListItem(iterable, item);
-        node.retained = true;
-        list.insertBefore(node, reference);
-        return node;
-    }
-    move(item, reference) {
-        let { list } = this;
-        item.retained = true;
-        list.remove(item);
-        list.insertBefore(item, reference);
-    }
-    remove(item) {
-        let { list } = this;
-        list.remove(item);
-        delete this.map[item.key];
-    }
-    nextNode(item) {
-        return this.list.nextNode(item);
-    }
-    head() {
-        return this.list.head();
-    }
-}
-class ReferenceIterator {
-    // if anyone needs to construct this object with something other than
-    // an iterable, let @wycats know.
-    constructor(iterable) {
-        this.iterator = null;
-        let artifacts = new IterationArtifacts(iterable);
-        this.artifacts = artifacts;
-    }
-    next() {
-        let { artifacts } = this;
-        let iterator = this.iterator = this.iterator || artifacts.iterate();
-        let item = iterator.next();
-        if (item === null) return null;
-        return artifacts.append(item);
-    }
-}
-var Phase;
-(function (Phase) {
-    Phase[Phase["Append"] = 0] = "Append";
-    Phase[Phase["Prune"] = 1] = "Prune";
-    Phase[Phase["Done"] = 2] = "Done";
-})(Phase || (Phase = {}));
-class IteratorSynchronizer {
-    constructor({ target, artifacts }) {
-        this.target = target;
-        this.artifacts = artifacts;
-        this.iterator = artifacts.iterate();
-        this.current = artifacts.head();
-    }
-    sync() {
-        let phase = Phase.Append;
-        while (true) {
-            switch (phase) {
-                case Phase.Append:
-                    phase = this.nextAppend();
-                    break;
-                case Phase.Prune:
-                    phase = this.nextPrune();
-                    break;
-                case Phase.Done:
-                    this.nextDone();
-                    return;
-            }
-        }
-    }
-    advanceToKey(key) {
-        let { current, artifacts } = this;
-        let seek = current;
-        while (seek !== null && seek.key !== key) {
-            seek.seen = true;
-            seek = artifacts.nextNode(seek);
-        }
-        if (seek !== null) {
-            this.current = artifacts.nextNode(seek);
-        }
-    }
-    nextAppend() {
-        let { iterator, current, artifacts } = this;
-        let item = iterator.next();
-        if (item === null) {
-            return this.startPrune();
-        }
-        let { key } = item;
-        if (current !== null && current.key === key) {
-            this.nextRetain(item);
-        } else if (artifacts.has(key)) {
-            this.nextMove(item);
-        } else {
-            this.nextInsert(item);
-        }
-        return Phase.Append;
-    }
-    nextRetain(item) {
-        let { artifacts, current } = this;
-        current = current;
-        current.update(item);
-        this.current = artifacts.nextNode(current);
-        this.target.retain(item.key, current.value, current.memo);
-    }
-    nextMove(item) {
-        let { current, artifacts, target } = this;
-        let { key } = item;
-        let found = artifacts.get(item.key);
-        found.update(item);
-        if (artifacts.wasSeen(item.key)) {
-            artifacts.move(found, current);
-            target.move(found.key, found.value, found.memo, current ? current.key : null);
-        } else {
-            this.advanceToKey(key);
-        }
-    }
-    nextInsert(item) {
-        let { artifacts, target, current } = this;
-        let node = artifacts.insertBefore(item, current);
-        target.insert(node.key, node.value, node.memo, current ? current.key : null);
-    }
-    startPrune() {
-        this.current = this.artifacts.head();
-        return Phase.Prune;
-    }
-    nextPrune() {
-        let { artifacts, target, current } = this;
-        if (current === null) {
-            return Phase.Done;
-        }
-        let node = current;
-        this.current = artifacts.nextNode(node);
-        if (node.shouldRemove()) {
-            artifacts.remove(node);
-            target.delete(node.key);
-        } else {
-            node.reset();
-        }
-        return Phase.Prune;
-    }
-    nextDone() {
-        this.target.done();
-    }
-}
-
-export { ConstReference, ListItem, IterationArtifacts, ReferenceIterator, IteratorSynchronizer, CONSTANT, INITIAL, VOLATILE, RevisionTag, TagWrapper, CONSTANT_TAG, VOLATILE_TAG, CURRENT_TAG, isConst, isConstTag, bump, DirtyableTag, combineTagged, combineSlice, combine, CachedTag, UpdatableTag, CachedReference, map, ReferenceCache, isModified };