@idlizer/core 2.0.32 → 2.0.35

package/build/lib/src/from-idl/deserialize.js

@@ -28,16 +28,13 @@ export function addSyntheticType(name, type) {
 export function resolveSyntheticType(type) {
     return syntheticTypes.get(type.name);
 }
-export function toIDLNode(file, node) {
+function toIDLNode(file, node) {
     return toIDLNodeForward(file, node);
 }
 function toIDLNodeForward(file, node) {
     if (isEnum(node)) {
         return toIDLEnum(file, node);
     }
-    if (isPackage(node)) {
-        return toIDLPackage(node);
-    }
     if (isImport(node)) {
         return toIDLImport(node);
     }
@@ -85,13 +82,6 @@ function isImport(node) {
 function isCallable(node) {
     return node.extAttrs.some(it => it.name == "Invoke");
 }
-function toIDLPackage(node) {
-    if (node.clause.startsWith('"')) { // TODO: remove after new schema formation
-        //node.clause = node.clause.substring(1, node.clause.length - 1)
-        throw new Error("Obsolete IDL-source syntax detected");
-    }
-    return idl.createPackage(node.clause.split("."));
-}
 function toIDLImport(node) {
     // console.log(node)
     return idl.createImport(node.clause.split("."), node.alias || undefined);
@@ -369,14 +359,22 @@ function findExtendedAttribute(extAttrs, name) {
     const attr = extAttrs.find(it => it.name === name);
     return attr ? toExtendedAttributeValue(attr) : undefined;
 }
-export function toIDL(file) {
-    const content = fs.readFileSync(file).toString();
-    return webidl2.parse(content).map(it => toIDLNode(file, it));
-}
-export function toIDLFile(fileName) {
-    const content = fs.readFileSync(fileName).toString();
-    const entries = webidl2.parse(content).map(it => toIDLNode(fileName, it));
-    const file = idl.createFile(entries, fileName);
+export function toIDLFile(fileName, content) {
+    if (undefined === content)
+        content = fs.readFileSync(fileName).toString();
+    let packageClause = [];
+    const entries = webidl2.parse(content)
+        .filter(it => {
+        if (!it.type)
+            return false;
+        if (isPackage(it)) {
+            packageClause = it.clause.split(".");
+            return false;
+        }
+        return true;
+    })
+        .map(it => toIDLNode(fileName, it));
+    const file = idl.createFile(entries, fileName, packageClause);
     return idl.linkParentBack(file);
 }
 //# sourceMappingURL=deserialize.js.map

package/build/lib/src/idl.d.ts

@@ -1,33 +1,31 @@
 import { stringOrNone } from "./util";
 export declare enum IDLKind {
     Interface = 0,
-    Package = 1,
-    Import = 2,
-    Callback = 3,
-    Const = 4,
-    Property = 5,
-    Parameter = 6,
-    Method = 7,
-    Callable = 8,
-    Constructor = 9,
-    Enum = 10,
-    EnumMember = 11,
-    Typedef = 12,
-    PrimitiveType = 13,
-    ContainerType = 14,
-    UnspecifiedGenericType = 15,
-    ReferenceType = 16,
-    UnionType = 17,
-    TypeParameterType = 18,
-    OptionalType = 19,
-    Version = 20,
-    Namespace = 21,
-    File = 22
+    Import = 1,
+    Callback = 2,
+    Const = 3,
+    Property = 4,
+    Parameter = 5,
+    Method = 6,
+    Callable = 7,
+    Constructor = 8,
+    Enum = 9,
+    EnumMember = 10,
+    Typedef = 11,
+    PrimitiveType = 12,
+    ContainerType = 13,
+    UnspecifiedGenericType = 14,
+    ReferenceType = 15,
+    UnionType = 16,
+    TypeParameterType = 17,
+    OptionalType = 18,
+    Version = 19,
+    Namespace = 20,
+    File = 21
 }
 export declare enum IDLEntity {
     Class = "Class",
     Interface = "Interface",
-    Package = "Package",
     Import = "Import",
     Intersection = "Intersection",
     Literal = "Literal",
@@ -49,7 +47,6 @@ export declare enum IDLExtendedAttributes {
     DtsName = "DtsName",
     DtsTag = "DtsTag",
     Entity = "Entity",
-    GlobalScope = "GlobalScope",
     Import = "Import",
     IndexSignature = "IndexSignature",
     Interfaces = "Interfaces",
@@ -59,6 +56,7 @@ export declare enum IDLExtendedAttributes {
     Predefined = "Predefined",
     Protected = "Protected",
     Synthetic = "Synthetic",
+    Throws = "Throws",
     TSType = "TSType",
     TypeArguments = "TypeArguments",
     TypeParameters = "TypeParameters",
@@ -82,6 +80,7 @@ export interface IDLNode {
     documentation?: string;
 }
 export interface IDLFile extends IDLNode {
+    packageClause: string[];
     entries: IDLEntry[];
     fileName?: string;
 }
@@ -206,10 +205,6 @@ export interface IDLInterface extends IDLEntry {
     methods: IDLMethod[];
     callables: IDLCallable[];
 }
-export interface IDLPackage extends IDLEntry {
-    kind: IDLKind.Package;
-    clause: string[];
-}
 export interface IDLImport extends IDLEntry {
     kind: IDLKind.Import;
     clause: string[];
@@ -237,7 +232,6 @@ export declare function isEnumMember(type: IDLNode): type is IDLEnumMember;
 export declare function isUnionType(type: IDLNode): type is IDLUnionType;
 export declare function isTypeParameterType(type: IDLNode): type is IDLTypeParameterType;
 export declare function isInterface(node: IDLNode): node is IDLInterface;
-export declare function isPackage(type: IDLNode): type is IDLPackage;
 export declare function isImport(type: IDLNode): type is IDLImport;
 export declare function isCallable(node: IDLNode): node is IDLCallable;
 export declare function isMethod(node: IDLNode): node is IDLMethod;
@@ -316,8 +310,7 @@ export declare function createUnspecifiedGenericType(name: string, typeArguments
 export declare function entityToType(entity: IDLNode): IDLType;
 export declare function createContainerType(container: IDLContainerKind, element: IDLType[]): IDLContainerType;
 export declare function createUnionType(types: IDLType[], name?: string): IDLUnionType;
-export declare function createFile(entries: IDLEntry[], fileName?: string): IDLFile;
-export declare function createPackage(clause: string[]): IDLPackage;
+export declare function createFile(entries: IDLEntry[], fileName?: string, packageClause?: string[]): IDLFile;
 export declare function createImport(clause: string[], name?: string, nodeInitializer?: IDLNodeInitializer): IDLImport;
 export declare function createEnum(name: string, elements: IDLEnumMember[], nodeInitializer: IDLNodeInitializer): IDLEnum;
 export declare function createEnumMember(name: string, parent: IDLEnum, type: IDLPrimitiveType, initializer: number | string | undefined, nodeInitializer?: IDLNodeInitializer): IDLEnumMember;
@@ -360,7 +353,7 @@ export declare function printExtendedAttributes(idl: IDLNode, indentLevel: numbe
 export declare const attributesToQuote: Set<IDLExtendedAttributes>;
 export declare function printFunction(idl: IDLFunction): PrintedLine[];
 export declare function printMethod(idl: IDLMethod): PrintedLine[];
-export declare function printPackage(idl: IDLPackage): PrintedLine[];
+export declare function printPackage(idl: IDLFile): PrintedLine[];
 export declare function printImport(idl: IDLImport): PrintedLine[];
 export declare function printNamespace(idl: IDLNamespace): PrintedLine[];
 export declare function printCallback(idl: IDLCallback): PrintedLine[];
@@ -377,7 +370,7 @@ export interface IDLPrintOptions {
     disableEnumInitializers: boolean;
     allowUnknownKinds: boolean;
 }
-export declare function toIDLString(entries: IDLEntry[], options: Partial<IDLPrintOptions>): string;
+export declare function toIDLString(file: IDLFile, options: Partial<IDLPrintOptions>): string;
 export declare function verifyIDLString(source: string): true;
 export declare function hasExtAttribute(node: IDLNode, attribute: IDLExtendedAttributes): boolean;
 export declare function getExtAttribute(node: IDLNode, name: IDLExtendedAttributes): stringOrNone;

package/build/lib/src/idl.js

@@ -19,34 +19,32 @@ import { IDLKeywords } from "./languageSpecificKeywords";
 export var IDLKind;
 (function (IDLKind) {
     IDLKind[IDLKind["Interface"] = 0] = "Interface";
-    IDLKind[IDLKind["Package"] = 1] = "Package";
-    IDLKind[IDLKind["Import"] = 2] = "Import";
-    IDLKind[IDLKind["Callback"] = 3] = "Callback";
-    IDLKind[IDLKind["Const"] = 4] = "Const";
-    IDLKind[IDLKind["Property"] = 5] = "Property";
-    IDLKind[IDLKind["Parameter"] = 6] = "Parameter";
-    IDLKind[IDLKind["Method"] = 7] = "Method";
-    IDLKind[IDLKind["Callable"] = 8] = "Callable";
-    IDLKind[IDLKind["Constructor"] = 9] = "Constructor";
-    IDLKind[IDLKind["Enum"] = 10] = "Enum";
-    IDLKind[IDLKind["EnumMember"] = 11] = "EnumMember";
-    IDLKind[IDLKind["Typedef"] = 12] = "Typedef";
-    IDLKind[IDLKind["PrimitiveType"] = 13] = "PrimitiveType";
-    IDLKind[IDLKind["ContainerType"] = 14] = "ContainerType";
-    IDLKind[IDLKind["UnspecifiedGenericType"] = 15] = "UnspecifiedGenericType";
-    IDLKind[IDLKind["ReferenceType"] = 16] = "ReferenceType";
-    IDLKind[IDLKind["UnionType"] = 17] = "UnionType";
-    IDLKind[IDLKind["TypeParameterType"] = 18] = "TypeParameterType";
-    IDLKind[IDLKind["OptionalType"] = 19] = "OptionalType";
-    IDLKind[IDLKind["Version"] = 20] = "Version";
-    IDLKind[IDLKind["Namespace"] = 21] = "Namespace";
-    IDLKind[IDLKind["File"] = 22] = "File";
+    IDLKind[IDLKind["Import"] = 1] = "Import";
+    IDLKind[IDLKind["Callback"] = 2] = "Callback";
+    IDLKind[IDLKind["Const"] = 3] = "Const";
+    IDLKind[IDLKind["Property"] = 4] = "Property";
+    IDLKind[IDLKind["Parameter"] = 5] = "Parameter";
+    IDLKind[IDLKind["Method"] = 6] = "Method";
+    IDLKind[IDLKind["Callable"] = 7] = "Callable";
+    IDLKind[IDLKind["Constructor"] = 8] = "Constructor";
+    IDLKind[IDLKind["Enum"] = 9] = "Enum";
+    IDLKind[IDLKind["EnumMember"] = 10] = "EnumMember";
+    IDLKind[IDLKind["Typedef"] = 11] = "Typedef";
+    IDLKind[IDLKind["PrimitiveType"] = 12] = "PrimitiveType";
+    IDLKind[IDLKind["ContainerType"] = 13] = "ContainerType";
+    IDLKind[IDLKind["UnspecifiedGenericType"] = 14] = "UnspecifiedGenericType";
+    IDLKind[IDLKind["ReferenceType"] = 15] = "ReferenceType";
+    IDLKind[IDLKind["UnionType"] = 16] = "UnionType";
+    IDLKind[IDLKind["TypeParameterType"] = 17] = "TypeParameterType";
+    IDLKind[IDLKind["OptionalType"] = 18] = "OptionalType";
+    IDLKind[IDLKind["Version"] = 19] = "Version";
+    IDLKind[IDLKind["Namespace"] = 20] = "Namespace";
+    IDLKind[IDLKind["File"] = 21] = "File";
 })(IDLKind || (IDLKind = {}));
 export var IDLEntity;
 (function (IDLEntity) {
     IDLEntity["Class"] = "Class";
     IDLEntity["Interface"] = "Interface";
-    IDLEntity["Package"] = "Package";
     IDLEntity["Import"] = "Import";
     IDLEntity["Intersection"] = "Intersection";
     IDLEntity["Literal"] = "Literal";
@@ -69,7 +67,6 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["DtsName"] = "DtsName";
     IDLExtendedAttributes["DtsTag"] = "DtsTag";
     IDLExtendedAttributes["Entity"] = "Entity";
-    IDLExtendedAttributes["GlobalScope"] = "GlobalScope";
     IDLExtendedAttributes["Import"] = "Import";
     IDLExtendedAttributes["IndexSignature"] = "IndexSignature";
     IDLExtendedAttributes["Interfaces"] = "Interfaces";
@@ -79,6 +76,7 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["Predefined"] = "Predefined";
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
+    IDLExtendedAttributes["Throws"] = "Throws";
     IDLExtendedAttributes["TSType"] = "TSType";
     IDLExtendedAttributes["TypeArguments"] = "TypeArguments";
     IDLExtendedAttributes["TypeParameters"] = "TypeParameters";
@@ -170,7 +168,6 @@ export function forEachChild(node, cbEnter, cbLeave) {
         case IDLKind.ReferenceType:
         case IDLKind.TypeParameterType:
         case IDLKind.EnumMember:
-        case IDLKind.Package:
         case IDLKind.Import:
         case IDLKind.PrimitiveType:
         case IDLKind.Version:
@@ -227,9 +224,6 @@ export function isTypeParameterType(type) {
 export function isInterface(node) {
     return node.kind === IDLKind.Interface;
 }
-export function isPackage(type) {
-    return type.kind == IDLKind.Package;
-}
 export function isImport(type) {
     return type.kind == IDLKind.Import;
 }
@@ -399,13 +393,7 @@ export function isEqualByQualifedName(a, b) {
 }
 export function getPackageClause(entry) {
     let file = getFileFor(entry);
-    if (!file)
-        return [];
-    for (const child of file.entries)
-        if (isPackage(child))
-            return child.clause;
-    // console.warn("Expected to have one IDLPackage inside IDLFile. Using empty package name")
-    return [];
+    return (file === null || file === void 0 ? void 0 : file.packageClause) || [];
 }
 export function getPackageName(entry) {
     return getPackageClause(entry).join(".");
@@ -498,24 +486,15 @@ export function createUnionType(types, name) {
         _idlNamedNodeBrand: innerIdlSymbol,
     };
 }
-export function createFile(entries, fileName) {
+export function createFile(entries, fileName, packageClause = []) {
     return {
         kind: IDLKind.File,
+        packageClause,
         entries: entries,
         fileName,
         _idlNodeBrand: innerIdlSymbol,
     };
 }
-export function createPackage(clause) {
-    return {
-        kind: IDLKind.Package,
-        name: "",
-        clause,
-        _idlNodeBrand: innerIdlSymbol,
-        _idlEntryBrand: innerIdlSymbol,
-        _idlNamedNodeBrand: innerIdlSymbol,
-    };
-}
 export function createImport(clause, name, nodeInitializer) {
     return Object.assign(Object.assign({ kind: IDLKind.Import, name: name || "", clause }, nodeInitializer), { _idlNodeBrand: innerIdlSymbol, _idlEntryBrand: innerIdlSymbol, _idlNamedNodeBrand: innerIdlSymbol });
 }
@@ -753,10 +732,10 @@ export function printMethod(idl) {
     ];
 }
 export function printPackage(idl) {
-    if (!idl.clause.length)
+    if (!idl.packageClause.length)
         return [];
     return [
-        `package ${idl.clause.join(".")};`
+        `package ${idl.packageClause.join(".")};`
     ];
 }
 export function printImport(idl) {
@@ -855,6 +834,7 @@ export function printTypedef(idl) {
         `typedef ${printType(idl.type)} ${idl.name};`
     ];
 }
+// TODO: use IndentedPrinter instead!
 export function printIDL(idl, options) {
     var _a;
     if (idl.kind == IDLKind.Interface)
@@ -865,8 +845,6 @@ export function printIDL(idl, options) {
         return printTypedef(idl);
     if (idl.kind == IDLKind.Callback)
         return printCallback(idl);
-    if (idl.kind == IDLKind.Package)
-        return printPackage(idl);
     if (idl.kind == IDLKind.Import)
         return printImport(idl);
     if (idl.kind == IDLKind.Namespace)
@@ -882,23 +860,27 @@ export function printIDL(idl, options) {
         throw new Error(`unexpected kind: ${idl.kind}`);
     }
 }
-export function toIDLString(entries, options) {
+export function toIDLString(file, options) {
     let indent = 0;
-    const generatedIdl = entries
+    const generated = printPackage(file);
+    return generated.concat(file.entries
         .map(it => printIDL(it, options))
         .flat()
         .filter(isDefined)
         .filter(it => it.length > 0)
         .map(it => {
-        if (it === printedIndentInc)
+        if (it === printedIndentInc) {
             ++indent;
-        else if (it === printedIndentDec)
+            return undefined;
+        }
+        else if (it === printedIndentDec) {
             --indent;
+            return undefined;
+        }
         else
             return indentedBy(it, indent);
     })
-        .join("\n");
-    return generatedIdl;
+        .filter(isDefined)).join("\n");
 }
 // throws validation error
 export function verifyIDLString(source) {

package/build/lib/src/index.d.ts

@@ -45,5 +45,5 @@ export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export { fromIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { toIDL, toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
 //# sourceMappingURL=index.d.ts.map

package/build/lib/src/index.js

@@ -59,5 +59,5 @@ export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";
 export { fromIDL } from "./from-idl/common";
 export { idlToDtsString, CustomPrintVisitor } from "./from-idl/DtsPrinter";
-export { toIDL, toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
+export { toIDLFile, addSyntheticType, resolveSyntheticType } from "./from-idl/deserialize";
 //# sourceMappingURL=index.js.map

package/build/lib/src/library.d.ts

@@ -31,7 +31,6 @@ export type QueryType<T> = LibraryQuery<IDLLibrary, T> | LensBuilder<T>;
 export declare function query<T>(lib: IDLLibrary, input: QueryType<T>): T;
 interface EntitiesParams {
     expandNamespaces?: boolean;
-    slipPackage?: boolean;
 }
 export declare const lib: {
     createLibrary: typeof createLibrary;
@@ -40,7 +39,7 @@ export declare const lib: {
     query: typeof query;
     select: {
         files(): LibraryReducer<readonly idl.IDLFile[]>;
-        nodes(params: EntitiesParams): LibraryQuery<readonly idl.IDLFile[], idl.IDLNode[]>;
+        nodes(params?: EntitiesParams): LibraryQuery<readonly idl.IDLFile[], idl.IDLNode[]>;
         entries(): LibraryQuery<idl.IDLNode[], idl.IDLEntry[]>;
         interfaces(): LibraryQuery<idl.IDLNode[], idl.IDLInterface[]>;
         hasExt<T extends idl.IDLNode>(attr: idl.IDLExtendedAttributes): LibraryQuery<T[], T[]>;

package/build/lib/src/library.js

@@ -139,12 +139,9 @@ const select = {
     nodes(params) {
         const key = 'entities' + serializeParam(params);
         function go(node) {
-            if (idl.isNamespace(node) && params.expandNamespaces) {
+            if (idl.isNamespace(node) && (params === null || params === void 0 ? void 0 : params.expandNamespaces)) {
                 return node.members.flatMap(go);
             }
-            if (idl.isPackage(node) && params.slipPackage) {
-                return [];
-            }
             return [node];
         }
         return req(key, xs => {

package/build/lib/src/peer-generation/Materialized.d.ts

@@ -52,9 +52,11 @@ export declare class MaterializedClass implements PeerClassBase {
     getComponentName(): string;
     getImplementationName(): string;
     generatedName(isCallSignature: boolean): string;
+    private _isGlobal;
+    setGlobalScope(): void;
     isGlobalScope(): boolean;
 }
-export declare function createDestroyPeerMethod(clazz: MaterializedClass): MaterializedMethod;
+export declare function createDestroyPeerMethod(clazz: MaterializedClass): MaterializedMethod | undefined;
 export declare function getInternalClassName(name: string): string;
 export declare function getInternalClassQualifiedName(target: idl.IDLEntry): string;
 export declare function getMaterializedFileName(name: string): string;

package/build/lib/src/peer-generation/Materialized.js

@@ -111,6 +111,7 @@ export class MaterializedClass {
         this.methods = methods;
         this.needBeGenerated = needBeGenerated;
         this.taggedMethods = taggedMethods;
+        this._isGlobal = false;
         PeerMethod.markAndGroupOverloads(methods);
     }
     getComponentName() {
@@ -122,11 +123,17 @@ export class MaterializedClass {
     generatedName(isCallSignature) {
         return this.className;
     }
+    setGlobalScope() {
+        this._isGlobal = true;
+    }
     isGlobalScope() {
-        return idl.hasExtAttribute(this.decl, idl.IDLExtendedAttributes.GlobalScope);
+        return this._isGlobal;
     }
 }
 export function createDestroyPeerMethod(clazz) {
+    if (clazz.isGlobalScope()) {
+        return undefined;
+    }
     return new MaterializedMethod(clazz.className, clazz.getImplementationName(), [], idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.className)], ['peer'])));
 }
 export function getInternalClassName(name) {

package/build/lib/src/peer-generation/PeerFile.d.ts

@@ -7,7 +7,7 @@ export declare class PeerFile implements LibraryFileInterface {
     readonly peers: Map<string, PeerClass>;
     constructor(file: idl.IDLFile, isPredefined?: boolean);
     packageName(): string;
-    package(): idl.IDLPackage | undefined;
+    packageClause(): string[];
     get peersToGenerate(): PeerClass[];
     get entries(): idl.IDLEntry[];
     get originalFilename(): string;

package/build/lib/src/peer-generation/PeerFile.js

@@ -12,7 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as idl from '../idl';
 export class PeerFile {
     constructor(file, isPredefined = false) {
         this.file = file;
@@ -20,17 +19,10 @@ export class PeerFile {
         this.peers = new Map();
     }
     packageName() {
-        const packageTag = this.package();
-        if (packageTag === undefined) {
-            return "";
-        }
-        if (packageTag.name.startsWith('"') && packageTag.name.endsWith('"')) {
-            return packageTag.name.slice(1, packageTag.name.length - 1);
-        }
-        return packageTag.name;
+        return this.packageClause().join(".");
     }
-    package() {
-        return this.entries.find(it => idl.isPackage(it));
+    packageClause() {
+        return this.file.packageClause;
     }
     get peersToGenerate() {
         const peers = Array.from(this.peers.values());

package/build/lib/src/peer-generation/PeerLibrary.d.ts

@@ -9,10 +9,14 @@ import { MaterializedClass } from './Materialized';
 import { PeerFile } from './PeerFile';
 import { LayoutManager, LayoutManagerStrategy } from './LayoutManager';
 import { IDLLibrary } from '../library';
+export interface GlobalScopeDeclarations {
+    methods: idl.IDLMethod[];
+    constants: idl.IDLConstant[];
+}
 export declare const lenses: {
     globals: {
-        req: import("../library").LibraryReducer<idl.IDLInterface[]>;
-        pipe<T>(r: import("../library").LibraryQuery<idl.IDLInterface[], T>): {
+        req: import("../library").LibraryReducer<GlobalScopeDeclarations[]>;
+        pipe<T>(r: import("../library").LibraryQuery<GlobalScopeDeclarations[], T>): {
             req: import("../library").LibraryReducer<T>;
             pipe<T_1>(r: import("../library").LibraryQuery<T, T_1>): {
                 req: import("../library").LibraryReducer<T_1>;
@@ -5128,7 +5132,7 @@ export declare const lenses: {
             };
             query(): import("../library").LibraryReducer<T>;
         };
-        row<T_2047>(key: string, f: (x: idl.IDLInterface[]) => T_2047): {
+        row<T_2047>(key: string, f: (x: GlobalScopeDeclarations[]) => T_2047): {
             req: import("../library").LibraryReducer<T_2047>;
             pipe<T_2048>(r: import("../library").LibraryQuery<T_2047, T_2048>): {
                 req: import("../library").LibraryReducer<T_2048>;
@@ -10244,7 +10248,7 @@ export declare const lenses: {
             };
             query(): import("../library").LibraryReducer<T_2047>;
         };
-        query(): import("../library").LibraryReducer<idl.IDLInterface[]>;
+        query(): import("../library").LibraryReducer<GlobalScopeDeclarations[]>;
     };
 };
 export declare class PeerLibrary implements LibraryInterface {
@@ -10252,10 +10256,11 @@ export declare class PeerLibrary implements LibraryInterface {
     libraryPackages: string[] | undefined;
     private _cachedIdlLibrary?;
     asIDLLibrary(): IDLLibrary;
-    get globalScopeInterfaces(): idl.IDLInterface[];
+    get globals(): GlobalScopeDeclarations[];
     layout: LayoutManager;
     private _syntheticFile;
     initSyntheticEntries(file: idl.IDLFile): void;
+    getSyntheticData(): idl.IDLInterface[];
     readonly files: PeerFile[];
     readonly builderClasses: Map<string, BuilderClass>;
     get buildersToGenerate(): BuilderClass[];

package/build/lib/src/peer-generation/PeerLibrary.js

@@ -30,9 +30,33 @@ import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
 export const lenses = {
     globals: lib.lens(lib.select.files())
-        .pipe(lib.select.nodes({ expandNamespaces: true }))
-        .pipe(lib.select.interfaces())
-        .pipe(lib.select.hasExt(idl.IDLExtendedAttributes.GlobalScope))
+        .pipe(lib.select.nodes())
+        .pipe(lib.req('globals', (nodes) => {
+        const result = [];
+        const queue = [nodes];
+        while (queue.length) {
+            const line = {
+                constants: [],
+                methods: []
+            };
+            const next = queue.pop();
+            next.forEach(node => {
+                if (idl.isNamespace(node)) {
+                    queue.push(node.members);
+                }
+                if (idl.isConstant(node)) {
+                    line.constants.push(node);
+                }
+                if (idl.isMethod(node)) {
+                    line.methods.push(node);
+                }
+            });
+            if (line.constants.length || line.methods.length) {
+                result.push(line);
+            }
+        }
+        return result;
+    }))
 };
 export class PeerLibrary {
     asIDLLibrary() {
@@ -44,10 +68,13 @@ export class PeerLibrary {
         };
         return this._cachedIdlLibrary;
     }
-    get globalScopeInterfaces() { return query(this.asIDLLibrary(), lenses.globals); }
+    get globals() { return query(this.asIDLLibrary(), lenses.globals); }
     initSyntheticEntries(file) {
         this._syntheticFile = file;
     }
+    getSyntheticData() {
+        return this._syntheticFile.entries.filter(it => idl.isInterface(it));
+    }
     get buildersToGenerate() {
         return Array.from(this.builderClasses.values()).filter(it => it.needBeGenerated);
     }

package/build/lib/src/peer-generation/PeerMethod.js

@@ -12,6 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { generatorTypePrefix } from "../config";
 import { mangleMethodName, MethodModifier } from "../LanguageWriters/LanguageWriter";
 import { capitalize, isDefined } from "../util";
 import { PrimitiveTypesInstance } from "./PrimitiveType";
@@ -69,13 +70,16 @@ export class PeerMethod {
         return !((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC));
     }
     generateAPIParameters(converter) {
+        var _a;
         const args = this.argAndOutConvertors.map(it => {
             let isPointer = it.isPointerType();
             return `${isPointer ? "const " : ""}${converter.convert(it.nativeType())}${isPointer ? "*" : ""} ${it.param}`;
         });
         const receiver = this.generateReceiver();
         if (receiver)
-            return [`${receiver.argType} ${receiver.argName}`, ...args];
+            args.unshift(`${receiver.argType} ${receiver.argName}`);
+        if ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS))
+            args.unshift(`${generatorTypePrefix()}VMContext vmContext`);
         return args;
     }
     generateReceiver() {

package/build/lib/src/peer-generation/PrimitiveType.d.ts

@@ -3,6 +3,7 @@ export declare class PrimitiveType {
     protected isPointer: boolean;
     constructor(name: string, isPointer?: boolean);
     getText(): string;
+    getInterop(): string;
     toString(): string;
 }
 export declare class PrimitiveTypeList {
@@ -11,6 +12,7 @@ export declare class PrimitiveTypeList {
     static get ObjectTag(): string;
     readonly Int32: PrimitiveType;
     readonly Int64: PrimitiveType;
+    readonly Number: PrimitiveType;
     readonly Boolean: PrimitiveType;
     readonly Function: PrimitiveType;
     readonly Undefined: PrimitiveType;