@fluidframework/matrix 0.59.2001 → 0.59.3000

package/dist/bspSet.d.ts

@@ -117,8 +117,8 @@ export declare function except<Key extends Cachable<Key>, Id>(left: BspSet<Key,
 export declare function combineCmp(left: -1 | 0 | 1 | undefined, right: -1 | 0 | 1 | undefined): 0 | 1 | -1 | undefined;
 export declare function compareUntyped<Key extends Cachable<Key>, Id>(setOperations: SetOperations<Key, Id>, left: UntypedBspSet<Key>, right: UntypedBspSet<Key>): -1 | 0 | 1 | undefined;
 export declare function compare<Key extends Cachable<Key>, Id>(left: BspSet<Key, Id>, right: BspSet<Key, Id>): 0 | 1 | -1 | undefined;
-export declare const symmetricDiff: <Key extends Disjoint<keyof Key, "depth" | "split">, Id>(left: BspSet<Key, Id>, right: BspSet<Key, Id>) => BspSet<Key, Id>;
-export declare const complement: <Key extends Disjoint<keyof Key, "depth" | "split">, Id>(set: BspSet<Key, Id>) => BspSet<Key, Id>;
+export declare const symmetricDiff: <Key extends Disjoint<keyof Key, keyof KeyCache<T>>, Id>(left: BspSet<Key, Id>, right: BspSet<Key, Id>) => BspSet<Key, Id>;
+export declare const complement: <Key extends Disjoint<keyof Key, keyof KeyCache<T>>, Id>(set: BspSet<Key, Id>) => BspSet<Key, Id>;
 export declare function getNodeCount<Key extends Cachable<Key>, Id>(set: BspSet<Key, Id>): number;
 export declare function forEachKey<Key extends Cachable<Key>, Id>(set: Empty | Sparse<Key, Id>, f: (key: Key) => boolean): boolean;
 export {};

package/dist/bspSet.js

@@ -68,7 +68,7 @@ function lazy(setOperations, pathKey, key) {
 }
 exports.lazy = lazy;
 function createFromKey(uncachedSetOperations) {
-    const setOperations = Object.assign(Object.assign({}, uncachedSetOperations), { split: exports.cacheKeySplitting(uncachedSetOperations.split, uncachedSetOperations.top) });
+    const setOperations = Object.assign(Object.assign({}, uncachedSetOperations), { split: (0, exports.cacheKeySplitting)(uncachedSetOperations.split, uncachedSetOperations.top) });
     return (key) => fromUntyped(setOperations, lazy(setOperations, setOperations.top, key));
 }
 exports.createFromKey = createFromKey;

package/dist/bspSet.js.map

@@ -1 +1 @@
-{"version":3,"file":"bspSet.js","sourceRoot":"","sources":["../src/bspSet.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { __assign } from \"tslib\";\n/** An interface for representing a readonly pair */\nexport type Pair<S, T = S> = readonly [S, T];\n\nexport const pair = <S, T = S>(left: S, right: T): Pair<S, T> => [left, right];\n\n// using this polyfill, because `Object.assign` is not supported in IE.\nconst ObjectAssign: typeof Object.assign = __assign;\n\nexport enum SetKind {\n    Dense,\n    Empty,\n}\n\ninterface TreeNode<Left, Right> {\n    readonly left: Left;\n    readonly right: Right;\n}\n\ninterface KeyNode<Key, Exact> {\n    readonly key: Key;\n    readonly pathKey: Key;\n    readonly isExact: Exact;\n}\n\nexport type Empty = SetKind.Empty;\n\n/** The term *Dense* means that a given subset contains all the elements of its particular\n * bounds. E.g. the whole set would be dense w.r.t. the bounds of the whole space. Or\n * if a set represents an interval [a, b), then it would be dense, if there are no holes in it,\n * i.e. the set is represented exactly using the current bounds.\n */\nexport type Dense = SetKind.Dense;\n\nexport const dense = SetKind.Dense;\nexport const empty = SetKind.Empty;\n\ntype KeyUnexact<Key> = KeyNode<Key, false>;\n\n/** In the BSP-set, each node carries with it implicit bounds just by the position in the tree.\n * Furthermore, it can carry around a key. The key can either be an approximation, i.e. an upper bound\n * or it can be *exact*. Exact means, that the whole set can be exactly represented in terms of just the key.\n *\n * One might wonder, why we don't prune the tree at this point. This has to do with the fact that we are\n * representing arbitrary sets and so even though one of two sets could be represented exactly the other\n * might not be able to yet. In this case we need to unfold the key by splitting further. In order to avoid\n * excessive splitting and pruning, we just carry around the key but allow the tree to also be materialized, on-demand.\n */\ntype KeyExact<Key> = KeyNode<Key, true>;\n\ntype KeyUndefined = KeyNode<undefined, false>;\ntype KeyDefined<Key> = KeyUnexact<Key> | KeyExact<Key>;\n\ntype BalancePropertyHelper<Key, Left, Right> = TreeNode<UntypedSparse<Key> | Left, UntypedSparse<Key> | Right>;\n\ntype TreeDefined<Key> =\n    | BalancePropertyHelper<Key, Empty, Dense>\n    | BalancePropertyHelper<Key, Dense, Empty>;\ntype TreeUndefined = TreeNode<undefined, undefined>;\n\ntype KeyDefinednessProperty<Key> = KeyDefined<Key> | KeyUndefined;\n\nexport type UntypedSparse<Key> =\n    | (KeyDefinednessProperty<Key> & TreeDefined<Key>)\n    | (KeyDefined<Key> & TreeUndefined);\n/** The term *untyped* refers to the tree representation of a BSP set. Because BSP set trees are only compared in terms\n * of their structure, we need to ensure that cuts occur at the same exact points across all possible sets. This is\n * enforced by the fact, that at construction time, we attach an `Id` to each BSP set and only allow operations to\n * occur on sets with the same `Id`.\n *\n * The BSP set becomes *untyped*, when we drop that `Id`; now it is possible to operate on sets that are incompatible.\n * Doing this, however, allows us to store the set operations only once per set as opposed to carrying them around with\n * every node.\n */\nexport type UntypedBspSet<Key> = Empty | Dense | UntypedSparse<Key>;\n\n/** A set is considred *sparse*, if we know that w.r.t. to it's bounds it is neither empty, nor dense. */\ninterface Sparse<Key extends Cachable<Key>, Id> {\n    setOperations: SetOperations<Key, Id>;\n    root: UntypedSparse<Key>;\n}\nexport type BspSet<Key extends Cachable<Key>, Id> =\n    | Empty\n    | Dense\n    | Sparse<Key, Id>;\n\nexport interface KeyCache<T> {\n    depth?: number;\n    split?: Pair<Pair<CachedKey<T>, number>>;\n}\nexport type CachedKey<T> = T & KeyCache<T>;\nexport type Cachable<T> = Disjoint<keyof T, keyof KeyCache<T>>;\n\nexport type Disjoint<T, U> = [T, U] extends [Exclude<T, U>, Exclude<U, T>]\n    ? any\n    : never;\nexport type RequireAtLeastOne<T> = {\n    [K in keyof T]-?: Required<Pick<T, K>> &\n    Partial<Pick<T, Exclude<keyof T, K>>>;\n}[keyof T];\n\n/** This is a concrete set operations implementation, tagged with an arbitrary id. */\nexport interface SetOperations<Key extends Cachable<Key>, Id> {\n    /** Id here is just a phantom type, so that we can associate the various set instances together */\n    readonly id: Id;\n\n    /** Split the key into two. This will only be called when the current key is incomparable with an element.\n     * E.g. this would never be called if the key is already a 1x1 rectangle. */\n    readonly split: (key: CachedKey<Key>) => Pair<Pair<CachedKey<Key>, number>>;\n\n    /** Tells, if a given key can be split further */\n    readonly canSplit: (key: CachedKey<Key>) => boolean;\n\n    /** Tells if two keys overlap at all. */\n    readonly meets: (key1: Key, key2: Key) => boolean;\n\n    /** Intersect the keys, if it is possible to exactly respresent their intersection.\n     * An implementation is never required to compute the intersection as this is just an optimization.\n     * Precondition: It is guaranteed that the keys meet and that they are incomparable.\n     */\n    readonly intersect: (key1: Key, key2: Key) => Key | undefined;\n\n    /** Unions the keys, if it is possible to exactly represent their union.\n     * An implementation is never required to compute the union as this is just an optimization.\n     * Precondition: It is guaranteed that the keys are incomparable.\n     */\n    readonly union: (key1: Key, key2: Key) => Key | undefined;\n\n    /** Computes the set difference between two keys, if it is possible to exactly represent their set difference.\n     * An implementation is never required to compute the difference as this is just an optimization.\n     * Precondition: It is guaranteed that the keys meet.\n     */\n    readonly except: (key1: Key, key2: Key) => Key | undefined;\n\n    /** Compare two keys */\n    readonly compare: (key1: Key, key2: Key) => -1 | 0 | 1 | undefined;\n\n    /** The top element of the set. */\n    readonly top: Key;\n}\n\nexport const cacheKeySplitting = <Key>(\n    splitFunction: (key: CachedKey<Key>) => Pair<Pair<CachedKey<Key>, number>>,\n    top: CachedKey<Key>,\n    maxDepth: number = 10,\n) => (key: CachedKey<Key>) => {\n    if (key.split !== undefined) {\n        return key.split;\n    }\n\n    const split = splitFunction(key);\n    const depth = key === top ? 0 : key.depth;\n    if (depth !== undefined && depth < maxDepth) {\n        key.split = split;\n        split[0][0].depth = depth + 1;\n        split[1][0].depth = depth + 1;\n    }\n\n    return split;\n};\n\nexport function fromUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    root: UntypedBspSet<Key>,\n): BspSet<Key, Id> {\n    if (root === empty || root === dense) { return root; }\n    return { setOperations, root };\n}\n\nconst sparse = <Key, Exact, Left, Right>(\n    left: Left,\n    right: Right,\n    pathKey: Key,\n    key: Key,\n    isExact: Exact,\n) => ({ key, pathKey, left, right, isExact });\n\nfunction fromKey<Key>(\n    pathKey: Key,\n    key: Key,\n    isExact: boolean,\n): UntypedSparse<Key> {\n    if (isExact) {\n        return sparse(undefined, undefined, pathKey, key, true as const);\n    }\n\n    return sparse(undefined, undefined, pathKey, key, false as const);\n}\n\nexport function lazy<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    pathKey: Key,\n    key: Key,\n): UntypedBspSet<Key> {\n    if (!setOperations.meets(pathKey, key)) { return empty; }\n    const cmp = setOperations.compare(pathKey, key);\n    if (cmp !== undefined) {\n        if (cmp <= 0) { return dense; }\n\n        return fromKey(pathKey, key, true);\n    }\n\n    // this is not exactly necessary, but increases the amount of exact nodes and thus we can often\n    // prune earlier.\n    // Also, having intersect always work guarantees exact nodes, thus allowing for more efficient\n    // storage and computation.\n    const newKey = setOperations.intersect(pathKey, key);\n\n    if (newKey !== undefined) {\n        return fromKey(pathKey, newKey, true);\n    }\n\n    return fromKey(pathKey, key, false);\n}\n\nexport function createFromKey<Key extends Cachable<Key>, Id>(\n    uncachedSetOperations: SetOperations<Key, Id>,\n) {\n    const setOperations = {\n        ...uncachedSetOperations,\n        split: cacheKeySplitting(\n            uncachedSetOperations.split,\n            uncachedSetOperations.top,\n        ),\n    };\n    return (key: Key) =>\n        fromUntyped(setOperations, lazy(setOperations, setOperations.top, key));\n}\n\nfunction unionExact<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key> & KeyExact<Key>,\n    right: UntypedBspSet<Key> & KeyExact<Key>,\n) {\n    const { pathKey, key: leftKey } = left;\n    const { key: rightKey } = right;\n\n    const cmp = setOperations.compare(leftKey, rightKey);\n    if (cmp !== undefined) {\n        return cmp < 0 ? right : left;\n    }\n\n    const combinedKey = setOperations.union(leftKey, rightKey);\n    if (combinedKey !== undefined) {\n        const combinedCmp = setOperations.compare(combinedKey, pathKey);\n        if (combinedCmp !== undefined && combinedCmp === 0) { return dense; }\n        return fromKey(pathKey, combinedKey, true);\n    }\n    return undefined;\n}\n\n/** This is an local combination, not a proper union. We use it to have simpler code elsewhere */\nfunction combineChildren<Key>(\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): Empty | Dense | (UntypedSparse<Key> & TreeDefined<Key>) {\n    if (left === empty) {\n        if (right === empty) {\n            return empty;\n        }\n\n        return sparse(left, right, undefined, undefined, false as const);\n    }\n\n    if (right === empty) {\n        return sparse(left, right, undefined, undefined, false as const);\n    }\n\n    if (left === dense) {\n        if (right === dense) {\n            return dense;\n        }\n        return sparse(left, right, undefined, undefined, false as const);\n    }\n\n    return sparse(left, right, undefined, undefined, false as const);\n}\n\nfunction materialize<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    set: UntypedSparse<Key>,\n): UntypedSparse<Key> & TreeDefined<Key> {\n    if (set.left !== undefined) {\n        return set;\n    }\n\n    const [[left], [right]] = setOperations.split(set.pathKey);\n    const lChild = lazy(setOperations, left, set.key);\n    const rChild = lazy(setOperations, right, set.key);\n\n    const res = combineChildren<Key>(lChild, rChild);\n\n    if (res === empty || res === dense) {\n        throw new Error(\"incorrect set operations implementation\");\n    }\n\n    // first check, that res actually has the desired type\n    const typeCheck: TreeDefined<Key> = res;\n\n    const setAlias: UntypedSparse<Key> = set;\n    return ObjectAssign(setAlias, {\n        left: typeCheck.left,\n        right: typeCheck.right,\n    });\n}\n\nexport function unionUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): UntypedBspSet<Key> {\n    if (right === empty) { return left; }\n    if (right === dense) { return right; }\n    if (left === empty) { return right; }\n    if (left === dense) { return left; }\n\n    if (left.isExact && right.isExact) {\n        const res = unionExact<Key, Id>(setOperations, left, right);\n        if (res !== undefined) { return res; }\n    }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    const lChild = unionUntyped(setOperations, newLeft.left, newRight.left);\n    const rChild = unionUntyped(setOperations, newLeft.right, newRight.right);\n\n    return combineChildren(lChild, rChild);\n}\n\nexport function union<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): BspSet<Key, Id> {\n    if (right === empty) { return left; }\n    if (right === dense) { return right; }\n    if (left === empty) { return right; }\n    if (left === dense) { return left; }\n\n    return fromUntyped(\n        left.setOperations,\n        unionUntyped<Key, Id>(left.setOperations, left.root, right.root),\n    );\n}\n\nfunction intersectExact<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key> & KeyExact<Key>,\n    right: UntypedBspSet<Key> & KeyExact<Key>,\n) {\n    const { pathKey, key: leftKey } = left;\n    const { key: rightKey } = right;\n\n    if (!setOperations.meets(leftKey, rightKey)) {\n        return empty;\n    }\n\n    const cmp = setOperations.compare(leftKey, rightKey);\n    if (cmp !== undefined) {\n        return cmp < 0 ? left : right;\n    }\n\n    const combinedKey = setOperations.intersect(leftKey, rightKey);\n    if (combinedKey !== undefined) {\n        return fromKey(pathKey, combinedKey, true);\n    }\n\n    return undefined;\n}\n\nexport function intersectUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): UntypedBspSet<Key> {\n    if (left === empty) { return left; }\n    if (right === empty) { return right; }\n    if (left === dense) { return right; }\n    if (right === dense) { return left; }\n\n    if (left.isExact && right.isExact) {\n        const res = intersectExact<Key, Id>(setOperations, left, right);\n        if (res !== undefined) { return res; }\n    }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    const lChild = intersectUntyped(setOperations, newLeft.left, newRight.left);\n    const rChild = intersectUntyped(\n        setOperations,\n        newLeft.right,\n        newRight.right,\n    );\n\n    return combineChildren(lChild, rChild);\n}\n\nexport function intersect<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): BspSet<Key, Id> {\n    if (left === empty) { return left; }\n    if (right === empty) { return right; }\n    if (left === dense) { return right; }\n    if (right === dense) { return left; }\n\n    return fromUntyped(\n        left.setOperations,\n        intersectUntyped<Key, Id>(left.setOperations, left.root, right.root),\n    );\n}\n\nexport function meetsUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): boolean {\n    if (left === empty || right === empty) { return false; }\n    if (left === dense || right === dense) { return true; }\n    if (left.isExact && right.isExact) { return setOperations.meets(left.key, right.key); }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    return (\n        meetsUntyped(setOperations, newLeft.left, newRight.left) ||\n        meetsUntyped(setOperations, newLeft.right, newRight.right)\n    );\n}\n\nexport function meets<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): boolean {\n    if (left === empty || right === empty) { return false; }\n    if (left === dense || right === dense) { return true; }\n    return meetsUntyped<Key, Id>(left.setOperations, left.root, right.root);\n}\n\nfunction exceptExact<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedSparse<Key> & KeyExact<Key>,\n    right: KeyExact<Key>,\n) {\n    const { pathKey, key: leftKey } = left;\n    const { key: rightKey } = right;\n\n    if (!setOperations.meets(leftKey, rightKey)) {\n        return left;\n    }\n\n    const combinedKey = setOperations.except(leftKey, rightKey);\n    if (combinedKey !== undefined) {\n        return fromKey(pathKey, combinedKey, true);\n    }\n\n    return undefined;\n}\n\nexport function exceptUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): UntypedBspSet<Key> {\n    if (left === empty) { return left; }\n    if (right === empty) { return left; }\n    if (right === dense) { return empty; }\n    if (left === dense) {\n        const newRight_inner = materialize<Key, Id>(setOperations, right);\n        const lChild_inner = exceptUntyped(setOperations, dense, newRight_inner.left);\n        const rChild_inner = exceptUntyped(setOperations, dense, newRight_inner.right);\n        return combineChildren(lChild_inner, rChild_inner);\n    }\n    if (left.isExact && right.isExact) {\n        const res = exceptExact<Key, Id>(setOperations, left, right);\n        if (res !== undefined) { return res; }\n    }\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    const lChild = exceptUntyped(setOperations, newLeft.left, newRight.left);\n    const rChild = exceptUntyped(setOperations, newLeft.right, newRight.right);\n\n    return combineChildren(lChild, rChild);\n}\n\nexport function except<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): BspSet<Key, Id> {\n    if (left === empty) { return left; }\n    if (right === empty) { return left; }\n    if (right === dense) { return empty; }\n    if (left === dense) {\n        return fromUntyped(\n            right.setOperations,\n            exceptUntyped<Key, Id>(right.setOperations, left, right.root),\n        );\n    }\n\n    return fromUntyped(\n        left.setOperations,\n        exceptUntyped<Key, Id>(left.setOperations, left.root, right.root),\n    );\n}\n\nconst compareExact = <Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: KeyExact<Key>,\n    right: KeyExact<Key>,\n) => setOperations.compare(left.key, right.key);\n\nexport function combineCmp(\n    left: -1 | 0 | 1 | undefined,\n    right: -1 | 0 | 1 | undefined,\n) {\n    if (left === undefined || right === undefined) { return undefined; }\n    if (left === 0) { return right; }\n    if (right === 0) { return left; }\n    return left === right ? left : undefined;\n}\n\nexport function compareUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): -1 | 0 | 1 | undefined {\n    if (left === right) { return 0; }\n\n    if (left === empty) {\n        return -1;\n    }\n\n    if (right === empty) {\n        return 1;\n    }\n\n    if (left === dense) {\n        if (right === dense) {\n            return 0;\n        }\n\n        return 1;\n    }\n\n    if (right === dense) {\n        return -1;\n    }\n\n    if (left.isExact && right.isExact) {\n        return compareExact(setOperations, left, right);\n    }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n    const lCmp = compareUntyped(setOperations, newLeft.left, newRight.left);\n    if (lCmp === undefined) { return undefined; }\n\n    const rCmp = compareUntyped(setOperations, newLeft.right, newRight.right);\n\n    if (rCmp === undefined) { return undefined; }\n\n    return combineCmp(lCmp, rCmp);\n}\n\nexport function compare<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n) {\n    if (left === right) { return 0; }\n\n    if (left === empty) {\n        return -1;\n    }\n\n    if (right === empty) {\n        return 1;\n    }\n\n    if (left === dense) {\n        if (right === dense) {\n            return 0;\n        }\n\n        return 1;\n    }\n\n    if (right === dense) {\n        return -1;\n    }\n\n    return compareUntyped<Key, Id>(left.setOperations, left.root, right.root);\n}\n\nexport const symmetricDiff = <Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n) => union(except(left, right), except(right, left));\n\nexport const complement = <Key extends Cachable<Key>, Id>(\n    set: BspSet<Key, Id>,\n) => except(dense, set);\n\nfunction getNodeCountUntyped<T>(set: UntypedBspSet<T> | undefined): number {\n    if (set === undefined || set === empty || set === dense) {\n        return 0;\n    }\n\n    return getNodeCountUntyped(set.left) + getNodeCountUntyped(set.right) + 1;\n}\n\nexport function getNodeCount<Key extends Cachable<Key>, Id>(\n    set: BspSet<Key, Id>,\n) {\n    if (set === empty || set === dense) { return 0; }\n    return getNodeCountUntyped(set.root);\n}\n\nfunction forEachKeyUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    set: UntypedBspSet<Key>,\n    f: (key: Key) => boolean,\n): boolean {\n    function loop(pathKey: Key, set_inner: UntypedBspSet<Key>): boolean {\n        if (set_inner === empty) { return true; }\n        if (set_inner === dense) { return f(pathKey); }\n        if (set_inner.isExact) { return f(set_inner.key); }\n\n        const newSet = materialize<Key, Id>(setOperations, set_inner);\n        const [[left], [right]] = setOperations.split(pathKey);\n        return loop(left, newSet.left) && loop(right, newSet.right);\n    }\n\n    return loop(setOperations.top, set);\n}\n\nexport function forEachKey<Key extends Cachable<Key>, Id>(\n    set: Empty | Sparse<Key, Id>,\n    f: (key: Key) => boolean,\n): boolean {\n    if (set === empty) { return true; }\n    return forEachKeyUntyped(set.setOperations, set.root, f);\n}\n"]}
+{"version":3,"file":"bspSet.js","sourceRoot":"","sources":["../src/bspSet.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { __assign } from \"tslib\";\n/** An interface for representing a readonly pair */\nexport type Pair<S, T = S> = readonly [S, T];\n\nexport const pair = <S, T = S>(left: S, right: T): Pair<S, T> => [left, right];\n\n// using this polyfill, because `Object.assign` is not supported in IE.\nconst ObjectAssign: typeof Object.assign = __assign;\n\nexport enum SetKind {\n    Dense,\n    Empty,\n}\n\ninterface TreeNode<Left, Right> {\n    readonly left: Left;\n    readonly right: Right;\n}\n\ninterface KeyNode<Key, Exact> {\n    readonly key: Key;\n    readonly pathKey: Key;\n    readonly isExact: Exact;\n}\n\nexport type Empty = SetKind.Empty;\n\n/** The term *Dense* means that a given subset contains all the elements of its particular\n * bounds. E.g. the whole set would be dense w.r.t. the bounds of the whole space. Or\n * if a set represents an interval [a, b), then it would be dense, if there are no holes in it,\n * i.e. the set is represented exactly using the current bounds.\n */\nexport type Dense = SetKind.Dense;\n\nexport const dense = SetKind.Dense;\nexport const empty = SetKind.Empty;\n\ntype KeyUnexact<Key> = KeyNode<Key, false>;\n\n/** In the BSP-set, each node carries with it implicit bounds just by the position in the tree.\n * Furthermore, it can carry around a key. The key can either be an approximation, i.e. an upper bound\n * or it can be *exact*. Exact means, that the whole set can be exactly represented in terms of just the key.\n *\n * One might wonder, why we don't prune the tree at this point. This has to do with the fact that we are\n * representing arbitrary sets and so even though one of two sets could be represented exactly the other\n * might not be able to yet. In this case we need to unfold the key by splitting further. In order to avoid\n * excessive splitting and pruning, we just carry around the key but allow the tree to also be materialized, on-demand.\n */\ntype KeyExact<Key> = KeyNode<Key, true>;\n\ntype KeyUndefined = KeyNode<undefined, false>;\ntype KeyDefined<Key> = KeyUnexact<Key> | KeyExact<Key>;\n\ntype BalancePropertyHelper<Key, Left, Right> = TreeNode<UntypedSparse<Key> | Left, UntypedSparse<Key> | Right>;\n\ntype TreeDefined<Key> =\n    | BalancePropertyHelper<Key, Empty, Dense>\n    | BalancePropertyHelper<Key, Dense, Empty>;\ntype TreeUndefined = TreeNode<undefined, undefined>;\n\ntype KeyDefinednessProperty<Key> = KeyDefined<Key> | KeyUndefined;\n\nexport type UntypedSparse<Key> =\n    | (KeyDefinednessProperty<Key> & TreeDefined<Key>)\n    | (KeyDefined<Key> & TreeUndefined);\n/** The term *untyped* refers to the tree representation of a BSP set. Because BSP set trees are only compared in terms\n * of their structure, we need to ensure that cuts occur at the same exact points across all possible sets. This is\n * enforced by the fact, that at construction time, we attach an `Id` to each BSP set and only allow operations to\n * occur on sets with the same `Id`.\n *\n * The BSP set becomes *untyped*, when we drop that `Id`; now it is possible to operate on sets that are incompatible.\n * Doing this, however, allows us to store the set operations only once per set as opposed to carrying them around with\n * every node.\n */\nexport type UntypedBspSet<Key> = Empty | Dense | UntypedSparse<Key>;\n\n/** A set is considred *sparse*, if we know that w.r.t. to it's bounds it is neither empty, nor dense. */\ninterface Sparse<Key extends Cachable<Key>, Id> {\n    setOperations: SetOperations<Key, Id>;\n    root: UntypedSparse<Key>;\n}\nexport type BspSet<Key extends Cachable<Key>, Id> =\n    | Empty\n    | Dense\n    | Sparse<Key, Id>;\n\nexport interface KeyCache<T> {\n    depth?: number;\n    split?: Pair<Pair<CachedKey<T>, number>>;\n}\nexport type CachedKey<T> = T & KeyCache<T>;\nexport type Cachable<T> = Disjoint<keyof T, keyof KeyCache<T>>;\n\nexport type Disjoint<T, U> = [T, U] extends [Exclude<T, U>, Exclude<U, T>]\n    ? any\n    : never;\nexport type RequireAtLeastOne<T> = {\n    [K in keyof T]-?: Required<Pick<T, K>> &\n    Partial<Pick<T, Exclude<keyof T, K>>>;\n}[keyof T];\n\n/** This is a concrete set operations implementation, tagged with an arbitrary id. */\nexport interface SetOperations<Key extends Cachable<Key>, Id> {\n    /** Id here is just a phantom type, so that we can associate the various set instances together */\n    readonly id: Id;\n\n    /** Split the key into two. This will only be called when the current key is incomparable with an element.\n     * E.g. this would never be called if the key is already a 1x1 rectangle. */\n    readonly split: (key: CachedKey<Key>) => Pair<Pair<CachedKey<Key>, number>>;\n\n    /** Tells, if a given key can be split further */\n    readonly canSplit: (key: CachedKey<Key>) => boolean;\n\n    /** Tells if two keys overlap at all. */\n    readonly meets: (key1: Key, key2: Key) => boolean;\n\n    /** Intersect the keys, if it is possible to exactly respresent their intersection.\n     * An implementation is never required to compute the intersection as this is just an optimization.\n     * Precondition: It is guaranteed that the keys meet and that they are incomparable.\n     */\n    readonly intersect: (key1: Key, key2: Key) => Key | undefined;\n\n    /** Unions the keys, if it is possible to exactly represent their union.\n     * An implementation is never required to compute the union as this is just an optimization.\n     * Precondition: It is guaranteed that the keys are incomparable.\n     */\n    readonly union: (key1: Key, key2: Key) => Key | undefined;\n\n    /** Computes the set difference between two keys, if it is possible to exactly represent their set difference.\n     * An implementation is never required to compute the difference as this is just an optimization.\n     * Precondition: It is guaranteed that the keys meet.\n     */\n    readonly except: (key1: Key, key2: Key) => Key | undefined;\n\n    /** Compare two keys */\n    readonly compare: (key1: Key, key2: Key) => -1 | 0 | 1 | undefined;\n\n    /** The top element of the set. */\n    readonly top: Key;\n}\n\nexport const cacheKeySplitting = <Key>(\n    splitFunction: (key: CachedKey<Key>) => Pair<Pair<CachedKey<Key>, number>>,\n    top: CachedKey<Key>,\n    maxDepth: number = 10,\n) => (key: CachedKey<Key>) => {\n    if (key.split !== undefined) {\n        return key.split;\n    }\n\n    const split = splitFunction(key);\n    const depth = key === top ? 0 : key.depth;\n    if (depth !== undefined && depth < maxDepth) {\n        key.split = split;\n        split[0][0].depth = depth + 1;\n        split[1][0].depth = depth + 1;\n    }\n\n    return split;\n};\n\nexport function fromUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    root: UntypedBspSet<Key>,\n): BspSet<Key, Id> {\n    if (root === empty || root === dense) { return root; }\n    return { setOperations, root };\n}\n\nconst sparse = <Key, Exact, Left, Right>(\n    left: Left,\n    right: Right,\n    pathKey: Key,\n    key: Key,\n    isExact: Exact,\n) => ({ key, pathKey, left, right, isExact });\n\nfunction fromKey<Key>(\n    pathKey: Key,\n    key: Key,\n    isExact: boolean,\n): UntypedSparse<Key> {\n    if (isExact) {\n        return sparse(undefined, undefined, pathKey, key, true as const);\n    }\n\n    return sparse(undefined, undefined, pathKey, key, false as const);\n}\n\nexport function lazy<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    pathKey: Key,\n    key: Key,\n): UntypedBspSet<Key> {\n    if (!setOperations.meets(pathKey, key)) { return empty; }\n    const cmp = setOperations.compare(pathKey, key);\n    if (cmp !== undefined) {\n        if (cmp <= 0) { return dense; }\n\n        return fromKey(pathKey, key, true);\n    }\n\n    // this is not exactly necessary, but increases the amount of exact nodes and thus we can often\n    // prune earlier.\n    // Also, having intersect always work guarantees exact nodes, thus allowing for more efficient\n    // storage and computation.\n    const newKey = setOperations.intersect(pathKey, key);\n\n    if (newKey !== undefined) {\n        return fromKey(pathKey, newKey, true);\n    }\n\n    return fromKey(pathKey, key, false);\n}\n\nexport function createFromKey<Key extends Cachable<Key>, Id>(\n    uncachedSetOperations: SetOperations<Key, Id>,\n) {\n    const setOperations = {\n        ...uncachedSetOperations,\n        split: cacheKeySplitting(\n            uncachedSetOperations.split,\n            uncachedSetOperations.top,\n        ),\n    };\n    return (key: Key) =>\n        fromUntyped(setOperations, lazy(setOperations, setOperations.top, key));\n}\n\nfunction unionExact<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key> & KeyExact<Key>,\n    right: UntypedBspSet<Key> & KeyExact<Key>,\n) {\n    const { pathKey, key: leftKey } = left;\n    const { key: rightKey } = right;\n\n    const cmp = setOperations.compare(leftKey, rightKey);\n    if (cmp !== undefined) {\n        return cmp < 0 ? right : left;\n    }\n\n    const combinedKey = setOperations.union(leftKey, rightKey);\n    if (combinedKey !== undefined) {\n        const combinedCmp = setOperations.compare(combinedKey, pathKey);\n        if (combinedCmp !== undefined && combinedCmp === 0) { return dense; }\n        return fromKey(pathKey, combinedKey, true);\n    }\n    return undefined;\n}\n\n/** This is an local combination, not a proper union. We use it to have simpler code elsewhere */\nfunction combineChildren<Key>(\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): Empty | Dense | (UntypedSparse<Key> & TreeDefined<Key>) {\n    if (left === empty) {\n        if (right === empty) {\n            return empty;\n        }\n\n        return sparse(left, right, undefined, undefined, false as const);\n    }\n\n    if (right === empty) {\n        return sparse(left, right, undefined, undefined, false as const);\n    }\n\n    if (left === dense) {\n        if (right === dense) {\n            return dense;\n        }\n        return sparse(left, right, undefined, undefined, false as const);\n    }\n\n    return sparse(left, right, undefined, undefined, false as const);\n}\n\nfunction materialize<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    set: UntypedSparse<Key>,\n): UntypedSparse<Key> & TreeDefined<Key> {\n    if (set.left !== undefined) {\n        return set;\n    }\n\n    const [[left], [right]] = setOperations.split(set.pathKey);\n    const lChild = lazy(setOperations, left, set.key);\n    const rChild = lazy(setOperations, right, set.key);\n\n    const res = combineChildren<Key>(lChild, rChild);\n\n    if (res === empty || res === dense) {\n        throw new Error(\"incorrect set operations implementation\");\n    }\n\n    // first check, that res actually has the desired type\n    const typeCheck: TreeDefined<Key> = res;\n\n    const setAlias: UntypedSparse<Key> = set;\n    return ObjectAssign(setAlias, {\n        left: typeCheck.left,\n        right: typeCheck.right,\n    });\n}\n\nexport function unionUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): UntypedBspSet<Key> {\n    if (right === empty) { return left; }\n    if (right === dense) { return right; }\n    if (left === empty) { return right; }\n    if (left === dense) { return left; }\n\n    if (left.isExact && right.isExact) {\n        const res = unionExact<Key, Id>(setOperations, left, right);\n        if (res !== undefined) { return res; }\n    }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    const lChild = unionUntyped(setOperations, newLeft.left, newRight.left);\n    const rChild = unionUntyped(setOperations, newLeft.right, newRight.right);\n\n    return combineChildren(lChild, rChild);\n}\n\nexport function union<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): BspSet<Key, Id> {\n    if (right === empty) { return left; }\n    if (right === dense) { return right; }\n    if (left === empty) { return right; }\n    if (left === dense) { return left; }\n\n    return fromUntyped(\n        left.setOperations,\n        unionUntyped<Key, Id>(left.setOperations, left.root, right.root),\n    );\n}\n\nfunction intersectExact<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key> & KeyExact<Key>,\n    right: UntypedBspSet<Key> & KeyExact<Key>,\n) {\n    const { pathKey, key: leftKey } = left;\n    const { key: rightKey } = right;\n\n    if (!setOperations.meets(leftKey, rightKey)) {\n        return empty;\n    }\n\n    const cmp = setOperations.compare(leftKey, rightKey);\n    if (cmp !== undefined) {\n        return cmp < 0 ? left : right;\n    }\n\n    const combinedKey = setOperations.intersect(leftKey, rightKey);\n    if (combinedKey !== undefined) {\n        return fromKey(pathKey, combinedKey, true);\n    }\n\n    return undefined;\n}\n\nexport function intersectUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): UntypedBspSet<Key> {\n    if (left === empty) { return left; }\n    if (right === empty) { return right; }\n    if (left === dense) { return right; }\n    if (right === dense) { return left; }\n\n    if (left.isExact && right.isExact) {\n        const res = intersectExact<Key, Id>(setOperations, left, right);\n        if (res !== undefined) { return res; }\n    }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    const lChild = intersectUntyped(setOperations, newLeft.left, newRight.left);\n    const rChild = intersectUntyped(\n        setOperations,\n        newLeft.right,\n        newRight.right,\n    );\n\n    return combineChildren(lChild, rChild);\n}\n\nexport function intersect<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): BspSet<Key, Id> {\n    if (left === empty) { return left; }\n    if (right === empty) { return right; }\n    if (left === dense) { return right; }\n    if (right === dense) { return left; }\n\n    return fromUntyped(\n        left.setOperations,\n        intersectUntyped<Key, Id>(left.setOperations, left.root, right.root),\n    );\n}\n\nexport function meetsUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): boolean {\n    if (left === empty || right === empty) { return false; }\n    if (left === dense || right === dense) { return true; }\n    if (left.isExact && right.isExact) { return setOperations.meets(left.key, right.key); }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    return (\n        meetsUntyped(setOperations, newLeft.left, newRight.left) ||\n        meetsUntyped(setOperations, newLeft.right, newRight.right)\n    );\n}\n\nexport function meets<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): boolean {\n    if (left === empty || right === empty) { return false; }\n    if (left === dense || right === dense) { return true; }\n    return meetsUntyped<Key, Id>(left.setOperations, left.root, right.root);\n}\n\nfunction exceptExact<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedSparse<Key> & KeyExact<Key>,\n    right: KeyExact<Key>,\n) {\n    const { pathKey, key: leftKey } = left;\n    const { key: rightKey } = right;\n\n    if (!setOperations.meets(leftKey, rightKey)) {\n        return left;\n    }\n\n    const combinedKey = setOperations.except(leftKey, rightKey);\n    if (combinedKey !== undefined) {\n        return fromKey(pathKey, combinedKey, true);\n    }\n\n    return undefined;\n}\n\nexport function exceptUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): UntypedBspSet<Key> {\n    if (left === empty) { return left; }\n    if (right === empty) { return left; }\n    if (right === dense) { return empty; }\n    if (left === dense) {\n        const newRight_inner = materialize<Key, Id>(setOperations, right);\n        const lChild_inner = exceptUntyped(setOperations, dense, newRight_inner.left);\n        const rChild_inner = exceptUntyped(setOperations, dense, newRight_inner.right);\n        return combineChildren(lChild_inner, rChild_inner);\n    }\n    if (left.isExact && right.isExact) {\n        const res = exceptExact<Key, Id>(setOperations, left, right);\n        if (res !== undefined) { return res; }\n    }\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n\n    const lChild = exceptUntyped(setOperations, newLeft.left, newRight.left);\n    const rChild = exceptUntyped(setOperations, newLeft.right, newRight.right);\n\n    return combineChildren(lChild, rChild);\n}\n\nexport function except<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n): BspSet<Key, Id> {\n    if (left === empty) { return left; }\n    if (right === empty) { return left; }\n    if (right === dense) { return empty; }\n    if (left === dense) {\n        return fromUntyped(\n            right.setOperations,\n            exceptUntyped<Key, Id>(right.setOperations, left, right.root),\n        );\n    }\n\n    return fromUntyped(\n        left.setOperations,\n        exceptUntyped<Key, Id>(left.setOperations, left.root, right.root),\n    );\n}\n\nconst compareExact = <Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: KeyExact<Key>,\n    right: KeyExact<Key>,\n) => setOperations.compare(left.key, right.key);\n\nexport function combineCmp(\n    left: -1 | 0 | 1 | undefined,\n    right: -1 | 0 | 1 | undefined,\n) {\n    if (left === undefined || right === undefined) { return undefined; }\n    if (left === 0) { return right; }\n    if (right === 0) { return left; }\n    return left === right ? left : undefined;\n}\n\nexport function compareUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    left: UntypedBspSet<Key>,\n    right: UntypedBspSet<Key>,\n): -1 | 0 | 1 | undefined {\n    if (left === right) { return 0; }\n\n    if (left === empty) {\n        return -1;\n    }\n\n    if (right === empty) {\n        return 1;\n    }\n\n    if (left === dense) {\n        if (right === dense) {\n            return 0;\n        }\n\n        return 1;\n    }\n\n    if (right === dense) {\n        return -1;\n    }\n\n    if (left.isExact && right.isExact) {\n        return compareExact(setOperations, left, right);\n    }\n\n    const newLeft = materialize<Key, Id>(setOperations, left);\n    const newRight = materialize<Key, Id>(setOperations, right);\n    const lCmp = compareUntyped(setOperations, newLeft.left, newRight.left);\n    if (lCmp === undefined) { return undefined; }\n\n    const rCmp = compareUntyped(setOperations, newLeft.right, newRight.right);\n\n    if (rCmp === undefined) { return undefined; }\n\n    return combineCmp(lCmp, rCmp);\n}\n\nexport function compare<Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n) {\n    if (left === right) { return 0; }\n\n    if (left === empty) {\n        return -1;\n    }\n\n    if (right === empty) {\n        return 1;\n    }\n\n    if (left === dense) {\n        if (right === dense) {\n            return 0;\n        }\n\n        return 1;\n    }\n\n    if (right === dense) {\n        return -1;\n    }\n\n    return compareUntyped<Key, Id>(left.setOperations, left.root, right.root);\n}\n\nexport const symmetricDiff = <Key extends Cachable<Key>, Id>(\n    left: BspSet<Key, Id>,\n    right: BspSet<Key, Id>,\n) => union(except(left, right), except(right, left));\n\nexport const complement = <Key extends Cachable<Key>, Id>(\n    set: BspSet<Key, Id>,\n) => except(dense, set);\n\nfunction getNodeCountUntyped<T>(set: UntypedBspSet<T> | undefined): number {\n    if (set === undefined || set === empty || set === dense) {\n        return 0;\n    }\n\n    return getNodeCountUntyped(set.left) + getNodeCountUntyped(set.right) + 1;\n}\n\nexport function getNodeCount<Key extends Cachable<Key>, Id>(\n    set: BspSet<Key, Id>,\n) {\n    if (set === empty || set === dense) { return 0; }\n    return getNodeCountUntyped(set.root);\n}\n\nfunction forEachKeyUntyped<Key extends Cachable<Key>, Id>(\n    setOperations: SetOperations<Key, Id>,\n    set: UntypedBspSet<Key>,\n    f: (key: Key) => boolean,\n): boolean {\n    function loop(pathKey: Key, set_inner: UntypedBspSet<Key>): boolean {\n        if (set_inner === empty) { return true; }\n        if (set_inner === dense) { return f(pathKey); }\n        if (set_inner.isExact) { return f(set_inner.key); }\n\n        const newSet = materialize<Key, Id>(setOperations, set_inner);\n        const [[left], [right]] = setOperations.split(pathKey);\n        return loop(left, newSet.left) && loop(right, newSet.right);\n    }\n\n    return loop(setOperations.top, set);\n}\n\nexport function forEachKey<Key extends Cachable<Key>, Id>(\n    set: Empty | Sparse<Key, Id>,\n    f: (key: Key) => boolean,\n): boolean {\n    if (set === empty) { return true; }\n    return forEachKeyUntyped(set.setOperations, set.root, f);\n}\n"]}

package/dist/handlecache.d.ts

@@ -6,7 +6,7 @@ import { IVectorConsumer } from "@tiny-calc/nano";
 import { Handle } from "./handletable";
 import { PermutationVector } from "./permutationvector";
 /**
- * Used by PermutationVector to cache position -> handle lookups.
+ * Used by PermutationVector to cache position -\> handle lookups.
  *
  * Perf: Possibly, this should eventually be inlined into PermutationVector itself, but
  *       so far there's no measurable perf penalty for being a separate object (node 12 x64)

package/dist/handlecache.js

@@ -10,7 +10,7 @@ const common_utils_1 = require("@fluidframework/common-utils");
 const handletable_1 = require("./handletable");
 const range_1 = require("./range");
 /**
- * Used by PermutationVector to cache position -> handle lookups.
+ * Used by PermutationVector to cache position -\> handle lookups.
  *
  * Perf: Possibly, this should eventually be inlined into PermutationVector itself, but
  *       so far there's no measurable perf penalty for being a separate object (node 12 x64)
@@ -49,10 +49,10 @@ class HandleCache {
     }
     /** Update the cache when a handle has been allocated for a given position. */
     addHandle(position, handle) {
-        common_utils_1.assert(handletable_1.isHandleValid(handle), 0x017 /* "Trying to add invalid handle!" */);
+        (0, common_utils_1.assert)((0, handletable_1.isHandleValid)(handle), 0x017 /* "Trying to add invalid handle!" */);
         const index = this.getIndex(position);
         if (index < this.handles.length) {
-            common_utils_1.assert(!handletable_1.isHandleValid(this.handles[index]), 0x018 /* "Trying to insert handle into position with already valid handle!" */);
+            (0, common_utils_1.assert)(!(0, handletable_1.isHandleValid)(this.handles[index]), 0x018 /* "Trying to insert handle into position with already valid handle!" */);
             this.handles[index] = handle;
         }
     }
@@ -85,7 +85,7 @@ class HandleCache {
             return this.handles[0];
         }
         else {
-            range_1.ensureRange(_position, this.vector.getLength());
+            (0, range_1.ensureRange)(_position, this.vector.getLength());
             this.handles = this.handles.concat(this.getHandles(this.start + this.handles.length, _position + 1));
             return this.handles[this.handles.length - 1];
         }

package/dist/handlecache.js.map

@@ -1 +1 @@
-{"version":3,"file":"handlecache.js","sourceRoot":"","sources":["../src/handlecache.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+BAA+B;AAE/B,+DAAsD;AAEtD,+CAAsD;AAEtD,mCAAsC;AAEtC;;;;;GAKG;AACH,MAAa,WAAW;IAIpB,YAA4B,MAAyB;QAAzB,WAAM,GAAN,MAAM,CAAmB;QAH7C,YAAO,GAAa,EAAE,CAAC;QACvB,UAAK,GAAG,CAAC,CAAC;IAEuC,CAAC;IAE1D;;;OAGG;IACK,QAAQ,CAAC,QAAgB;QAC7B,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;OAOG;IACI,SAAS,CAAC,QAAgB;QAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAEtC,uFAAuF;QACvF,8BAA8B;QAE9B,oFAAoF;QACpF,qFAAqF;QACrF,uEAAuE;QAEvE,OAAO,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM;YAC9B,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YACrB,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;IAED,8EAA8E;IACvE,SAAS,CAAC,QAAgB,EAAE,MAAc;QAC7C,qBAAM,CAAC,2BAAa,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,qCAAqC,CAAC,CAAC;QAE3E,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YAC7B,qBAAM,CAAC,CAAC,2BAAa,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EACtC,KAAK,CAAC,wEAAwE,CAAC,CAAC;YACpF,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;SAChC;IACL,CAAC;IAED,0EAA0E;IAClE,UAAU,CAAC,KAAa,EAAE,GAAW;QACzC,sFAAsF;QACtF,gBAAgB;QAEhB,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAExB,KAAK,IAAI,GAAG,GAAG,KAAK,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE;YACpC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;YAC7D,MAAM,MAAM,GAAG,OAA6B,CAAC;YAC7C,oEAAoE;YACpE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,MAAO,CAAC,CAAC;SACxC;QAED,OAAO,OAAO,CAAC;IACnB,CAAC;IAEO,SAAS,CAAC,QAAgB;QAC9B,mFAAmF;QACnF,yDAAyD;QACzD,MAAM,SAAS,GAAG,QAAQ,KAAK,CAAC,CAAC;QAEjC,8EAA8E;QAC9E,kBAAkB;QAElB,6EAA6E;QAC7E,+EAA+E;QAC/E,2BAA2B;QAE3B,IAAI,SAAS,GAAG,IAAI,CAAC,KAAK,EAAE;YACxB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC3E,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;YACvB,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;SAC1B;aAAM;YACH,mBAAW,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;YAEhD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC;YACrG,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;SAChD;IACL,CAAC;IAED,0BAA0B;IAE1B,YAAY,CAAC,KAAa,EAAE,YAAoB,EAAE,aAAqB;QACnE,8EAA8E;QAC9E,6EAA6E;QAC7E,aAAa;QACb,EAAE;QACF,4EAA4E;QAC5E,wBAAwB;QACxB,EAAE;QACF,6FAA6F;QAC7F,2EAA2E;QAC3E,EAAE;QACF,gFAAgF;QAEhF,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YAC7B,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC;SAC/B;IACL,CAAC;CAGJ;AAjHD,kCAiHC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/* eslint-disable no-bitwise */\n\nimport { assert } from \"@fluidframework/common-utils\";\nimport { IVectorConsumer } from \"@tiny-calc/nano\";\nimport { Handle, isHandleValid } from \"./handletable\";\nimport { PermutationVector, PermutationSegment } from \"./permutationvector\";\nimport { ensureRange } from \"./range\";\n\n/**\n * Used by PermutationVector to cache position -> handle lookups.\n *\n * Perf: Possibly, this should eventually be inlined into PermutationVector itself, but\n *       so far there's no measurable perf penalty for being a separate object (node 12 x64)\n */\nexport class HandleCache implements IVectorConsumer<Handle> {\n    private handles: Handle[] = [];\n    private start = 0;\n\n    constructor(public readonly vector: PermutationVector) { }\n\n    /**\n     * Returns the index of the given position in the 'handles' array as a Uint32.\n     * (If the position is not in the array, returns an integer greater than 'handles.length').\n     */\n    private getIndex(position: number) {\n        return (position - this.start) >>> 0;\n    }\n\n    /**\n     * Returns the handle currently assigned to the given 'position' (if any).  Check\n     * the result with 'isValidHandle(..)' to see if a handle has been allocated for\n     * the given position.\n     *\n     * Throws a 'RangeError' if the provided 'position' is out-of-bounds wrt. the\n     * PermutationVector's length.\n     */\n    public getHandle(position: number) {\n        const index = this.getIndex(position);\n\n        // Perf: To encourage inlining, handling of the 'cacheMiss(..)' case has been extracted\n        //       to a separate method.\n\n        // Perf: A cache hit implies that 'position' was in bounds.  Therefore, we can defer\n        //       checking that 'position' is in bounds until 'cacheMiss(..)'.  This yields an\n        //       ~40% speedup when the position is in the cache (node v12 x64).\n\n        return index < this.handles.length\n            ? this.handles[index]\n            : this.cacheMiss(position);\n    }\n\n    /** Update the cache when a handle has been allocated for a given position. */\n    public addHandle(position: number, handle: Handle) {\n        assert(isHandleValid(handle), 0x017 /* \"Trying to add invalid handle!\" */);\n\n        const index = this.getIndex(position);\n        if (index < this.handles.length) {\n            assert(!isHandleValid(this.handles[index]),\n                0x018 /* \"Trying to insert handle into position with already valid handle!\" */);\n            this.handles[index] = handle;\n        }\n    }\n\n    /** Used by 'CacheMiss()' to retrieve handles for a range of positions. */\n    private getHandles(start: number, end: number) {\n        // TODO: This can be accelerated substantially using 'walkSegments()'.  The only catch\n        //       is that\n\n        const handles: Handle[] = [];\n        const { vector } = this;\n\n        for (let pos = start; pos < end; pos++) {\n            const { segment, offset } = vector.getContainingSegment(pos);\n            const asPerm = segment as PermutationSegment;\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            handles.push(asPerm.start + offset!);\n        }\n\n        return handles;\n    }\n\n    private cacheMiss(position: number) {\n        // Coercing 'position' to an Uint32 allows us to handle a negative 'position' value\n        // with the same logic that handles 'position' >= length.\n        const _position = position >>> 0;\n\n        // TODO: To bound memory usage, there should be a limit on the maximum size of\n        //       handle[].\n\n        // TODO: To reduce MergeTree lookups, this code should opportunistically grow\n        //       the cache to the next MergeTree segment boundary (within the limits of\n        //       the handle cache).\n\n        if (_position < this.start) {\n            this.handles = this.getHandles(_position, this.start).concat(this.handles);\n            this.start = _position;\n            return this.handles[0];\n        } else {\n            ensureRange(_position, this.vector.getLength());\n\n            this.handles = this.handles.concat(this.getHandles(this.start + this.handles.length, _position + 1));\n            return this.handles[this.handles.length - 1];\n        }\n    }\n\n    // #region IVectorConsumer\n\n    itemsChanged(start: number, removedCount: number, insertedCount: number): void {\n        // If positions were inserted/removed, our current policy is to trim the array\n        // at the beginning of the invalidate range and lazily repopulate the handles\n        // on demand.\n        //\n        // Some alternatives to consider that preserve the previously cached handles\n        // that are still valid:\n        //\n        //      * Eagerly populate the 'handles[]' with the newly insert values (currently guaranteed\n        //        to be Handle.unallocated, so we don't even need to look them up.)\n        //\n        //      * Use a sentinel value or other mechanism to allow \"holes\" in the cache.\n\n        const index = this.getIndex(start);\n        if (index < this.handles.length) {\n            this.handles.length = index;\n        }\n    }\n\n    // #endregion IVectorConsumer\n}\n"]}
+{"version":3,"file":"handlecache.js","sourceRoot":"","sources":["../src/handlecache.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/* eslint-disable no-bitwise */\n\nimport { assert } from \"@fluidframework/common-utils\";\nimport { IVectorConsumer } from \"@tiny-calc/nano\";\nimport { Handle, isHandleValid } from \"./handletable\";\nimport { PermutationVector, PermutationSegment } from \"./permutationvector\";\nimport { ensureRange } from \"./range\";\n\n/**\n * Used by PermutationVector to cache position -\\> handle lookups.\n *\n * Perf: Possibly, this should eventually be inlined into PermutationVector itself, but\n *       so far there's no measurable perf penalty for being a separate object (node 12 x64)\n */\nexport class HandleCache implements IVectorConsumer<Handle> {\n    private handles: Handle[] = [];\n    private start = 0;\n\n    constructor(public readonly vector: PermutationVector) { }\n\n    /**\n     * Returns the index of the given position in the 'handles' array as a Uint32.\n     * (If the position is not in the array, returns an integer greater than 'handles.length').\n     */\n    private getIndex(position: number) {\n        return (position - this.start) >>> 0;\n    }\n\n    /**\n     * Returns the handle currently assigned to the given 'position' (if any).  Check\n     * the result with 'isValidHandle(..)' to see if a handle has been allocated for\n     * the given position.\n     *\n     * Throws a 'RangeError' if the provided 'position' is out-of-bounds wrt. the\n     * PermutationVector's length.\n     */\n    public getHandle(position: number) {\n        const index = this.getIndex(position);\n\n        // Perf: To encourage inlining, handling of the 'cacheMiss(..)' case has been extracted\n        //       to a separate method.\n\n        // Perf: A cache hit implies that 'position' was in bounds.  Therefore, we can defer\n        //       checking that 'position' is in bounds until 'cacheMiss(..)'.  This yields an\n        //       ~40% speedup when the position is in the cache (node v12 x64).\n\n        return index < this.handles.length\n            ? this.handles[index]\n            : this.cacheMiss(position);\n    }\n\n    /** Update the cache when a handle has been allocated for a given position. */\n    public addHandle(position: number, handle: Handle) {\n        assert(isHandleValid(handle), 0x017 /* \"Trying to add invalid handle!\" */);\n\n        const index = this.getIndex(position);\n        if (index < this.handles.length) {\n            assert(!isHandleValid(this.handles[index]),\n                0x018 /* \"Trying to insert handle into position with already valid handle!\" */);\n            this.handles[index] = handle;\n        }\n    }\n\n    /** Used by 'CacheMiss()' to retrieve handles for a range of positions. */\n    private getHandles(start: number, end: number) {\n        // TODO: This can be accelerated substantially using 'walkSegments()'.  The only catch\n        //       is that\n\n        const handles: Handle[] = [];\n        const { vector } = this;\n\n        for (let pos = start; pos < end; pos++) {\n            const { segment, offset } = vector.getContainingSegment(pos);\n            const asPerm = segment as PermutationSegment;\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            handles.push(asPerm.start + offset!);\n        }\n\n        return handles;\n    }\n\n    private cacheMiss(position: number) {\n        // Coercing 'position' to an Uint32 allows us to handle a negative 'position' value\n        // with the same logic that handles 'position' >= length.\n        const _position = position >>> 0;\n\n        // TODO: To bound memory usage, there should be a limit on the maximum size of\n        //       handle[].\n\n        // TODO: To reduce MergeTree lookups, this code should opportunistically grow\n        //       the cache to the next MergeTree segment boundary (within the limits of\n        //       the handle cache).\n\n        if (_position < this.start) {\n            this.handles = this.getHandles(_position, this.start).concat(this.handles);\n            this.start = _position;\n            return this.handles[0];\n        } else {\n            ensureRange(_position, this.vector.getLength());\n\n            this.handles = this.handles.concat(this.getHandles(this.start + this.handles.length, _position + 1));\n            return this.handles[this.handles.length - 1];\n        }\n    }\n\n    // #region IVectorConsumer\n\n    itemsChanged(start: number, removedCount: number, insertedCount: number): void {\n        // If positions were inserted/removed, our current policy is to trim the array\n        // at the beginning of the invalidate range and lazily repopulate the handles\n        // on demand.\n        //\n        // Some alternatives to consider that preserve the previously cached handles\n        // that are still valid:\n        //\n        //      * Eagerly populate the 'handles[]' with the newly insert values (currently guaranteed\n        //        to be Handle.unallocated, so we don't even need to look them up.)\n        //\n        //      * Use a sentinel value or other mechanism to allow \"holes\" in the cache.\n\n        const index = this.getIndex(start);\n        if (index < this.handles.length) {\n            this.handles.length = index;\n        }\n    }\n\n    // #endregion IVectorConsumer\n}\n"]}

package/dist/handletable.js.map

@@ -1 +1 @@
-{"version":3,"file":"handletable.js","sourceRoot":"","sources":["../src/handletable.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAUI,MAAM,aAAa,GAAG,CAAC,MAAc,EAAE,EAAE,CAAC,MAAM,iBAAgB,CAAC;AAA3D,QAAA,aAAa,iBAA8C;AAExE;;GAEG;AACH,MAAa,WAAW;IACpB,4FAA4F;IAC5F,2FAA2F;IAC3F,sFAAsF;IACtF,YAAoC,UAA0B,CAAC,CAAC,CAAC;QAA7B,YAAO,GAAP,OAAO,CAAsB;IAAI,CAAC;IAE/D,KAAK;QACR,qFAAqF;QACrF,uFAAuF;QACvF,oBAAoB;QACpB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACI,QAAQ;;QACX,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,IAAI,SAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAY,mCAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,KAAa;QAC7B,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;YAC5B,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;SAChC;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;OAEG;IACI,IAAI,CAAC,MAAc;QACtB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACI,GAAG,CAAC,MAAc;QACrB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAM,CAAC;IACrC,CAAC;IAED;;OAEG;IACI,GAAG,CAAC,MAAc,EAAE,KAAQ;QAC/B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;IACjC,CAAC;IAED,wFAAwF;IACxF,uBAAuB;IACvB,IAAY,IAAI,KAAK,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAW,CAAC,CAAC,CAAC;IACxD,IAAY,IAAI,CAAC,MAAc,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;IAEvD,iBAAiB;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAEM,MAAM,CAAC,IAAI,CAAI,IAAoB;QACtC,OAAO,IAAI,WAAW,CAAI,IAAI,CAAC,CAAC;IACpC,CAAC;CACJ;AApED,kCAoEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport const enum Handle {\n    /** Minimum valid handle. */\n    valid = 1,\n\n    /** Sentinel representing an unallocated Handle. */\n    unallocated = -0x80000000,\n}\n\nexport const isHandleValid = (handle: Handle) => handle >= Handle.valid;\n\n/**\n * A handle table provides a fast mapping from an integer `handle` to a value `T`.\n */\nexport class HandleTable<T> {\n    // Note: the first slot of the 'handles' array is reserved to store the pointer to the first\n    //       free handle.  We initialize this slot with a pointer to slot '1', which will cause\n    //       us to delay allocate the following slot in the array on the first allocation.\n    public constructor(private readonly handles: (Handle | T)[] = [1]) { }\n\n    public clear() {\n        // Restore the HandleTable's initial state by deleting all items in the handles array\n        // and then re-inserting the value '1' in the 0th slot.  (See comment at `handles` decl\n        // for explanation.)\n        this.handles.splice(0, this.handles.length, 1);\n    }\n\n    /**\n     * Allocates and returns the next available handle.  Note that freed handles are recycled.\n     */\n    public allocate(): Handle {\n        const free = this.next;\n        this.next = (this.handles[free] as Handle) ?? (free + 1);\n        this.handles[free] = 0;\n        return free;\n    }\n\n    /**\n     * Allocates and returns the next available `count` handles.\n     */\n    public allocateMany(count: Handle) {\n        const handles = new Uint32Array(count);\n        for (let i = 0; i < count; i++) {\n            handles[i] = this.allocate();\n        }\n        return handles;\n    }\n\n    /**\n     * Returns the given handle to the free list.\n     */\n    public free(handle: Handle) {\n        this.handles[handle] = this.next;\n        this.next = handle;\n    }\n\n    /**\n     * Get the value `T` associated with the given handle, if any.\n     */\n    public get(handle: Handle): T {\n        return this.handles[handle] as T;\n    }\n\n    /**\n     * Set the value `T` associated with the given handle.\n     */\n    public set(handle: Handle, value: T) {\n        this.handles[handle] = value;\n    }\n\n    // Private helpers to get/set the head of the free list, which is stored in the 0th slot\n    // of the handle array.\n    private get next() { return this.handles[0] as Handle; }\n    private set next(handle: Handle) { this.handles[0] = handle; }\n\n    public getSummaryContent() {\n        return this.handles;\n    }\n\n    public static load<T>(data: (Handle | T)[]) {\n        return new HandleTable<T>(data);\n    }\n}\n"]}
+{"version":3,"file":"handletable.js","sourceRoot":"","sources":["../src/handletable.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAUI,MAAM,aAAa,GAAG,CAAC,MAAc,EAAE,EAAE,CAAC,MAAM,iBAAgB,CAAC;AAA3D,QAAA,aAAa,iBAA8C;AAExE;;GAEG;AACH,MAAa,WAAW;IACpB,4FAA4F;IAC5F,2FAA2F;IAC3F,sFAAsF;IACtF,YAAoC,UAA0B,CAAC,CAAC,CAAC;QAA7B,YAAO,GAAP,OAAO,CAAsB;IAAI,CAAC;IAE/D,KAAK;QACR,qFAAqF;QACrF,uFAAuF;QACvF,oBAAoB;QACpB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACI,QAAQ;;QACX,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,MAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAY,mCAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,KAAa;QAC7B,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;YAC5B,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;SAChC;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;OAEG;IACI,IAAI,CAAC,MAAc;QACtB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACI,GAAG,CAAC,MAAc;QACrB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAM,CAAC;IACrC,CAAC;IAED;;OAEG;IACI,GAAG,CAAC,MAAc,EAAE,KAAQ;QAC/B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;IACjC,CAAC;IAED,wFAAwF;IACxF,uBAAuB;IACvB,IAAY,IAAI,KAAK,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAW,CAAC,CAAC,CAAC;IACxD,IAAY,IAAI,CAAC,MAAc,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;IAEvD,iBAAiB;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAEM,MAAM,CAAC,IAAI,CAAI,IAAoB;QACtC,OAAO,IAAI,WAAW,CAAI,IAAI,CAAC,CAAC;IACpC,CAAC;CACJ;AApED,kCAoEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport const enum Handle {\n    /** Minimum valid handle. */\n    valid = 1,\n\n    /** Sentinel representing an unallocated Handle. */\n    unallocated = -0x80000000,\n}\n\nexport const isHandleValid = (handle: Handle) => handle >= Handle.valid;\n\n/**\n * A handle table provides a fast mapping from an integer `handle` to a value `T`.\n */\nexport class HandleTable<T> {\n    // Note: the first slot of the 'handles' array is reserved to store the pointer to the first\n    //       free handle.  We initialize this slot with a pointer to slot '1', which will cause\n    //       us to delay allocate the following slot in the array on the first allocation.\n    public constructor(private readonly handles: (Handle | T)[] = [1]) { }\n\n    public clear() {\n        // Restore the HandleTable's initial state by deleting all items in the handles array\n        // and then re-inserting the value '1' in the 0th slot.  (See comment at `handles` decl\n        // for explanation.)\n        this.handles.splice(0, this.handles.length, 1);\n    }\n\n    /**\n     * Allocates and returns the next available handle.  Note that freed handles are recycled.\n     */\n    public allocate(): Handle {\n        const free = this.next;\n        this.next = (this.handles[free] as Handle) ?? (free + 1);\n        this.handles[free] = 0;\n        return free;\n    }\n\n    /**\n     * Allocates and returns the next available `count` handles.\n     */\n    public allocateMany(count: Handle) {\n        const handles = new Uint32Array(count);\n        for (let i = 0; i < count; i++) {\n            handles[i] = this.allocate();\n        }\n        return handles;\n    }\n\n    /**\n     * Returns the given handle to the free list.\n     */\n    public free(handle: Handle) {\n        this.handles[handle] = this.next;\n        this.next = handle;\n    }\n\n    /**\n     * Get the value `T` associated with the given handle, if any.\n     */\n    public get(handle: Handle): T {\n        return this.handles[handle] as T;\n    }\n\n    /**\n     * Set the value `T` associated with the given handle.\n     */\n    public set(handle: Handle, value: T) {\n        this.handles[handle] = value;\n    }\n\n    // Private helpers to get/set the head of the free list, which is stored in the 0th slot\n    // of the handle array.\n    private get next() { return this.handles[0] as Handle; }\n    private set next(handle: Handle) { this.handles[0] = handle; }\n\n    public getSummaryContent() {\n        return this.handles;\n    }\n\n    public static load<T>(data: (Handle | T)[]) {\n        return new HandleTable<T>(data);\n    }\n}\n"]}

package/dist/matrix.d.ts

@@ -103,6 +103,9 @@ export declare class SharedMatrix<T = any> extends SharedObject implements IMatr
      */
     private isLatestPendingWrite;
     toString(): string;
-    protected applyStashedOp(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    protected applyStashedOp(content: any): unknown;
 }
 //# sourceMappingURL=matrix.d.ts.map

package/dist/matrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../src/matrix.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../src/matrix.ts"],"names":[],"mappings":"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"}

package/dist/matrix.js

@@ -67,7 +67,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
      * Subscribes the given IUndoConsumer to the matrix.
      */
     openUndo(consumer) {
-        common_utils_1.assert(this.undo === undefined, 0x019 /* "SharedMatrix.openUndo() supports at most a single IUndoConsumer." */);
+        (0, common_utils_1.assert)(this.undo === undefined, 0x019 /* "SharedMatrix.openUndo() supports at most a single IUndoConsumer." */);
         this.undo = new undoprovider_1.MatrixUndoProvider(consumer, this, this.rows, this.cols);
     }
     // TODO: closeUndo()?
@@ -97,23 +97,23 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         //       yields an ~40% improvement in the case of a cache hit (node v12 x64)
         // Map the logical (row, col) to associated storage handles.
         const rowHandle = this.rowHandles.getHandle(row);
-        if (handletable_1.isHandleValid(rowHandle)) {
+        if ((0, handletable_1.isHandleValid)(rowHandle)) {
             const colHandle = this.colHandles.getHandle(col);
-            if (handletable_1.isHandleValid(colHandle)) {
+            if ((0, handletable_1.isHandleValid)(colHandle)) {
                 return this.cells.getCell(rowHandle, colHandle);
             }
         }
         else {
             // If we early exit because the given rowHandle is unallocated, we still need to
             // bounds-check the 'col' parameter.
-            range_1.ensureRange(col, this.cols.getLength());
+            (0, range_1.ensureRange)(col, this.cols.getLength());
         }
         return undefined;
     }
     get matrixProducer() { return this; }
     // #endregion IMatrixReader
     setCell(row, col, value) {
-        common_utils_1.assert(0 <= row && row < this.rowCount
+        (0, common_utils_1.assert)(0 <= row && row < this.rowCount
             && 0 <= col && col < this.colCount, 0x01a /* "Trying to set out-of-bounds cell!" */);
         this.setCellCore(row, col, value);
         // Avoid reentrancy by raising change notifications after the op is queued.
@@ -123,7 +123,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
     }
     setCells(rowStart, colStart, colCount, values) {
         const rowCount = Math.ceil(values.length / colCount);
-        common_utils_1.assert((0 <= rowStart && rowStart < this.rowCount)
+        (0, common_utils_1.assert)((0 <= rowStart && rowStart < this.rowCount)
             && (0 <= colStart && colStart < this.colCount)
             && (1 <= colCount && colCount <= (this.colCount - colStart))
             && (rowCount <= (this.rowCount - rowStart)), 0x01b /* "Trying to set multiple out-of-bounds cells!" */);
@@ -156,7 +156,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         }
     }
     sendSetCellOp(row, col, value, rowHandle, colHandle, localSeq = this.nextLocalSeq()) {
-        common_utils_1.assert(this.isAttached(), 0x1e2 /* "Caller must ensure 'isAttached()' before calling 'sendSetCellOp'." */);
+        (0, common_utils_1.assert)(this.isAttached(), 0x1e2 /* "Caller must ensure 'isAttached()' before calling 'sendSetCellOp'." */);
         const op = {
             type: ops_1.MatrixOp.set,
             row,
@@ -179,7 +179,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         const oppositeWindow = oppositeVector.getCollabWindow();
         // Note that the comparison is '>=' because, in the case the MergeTree is regenerating ops for reconnection,
         // the MergeTree submits the op with the original 'localSeq'.
-        common_utils_1.assert(localSeq >= oppositeWindow.localSeq, 0x01c /* "The 'localSeq' of the vector submitting an op must >= the 'localSeq' of the other vector." */);
+        (0, common_utils_1.assert)(localSeq >= oppositeWindow.localSeq, 0x01c /* "The 'localSeq' of the vector submitting an op must >= the 'localSeq' of the other vector." */);
         oppositeWindow.localSeq = localSeq;
         // If the SharedMatrix is local, it's state will be submitted via a Snapshot when initially connected.
         // Do not queue a message or track the pending op, as there will never be an ACK, etc.
@@ -309,10 +309,10 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
     submitLocalMessage(message, localOpMetadata) {
         // TODO: Recommend moving this assertion into SharedObject
         //       (See https://github.com/microsoft/FluidFramework/issues/2559)
-        common_utils_1.assert(this.isAttached() === true, 0x01d /* "Trying to submit message to runtime while detached!" */);
-        super.submitLocalMessage(shared_object_base_1.makeHandlesSerializable(message, this.serializer, this.handle), localOpMetadata);
+        (0, common_utils_1.assert)(this.isAttached() === true, 0x01d /* "Trying to submit message to runtime while detached!" */);
+        super.submitLocalMessage((0, shared_object_base_1.makeHandlesSerializable)(message, this.serializer, this.handle), localOpMetadata);
         // Ensure that row/col 'localSeq' are synchronized (see 'nextLocalSeq()').
-        common_utils_1.assert(this.rows.getCollabWindow().localSeq === this.cols.getCollabWindow().localSeq, 0x01e /* "Row and col collab window 'localSeq' desynchronized!" */);
+        (0, common_utils_1.assert)(this.rows.getCollabWindow().localSeq === this.cols.getCollabWindow().localSeq, 0x01e /* "Row and col collab window 'localSeq' desynchronized!" */);
     }
     didAttach() {
         var _a, _b;
@@ -324,7 +324,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         }
     }
     onConnect() {
-        common_utils_1.assert(this.rows.getCollabWindow().collaborating === this.cols.getCollabWindow().collaborating, 0x01f /* "Row and col collab window 'collaborating' status desynchronized!" */);
+        (0, common_utils_1.assert)(this.rows.getCollabWindow().collaborating === this.cols.getCollabWindow().collaborating, 0x01f /* "Row and col collab window 'collaborating' status desynchronized!" */);
         // Update merge tree collaboration information with new client ID and then resend pending ops
         this.rows.startOrUpdateCollaboration(this.runtime.clientId);
         this.cols.startOrUpdateCollaboration(this.runtime.clientId);
@@ -338,7 +338,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
                 this.submitRowMessage(this.rows.regeneratePendingOp(content, localOpMetadata));
                 break;
             default: {
-                common_utils_1.assert(content.type === ops_1.MatrixOp.set, 0x020 /* "Unknown SharedMatrix 'op' type." */);
+                (0, common_utils_1.assert)(content.type === ops_1.MatrixOp.set, 0x020 /* "Unknown SharedMatrix 'op' type." */);
                 const setOp = content;
                 const { rowHandle, colHandle, localSeq } = localOpMetadata;
                 // If there are more pending local writes to the same row/col handle, it is important
@@ -363,7 +363,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         try {
             await this.rows.load(this.runtime, new runtime_utils_1.ObjectStoragePartition(storage, "rows" /* rows */), this.serializer);
             await this.cols.load(this.runtime, new runtime_utils_1.ObjectStoragePartition(storage, "cols" /* cols */), this.serializer);
-            const [cellData, pendingCliSeqData] = await serialization_1.deserializeBlob(storage, "cells" /* cells */, this.serializer);
+            const [cellData, pendingCliSeqData] = await (0, serialization_1.deserializeBlob)(storage, "cells" /* cells */, this.serializer);
             this.cells = sparsearray2d_1.SparseArray2D.load(cellData);
             this.pending = sparsearray2d_1.SparseArray2D.load(pendingCliSeqData);
         }
@@ -372,17 +372,17 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         }
     }
     processCore(rawMessage, local, localOpMetadata) {
-        const msg = shared_object_base_1.parseHandles(rawMessage, this.serializer);
+        const msg = (0, shared_object_base_1.parseHandles)(rawMessage, this.serializer);
         const contents = msg.contents;
         switch (contents.target) {
             case "cols" /* cols */:
-                this.cols.applyMsg(msg);
+                this.cols.applyMsg(msg, local);
                 break;
             case "rows" /* rows */:
-                this.rows.applyMsg(msg);
+                this.rows.applyMsg(msg, local);
                 break;
             default: {
-                common_utils_1.assert(contents.type === ops_1.MatrixOp.set, 0x021 /* "SharedMatrix message contents have unexpected type!" */);
+                (0, common_utils_1.assert)(contents.type === ops_1.MatrixOp.set, 0x021 /* "SharedMatrix message contents have unexpected type!" */);
                 const { referenceSequenceNumber: refSeq, clientId } = rawMessage;
                 const { row, col } = contents;
                 if (local) {
@@ -403,7 +403,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
                         if (adjustedCol !== undefined) {
                             const rowHandle = this.rows.getAllocatedHandle(adjustedRow);
                             const colHandle = this.cols.getAllocatedHandle(adjustedCol);
-                            common_utils_1.assert(handletable_1.isHandleValid(rowHandle) && handletable_1.isHandleValid(colHandle), 0x022 /* "SharedMatrix row and/or col handles are invalid!" */);
+                            (0, common_utils_1.assert)((0, handletable_1.isHandleValid)(rowHandle) && (0, handletable_1.isHandleValid)(colHandle), 0x022 /* "SharedMatrix row and/or col handles are invalid!" */);
                             // If there is a pending (unACKed) local write to the same cell, skip the current op
                             // since it "happened before" the pending write.
                             if (this.pending.getCell(rowHandle, colHandle) === undefined) {
@@ -433,7 +433,7 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         // Note while we're awaiting the ACK for a local set, it's possible for the row/col to be
         // locally removed and the row/col handles recycled.  If this happens, the pendingLocalSeq will
         // be 'undefined' or > 'localSeq'.
-        common_utils_1.assert(!(pendingLocalSeq < localSeq), 
+        (0, common_utils_1.assert)(!(pendingLocalSeq < localSeq), 
         // eslint-disable-next-line max-len
         0x023 /* "The 'localSeq' of pending write (if any) must be <= the localSeq of the currently processed op." */);
         // If this is the most recent write to the cell by the local client, the stored localSeq
@@ -454,8 +454,43 @@ class SharedMatrix extends shared_object_base_1.SharedObject {
         }
         return `${s}\n`;
     }
-    applyStashedOp() {
-        throw new Error("not implemented");
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    applyStashedOp(content) {
+        if (content.target === "cols" /* cols */ || content.target === "rows" /* rows */) {
+            const op = content;
+            const currentVector = content.target === "cols" /* cols */ ? this.cols : this.rows;
+            const oppositeVector = content.target === "cols" /* cols */ ? this.rows : this.cols;
+            const metadata = currentVector.applyStashedOp(op);
+            const localSeq = currentVector.getCollabWindow().localSeq;
+            const oppositeWindow = oppositeVector.getCollabWindow();
+            (0, common_utils_1.assert)(localSeq > oppositeWindow.localSeq, 0x2d9);
+            oppositeWindow.localSeq = localSeq;
+            return metadata;
+        }
+        else {
+            (0, common_utils_1.assert)(content.type === ops_1.MatrixOp.set, 0x2da /* "Unknown SharedMatrix 'op' type." */);
+            const setOp = content;
+            const rowHandle = this.rows.getAllocatedHandle(setOp.row);
+            const colHandle = this.cols.getAllocatedHandle(setOp.col);
+            if (this.undo !== undefined) {
+                let oldValue = this.cells.getCell(rowHandle, colHandle);
+                if (oldValue === null) {
+                    oldValue = undefined;
+                }
+                this.undo.cellSet(rowHandle, colHandle, oldValue);
+            }
+            this.cells.setCell(rowHandle, colHandle, setOp.value);
+            const localSeq = this.nextLocalSeq();
+            const metadata = {
+                rowHandle,
+                colHandle,
+                localSeq,
+            };
+            this.pending.setCell(rowHandle, colHandle, localSeq);
+            return metadata;
+        }
     }
 }
 exports.SharedMatrix = SharedMatrix;