@scriptc/compiler 0.4.6 → 0.4.8

package/dist/ir/class-key-index.d.ts

@@ -0,0 +1,18 @@
+/** A generated class table's index over a class key. A key starts with
+ * `object:` and is printable ASCII, so its length and its last four bytes
+ * together name it apart from every other key of the table in nearly every
+ * case: the folded word below selects the table's switch case, and the keys
+ * that still agree (equal length, equal last four bytes) share a case, where
+ * the branches' own exact key tests keep them apart. */
+/** The odd constant the index multiplies a key's length by: the fractional
+ * part of the golden ratio read as a 32-bit word. The emitted code multiplies
+ * the capsule's key length by the same word. */
+export declare const CLASS_KEY_LEN_MIX: number;
+/** The key's last four ASCII bytes as a little-endian word: the word the
+ * emitted code loads from the key's tail. */
+export declare function classKeyTail(key: string): number;
+/** The switch case a class key selects, masked to 31 bits: the key's last
+ * four bytes plus its length times CLASS_KEY_LEN_MIX, so keys that share a
+ * tail answer different values unless their lengths match too. A key too
+ * short to hold four answers -1, which no case holds. */
+export declare function classKeyHash(key: string): number;

package/dist/ir/class-key-index.js

@@ -0,0 +1,29 @@
+/** A generated class table's index over a class key. A key starts with
+ * `object:` and is printable ASCII, so its length and its last four bytes
+ * together name it apart from every other key of the table in nearly every
+ * case: the folded word below selects the table's switch case, and the keys
+ * that still agree (equal length, equal last four bytes) share a case, where
+ * the branches' own exact key tests keep them apart. */
+/** The odd constant the index multiplies a key's length by: the fractional
+ * part of the golden ratio read as a 32-bit word. The emitted code multiplies
+ * the capsule's key length by the same word. */
+export const CLASS_KEY_LEN_MIX = 0x9e3779b1 | 0;
+/** The key's last four ASCII bytes as a little-endian word: the word the
+ * emitted code loads from the key's tail. */
+export function classKeyTail(key) {
+    const start = key.length - 4;
+    let word = 0;
+    for (let i = 0; i < 4; i++)
+        word |= key.charCodeAt(start + i) << (8 * i);
+    return word >>> 0;
+}
+/** The switch case a class key selects, masked to 31 bits: the key's last
+ * four bytes plus its length times CLASS_KEY_LEN_MIX, so keys that share a
+ * tail answer different values unless their lengths match too. A key too
+ * short to hold four answers -1, which no case holds. */
+export function classKeyHash(key) {
+    if (key.length < 4)
+        return -1;
+    return (Math.imul(key.length, 0x9e3779b1) + classKeyTail(key)) & 0x7fffffff;
+}
+//# sourceMappingURL=class-key-index.js.map

package/dist/ir/class-key-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-key-index.js","sourceRoot":"","sources":["../../src/ir/class-key-index.ts"],"names":[],"mappings":"AAAA;;;;;wDAKwD;AAExD;;gDAEgD;AAChD,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,GAAG,CAAC,CAAC;AAEhD;6CAC6C;AAC7C,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;IAC7B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;QAAE,IAAI,IAAI,GAAG,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzE,OAAO,IAAI,KAAK,CAAC,CAAC;AACpB,CAAC;AAED;;;yDAGyD;AACzD,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC;IAC9B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC;AAC9E,CAAC"}

package/dist/ir/class-key-index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ir/class-key-index.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { CLASS_KEY_LEN_MIX, classKeyHash, classKeyTail } from "./class-key-index.js";
+describe("class key index", () => {
+    it("reads the last four key bytes as a little-endian word", () => {
+        expect(classKeyTail("object:C00")).toBe(0x3030433a);
+        expect(classKeyTail("object:C01")).toBe(0x3130433a);
+    });
+    it("pins the case a key selects", () => {
+        // The emitted code computes the same number from the capsule's key: its
+        // length times CLASS_KEY_LEN_MIX plus the word it loads from the tail.
+        expect(CLASS_KEY_LEN_MIX).toBe(-1640531535);
+        expect(classKeyHash("object:C00")).toBe(1583023140);
+        expect(classKeyHash("object:AlphaThing")).toBe(1763540521);
+    });
+    it("gives keys of one length apart", () => {
+        expect(classKeyHash("object:C00")).not.toBe(classKeyHash("object:C01"));
+    });
+    it("gives two keys sharing a length and a tail the same case", () => {
+        expect(classKeyHash("object:AlphaThing")).toBe(classKeyHash("object:BravoThing"));
+    });
+    it("gives a key too short for a tail -1", () => {
+        expect(classKeyHash("abc")).toBe(-1);
+    });
+});
+//# sourceMappingURL=class-key-index.test.js.map

package/dist/ir/class-key-index.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-key-index.test.js","sourceRoot":"","sources":["../../src/ir/class-key-index.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAErF,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;IAC/B,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,MAAM,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpD,MAAM,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6BAA6B,EAAE,GAAG,EAAE;QACrC,wEAAwE;QACxE,uEAAuE;QACvE,MAAM,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC;QAC5C,MAAM,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpD,MAAM,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACxC,MAAM,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;QAClE,MAAM,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC7C,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

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 = "38fbaf504aaf737f";
+/** 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;