@thi.ng/wasm-api 0.18.0 → 1.0.0

package/codegen/typescript.js

@@ -1,240 +0,0 @@
-import { BIGINT_ARRAY_CTORS, BIT_SHIFTS, TYPEDARRAY_CTORS, } from "@thi.ng/api/typedarray";
-import { isString } from "@thi.ng/checks/is-string";
-import { PKG_NAME, } from "../api.js";
-import { ensureLines, enumName, isBigNumeric, isNumeric, isPadding, isStringSlice, isWasmPrim, isWasmString, pointerFields, prefixLines, stringFields, withIndentation, } from "./utils.js";
-import { fieldType as zigFieldType } from "./zig.js";
-/**
- * TypeScript code generator. Call with options and then pass to
- * {@link generateTypes} (see its docs for further usage).
- *
- * @remarks
- * This codegen generates interface and enum definitions for a {@link TypeColl}
- * given to {@link generateTypes}. For structs it will also generate memory
- * mapped wrappers with fully typed accessors.
- *
- * @param opts
- */
-export const TYPESCRIPT = (opts = {}) => {
-    const { indent } = {
-        indent: "\t",
-        stringType: "slice",
-        ...opts,
-    };
-    const SCOPES = [/\{$/, /\}\)?[;,]?$/];
-    const gen = {
-        pre: (opts) => `// @ts-ignore possibly includes unused imports
-import { MemorySlice, Pointer, ${__stringImpl(opts)}, WasmTypeBase, WasmTypeConstructor } from "${PKG_NAME}";${opts.pre ? `\n${opts.pre}` : ""}`,
-        post: () => opts.post || "",
-        doc: (doc, acc, opts) => {
-            acc.push("/**", ...prefixLines(" * ", doc, opts.lineWidth), " */");
-        },
-        enum: (e, _, acc, opts) => {
-            const res = [];
-            res.push(`export enum ${e.name} {`);
-            for (let v of e.values) {
-                let line;
-                if (!isString(v)) {
-                    v.doc && gen.doc(v.doc, res, opts);
-                    line = enumName(opts, v.name);
-                    if (v.value != null)
-                        line += ` = ${v.value}`;
-                }
-                else {
-                    line = enumName(opts, v);
-                }
-                res.push(line + ",");
-            }
-            res.push("}", "");
-            acc.push(...withIndentation(res, indent, ...SCOPES));
-        },
-        struct: (struct, types, acc, opts) => {
-            const fieldTypes = {};
-            const $stringImpl = __stringImpl(opts);
-            const lines = [];
-            // interface definition
-            lines.push(`export interface ${struct.name} extends WasmTypeBase {`);
-            for (let f of struct.fields) {
-                if (isPadding(f))
-                    continue;
-                const doc = __docType(struct, f, opts);
-                doc && gen.doc(doc, lines, opts);
-                const ftype = __fieldType(f, opts);
-                fieldTypes[f.name] = ftype;
-                lines.push(`${f.name}: ${ftype};`);
-            }
-            if (struct.body?.ts) {
-                lines.push("", ...ensureLines(struct.body.ts, "decl"));
-            }
-            lines.push("}", "");
-            const pointerDecls = pointerFields(struct.fields).map((x) => {
-                return `let $${x.name}: ${fieldTypes[x.name]} | null = null;`;
-            });
-            const stringDecls = stringFields(struct.fields).map((x) => {
-                const suffix = x.tag === "array" || x.tag === "slice" ? "[]" : "";
-                return `let $${x.name}: ${$stringImpl}${suffix} | null = null;`;
-            });
-            // type implementation
-            lines.push(`export const $${struct.name}: WasmTypeConstructor<${struct.name}> = (mem) => ({`, `get align() {`, `return ${struct.__align};`, `},`, `get size() {`, `return ${struct.__size};`, `},`, `instance: (base) => {`, ...pointerDecls, ...stringDecls, `return {`, `get __base() {`, `return base;`, `},`, `get __bytes() {`, `return mem.u8.subarray(base, base + ${struct.__size});`, `},`);
-            for (let f of struct.fields) {
-                // skip explicit padding fields
-                if (isPadding(f))
-                    continue;
-                const ftype = fieldTypes[f.name];
-                const offset = f.__offset || 0;
-                lines.push(`get ${f.name}(): ${ftype} {`);
-                const isPrim = isWasmPrim(f.type);
-                const isStr = isWasmString(f.type);
-                const isConst = isStr ? f.const !== false : !!f.const;
-                if (f.tag === "ptr") {
-                    if (isPrim) {
-                        const fn = f.len
-                            ? `(base) => mem.${f.type}.subarray(${__addrShift(0, f.type)}, (${__addrShift(0, f.type)}) + ${f.len})`
-                            : `(base) => mem.${f.type}[${__addrShift(0, f.type)}]`;
-                        lines.push(`return $${f.name} || ($${f.name} = new ${ftype}(mem, ${__addr(offset)}, ${fn}));`);
-                    }
-                    else if (isStr) {
-                        const fn = f.len
-                            ? [
-                                `(addr) => {`,
-                                ...__mapStringArray(opts.target, "buf", $stringImpl, f.len, isConst, true),
-                                `}`,
-                            ]
-                            : [
-                                `(addr) => new ${$stringImpl}(mem, addr, ${isConst})`,
-                            ];
-                        lines.push(`return $${f.name} || ($${f.name} = new ${ftype}(mem, ${__addr(offset)},`, ...fn, `));`);
-                    }
-                    else {
-                        const fn = f.len
-                            ? [`(addr) => {`, ...__mapArray(f, f.len), `}`]
-                            : [`(addr) => new $${f.type}.instance(addr)`];
-                        lines.push(`return $${f.name} || ($${f.name} = new ${ftype}(mem, ${__addr(offset)},`, ...fn, `));`);
-                    }
-                }
-                else if (f.tag === "slice") {
-                    lines.push(`const len = ${__ptr(opts.target, offset + 4)};`);
-                    if (isPrim) {
-                        lines.push(`const addr = ${__ptrShift(opts.target, offset, f.type)};`, `return mem.${f.type}.subarray(addr, addr + len);`);
-                    }
-                    else if (isStr) {
-                        lines.push(`const addr = ${__ptr(opts.target, offset)};`, ...__mapStringArray(opts.target, "buf", $stringImpl, "len", isConst));
-                    }
-                    else {
-                        lines.push(`const addr = ${__ptr(opts.target, offset)};`, ...__mapArray(f));
-                    }
-                }
-                else if (f.tag === "array" || f.tag === "vec") {
-                    if (isPrim) {
-                        lines.push(`const addr = ${__addrShift(offset, f.type)};`, `return mem.${f.type}.subarray(addr, addr + ${f.len});`);
-                    }
-                    else if (isStr) {
-                        lines.push(`if ($${f.name}) return $${f.name};`, `const addr = ${__addr(offset)};`, ...__mapStringArray(opts.target, f.name, $stringImpl, f.len, isConst));
-                    }
-                    else {
-                        lines.push(`const addr = ${__addr(offset)};`, ...__mapArray(f, f.len));
-                    }
-                }
-                else {
-                    let setter;
-                    if (isPrim) {
-                        const addr = __mem(f.type, f.__offset);
-                        lines.push(`return ${addr};`);
-                        setter = `${addr} = x`;
-                    }
-                    else if (isStr) {
-                        lines.push(`return $${f.name} || ($${f.name} = new ${$stringImpl}(mem, ${__addr(offset)}, ${isConst}));`);
-                    }
-                    else if (types[f.type].type === "enum") {
-                        const tag = types[f.type].tag;
-                        const addr = __mem(tag, f.__offset);
-                        lines.push(`return ${addr};`);
-                        setter = `${addr} = x`;
-                    }
-                    else {
-                        lines.push(`return $${f.type}(mem).instance(${__addr(offset)});`);
-                        setter = `mem.u8.set(x.__bytes, ${__addr(offset)})`;
-                    }
-                    // setter
-                    if (setter) {
-                        lines.push(
-                        // close getter
-                        `},`, `set ${f.name}(x: ${fieldTypes[f.name]}) {`, `${setter};`);
-                    }
-                }
-                // close field accessor
-                lines.push(`},`);
-            }
-            if (struct.body?.ts) {
-                lines.push("", ...ensureLines(struct.body.ts, "impl"), "");
-            }
-            lines.push("};", "}", "});", "");
-            acc.push(...withIndentation(lines, indent, ...SCOPES));
-        },
-        union: (type, coll, acc, opts) => {
-            gen.struct(type, coll, acc, opts);
-        },
-    };
-    return gen;
-};
-/** @internal */
-const __stringImpl = (opts) => isStringSlice(opts.stringType) ? "WasmStringSlice" : "WasmStringPtr";
-/** @internal */
-const __fieldType = (f, opts) => {
-    const ftype = f.tag == "array" ||
-        f.tag == "slice" ||
-        f.tag === "vec" ||
-        (f.tag === "ptr" && f.len)
-        ? isNumeric(f.type)
-            ? TYPEDARRAY_CTORS[f.type].name
-            : isBigNumeric(f.type)
-                ? BIGINT_ARRAY_CTORS[f.type].name
-                : isWasmString(f.type)
-                    ? __stringImpl(opts) + "[]"
-                    : f.type + "[]"
-        : !f.tag || f.tag === "scalar" || f.tag === "ptr"
-            ? isBigNumeric(f.type)
-                ? "bigint"
-                : isNumeric(f.type)
-                    ? "number"
-                    : isWasmString(f.type)
-                        ? __stringImpl(opts)
-                        : f.type
-            : f.type;
-    return f.tag === "ptr" ? `Pointer<${ftype}>` : ftype;
-};
-/** @internal */
-const __shift = (type) => BIT_SHIFTS[type];
-/** @internal */
-const __addr = (offset) => (offset > 0 ? `(base + ${offset})` : "base");
-/** @internal */
-const __addrShift = (offset, shift) => {
-    const bits = __shift(shift);
-    return __addr(offset) + (bits ? " >>> " + bits : "");
-};
-/** @internal */
-const __ptr = (target, offset) => `mem.${target.usize}[${__addrShift(offset, target.usize)}]`;
-/** @internal */
-const __ptrShift = (target, offset, shift) => __ptr(target, offset) + " >>> " + __shift(shift);
-const __mem = (type, offset) => `mem.${type}[${__addrShift(offset, type)}]`;
-/** @internal */
-const __mapArray = (f, len = "len") => [
-    `const inst = $${f.type}(mem);`,
-    `const slice: ${f.type}[] = [];`,
-    `for(let i = 0; i < ${len}; i++) slice.push(inst.instance(addr + i * ${f.__size}));`,
-    `return slice;`,
-];
-/** @internal */
-const __mapStringArray = (target, name, type, len, isConst, isLocal = false) => [
-    isLocal ? `const $${name}: ${type}[] = [];` : `$${name} = [];`,
-    `for(let i = 0; i < ${len}; i++) $${name}.push(new ${type}(mem, addr + i * ${target.usizeBytes * (type === "WasmStringSlice" ? 2 : 1)}, ${isConst}));`,
-    `return $${name};`,
-];
-const __docType = (parent, f, opts) => {
-    const doc = [...ensureLines(f.doc || [])];
-    if (isWasmPrim(f.type)) {
-        if (doc.length)
-            doc.push("");
-        doc.push(`WASM type: ${zigFieldType(parent, f, opts).type}`);
-    }
-    return doc.length ? doc : undefined;
-};

package/codegen/utils.d.ts

@@ -1,96 +0,0 @@
-import type { BigType } from "@thi.ng/api";
-import type { CodeGenOpts, Field, InjectedBody, WasmPrim, WasmPrim32 } from "../api.js";
-/**
- * Returns true iff `x` is a {@link WasmPrim32}.
- *
- * @param x
- */
-export declare const isNumeric: (x: string) => x is WasmPrim32;
-/**
- * Returns true iff `x` is a `i64` or `u64`.
- *
- * @param x
- */
-export declare const isBigNumeric: (x: string) => x is BigType;
-/**
- * Returns true iff `x` is a {@link WasmPrim}.
- *
- * @param x
- */
-export declare const isWasmPrim: (x: string) => x is WasmPrim;
-export declare const isWasmString: (x: string) => x is "string";
-export declare const isPadding: (f: Field) => boolean;
-export declare const isPointer: (f: Field) => boolean;
-export declare const isSlice: (f: Field) => boolean;
-/**
- * Returns true iff the struct field is a pointer, slice or "string" type
- *
- * @param f
- */
-export declare const isPointerLike: (f: Field) => boolean;
-/**
- * Returns true if `type` is "slice".
- *
- * @param type
- */
-export declare const isStringSlice: (type: CodeGenOpts["stringType"]) => type is "slice";
-/**
- * Returns filtered array of struct fields of with "ptr" tag.
- *
- * @param fields
- *
- * @internal
- */
-export declare const pointerFields: (fields: Field[]) => Field[];
-/**
- * Returns filtered array of struct fields of only "string" fields.
- *
- * @param fields
- *
- * @internal
- */
-export declare const stringFields: (fields: Field[]) => Field[];
-/**
- * Returns enum identifier formatted according to given opts.
- *
- * @param opts
- * @param name
- *
- * @internal
- */
-export declare const enumName: (opts: CodeGenOpts, name: string) => string;
-/**
- * Returns given field's default value (or undefined). The `lang` ID is required
- * to obtain the language specific value if the default is given as object.
- *
- * @param f
- * @param lang
- */
-export declare const defaultValue: (f: Field, lang: string) => import("@thi.ng/api").NumOrString | undefined;
-/**
- * Takes an array of strings or splits given string into lines, word wraps and
- * then prefixes each line with given `width` and `prefix`. Returns array of new
- * lines.
- *
- * @param prefix
- * @param str
- * @param width
- */
-export declare const prefixLines: (prefix: string, str: string | string[], width: number) => string[];
-export declare const ensureLines: (src: string | string[] | InjectedBody, key?: keyof InjectedBody) => Iterable<string>;
-/**
- * Yields iterator of given lines, each with applied indentation based on given
- * scope regexp's which are applied to each line to increase or decrease
- * indentation level (the initial indentation level can be specified via
- * optional `level` arg, default 0). If `scopeStart` succeeds, the indent is
- * increased for the _next_ line. If `scopeEnd` succeeds the level is decreased
- * for the _current_ line. ...
- *
- * @param lines
- * @param indent
- * @param scopeStart
- * @param scopeEnd
- * @param level
- */
-export declare function withIndentation(lines: string[], indent: string, scopeStart: RegExp, scopeEnd: RegExp, level?: number): Generator<string, void, unknown>;
-//# sourceMappingURL=utils.d.ts.map

package/codegen/utils.js

@@ -1,120 +0,0 @@
-import { isArray } from "@thi.ng/checks/is-array";
-import { isPlainObject } from "@thi.ng/checks/is-plain-object";
-import { isString } from "@thi.ng/checks/is-string";
-import { split } from "@thi.ng/strings/split";
-import { wordWrapLine, wordWrapLines } from "@thi.ng/strings/word-wrap";
-/**
- * Returns true iff `x` is a {@link WasmPrim32}.
- *
- * @param x
- */
-export const isNumeric = (x) => /^(([iu](8|16|32))|(f(32|64)))$/.test(x);
-/**
- * Returns true iff `x` is a `i64` or `u64`.
- *
- * @param x
- */
-export const isBigNumeric = (x) => /^[iu]64$/.test(x);
-/**
- * Returns true iff `x` is a {@link WasmPrim}.
- *
- * @param x
- */
-export const isWasmPrim = (x) => isNumeric(x) || isBigNumeric(x);
-export const isWasmString = (x) => x === "string";
-export const isPadding = (f) => f.pad != null && f.pad > 0;
-export const isPointer = (f) => f.tag === "ptr";
-export const isSlice = (f) => f.tag === "slice";
-/**
- * Returns true iff the struct field is a pointer, slice or "string" type
- *
- * @param f
- */
-export const isPointerLike = (f) => isPointer(f) || isSlice(f) || isWasmString(f.type);
-/**
- * Returns true if `type` is "slice".
- *
- * @param type
- */
-export const isStringSlice = (type) => type === "slice";
-/**
- * Returns filtered array of struct fields of with "ptr" tag.
- *
- * @param fields
- *
- * @internal
- */
-export const pointerFields = (fields) => fields.filter((f) => f.tag === "ptr");
-/**
- * Returns filtered array of struct fields of only "string" fields.
- *
- * @param fields
- *
- * @internal
- */
-export const stringFields = (fields) => fields.filter((f) => isWasmString(f.type) && f.tag !== "ptr");
-/**
- * Returns enum identifier formatted according to given opts.
- *
- * @param opts
- * @param name
- *
- * @internal
- */
-export const enumName = (opts, name) => opts.uppercaseEnums ? name.toUpperCase() : name;
-/**
- * Returns given field's default value (or undefined). The `lang` ID is required
- * to obtain the language specific value if the default is given as object.
- *
- * @param f
- * @param lang
- */
-export const defaultValue = (f, lang) => f.default !== undefined
-    ? isPlainObject(f.default)
-        ? f.default[lang]
-        : f.default
-    : undefined;
-/**
- * Takes an array of strings or splits given string into lines, word wraps and
- * then prefixes each line with given `width` and `prefix`. Returns array of new
- * lines.
- *
- * @param prefix
- * @param str
- * @param width
- */
-export const prefixLines = (prefix, str, width) => (isString(str)
-    ? wordWrapLines(str, { width: width - prefix.length })
-    : str.flatMap((x) => wordWrapLine(x, { width: width - prefix.length }))).map((line) => prefix + line);
-export const ensureLines = (src, key) => isString(src)
-    ? split(src)
-    : isArray(src)
-        ? src
-        : key
-            ? src[key]
-                ? ensureLines(src[key], key)
-                : []
-            : [];
-/**
- * Yields iterator of given lines, each with applied indentation based on given
- * scope regexp's which are applied to each line to increase or decrease
- * indentation level (the initial indentation level can be specified via
- * optional `level` arg, default 0). If `scopeStart` succeeds, the indent is
- * increased for the _next_ line. If `scopeEnd` succeeds the level is decreased
- * for the _current_ line. ...
- *
- * @param lines
- * @param indent
- * @param scopeStart
- * @param scopeEnd
- * @param level
- */
-export function* withIndentation(lines, indent, scopeStart, scopeEnd, level = 0) {
-    const stack = new Array(level).fill(indent);
-    for (let l of lines) {
-        scopeEnd.test(l) && stack.pop();
-        const curr = stack.length ? stack[stack.length - 1] : "";
-        yield curr + l;
-        scopeStart.test(l) && stack.push(curr + indent);
-    }
-}

package/codegen/zig.d.ts

@@ -1,23 +0,0 @@
-import type { CodeGenOpts, CodeGenOptsBase, Field, ICodeGen, Struct, Union } from "../api.js";
-/**
- * Zig code generator options.
- */
-export interface ZigOpts extends CodeGenOptsBase {
-}
-/**
- * Zig code generator. Call with options and then pass to {@link generateTypes}
- * (see its docs for further usage).
- *
- * @remarks
- * This codegen generates struct and enum definitions for a {@link TypeColl}
- * given to {@link generateTypes}.
- *
- * @param opts
- */
-export declare const ZIG: (opts?: Partial<ZigOpts>) => ICodeGen;
-/** @internal */
-export declare const fieldType: (parent: Struct | Union, f: Field, opts: CodeGenOpts) => {
-    type: string;
-    defaultVal: string;
-};
-//# sourceMappingURL=zig.d.ts.map

package/codegen/zig.js

@@ -1,149 +0,0 @@
-import { isNumber } from "@thi.ng/checks";
-import { isString } from "@thi.ng/checks/is-string";
-import { unsupported } from "@thi.ng/errors/unsupported";
-import { defaultValue, ensureLines, isPadding, isStringSlice, isWasmString, prefixLines, withIndentation, } from "./utils.js";
-/**
- * Zig code generator. Call with options and then pass to {@link generateTypes}
- * (see its docs for further usage).
- *
- * @remarks
- * This codegen generates struct and enum definitions for a {@link TypeColl}
- * given to {@link generateTypes}.
- *
- * @param opts
- */
-export const ZIG = (opts = {}) => {
-    const INDENT = "    ";
-    const SCOPES = [/\{$/, /\}\)?[;,]?$/];
-    const gen = {
-        pre: () => `const std = @import("std");${opts.pre ? `\n${opts.pre}` : ""}`,
-        post: () => opts.post || "",
-        doc: (doc, acc, opts, topLevel = false) => {
-            acc.push(...prefixLines(topLevel ? "//! " : "/// ", doc, opts.lineWidth));
-        },
-        enum: (e, _, acc, opts) => {
-            const lines = [];
-            lines.push(`pub const ${e.name} = enum(${e.tag}) {`);
-            for (let v of e.values) {
-                let line;
-                if (!isString(v)) {
-                    v.doc && gen.doc(v.doc, lines, opts);
-                    line = v.name;
-                    if (v.value != null)
-                        line += ` = ${v.value}`;
-                }
-                else {
-                    line = v;
-                }
-                lines.push(line + ",");
-            }
-            if (e.body?.zig) {
-                lines.push("", ...ensureLines(e.body.zig, "impl"), "");
-            }
-            lines.push("};", "");
-            acc.push(...withIndentation(lines, INDENT, ...SCOPES));
-        },
-        struct: (struct, _, acc, opts) => {
-            acc.push(...withIndentation([
-                `pub const ${struct.name} = ${struct.tag ? struct.tag + " " : ""}struct {`,
-                ...__generateFields(gen, struct, opts),
-            ], INDENT, ...SCOPES));
-        },
-        union: (union, _, acc, opts) => {
-            acc.push(...withIndentation([
-                `pub const ${union.name} = ${union.tag ? union.tag + " " : ""}union {`,
-                ...__generateFields(gen, union, opts),
-            ], INDENT, ...SCOPES));
-        },
-    };
-    return gen;
-};
-const __generateFields = (gen, parent, opts) => {
-    const res = [];
-    const ftypes = {};
-    const isUnion = parent.type === "union";
-    const name = parent.name;
-    let padID = 0;
-    for (let f of parent.fields) {
-        // autolabel explicit padding fields
-        if (isPadding(f)) {
-            parent.tag === "packed"
-                ? __packedPadding(padID, f.pad, res)
-                : res.push(`__pad${padID}: [${f.pad}]u8,`);
-            padID++;
-            continue;
-        }
-        f.doc && gen.doc(f.doc, res, opts);
-        const { type, defaultVal } = fieldType(parent, f, opts);
-        ftypes[f.name] = type;
-        res.push(`${f.name}: ${type}${defaultVal},`);
-    }
-    if (parent.body?.zig) {
-        res.push("", ...ensureLines(parent.body.zig, "impl"), "");
-    }
-    res.push("};");
-    if (opts.debug) {
-        const fn = (fname, body) => res.push("", `export fn ${name}_${fname}() usize {`, `return ${body};`, `}`);
-        fn("align", `@alignOf(${name})`);
-        fn("size", `@sizeOf(${name})`);
-        for (let f of parent.fields) {
-            if (isPadding(f))
-                continue;
-            fn(f.name + "_align", `@alignOf(${ftypes[f.name]})`);
-            !isUnion &&
-                fn(f.name + "_offset", `@offsetOf(${name}, "${f.name}")`);
-            fn(f.name + "_size", `@sizeOf(${ftypes[f.name]})`);
-        }
-    }
-    res.push("");
-    return res;
-};
-/** @internal */
-export const fieldType = (parent, f, opts) => {
-    let type = isWasmString(f.type)
-        ? isStringSlice(opts.stringType)
-            ? f.const !== false
-                ? "[]const u8"
-                : "[]u8"
-            : f.const !== false
-                ? "[*:0]const u8"
-                : "[*:0]u8"
-        : f.type;
-    let defaultVal = defaultValue(f, "zig");
-    switch (f.tag) {
-        case "array":
-            type =
-                f.sentinel !== undefined
-                    ? `[${f.len}:${f.sentinel}]${type}`
-                    : `[${f.len}]${type}`;
-            break;
-        case "slice":
-            type = `[${f.sentinel !== undefined ? ":" + f.sentinel : ""}]${f.const ? "const " : ""}${type}`;
-            break;
-        case "vec":
-            type = `@Vector(${f.len}, ${type})`;
-            break;
-        case "ptr":
-            type = `*${f.const ? "const " : ""}${f.len ? `[${f.len}]` : ""}${type}`;
-            break;
-        case "scalar":
-        default:
-            if (defaultVal != undefined) {
-                if (!(isString(defaultVal) || isNumber(defaultVal))) {
-                    unsupported(`wrong default value for ${parent.name}.${f.name} (${defaultVal})`);
-                }
-            }
-    }
-    return {
-        type,
-        defaultVal: defaultVal != undefined ? ` = ${defaultVal}` : "",
-    };
-};
-const __packedPadding = (id, n, res) => {
-    let i = 0;
-    n <<= 3;
-    for (; n >= 128; n -= 128, i++) {
-        res.push(`__pad${id}_${i}: u128,`);
-    }
-    res.push(`__pad${id}_${i}: u${n},`);
-};

package/codegen.d.ts

@@ -1,32 +0,0 @@
-import { CodeGenOpts, ICodeGen, TypeColl } from "./api.js";
-export declare const DEFAULT_CODEGEN_OPTS: CodeGenOpts;
-/**
- * Takes a type collection and analyzes each analyzed to compute individual
- * alignments and sizes.
- *
- * @remarks
- * This function is idempotent and called automatically by
- * {@link generateTypes}. Only exported for dev/debug purposes.
- *
- * @param types
- *
- * @internal
- */
-export declare const prepareTypes: (types: TypeColl, opts: CodeGenOpts) => TypeColl;
-/**
- * Code generator main entry point. Takes an object of {@link TopLevelType}
- * definitions, an actual code generator implementation for a single target
- * language and (optional) global codegen options. Returns generated source code
- * for all given types as a single string.
- *
- * @remarks
- * Before actual code generation the types are first analyzed to compute their
- * alignments and sizes. This is only ever done once (idempotent), even if
- * `generateTypes()` is called multiple times for different target langs.
- *
- * @param types
- * @param codegen
- * @param opts
- */
-export declare const generateTypes: (types: TypeColl, codegen: ICodeGen, opts?: Partial<CodeGenOpts>) => string;
-//# sourceMappingURL=codegen.d.ts.map