@aztec/foundation 0.0.0-test.0

package/dest/trees/sibling_path.js

@@ -0,0 +1,144 @@
+import { makeTuple } from '../array/array.js';
+import { pedersenHash } from '../crypto/index.js';
+import { Fr } from '../fields/index.js';
+import { schemas } from '../schemas/index.js';
+import { assertLength, deserializeArrayFromVector, serializeArrayOfBufferableToVector } from '../serialize/index.js';
+import { bufferToHex, hexToBuffer } from '../string/index.js';
+/**
+ * Contains functionality to compute and serialize/deserialize a sibling path.
+ * E.g. Sibling path for a leaf at index 3 in a tree of depth 3 consists of:
+ *      d0:                                            [ root ]
+ *      d1:                      [ ]                                               [*]
+ *      d2:         [*]                      [ ]                       [ ]                     [ ]
+ *      d3:   [ ]         [ ]          [*]         [ ]           [ ]         [ ]          [ ]        [ ].
+ *
+ *      And the elements would be ordered as: [ leaf_at_index_2, node_at_level_2_index_0, node_at_level_1_index_1 ].
+ */ export class SiblingPath {
+    pathSize;
+    data;
+    /**
+   * Constructor.
+   * @param pathSize - The size of the sibling path.
+   * @param path - The sibling path data.
+   */ constructor(/** Size of the sibling path (number of fields it contains). */ pathSize, /** The sibling path data. */ path){
+        this.pathSize = pathSize;
+        this.data = assertLength(path, pathSize);
+    }
+    static get schema() {
+        return schemas.Buffer.transform((b)=>SiblingPath.fromBuffer(b));
+    }
+    static schemaFor(size) {
+        return schemas.Buffer.transform((b)=>SiblingPath.fromBuffer(b)).refine((path)=>path.pathSize === size, (path)=>({
+                message: `Expected sibling path size ${size} but got ${path.pathSize}`
+            }));
+    }
+    toJSON() {
+        return this.toBuffer();
+    }
+    /**
+   * Returns sibling path hashed up from the a element.
+   * @param size - The number of elements in a given path.
+   * @param zeroElement - Value of the zero element.
+   * @param hasher - Implementation of a hasher interface.
+   * @returns A sibling path hashed up from a zero element.
+   */ static ZERO(size, zeroElement, hasher) {
+        const bufs = [];
+        let current = zeroElement;
+        for(let i = 0; i < size; ++i){
+            bufs.push(current);
+            current = hasher.hash(current, current);
+        }
+        return new SiblingPath(size, bufs);
+    }
+    static random(number) {
+        const data = Array.from({
+            length: number
+        }, ()=>Fr.random().toBuffer());
+        return new SiblingPath(number, data);
+    }
+    /**
+   * Serializes this SiblingPath object to a buffer.
+   * @returns The buffer representation of this object.
+   */ toBuffer() {
+        return serializeArrayOfBufferableToVector(this.data);
+    }
+    /**
+   * Returns the path buffer underlying the sibling path.
+   * @returns The Buffer array representation of this object.
+   */ toBufferArray() {
+        return this.data;
+    }
+    /**
+   * Convert the Sibling Path object into an array of field elements.
+   * @returns The field array representation of this object.
+   */ toFields() {
+        return this.data.map((buf)=>Fr.fromBuffer(buf));
+    }
+    /**
+   * Convert Sibling Path object into a tuple of field elements.
+   * @returns A tuple representation of the sibling path.
+   */ toTuple() {
+        const array = this.toFields();
+        return makeTuple(array.length, (i)=>array[i], 0);
+    }
+    /**
+   * Deserializes a SiblingPath from a buffer.
+   * @param buf - A buffer containing the buffer representation of SiblingPath.
+   * @param offset - An offset to start deserializing from.
+   * @returns A SiblingPath object.
+   */ static fromBuffer(buf, offset = 0) {
+        const { elem } = SiblingPath.deserialize(buf, offset);
+        return elem;
+    }
+    /**
+   * Deserializes a SiblingPath object from a slice of a part of a buffer and returns the amount of bytes advanced.
+   * @param buf - A buffer representation of the sibling path.
+   * @param offset - An offset to start deserializing from.
+   * @returns The deserialized sibling path and the number of bytes advanced.
+   */ static deserialize(buf, offset = 0) {
+        const deserializePath = (buf, offset)=>({
+                elem: buf.slice(offset, offset + 32),
+                adv: 32
+            });
+        const { elem, adv } = deserializeArrayFromVector(deserializePath, buf, offset);
+        const size = elem.length;
+        return {
+            elem: new SiblingPath(size, elem),
+            adv
+        };
+    }
+    /**
+   * Serializes this SiblingPath object to a hex string representation.
+   * @returns A hex string representation of the sibling path.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Deserializes a SiblingPath object from a hex string representation.
+   * @param repr - A hex string representation of the sibling path.
+   * @returns A SiblingPath object.
+   */ static fromString(repr) {
+        return SiblingPath.fromBuffer(hexToBuffer(repr));
+    }
+    /**
+   * Generate a subtree path from the current sibling path.
+   * @param subtreeHeight - The size of the subtree that we are getting the path for.
+   * @returns A new sibling path that is the for the requested subtree.
+   */ getSubtreeSiblingPath(subtreeHeight) {
+        // Drop the size of the subtree from the path, and return the rest.
+        const subtreeData = this.data.slice(subtreeHeight);
+        const subtreePathSize = this.pathSize - subtreeHeight;
+        return new SiblingPath(subtreePathSize, subtreeData);
+    }
+}
+/** Computes the expected root of a merkle tree given a leaf and its sibling path. */ export async function computeRootFromSiblingPath(leaf, siblingPath, index, hasher = async (left, right)=>(await pedersenHash([
+        left,
+        right
+    ])).toBuffer()) {
+    let result = leaf;
+    for (const sibling of siblingPath){
+        result = index & 1 ? await hasher(sibling, result) : await hasher(result, sibling);
+        index >>= 1;
+    }
+    return result;
+}

package/dest/trees/unbalanced_merkle_tree.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { sha256Trunc } from '../crypto/sha256/index.js';
+/**
+ * Computes the merkle root for an unbalanced tree.
+ *
+ * @dev Adapted from unbalanced_tree.ts.
+ * Calculates the tree upwards layer by layer until we reach the root.
+ * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
+ * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
+ */
+export declare function computeUnbalancedMerkleRoot(leaves: Buffer[], emptyLeaf?: Buffer, hasher?: typeof sha256Trunc): Buffer;
+export declare function findLeafLevelAndIndex(numLeaves: number, leafIndex: number): {
+    level: number;
+    indexAtLevel: number;
+};
+//# sourceMappingURL=unbalanced_merkle_tree.d.ts.map

package/dest/trees/unbalanced_merkle_tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalanced_merkle_tree.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_merkle_tree.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAExD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,qBAAc,GAAG,MAAM,CAwC9G;AAgDD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;EAGzE"}

package/dest/trees/unbalanced_merkle_tree.js

@@ -0,0 +1,100 @@
+import { padArrayEnd } from '../collection/array.js';
+import { sha256Trunc } from '../crypto/sha256/index.js';
+/**
+ * Computes the merkle root for an unbalanced tree.
+ *
+ * @dev Adapted from unbalanced_tree.ts.
+ * Calculates the tree upwards layer by layer until we reach the root.
+ * The L1 calculation instead computes the tree from right to left (slightly cheaper gas).
+ * TODO: A more thorough investigation of which method is cheaper, then use that method everywhere.
+ */ export function computeUnbalancedMerkleRoot(leaves, emptyLeaf, hasher = sha256Trunc) {
+    // Pad leaves to 2
+    if (leaves.length < 2) {
+        if (emptyLeaf === undefined) {
+            throw new Error('Cannot compute a Merkle root with less than 2 leaves');
+        } else {
+            leaves = padArrayEnd(leaves, emptyLeaf, 2);
+        }
+    }
+    const depth = Math.ceil(Math.log2(leaves.length));
+    let [layerWidth, nodeToShift] = leaves.length & 1 ? [
+        leaves.length - 1,
+        leaves[leaves.length - 1]
+    ] : [
+        leaves.length,
+        Buffer.alloc(0)
+    ];
+    // Allocate this layer's leaves and init the next layer up
+    let thisLayer = leaves.slice(0, layerWidth);
+    let nextLayer = [];
+    for(let i = 0; i < depth; i++){
+        for(let j = 0; j < layerWidth; j += 2){
+            // Store the hash of each pair one layer up
+            nextLayer[j / 2] = hasher(Buffer.concat([
+                thisLayer[j],
+                thisLayer[j + 1]
+            ]));
+        }
+        layerWidth /= 2;
+        if (layerWidth & 1) {
+            if (nodeToShift.length) {
+                // If the next layer has odd length, and we have a node that needs to be shifted up, add it here
+                nextLayer.push(nodeToShift);
+                layerWidth += 1;
+                nodeToShift = Buffer.alloc(0);
+            } else {
+                // If we don't have a node waiting to be shifted, store the next layer's final node to be shifted
+                layerWidth -= 1;
+                nodeToShift = nextLayer[layerWidth];
+            }
+        }
+        // reset the layers
+        thisLayer = nextLayer;
+        nextLayer = [];
+    }
+    // return the root
+    return thisLayer[0];
+}
+function getMaxBalancedTreeDepth(numLeaves) {
+    return Math.floor(Math.log2(numLeaves));
+}
+function getMaxUnbalancedTreeDepth(numLeaves) {
+    return Math.ceil(Math.log2(numLeaves));
+}
+function findPosition(rootLevel, leafLevel, numLeaves, indexOffset, targetIndex) {
+    if (numLeaves <= 1) {
+        // Single leaf.
+        return {
+            level: rootLevel,
+            indexAtLevel: indexOffset
+        };
+    }
+    // The largest balanced tree that can be created with the given number of leaves.
+    const maxBalancedTreeDepth = getMaxBalancedTreeDepth(numLeaves);
+    const numBalancedLeaves = 2 ** maxBalancedTreeDepth;
+    const numRemainingLeaves = numLeaves - numBalancedLeaves;
+    if (targetIndex < numBalancedLeaves) {
+        // Target is in the balanced tree.
+        // - If numRemainingLeaves is 0: this balanced tree is grown from the current root.
+        // - If numRemainingLeaves is not 0: the remaining leaves will form another tree, which will become the right child of the root.
+        //   And the balanced tree will be the left child of the root.
+        //   There will be an extra level between the root of the balanced tree and the current root.
+        const extraLevel = numRemainingLeaves ? 1 : 0;
+        return {
+            level: rootLevel + maxBalancedTreeDepth + extraLevel,
+            indexAtLevel: indexOffset + targetIndex
+        };
+    } else {
+        // Target is in the right branch.
+        const rightBranchMaxLevel = getMaxUnbalancedTreeDepth(numRemainingLeaves);
+        const shiftedUp = leafLevel - rootLevel - rightBranchMaxLevel - 1;
+        const nextLeafLevel = leafLevel - shiftedUp;
+        const newIndexOffset = indexOffset + numBalancedLeaves >> shiftedUp;
+        const shiftedTargetIndex = targetIndex - numBalancedLeaves;
+        return findPosition(rootLevel + 1, nextLeafLevel, numRemainingLeaves, newIndexOffset, shiftedTargetIndex);
+    }
+}
+export function findLeafLevelAndIndex(numLeaves, leafIndex) {
+    const maxLevel = getMaxUnbalancedTreeDepth(numLeaves);
+    return findPosition(0, maxLevel, numLeaves, 0, leafIndex);
+}

package/dest/trees/unbalanced_tree_store.d.ts

@@ -0,0 +1,19 @@
+export interface TreeNodeLocation {
+    level: number;
+    index: number;
+}
+export declare class UnbalancedTreeStore<T> {
+    #private;
+    constructor(numLeaves: number);
+    setLeaf(leafIndex: number, value: T): TreeNodeLocation;
+    setNode({ level, index }: TreeNodeLocation, value: T): void;
+    getParentLocation({ level, index }: TreeNodeLocation): TreeNodeLocation;
+    getSiblingLocation({ level, index }: TreeNodeLocation): TreeNodeLocation;
+    getChildLocations({ level, index }: TreeNodeLocation): [TreeNodeLocation, TreeNodeLocation];
+    getLeaf(leafIndex: number): T | undefined;
+    getNode(location: TreeNodeLocation): T | undefined;
+    getParent(location: TreeNodeLocation): T | undefined;
+    getSibling(location: TreeNodeLocation): T | undefined;
+    getChildren(location: TreeNodeLocation): [T | undefined, T | undefined];
+}
+//# sourceMappingURL=unbalanced_tree_store.d.ts.map

package/dest/trees/unbalanced_tree_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbalanced_tree_store.d.ts","sourceRoot":"","sources":["../../src/trees/unbalanced_tree_store.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAOD,qBAAa,mBAAmB,CAAC,CAAC;;gBAIpB,SAAS,EAAE,MAAM;IAI7B,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,gBAAgB;IAiBtD,OAAO,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC;IAWpD,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;IAQvE,kBAAkB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;IAQxE,iBAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,gBAAgB,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAM3F,OAAO,CAAC,SAAS,EAAE,MAAM;IASzB,OAAO,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS;IAIlD,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS;IAKpD,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,GAAG,SAAS;IAKrD,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,SAAS,CAAC;CAQxE"}

package/dest/trees/unbalanced_tree_store.js

@@ -0,0 +1,94 @@
+import { findLeafLevelAndIndex } from './unbalanced_merkle_tree.js';
+export class UnbalancedTreeStore {
+    #nodeMapping = new Map();
+    #numLeaves;
+    constructor(numLeaves){
+        this.#numLeaves = numLeaves;
+    }
+    setLeaf(leafIndex, value) {
+        if (leafIndex >= this.#numLeaves) {
+            throw new Error(`Expected at most ${this.#numLeaves} leaves. Received a leaf at index ${leafIndex}.`);
+        }
+        const { level, indexAtLevel } = findLeafLevelAndIndex(this.#numLeaves, leafIndex);
+        const location = {
+            level,
+            index: indexAtLevel
+        };
+        this.#nodeMapping.set(this.#getKey(location), {
+            location,
+            value
+        });
+        return location;
+    }
+    setNode({ level, index }, value) {
+        const location = {
+            level,
+            index
+        };
+        this.#nodeMapping.set(this.#getKey(location), {
+            location,
+            value
+        });
+    }
+    getParentLocation({ level, index }) {
+        if (level === 0) {
+            throw new Error('Tree root does not have a parent.');
+        }
+        return {
+            level: level - 1,
+            index: Math.floor(index / 2)
+        };
+    }
+    getSiblingLocation({ level, index }) {
+        if (level === 0) {
+            throw new Error('Tree root does not have a sibling.');
+        }
+        return {
+            level,
+            index: index % 2 ? index - 1 : index + 1
+        };
+    }
+    getChildLocations({ level, index }) {
+        const left = {
+            level: level + 1,
+            index: index * 2
+        };
+        const right = {
+            level: level + 1,
+            index: index * 2 + 1
+        };
+        return [
+            left,
+            right
+        ];
+    }
+    getLeaf(leafIndex) {
+        const { level, indexAtLevel } = findLeafLevelAndIndex(this.#numLeaves, leafIndex);
+        const location = {
+            level,
+            index: indexAtLevel
+        };
+        return this.getNode(location);
+    }
+    getNode(location) {
+        return this.#nodeMapping.get(this.#getKey(location))?.value;
+    }
+    getParent(location) {
+        const parentLocation = this.getParentLocation(location);
+        return this.getNode(parentLocation);
+    }
+    getSibling(location) {
+        const siblingLocation = this.getSiblingLocation(location);
+        return this.getNode(siblingLocation);
+    }
+    getChildren(location) {
+        const [left, right] = this.getChildLocations(location);
+        return [
+            this.getNode(left),
+            this.getNode(right)
+        ];
+    }
+    #getKey(location) {
+        return `${location.level}-${location.index}`;
+    }
+}

package/dest/types/index.d.ts

@@ -0,0 +1,19 @@
+/** Strips methods of a type. */
+export type FieldsOf<T> = {
+    [P in keyof T as T[P] extends Function ? never : P]: T[P];
+};
+/** Extracts methods of a type. */
+export type FunctionsOf<T> = {
+    [P in keyof T as T[P] extends Function ? P : never]: T[P];
+};
+/** Marks a set of properties of a type as optional. */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/** Removes readonly modifiers for a type. */
+export type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/** Removes readonly modifiers for an object. */
+export declare function unfreeze<T>(obj: T): Writeable<T>;
+/** Maybe exists, maybe not. */
+export type Maybe<T extends object> = T | unknown;
+//# sourceMappingURL=index.d.ts.map

package/dest/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;KAEvB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,kCAAkC;AAClC,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KAE1B,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE/E,6CAA6C;AAC7C,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAE9D,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEhD;AAED,+BAA+B;AAC/B,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG,OAAO,CAAC"}

package/dest/types/index.js

@@ -0,0 +1,3 @@
+/** Strips methods of a type. */ /** Removes readonly modifiers for an object. */ export function unfreeze(obj) {
+    return obj;
+}

package/dest/url/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * File URI to Path function.
+ *
+ * @param {String} uri
+ * @return {String} path
+ * @api public
+ */
+export declare function fileURLToPath(uri: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dest/url/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/url/index.ts"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AAEH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA4CjD"}

package/dest/url/index.js

@@ -0,0 +1,62 @@
+/* eslint-disable */ // Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// 'Software'), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+import { sep } from 'path';
+/**
+ * File URI to Path function.
+ *
+ * @param {String} uri
+ * @return {String} path
+ * @api public
+ */ export function fileURLToPath(uri) {
+    if (typeof uri !== 'string' || uri.length <= 7 || uri.substring(0, 7) !== 'file://') {
+        throw new TypeError('must pass in a file:// URI to convert to a file path');
+    }
+    const rest = decodeURI(uri.substring(7));
+    const firstSlash = rest.indexOf('/');
+    let host = rest.substring(0, firstSlash);
+    let path = rest.substring(firstSlash + 1);
+    // 2.  Scheme Definition
+    // As a special case, <host> can be the string "localhost" or the empty
+    // string; this is interpreted as "the machine from which the URL is
+    // being interpreted".
+    if (host === 'localhost') {
+        host = '';
+    }
+    if (host) {
+        host = sep + sep + host;
+    }
+    // 3.2  Drives, drive letters, mount points, file system root
+    // Drive letters are mapped into the top of a file URI in various ways,
+    // depending on the implementation; some applications substitute
+    // vertical bar ("|") for the colon after the drive letter, yielding
+    // "file:///c|/tmp/test.txt".  In some cases, the colon is left
+    // unchanged, as in "file:///c:/tmp/test.txt".  In other cases, the
+    // colon is simply omitted, as in "file:///c/tmp/test.txt".
+    path = path.replace(/^(.+)\|/, '$1:');
+    // for Windows, we need to invert the path separators from what a URI uses
+    if (sep === '\\') {
+        path = path.replace(/\//g, '\\');
+    }
+    if (/^.+:/.test(path)) {
+    // has Windows drive at beginning of path
+    } else {
+        // unix path…
+        path = sep + path;
+    }
+    return host + path;
+}

package/dest/validation/index.d.ts

@@ -0,0 +1,9 @@
+/** Utility function to throw an error if a required value is missing. */
+export declare function required<T>(value: T | undefined, errMsg?: string): T;
+/**
+ * Helper function to assert a condition is truthy
+ * @param x - A boolean condition to assert.
+ * @param err - Error message to throw if x isn't met.
+ */
+export declare function assert(x: any, err: string): asserts x;
+//# sourceMappingURL=index.d.ts.map

package/dest/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validation/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,CAKpE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAIrD"}

package/dest/validation/index.js

@@ -0,0 +1,15 @@
+/** Utility function to throw an error if a required value is missing. */ export function required(value, errMsg) {
+    if (value === undefined) {
+        throw new Error(errMsg || 'Value is required');
+    }
+    return value;
+}
+/**
+ * Helper function to assert a condition is truthy
+ * @param x - A boolean condition to assert.
+ * @param err - Error message to throw if x isn't met.
+ */ export function assert(x, err) {
+    if (!x) {
+        throw new Error(err);
+    }
+}

package/dest/wasm/empty_wasi_sdk.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Dummy implementation of a necessary part of the wasi api:
+ * https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
+ * We don't use these functions, but the environment expects them.
+ * TODO find a way to update off of wasi 12.
+ */
+export declare const getEmptyWasiSdk: (debug?: import("../log/log_fn.js").LogFn) => {
+    /**
+     * Retrieves the current time from the system clock.
+     * This function is a dummy implementation of the WASI API's `clock_time_get` method,
+     * which is expected by the environment but not used in this context.
+     *
+     * No input parameters or return values are required, as the purpose of this function
+     * is solely to satisfy the environment expectations and provide debugging information.
+     */
+    clock_time_get(): void;
+    /**
+     * Dummy implementation of WASI's environ_get function.
+     * This function is used to obtain a snapshot of the current environment variables.
+     * In this dummy implementation, no actual actions are performed, but the debug logger logs 'environ_get' when called.
+     * Environment variables are not used in this context, so the real implementation is not required.
+     *
+     * @see https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#environ_get
+     */
+    environ_get(): void;
+    /**
+     * Retrieves the environment variable sizes from the WebAssembly environment.
+     * This function is part of the WASI API and provides a dummy implementation to fulfill the expected APIs.
+     * It does not have any actual functionality, but serves as a placeholder in the environment.
+     */
+    environ_sizes_get(): void;
+    /**
+     * Closes a file descriptor, releasing any resources associated with it.
+     * This function does not perform any actual closing operation, but exists to
+     * satisfy the requirements of the WebAssembly System Interface (WASI) API,
+     * which expects certain functions to be present for compatibility purposes.
+     *
+     * @see https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
+     */
+    fd_close(): void;
+    /**
+     * A dummy implementation of the 'fd_read' function from the WASI API.
+     * This function is required by the environment, but not used in this context.
+     * It would normally read data from a file descriptor into an array buffer,
+     * but here it simply logs the invocation for debugging purposes.
+     */
+    fd_read(): void;
+    /**
+     * Handles the file descriptor write operation.
+     * This dummy implementation of the WASI 'fd_write' function is part of the wasi API:
+     * https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
+     * The environment expects this function, but it is not used in the current implementation.
+     * It is used to write data from WebAssembly memory to a file descriptor.
+     */
+    fd_write(): void;
+    /**
+     * Perform a file seek operation on the given file descriptor to change its current position.
+     * The new position is calculated using the provided offset and whence values.
+     * Throws an error if the file descriptor is invalid or the operation cannot be performed.
+     *
+     * @param fd - The file descriptor of the file to perform the seek operation on.
+     * @param offset - The relative offset to apply, based on the whence value.
+     * @param whence - The reference point from which the offset should be calculated. One of SEEK_SET (start), SEEK_CUR (current), or SEEK_END (end).
+     * @returns The new position in the file after the seek operation has been performed.
+     */
+    fd_seek(): void;
+    /**
+     * This function is a dummy implementation of the 'fd_fdstat_get' function in the WebAssembly System Interface (WASI) API.
+     * Although not actually used in this context, it is present due to the environment's expectation of its existence.
+     * The 'fd_fdstat_get' function is typically responsible for obtaining file descriptor status information.
+     */
+    fd_fdstat_get(): void;
+    /**
+     * Sets the file descriptor flags for a given file descriptor.
+     * This function is a dummy implementation of the WASI API function 'fd_fdstat_set_flags'.
+     * It currently does not perform any operation but logs the function call with a debug instance.
+     * This is provided since the environment expects this function to be present.
+     */
+    fd_fdstat_set_flags(): void;
+    /**
+     * Handles the `fd_prestat_get` function call for the dummy WebAssembly System Interface (WASI) implementation.
+     * This function is expected by the WASI environment, although it is not used in this implementation.
+     * The `fd_prestat_get` function retrieves pre-opened file descriptor properties.
+     *
+     * @returns A constant integer value indicating successful completion of the function call.
+     */
+    fd_prestat_get(): number;
+    /**
+     * Provides a dummy implementation for the `fd_prestat_dir_name` function, which is expected to be called by the WASI environment.
+     * This function is intended to retrieve the pre-opened directory's path associated with the given file descriptor. However, since it's a dummy implementation,
+     * it doesn't perform any actual operation and only logs the function call with the provided debug logger.
+     *
+     * @returns A constant number representing a dummy return value for the function call.
+     */
+    fd_prestat_dir_name(): number;
+    /**
+     * Handles the opening of a file path within the WASI environment.
+     * This function is a dummy implementation required for compatibility with
+     * the WebAssembly System Interface (WASI) API, but it does not perform any
+     * actual file opening operation. It is mainly used for debugging purposes.
+     */
+    path_open(): void;
+    /**
+     * Retrieve file system information of the specified path.
+     * This function retrieves statistics, such as size and permissions, associated with the file or directory
+     * identified by the given path. In case of an error or non-existing path, appropriate debug logs will be generated.
+     *
+     * @returns An object containing file statistics like size, permissions, etc.
+     */
+    path_filestat_get(): void;
+    /**
+     * Terminate the process normally, performing the regular cleanup for terminating programs.
+     * The input 'status' represents the exit code and is used to indicate success or failure
+     * of the program execution. A zero value typically indicates successful execution,
+     * while non-zero values are treated as errors by the operating system.
+     *
+     * @param status - The exit code representing the success or failure of the program execution.
+     * @returns The exit status code.
+     */
+    proc_exit(): number;
+    /**
+     * Generates a random number and returns it.
+     * This dummy implementation of 'random_get' method in the wasi API is expected by the environment.
+     * In this case, the function always returns 1 to maintain consistency with the environment's expectations.
+     *
+     * @returns A random number. In this implementation, always returns 1.
+     */
+    random_get(): number;
+};
+//# sourceMappingURL=empty_wasi_sdk.d.ts.map

package/dest/wasm/empty_wasi_sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty_wasi_sdk.d.ts","sourceRoot":"","sources":["../../src/wasm/empty_wasi_sdk.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,eAAO,MAAM,eAAe;IAC1B;;;;;;;OAOG;;IAIH;;;;;;;OAOG;;IAIH;;;;OAIG;;IAIH;;;;;;;OAOG;;IAIH;;;;;OAKG;;IAIH;;;;;;OAMG;;IAIH;;;;;;;;;OASG;;IAIH;;;;OAIG;;IAIH;;;;;OAKG;;IAIH;;;;;;OAMG;;IAKH;;;;;;OAMG;;IAKH;;;;;OAKG;;IAIH;;;;;;OAMG;;IAIH;;;;;;;;OAQG;;IAKH;;;;;;OAMG;;CAKH,CAAC"}