@wasmgroundup/emit 0.2.18 → 0.4.0

package/dist/index.d.ts

@@ -1,144 +0,0 @@
-type BytecodeFragment = (number | BytecodeFragment)[];
-declare enum valtype {
-    i32 = 127,
-    i64 = 126,
-    f32 = 125,
-    f64 = 124
-}
-declare function blocktype(t?: valtype): number;
-declare function vec<T extends BytecodeFragment>(elements: T): BytecodeFragment;
-declare function section(id: number, contents: BytecodeFragment): (number | BytecodeFragment)[];
-declare function functype(paramTypes: valtype[], resultTypes: valtype[]): BytecodeFragment;
-declare function typesec(functypes: BytecodeFragment): BytecodeFragment;
-declare const typeidx: typeof u32;
-declare function funcsec(typeidxs: BytecodeFragment): BytecodeFragment;
-declare function code(func: BytecodeFragment): BytecodeFragment;
-declare function func(locals: BytecodeFragment, body: BytecodeFragment): BytecodeFragment;
-declare function codesec(codes: BytecodeFragment): BytecodeFragment;
-declare function name(s: string): BytecodeFragment;
-declare function export_(nm: string, exportdesc: BytecodeFragment): BytecodeFragment;
-declare function exportsec(exports: BytecodeFragment): BytecodeFragment;
-declare const funcidx: typeof u32;
-declare const exportdesc: {
-    func(idx: number): BytecodeFragment;
-    table(idx: number): BytecodeFragment;
-    mem(idx: number): BytecodeFragment;
-    global(idx: number): BytecodeFragment;
-};
-declare function module(sections: any): BytecodeFragment;
-declare const instr: {
-    unreachable: number;
-    nop: number;
-    block: number;
-    loop: number;
-    if: number;
-    else: number;
-    end: number;
-    br: number;
-    br_if: number;
-    br_table: number;
-    return: number;
-    call: number;
-    call_indirect: number;
-    drop: number;
-    select: number;
-    local: {
-        get: number;
-        set: number;
-        tee: number;
-    };
-    global: {
-        get: number;
-        set: number;
-        tee: number;
-    };
-    memory: {
-        size: number;
-        grow: number;
-    };
-    i32: {
-        load: number;
-        const: number;
-        eqz: number;
-        eq: number;
-        ne: number;
-        lt_s: number;
-        lt_u: number;
-        gt_s: number;
-        gt_u: number;
-        le_s: number;
-        le_u: number;
-        ge_s: number;
-        ge_u: number;
-        add: number;
-        sub: number;
-        mul: number;
-    };
-    i64: {
-        store32: number;
-        const: number;
-        ne: number;
-        add: number;
-        sub: number;
-        mul: number;
-    };
-    f32: {
-        const: number;
-        ne: number;
-        add: number;
-        sub: number;
-        mul: number;
-        div: number;
-    };
-    f64: {
-        load: number;
-        store: number;
-        const: number;
-        ne: number;
-        add: number;
-        sub: number;
-        mul: number;
-        div: number;
-        reinterpret_i64: number;
-    };
-};
-declare function u32(v: number | bigint): number[];
-declare function i32(v: number | bigint): number[];
-declare function f64(v: number): number[];
-declare function locals(n: number, type: valtype): BytecodeFragment;
-declare function import_(mod: string, nm: string, d: BytecodeFragment): BytecodeFragment;
-declare function importsec(ims: BytecodeFragment): BytecodeFragment;
-declare const importdesc: {
-    func(x: BytecodeFragment): BytecodeFragment;
-    table(tt: BytecodeFragment): BytecodeFragment;
-    mem(mt: BytecodeFragment): BytecodeFragment;
-    global(gt: BytecodeFragment): BytecodeFragment;
-};
-declare function memsec(mems: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function memtype(limits: BytecodeFragment): BytecodeFragment;
-declare const limits: {
-    min(n: number): (number | number[])[];
-    minmax(n: number, m: number): (number | number[])[];
-};
-declare const mut: {
-    const: number;
-    var: number;
-};
-declare function globaltype(t: any, m: any): any[];
-declare function global(gt: any, e: any): any[];
-declare function globalsec(globs: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function tabletype(elemtype: number, limits: BytecodeFragment): (number | BytecodeFragment)[];
-declare function table(tabletype: BytecodeFragment): BytecodeFragment;
-declare function tablesec(tables: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare const elemtype: {
-    funcref: number;
-};
-declare const tableidx: typeof u32;
-declare const start: typeof u32;
-declare function startsec(st: BytecodeFragment): (number | BytecodeFragment)[];
-declare function data(x: BytecodeFragment, e: BytecodeFragment, bs: BytecodeFragment[]): BytecodeFragment[];
-declare function datasec(segs: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function elem(x: BytecodeFragment, e: BytecodeFragment, ys: BytecodeFragment[]): BytecodeFragment[];
-declare function elemsec(segs: BytecodeFragment[]): (number | BytecodeFragment)[];
-declare function memarg(align: number, offset: number): number[][];
-export { blocktype, BytecodeFragment, code, codesec, data, datasec, elem, elemsec, elemtype, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, global, globalsec, globaltype, i32, import_, importdesc, importsec, instr, limits, locals, memarg, memsec, memtype, module, mut, name, section, start, startsec, table, tableidx, tablesec, tabletype, typeidx, typesec, u32, valtype, vec, };

package/dist/index.js

@@ -1,312 +0,0 @@
-const SECTION_ID_TYPE = 1;
-const SECTION_ID_IMPORT = 2;
-const SECTION_ID_FUNCTION = 3;
-const SECTION_ID_TABLE = 4;
-const SECTION_ID_MEMORY = 5;
-const SECTION_ID_GLOBAL = 6;
-const SECTION_ID_EXPORT = 7;
-const SECTION_ID_START = 8;
-const SECTION_ID_ELEMENT = 9;
-const SECTION_ID_CODE = 10;
-const SECTION_ID_DATA = 11;
-const TYPE_FUNCTION = 0x60;
-function stringToBytes(s) {
-    const bytes = new TextEncoder().encode(s);
-    return Array.from(bytes);
-}
-function int32ToBytes(v) {
-    // prettier-ignore
-    return [
-        v & 0xff,
-        (v >> 8) & 0xff,
-        (v >> 16) & 0xff,
-        (v >> 24) & 0xff,
-    ];
-}
-function magic() {
-    // [0x00, 0x61, 0x73, 0x6d]
-    return stringToBytes("\0asm");
-}
-function version() {
-    // [0x01, 0x00, 0x00, 0x00]
-    return int32ToBytes(1);
-}
-var valtype;
-(function (valtype) {
-    valtype[valtype["i32"] = 127] = "i32";
-    valtype[valtype["i64"] = 126] = "i64";
-    valtype[valtype["f32"] = 125] = "f32";
-    valtype[valtype["f64"] = 124] = "f64";
-})(valtype || (valtype = {}));
-// t: valtype
-function blocktype(t) {
-    return t ?? 0x40;
-}
-function vec(elements) {
-    return [u32(elements.length), ...elements];
-}
-function section(id, contents) {
-    const sizeInBytes = contents.flat(Infinity).length;
-    return [id, u32(sizeInBytes), contents];
-}
-function functype(paramTypes, resultTypes) {
-    return [TYPE_FUNCTION, vec(paramTypes), vec(resultTypes)];
-}
-function typesec(functypes) {
-    return section(SECTION_ID_TYPE, vec(functypes));
-}
-const typeidx = u32;
-function funcsec(typeidxs) {
-    return section(SECTION_ID_FUNCTION, vec(typeidxs));
-}
-function code(func) {
-    const sizeInBytes = func.flat(Infinity).length;
-    return [u32(sizeInBytes), func];
-}
-function func(locals, body) {
-    return [vec(locals), body];
-}
-function codesec(codes) {
-    return section(SECTION_ID_CODE, vec(codes));
-}
-function name(s) {
-    return vec(stringToBytes(s));
-}
-function export_(nm, exportdesc) {
-    return [name(nm), exportdesc];
-}
-function exportsec(exports) {
-    return section(SECTION_ID_EXPORT, vec(exports));
-}
-const funcidx = u32;
-const exportdesc = {
-    func(idx) {
-        return [0x00, funcidx(idx)];
-    },
-    table(idx) {
-        return [0x01, tableidx(idx)];
-    },
-    mem(idx) {
-        return [0x02, memidx(idx)];
-    },
-    global(idx) {
-        return [0x03, globalidx(idx)];
-    },
-};
-function module(sections) {
-    return [magic(), version(), sections];
-}
-const instr = {
-    unreachable: 0x00,
-    nop: 0x01,
-    block: 0x02,
-    loop: 0x03,
-    if: 0x04,
-    else: 0x05,
-    end: 0x0b,
-    br: 0x0c,
-    br_if: 0x0d,
-    br_table: 0x0e,
-    return: 0x0f,
-    call: 0x10,
-    call_indirect: 0x11,
-    drop: 0x1a,
-    select: 0x1b,
-    local: {
-        get: 0x20,
-        set: 0x21,
-        tee: 0x22,
-    },
-    global: {
-        get: 0x23,
-        set: 0x24,
-        tee: 0x25,
-    },
-    memory: {
-        size: 0x3f,
-        grow: 0x40,
-    },
-    i32: {
-        load: 0x28,
-        const: 0x41,
-        eqz: 0x45,
-        eq: 0x46,
-        ne: 0x47,
-        lt_s: 0x48,
-        lt_u: 0x49,
-        gt_s: 0x4a,
-        gt_u: 0x4b,
-        le_s: 0x4c,
-        le_u: 0x4d,
-        ge_s: 0x4e,
-        ge_u: 0x4f,
-        add: 0x6a,
-        sub: 0x6b,
-        mul: 0x6c,
-    },
-    i64: {
-        store32: 0x3e,
-        const: 0x42,
-        ne: 0x52,
-        add: 0x7c,
-        sub: 0x7d,
-        mul: 0x7e,
-    },
-    f32: {
-        const: 0x43,
-        ne: 0x5c,
-        add: 0x92,
-        sub: 0x93,
-        mul: 0x94,
-        div: 0x95,
-    },
-    f64: {
-        load: 0x2b,
-        store: 0x39,
-        const: 0x44,
-        ne: 0x62,
-        add: 0xa0,
-        sub: 0xa1,
-        mul: 0xa2,
-        div: 0xa3,
-        reinterpret_i64: 0xbf,
-    },
-};
-const SEVEN_BIT_MASK_BIG_INT = 127n;
-const CONTINUATION_BIT = 0b10000000;
-function u32(v) {
-    let val = BigInt(v);
-    let more = true;
-    const r = [];
-    while (more) {
-        const b = Number(val & SEVEN_BIT_MASK_BIG_INT);
-        val = val >> 7n;
-        more = val !== 0n;
-        if (more) {
-            r.push(b | CONTINUATION_BIT);
-        }
-        else {
-            r.push(b);
-        }
-    }
-    return r;
-}
-function i32(v) {
-    let val = BigInt(v);
-    const r = [];
-    let more = true;
-    while (more) {
-        const b = Number(val & 127n);
-        const signBitSet = !!(b & 0x40);
-        val = val >> 7n;
-        if ((val === 0n && !signBitSet) || (val === -1n && signBitSet)) {
-            more = false;
-            r.push(b);
-        }
-        else {
-            r.push(b | CONTINUATION_BIT);
-        }
-    }
-    return r;
-}
-function f64(v) {
-    var buf = new ArrayBuffer(8);
-    new Float64Array(buf)[0] = v;
-    return Array.from(new Uint8Array(buf));
-}
-function locals(n, type) {
-    return [u32(n), type];
-}
-// mod:name  nm:name  d:importdesc
-function import_(mod, nm, d) {
-    return [name(mod), name(nm), d];
-}
-// im*:vec(import)
-function importsec(ims) {
-    return section(SECTION_ID_IMPORT, vec(ims));
-}
-const importdesc = {
-    // x:typeidx
-    func(x) {
-        return [0x00, x];
-    },
-    // tt:tabletype
-    table(tt) {
-        return [0x01, tt];
-    },
-    // mt:memtype
-    mem(mt) {
-        return [0x02, mt];
-    },
-    // gt:globaltype
-    global(gt) {
-        return [0x03, gt];
-    },
-};
-const memidx = u32;
-function memsec(mems) {
-    return section(SECTION_ID_MEMORY, vec(mems));
-}
-// lim:limits
-function memtype(limits) {
-    return limits;
-}
-const limits = {
-    min(n) {
-        return [0x00, u32(n)];
-    },
-    minmax(n, m) {
-        return [0x01, u32(n), u32(m)];
-    },
-};
-const globalidx = u32;
-const mut = {
-    const: 0x00,
-    var: 0x01,
-};
-// t:valtype  m:mut
-function globaltype(t, m) {
-    return [t, m];
-}
-// gt:globaltype  e:expr
-function global(gt, e) {
-    return [gt, e];
-}
-// glob*:vec(global)
-function globalsec(globs) {
-    return section(SECTION_ID_GLOBAL, vec(globs));
-}
-function tabletype(elemtype, limits) {
-    return [elemtype, limits];
-}
-function table(tabletype) {
-    return tabletype;
-}
-function tablesec(tables) {
-    return section(SECTION_ID_TABLE, vec(tables));
-}
-const elemtype = { funcref: 0x70 };
-const tableidx = u32;
-const start = funcidx;
-// st:start
-function startsec(st) {
-    return section(SECTION_ID_START, st);
-}
-// x:memidx  e:expr  b∗:vec(byte)
-function data(x, e, bs) {
-    return [x, e, vec(bs)];
-}
-function datasec(segs) {
-    return section(SECTION_ID_DATA, vec(segs));
-}
-// x:tableidx  e:expr  y∗:vec(funcidx)
-function elem(x, e, ys) {
-    return [x, e, vec(ys)];
-}
-function elemsec(segs) {
-    return section(SECTION_ID_ELEMENT, vec(segs));
-}
-function memarg(align, offset) {
-    return [u32(align), u32(offset)];
-}
-export { blocktype, code, codesec, data, datasec, elem, elemsec, elemtype, export_, exportdesc, exportsec, f64, func, funcidx, funcsec, functype, global, globalsec, globaltype, i32, import_, importdesc, importsec, instr, limits, locals, memarg, memsec, memtype, module, mut, name, section, start, startsec, table, tableidx, tablesec, tabletype, typeidx, typesec, u32, valtype, vec, };