@mintlify/common 1.0.1269 → 1.0.1270

package/dist/mdx/estreeReferences.d.ts

@@ -0,0 +1,39 @@
+export type UnknownRecord = Record<string, unknown>;
+export declare const NON_CODE_KEYS: Set<string>;
+/** Collects the names a binding pattern declares (untyped estree records). */
+export declare function collectPatternNames(pattern: unknown, names: Set<string>): void;
+export declare function forEachCodeChild(node: UnknownRecord, callback: (child: unknown) => void): void;
+export type ReferenceVisitor = {
+    reference: (identifier: UnknownRecord) => void;
+    /** An assignment or update target. */
+    write?: (target: unknown, shadowed: ReadonlySet<string>) => void;
+    /** An expression whose object is changed in place: `delete`, mutating methods, `Object.assign`. */
+    mutate?: (object: unknown, shadowed: ReadonlySet<string>) => void;
+    /**
+     * Code that can change any object without a traceable write: `eval`, `with`, and any use of
+     * `Object` or `Reflect` other than a direct static call such as `Object.keys(value)`.
+     */
+    unknownWrite?: () => void;
+    /** Skips function bodies and parameters, which only run when called. */
+    eagerOnly?: boolean;
+};
+/**
+ * Visits every identifier that refers to a module-level binding: function, block, catch, and
+ * loop bindings shadow their scopes, and property keys and intrinsic JSX tags are not references.
+ */
+export declare function visitReferences(node: unknown, shadowed: ReadonlySet<string>, visit: ReferenceVisitor): void;
+export declare function collectFreeReferences(node: unknown, eagerOnly?: boolean): Set<string>;
+export type ModuleWrites = {
+    reassigned: Set<string>;
+    mutated: Set<string>;
+};
+/** Marks a write through an object that cannot be traced to particular module bindings. */
+export declare const UNKNOWN_WRITE_TARGET = "*";
+/** Whether `node` calls anything while it runs, outside function bodies. */
+export declare function hasEagerCall(node: unknown): boolean;
+/**
+ * Module-level names reassigned, and names whose objects are written through, in `node`. A write
+ * through a local counts as a write to every name the local's initializer references, since the
+ * local may alias that object; a local initialized from fresh values passes nothing on.
+ */
+export declare function collectModuleWrites(node: unknown, eagerOnly?: boolean): ModuleWrites;