@scriptc/compiler 0.4.6 → 0.4.7

package/dist/ir/codec.d.ts

@@ -0,0 +1,82 @@
+import type { IrFunction, IrModule } from "./ir.js";
+export declare class IrWriter {
+    private bytes;
+    private size;
+    private readonly strings;
+    /** The values of the string fields named `file` written so far. */
+    readonly files: Set<string>;
+    private readonly scratch;
+    /** Whether every object written so far reads back with its own key order
+     * (`keys`). False once one held a key its type does not declare, or its
+     * keys in another order than the declaration's. */
+    inOrder: boolean;
+    /** Notes an object's own keys against its type's declared fields. The
+     * decoder builds an object with its fields in declaration order, so an
+     * object whose keys come in another order, or include one the type does
+     * not declare, does not read back as it was. */
+    keys(own: readonly string[], declared: readonly string[]): void;
+    private reserve;
+    byte(value: number): void;
+    /** A non-negative integer below 2^53. */
+    length(value: number): void;
+    bool(value: boolean): void;
+    num(value: number): void;
+    str(value: string): void;
+    /** What the encoding could not write, such as a node whose kind its
+     * union does not declare, or null. Such an encoding does not decode. */
+    refused: string | null;
+    /** Notes that `what` could not be written (`refused`). */
+    refuse(what: string): void;
+    /** A string field named `file`: a source file the encoding names. */
+    file(value: string): void;
+    /** Raw bytes, after their count. */
+    blob(bytes: Uint8Array): void;
+    /** The strings written so far, each once, in the order first written. */
+    written(): IterableIterator<string>;
+    /** Starts a new encoding in the same buffer. */
+    reset(): void;
+    /** The bytes written so far. Throws when the encoding refused a value. */
+    finish(): Buffer;
+}
+export declare class IrReader {
+    private readonly bytes;
+    private offset;
+    private readonly strings;
+    /** The last presence byte `tag` read. */
+    lastTag: number;
+    constructor(bytes: Buffer);
+    private fail;
+    byte(): number;
+    length(): number;
+    bool(): boolean;
+    num(): number;
+    str(): string;
+    /** Raw bytes blob wrote, as a view of the bytes read. */
+    blob(): Buffer;
+    /** A presence byte below `limit`, kept in lastTag. */
+    tag(limit: number, where: string): number;
+    /** Whether every byte was read. */
+    done(): boolean;
+}
+/** Whether `bytes` start like an encoding this module writes. */
+export declare function isIrEncoding(bytes: Uint8Array): boolean;
+export declare function encodeModuleBinary(mod: IrModule): Buffer;
+export declare function decodeModuleBinary(bytes: Buffer): IrModule;
+export declare function encodeFunctionBinary(fn: IrFunction): Buffer;
+/** `fn`'s encoding when it reads back as `fn` is, every object with its
+ * own key order (IrWriter.inOrder), or null. */
+export declare function encodeFunctionInOrder(fn: IrFunction): Buffer | null;
+/** encodeFunctionInOrder's encoding of `fn`, with the strings it holds,
+ * each once, and the files its fields named `file` hold (IrWriter.file), or
+ * null. */
+export declare function encodeFunctionStrings(fn: IrFunction): {
+    readonly bytes: Buffer;
+    readonly strings: readonly string[];
+    readonly files: readonly string[];
+} | null;
+/** A 64-bit digest of `fn`'s content, the same for functions whose fields
+ * hold the same values in any key order, with the byte count of the
+ * content it covers. It covers the binary encoding, or the JSON text when
+ * the encoder refuses a value (IrWriter.refuse). */
+export declare function functionDigest(fn: IrFunction): string;
+export declare function decodeFunctionBinary(bytes: Buffer): IrFunction;

package/dist/ir/codec.generated.d.ts

@@ -0,0 +1,13 @@
+import type { IrFunction, IrModule } from "./ir.js";
+import type { IrReader, IrWriter } from "./codec.js";
+/** A digest of the coders below: an encoding written with other coders is
+ * refused instead of misread, also after a change that keeps IR_VERSION. */
+export declare const IR_CODEC_LAYOUT = "046d50de1884ed1e";
+/** Writes `mod` field by field (codec.ts describes the bytes). */
+export declare function encodeIrModule(w: IrWriter, mod: IrModule): void;
+/** Reads a module encodeIrModule wrote. */
+export declare function decodeIrModule(r: IrReader): IrModule;
+/** Writes one function. */
+export declare function encodeIrFunction(w: IrWriter, fn: IrFunction): void;
+/** Reads a function encodeIrFunction wrote. */
+export declare function decodeIrFunction(r: IrReader): IrFunction;