typesea 0.1.0

package/dist/optimize/fold-scalar.js

@@ -0,0 +1,174 @@
+/**
+ * @file fold-scalar.ts
+ * @brief Constant folding for scalar graph nodes.
+ */
+import { NodeTag } from "../kind/index.js";
+import { ensureConst, isFiniteNumber, isPlainRecord, keep, readConst, replace } from "./fold-common.js";
+/**
+ * @brief fold get prop.
+ */
+export function foldGetProp(node, nodes, aliases) {
+    const value = readConst(nodes, node.object);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, undefined));
+    }
+    return keep(node);
+}
+/**
+ * @brief fold unary.
+ */
+export function foldUnary(node, nodes, aliases) {
+    const value = readConst(nodes, node.value);
+    if (!value.found) {
+        return keep(node);
+    }
+    switch (node.tag) {
+        case NodeTag.IsString:
+            return replace(node, ensureConst(nodes, aliases, typeof value.value === "string"));
+        case NodeTag.IsNumber:
+            return replace(node, ensureConst(nodes, aliases, isFiniteNumber(value.value)));
+        case NodeTag.IsBoolean:
+            return replace(node, ensureConst(nodes, aliases, typeof value.value === "boolean"));
+        case NodeTag.IsObject:
+            return replace(node, ensureConst(nodes, aliases, isPlainRecord(value.value)));
+        case NodeTag.IsArray:
+            return replace(node, ensureConst(nodes, aliases, Array.isArray(value.value)));
+        case NodeTag.IsUndefined:
+            return replace(node, ensureConst(nodes, aliases, value.value === undefined));
+        case NodeTag.IsNull:
+            return replace(node, ensureConst(nodes, aliases, value.value === null));
+        case NodeTag.IsInteger:
+            return replace(node, ensureConst(nodes, aliases, Number.isInteger(value.value)));
+        case NodeTag.Not:
+            return replace(node, ensureConst(nodes, aliases, value.value !== true));
+        case NodeTag.IsBigInt:
+            return replace(node, ensureConst(nodes, aliases, typeof value.value === "bigint"));
+        case NodeTag.IsSymbol:
+            return replace(node, ensureConst(nodes, aliases, typeof value.value === "symbol"));
+    }
+}
+/**
+ * @brief fold equals.
+ */
+export function foldEquals(node, nodes, aliases) {
+    const left = readConst(nodes, node.left);
+    const right = readConst(nodes, node.right);
+    if (!left.found || !right.found) {
+        return keep(node);
+    }
+    return replace(node, ensureConst(nodes, aliases, Object.is(left.value, right.value)));
+}
+/**
+ * @brief fold numeric.
+ */
+export function foldNumeric(node, nodes, aliases) {
+    const left = readConst(nodes, node.left);
+    const right = readConst(nodes, node.right);
+    if (!left.found || !right.found) {
+        return keep(node);
+    }
+    const valid = typeof left.value === "number" && typeof right.value === "number";
+    const result = valid && (node.tag === NodeTag.Gte
+        ? left.value >= right.value
+        : left.value <= right.value);
+    return replace(node, ensureConst(nodes, aliases, result));
+}
+/**
+ * @brief fold string bound.
+ */
+export function foldStringBound(node, nodes, aliases) {
+    const value = readConst(nodes, node.value);
+    if (!value.found) {
+        return keep(node);
+    }
+    const result = typeof value.value === "string" && (node.tag === NodeTag.StringMin
+        ? value.value.length >= node.bound
+        : value.value.length <= node.bound);
+    return replace(node, ensureConst(nodes, aliases, result));
+}
+/**
+ * @brief fold regex.
+ */
+export function foldRegex(node, nodes, aliases) {
+    const value = readConst(nodes, node.value);
+    if (!value.found) {
+        return keep(node);
+    }
+    if (typeof value.value !== "string") {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    node.regex.lastIndex = 0;
+    const result = node.regex.test(value.value);
+    node.regex.lastIndex = 0;
+    return replace(node, ensureConst(nodes, aliases, result));
+}
+/**
+ * @brief fold has own.
+ */
+export function foldHasOwn(node, nodes, aliases) {
+    const value = readConst(nodes, node.object);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    return keep(node);
+}
+/**
+ * @brief fold has own data.
+ */
+export function foldHasOwnData(node, nodes, aliases) {
+    const value = readConst(nodes, node.object);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    return keep(node);
+}
+/**
+ * @brief fold strict keys.
+ */
+export function foldStrictKeys(node, nodes, aliases) {
+    const value = readConst(nodes, node.object);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    return keep(node);
+}
+/**
+ * @brief fold array every.
+ */
+export function foldArrayEvery(node, nodes, aliases) {
+    const value = readConst(nodes, node.value);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    return keep(node);
+}
+/**
+ * @brief fold tuple items.
+ */
+export function foldTupleItems(node, nodes, aliases) {
+    const value = readConst(nodes, node.value);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    return keep(node);
+}
+/**
+ * @brief fold record every.
+ */
+export function foldRecordEvery(node, nodes, aliases) {
+    const value = readConst(nodes, node.value);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    return keep(node);
+}
+/**
+ * @brief fold discriminant dispatch.
+ */
+export function foldDiscriminantDispatch(node, nodes, aliases) {
+    const value = readConst(nodes, node.value);
+    if (value.found) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    return keep(node);
+}

package/dist/optimize/fold.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file fold.ts
+ * @brief Constant folding pass driver.
+ */
+import type { Graph } from "../ir/index.js";
+/**
+ * @brief fold constants.
+ */
+export declare function foldConstants(graph: Graph): Graph;
+//# sourceMappingURL=fold.d.ts.map

package/dist/optimize/fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/optimize/fold.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,KAAK,EAGN,MAAM,gBAAgB,CAAC;AAoBxB;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAsCjD"}

package/dist/optimize/fold.js

@@ -0,0 +1,103 @@
+/**
+ * @file fold.ts
+ * @brief Constant folding pass driver.
+ */
+import { NodeTag } from "../kind/index.js";
+import { foldAnd, foldOr } from "./fold-boolean.js";
+import { keep } from "./fold-common.js";
+import { foldArrayEvery, foldDiscriminantDispatch, foldEquals, foldGetProp, foldHasOwn, foldHasOwnData, foldNumeric, foldRecordEvery, foldRegex, foldStrictKeys, foldStringBound, foldTupleItems, foldUnary } from "./fold-scalar.js";
+import { resolveAlias, rewriteNodeDeps } from "./rewrite.js";
+/**
+ * @brief fold constants.
+ */
+export function foldConstants(graph) {
+    const originalLength = graph.nodes.length;
+    const nodes = graph.nodes.slice();
+    const aliases = new Array(nodes.length);
+    for (let index = 0; index < aliases.length; index += 1) {
+        aliases[index] = index;
+    }
+    for (let index = 0; index < originalLength; index += 1) {
+        const node = nodes[index];
+        if (node === undefined) {
+            continue;
+        }
+        const rewritten = rewriteNodeDeps(node, aliases);
+        const folded = foldNode(rewritten, nodes, aliases);
+        nodes[index] = folded.node;
+        if (folded.replacement !== undefined) {
+            aliases[index] = folded.replacement;
+        }
+    }
+    for (let index = 0; index < aliases.length; index += 1) {
+        aliases[index] = resolveAlias(index, aliases);
+    }
+    const rewritten = new Array(nodes.length);
+    for (let index = 0; index < nodes.length; index += 1) {
+        const node = nodes[index];
+        if (node !== undefined) {
+            rewritten[index] = rewriteNodeDeps(node, aliases);
+        }
+    }
+    return {
+        nodes: rewritten,
+        entry: resolveAlias(graph.entry, aliases),
+        result: resolveAlias(graph.result, aliases)
+    };
+}
+/**
+ * @brief fold node.
+ */
+function foldNode(node, nodes, aliases) {
+    switch (node.tag) {
+        case NodeTag.Start:
+        case NodeTag.Param:
+        case NodeTag.Const:
+        case NodeTag.Return:
+            return keep(node);
+        case NodeTag.GetProp:
+            return foldGetProp(node, nodes, aliases);
+        case NodeTag.IsString:
+        case NodeTag.IsNumber:
+        case NodeTag.IsBoolean:
+        case NodeTag.IsObject:
+        case NodeTag.IsArray:
+        case NodeTag.IsUndefined:
+        case NodeTag.IsNull:
+        case NodeTag.IsInteger:
+        case NodeTag.Not:
+        case NodeTag.IsBigInt:
+        case NodeTag.IsSymbol:
+            return foldUnary(node, nodes, aliases);
+        case NodeTag.Equals:
+            return foldEquals(node, nodes, aliases);
+        case NodeTag.Gte:
+        case NodeTag.Lte:
+            return foldNumeric(node, nodes, aliases);
+        case NodeTag.StringMin:
+        case NodeTag.StringMax:
+            return foldStringBound(node, nodes, aliases);
+        case NodeTag.Regex:
+            return foldRegex(node, nodes, aliases);
+        case NodeTag.HasOwn:
+            return foldHasOwn(node, nodes, aliases);
+        case NodeTag.HasOwnData:
+            return foldHasOwnData(node, nodes, aliases);
+        case NodeTag.StrictKeys:
+            return foldStrictKeys(node, nodes, aliases);
+        case NodeTag.ArrayEvery:
+            return foldArrayEvery(node, nodes, aliases);
+        case NodeTag.TupleItems:
+            return foldTupleItems(node, nodes, aliases);
+        case NodeTag.RecordEvery:
+            return foldRecordEvery(node, nodes, aliases);
+        case NodeTag.DiscriminantDispatch:
+            return foldDiscriminantDispatch(node, nodes, aliases);
+        case NodeTag.SchemaCheck:
+            return keep(node);
+        case NodeTag.And:
+            return foldAnd(node, nodes, aliases);
+        case NodeTag.Or:
+            return foldOr(node, nodes, aliases);
+    }
+}

package/dist/optimize/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file index.ts
+ * @brief Public graph optimizer pipeline.
+ */
+import { type Graph } from "../ir/index.js";
+/**
+ * @brief optimize graph.
+ */
+export declare function optimizeGraph(graph: Graph): Graph;
+//# sourceMappingURL=index.d.ts.map

package/dist/optimize/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/optimize/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGL,KAAK,KAAK,EACX,MAAM,gBAAgB,CAAC;AAIxB;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAGjD"}

package/dist/optimize/index.js

@@ -0,0 +1,23 @@
+/**
+ * @file index.ts
+ * @brief Public graph optimizer pipeline.
+ */
+import { freezeGraph, isGraphValue } from "../ir/index.js";
+import { compactReachable } from "./compact.js";
+import { foldConstants } from "./fold.js";
+/**
+ * @brief optimize graph.
+ */
+export function optimizeGraph(graph) {
+    const input = readGraph(graph);
+    return freezeGraph(compactReachable(foldConstants(input)));
+}
+/**
+ * @brief read graph.
+ */
+function readGraph(value) {
+    if (!isGraphValue(value)) {
+        throw new TypeError("optimizeGraph requires a valid TypeSea graph");
+    }
+    return freezeGraph(value);
+}

package/dist/optimize/map-node.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file map-node.ts
+ * @brief Shared graph node-id mapping utility.
+ */
+import type { GraphNode, NodeId } from "../ir/index.js";
+/**
+ * @brief node id mapper.
+ * @details Converts one graph node id into the id visible in a rewritten graph.
+ * @invariant The caller owns range validation for the returned id.
+ */
+export type NodeIdMapper = (value: NodeId) => NodeId;
+/**
+ * @brief map node ids.
+ * @details Rebuilds one graph node with all dependency ids rewritten by the supplied mapper.
+ * @param node Borrowed graph node; payload fields are reused when their ids do not change.
+ * @param mapId Borrowed mapper applied to every dependency-bearing node id.
+ * @param id Replacement id for the returned node.
+ * @returns Graph node with rewritten id-bearing fields.
+ */
+export declare function mapNodeIds(node: GraphNode, mapId: NodeIdMapper, id: NodeId): GraphNode;
+//# sourceMappingURL=map-node.d.ts.map

package/dist/optimize/map-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-node.d.ts","sourceRoot":"","sources":["../../src/optimize/map-node.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,SAAS,EACT,MAAM,EACP,MAAM,gBAAgB,CAAC;AAExB;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,YAAY,EACnB,EAAE,EAAE,MAAM,GACT,SAAS,CA+LX"}

package/dist/optimize/map-node.js

@@ -0,0 +1,222 @@
+/**
+ * @file map-node.ts
+ * @brief Shared graph node-id mapping utility.
+ */
+import { NodeTag } from "../kind/index.js";
+/**
+ * @brief map node ids.
+ * @details Rebuilds one graph node with all dependency ids rewritten by the supplied mapper.
+ * @param node Borrowed graph node; payload fields are reused when their ids do not change.
+ * @param mapId Borrowed mapper applied to every dependency-bearing node id.
+ * @param id Replacement id for the returned node.
+ * @returns Graph node with rewritten id-bearing fields.
+ */
+export function mapNodeIds(node, mapId, id) {
+    switch (node.tag) {
+        case NodeTag.Start:
+            return {
+                id,
+                tag: node.tag,
+                deps: []
+            };
+        case NodeTag.Param:
+            return {
+                id,
+                tag: node.tag,
+                deps: [],
+                name: node.name
+            };
+        case NodeTag.Const:
+            return {
+                id,
+                tag: node.tag,
+                deps: [],
+                value: node.value
+            };
+        case NodeTag.GetProp: {
+            const object = mapId(node.object);
+            return {
+                id,
+                tag: node.tag,
+                deps: [object],
+                object,
+                key: node.key
+            };
+        }
+        case NodeTag.IsString:
+        case NodeTag.IsNumber:
+        case NodeTag.IsBoolean:
+        case NodeTag.IsObject:
+        case NodeTag.IsArray:
+        case NodeTag.IsUndefined:
+        case NodeTag.IsNull:
+        case NodeTag.IsInteger:
+        case NodeTag.Not:
+        case NodeTag.IsBigInt:
+        case NodeTag.IsSymbol: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value
+            };
+        }
+        case NodeTag.Equals:
+        case NodeTag.Gte:
+        case NodeTag.Lte: {
+            const left = mapId(node.left);
+            const right = mapId(node.right);
+            return {
+                id,
+                tag: node.tag,
+                deps: [left, right],
+                left,
+                right
+            };
+        }
+        case NodeTag.StringMin:
+        case NodeTag.StringMax: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value,
+                bound: node.bound
+            };
+        }
+        case NodeTag.Regex: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value,
+                regex: node.regex,
+                name: node.name
+            };
+        }
+        case NodeTag.HasOwn: {
+            const object = mapId(node.object);
+            return {
+                id,
+                tag: node.tag,
+                deps: [object],
+                object,
+                key: node.key
+            };
+        }
+        case NodeTag.HasOwnData: {
+            const object = mapId(node.object);
+            return {
+                id,
+                tag: node.tag,
+                deps: [object],
+                object,
+                key: node.key
+            };
+        }
+        case NodeTag.StrictKeys: {
+            const object = mapId(node.object);
+            return {
+                id,
+                tag: node.tag,
+                deps: [object],
+                object,
+                keys: node.keys
+            };
+        }
+        case NodeTag.ArrayEvery: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value,
+                item: node.item
+            };
+        }
+        case NodeTag.TupleItems: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value,
+                items: node.items
+            };
+        }
+        case NodeTag.RecordEvery: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value,
+                item: node.item
+            };
+        }
+        case NodeTag.DiscriminantDispatch: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value,
+                key: node.key,
+                literals: node.literals,
+                schemas: node.schemas,
+                lookup: node.lookup
+            };
+        }
+        case NodeTag.SchemaCheck: {
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [value],
+                value,
+                schema: node.schema
+            };
+        }
+        case NodeTag.And:
+        case NodeTag.Or: {
+            const values = mapNodeIdArray(node.values, mapId);
+            return {
+                id,
+                tag: node.tag,
+                deps: values,
+                values
+            };
+        }
+        case NodeTag.Return: {
+            const control = mapId(node.control);
+            const value = mapId(node.value);
+            return {
+                id,
+                tag: node.tag,
+                deps: [control, value],
+                control,
+                value
+            };
+        }
+    }
+}
+/**
+ * @brief map node id array.
+ * @details Applies one mapper to a dense node-id vector.
+ * @param values Borrowed input vector.
+ * @param mapId Borrowed mapper applied to each slot.
+ * @returns New dense vector with mapped ids.
+ */
+function mapNodeIdArray(values, mapId) {
+    const mapped = new Array(values.length);
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value !== undefined) {
+            mapped[index] = mapId(value);
+        }
+    }
+    return mapped;
+}

package/dist/optimize/remap.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file optimize-remap.ts
+ * @brief Dense node-id remapping helpers for graph compaction.
+ */
+import type { GraphNode, NodeId } from "../ir/index.js";
+/**
+ * @brief remap node.
+ * @details Applies a compacted id table to one graph node and its dependencies.
+ * @param node Borrowed graph node from the old dense graph.
+ * @param remap Borrowed old-id to new-id table.
+ * @returns Graph node rewritten into the compacted id space.
+ */
+export declare function remapNode(node: GraphNode, remap: readonly NodeId[]): GraphNode;
+/**
+ * @brief remap id.
+ * @details Reads one mandatory entry from the compacted id table.
+ * @param value Borrowed old node id.
+ * @param remap Borrowed old-id to new-id table.
+ * @returns New node id for the compacted graph.
+ */
+export declare function remapId(value: NodeId, remap: readonly NodeId[]): NodeId;
+/**
+ * @brief remap ids.
+ * @details Applies a compacted id table to a dense node-id vector.
+ * @param values Borrowed old-id vector.
+ * @param remap Borrowed old-id to new-id table.
+ * @returns New dense vector in compacted id space.
+ */
+export declare function remapIds(values: readonly NodeId[], remap: readonly NodeId[]): NodeId[];
+//# sourceMappingURL=remap.d.ts.map

package/dist/optimize/remap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remap.d.ts","sourceRoot":"","sources":["../../src/optimize/remap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,MAAM,EACP,MAAM,gBAAgB,CAAC;AAGxB;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,SAAS,CAMX;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMvE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAStF"}

package/dist/optimize/remap.js

@@ -0,0 +1,46 @@
+/**
+ * @file optimize-remap.ts
+ * @brief Dense node-id remapping helpers for graph compaction.
+ */
+import { mapNodeIds } from "./map-node.js";
+/**
+ * @brief remap node.
+ * @details Applies a compacted id table to one graph node and its dependencies.
+ * @param node Borrowed graph node from the old dense graph.
+ * @param remap Borrowed old-id to new-id table.
+ * @returns Graph node rewritten into the compacted id space.
+ */
+export function remapNode(node, remap) {
+    return mapNodeIds(node, (value) => remapId(value, remap), remapId(node.id, remap));
+}
+/**
+ * @brief remap id.
+ * @details Reads one mandatory entry from the compacted id table.
+ * @param value Borrowed old node id.
+ * @param remap Borrowed old-id to new-id table.
+ * @returns New node id for the compacted graph.
+ */
+export function remapId(value, remap) {
+    const mapped = remap[value];
+    if (mapped === undefined) {
+        throw new Error("Unreachable dependency escaped graph optimization");
+    }
+    return mapped;
+}
+/**
+ * @brief remap ids.
+ * @details Applies a compacted id table to a dense node-id vector.
+ * @param values Borrowed old-id vector.
+ * @param remap Borrowed old-id to new-id table.
+ * @returns New dense vector in compacted id space.
+ */
+export function remapIds(values, remap) {
+    const remapped = new Array(values.length);
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value !== undefined) {
+            remapped[index] = remapId(value, remap);
+        }
+    }
+    return remapped;
+}

package/dist/optimize/rewrite.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file rewrite.ts
+ * @brief Node dependency rewrite utilities.
+ */
+import type { GraphNode, NodeId } from "../ir/index.js";
+/**
+ * @brief rewrite node deps.
+ * @details Resolves dependency aliases while preserving the node's own id.
+ * @param node Borrowed graph node to rewrite.
+ * @param aliases Borrowed alias table produced by the folding pass.
+ * @returns Graph node with dependency ids rewritten through the alias table.
+ */
+export declare function rewriteNodeDeps(node: GraphNode, aliases: readonly NodeId[]): GraphNode;
+/**
+ * @brief resolve alias.
+ * @details Follows an alias chain until it reaches a stable node id.
+ * @param value Borrowed node id to resolve.
+ * @param aliases Borrowed alias table.
+ * @returns Canonical node id for the current folding pass.
+ */
+export declare function resolveAlias(value: NodeId, aliases: readonly NodeId[]): NodeId;
+//# sourceMappingURL=rewrite.d.ts.map

package/dist/optimize/rewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite.d.ts","sourceRoot":"","sources":["../../src/optimize/rewrite.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,MAAM,EACP,MAAM,gBAAgB,CAAC;AAGxB;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS,CAMX;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAW9E"}