@idlizer/core 2.0.37 → 2.0.40

package/build/lib/src/LanguageWriters/ArgConvertors.js

@@ -16,7 +16,7 @@ import * as idl from "../idl";
 import { Language } from "../Language";
 import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
 import { RuntimeType } from "./common";
-import { generatorConfiguration, generatorTypePrefix } from "../config";
+import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppNameConvertor } from "./convertors/CppConvertors";
@@ -509,7 +509,7 @@ export class ArrayConvertor extends BaseArgConvertor {
         const statements = [];
         const arrayType = this.idlType;
         statements.push(writer.makeAssign(lengthBuffer, idl.IDLI32Type, writer.makeString(`${deserializerName}.readInt32()`), true));
-        statements.push(writer.makeAssign(bufferName, arrayType, writer.makeArrayInit(this.type), true, false));
+        statements.push(writer.makeAssign(bufferName, arrayType, writer.makeArrayInit(this.type, lengthBuffer), true, false));
         statements.push(writer.makeArrayResize(bufferName, writer.getNodeName(arrayType), lengthBuffer, deserializerName));
         statements.push(writer.makeLoop(counterBuffer, lengthBuffer, this.elementConvertor.convertorDeserialize(`${bufferName}_buf`, deserializerName, (expr) => {
             return writer.makeAssign(writer.makeArrayAccess(bufferName, counterBuffer).asString(), undefined, expr, false);
@@ -549,7 +549,7 @@ export class MapConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, printer) {
         // Map size.
         const mapSize = printer.makeMapSize(value);
-        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [mapSize.asString()]);
+        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [printer.castToInt(mapSize.asString(), 32)]);
         printer.writeStatement(printer.makeMapForEach(value, `${value}_key`, `${value}_value`, () => {
             this.keyConvertor.convertorSerialize(param, `${value}_key`, printer);
             this.valueConvertor.convertorSerialize(param, `${value}_value`, printer);
@@ -750,12 +750,7 @@ export class OptionConvertor extends BaseArgConvertor {
         const statements = [];
         statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
         const bufferType = this.nativeType();
-        if (writer.language == Language.CJ) {
-            statements.push(writer.makeAssign(bufferName, bufferType, idl.isOptionalType(bufferType) ? writer.makeString('Option.None') : undefined, true, false));
-        }
-        else {
-            statements.push(writer.makeAssign(bufferName, bufferType, undefined, true, false));
-        }
+        statements.push(writer.makeAssign(bufferName, bufferType, writer.language == Language.CJ ? writer.makeNull() : undefined, true, false));
         const thenStatement = new BlockStatement([
             this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
@@ -894,7 +889,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorConfiguration().TypePrefix}${this.declaration.name}>(${param})`;
+                return `static_cast<${generatorTypePrefix()}${this.declaration.name}>(${param})`;
             case Language.JAVA:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${param})`;

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -249,7 +249,7 @@ export declare abstract class LanguageWriter {
     abstract writePrintLog(message: string): void;
     abstract makeUndefined(): LanguageExpression;
     makeUnwrapOptional(expression: LanguageExpression): LanguageExpression;
-    abstract makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
+    abstract makeArrayInit(type: idl.IDLContainerType, size?: number | string): LanguageExpression;
     abstract makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     abstract makeMapInit(type: idl.IDLType): LanguageExpression;
     abstract makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
@@ -336,7 +336,7 @@ export declare abstract class LanguageWriter {
     makeDiscriminatorFromFields(convertor: {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
-    makeCallIsResource(value: string): LanguageExpression;
+    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
     makeFieldModifiersList(modifiers: FieldModifier[] | undefined, customFieldFilter?: (field: FieldModifier) => boolean): string;
     escapeKeyword(keyword: string): string;
@@ -349,7 +349,6 @@ export declare abstract class LanguageWriter {
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
-    makeCallIsArrayBuffer(value: string): LanguageExpression;
     instanceOf(convertor: ArgConvertor, value: string, _duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;

package/build/lib/src/LanguageWriters/LanguageWriter.js

@@ -619,8 +619,8 @@ export class LanguageWriter {
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         return this.makeString(`(${this.makeNaryOp("||", accessors.map(it => this.makeString(`${value}!.hasOwnProperty("${it}")`))).asString()})`);
     }
-    makeCallIsResource(value) {
-        return this.makeString(`isResource(${value})`);
+    makeIsTypeCall(value, decl) {
+        return this.makeString(`is${decl.name}(${value})`);
     }
     makeEnumEntity(enumEntity, isExport) {
         return new TsEnumEntityStatement(enumEntity, isExport);
@@ -666,9 +666,6 @@ export class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
-    makeCallIsArrayBuffer(value) {
-        return this.makeString(`${value} instanceof ArrayBuffer`);
-    }
     instanceOf(convertor, value, _duplicateMembers) {
         return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
     }

package/build/lib/src/LanguageWriters/convertors/CJConvertors.js

@@ -37,6 +37,9 @@ export class CJTypeNameConvertor {
             const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
             return `Map<${stringes[0]}, ${stringes[1]}>`;
         }
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return `Any`;
+        }
         throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
     }
     convertNamespace(node) {
@@ -106,13 +109,14 @@ export class CJTypeNameConvertor {
             case idl.IDLF64Type: return 'Float64';
             case idl.IDLPointerType: return 'UInt64';
             case idl.IDLVoidType: return 'Unit';
-            case idl.IDLBufferType:
+            case idl.IDLBufferType: return 'Array<UInt8>';
             case idl.IDLInteropReturnBufferType: return 'Array<UInt8>';
+            case idl.IDLBigintType: return 'Int64';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
     callbackType(decl) {
-        const params = decl.parameters.map(it => `${it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${it.name}: ${this.convert(it.type)}`);
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
@@ -126,6 +130,7 @@ export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
         if (idl.isPrimitiveType(type)) {
             switch (type) {
                 case idl.IDLStringType: return 'CString';
+                case idl.IDLInteropReturnBufferType: return 'KInteropReturnBuffer';
             }
         }
         if (idl.isContainerType(type)) {

package/build/lib/src/LanguageWriters/convertors/CppConvertors.d.ts

@@ -30,6 +30,7 @@ export declare class GenericCppConvertor implements NodeConvertor<ConvertResult>
 }
 export declare class CppConvertor extends GenericCppConvertor implements IdlNameConvertor {
     private unwrap;
+    private isPrimitiveOrPrimitiveAlias;
     convert(node: idl.IDLNode): string;
 }
 export declare class CppNameConvertor implements IdlNameConvertor {

package/build/lib/src/LanguageWriters/convertors/CppConvertors.js

@@ -178,9 +178,23 @@ export class CppConvertor extends GenericCppConvertor {
         const typePrefix = conf.TypePrefix;
         // TODO remove this ugly hack for CustomObject's
         const convertedToCustomObject = result.text === idl.IDLCustomObjectType.name;
-        const libPrefix = idl.isPrimitiveType(type) || convertedToCustomObject ? "" : conf.LibraryPrefix;
+        const libPrefix = this.isPrimitiveOrPrimitiveAlias(type) || convertedToCustomObject ? "" : conf.LibraryPrefix;
         return `${typePrefix}${libPrefix}${result.text}`;
     }
+    isPrimitiveOrPrimitiveAlias(type) {
+        if (!idl.isType(type))
+            return false;
+        const { resolver } = this;
+        while (type && idl.isReferenceType(type)) {
+            const resolved = resolver.resolveTypeReference(type);
+            if (!resolved)
+                return false;
+            if (!idl.isTypedef(resolved))
+                break;
+            type = resolved.type;
+        }
+        return idl.isPrimitiveType(type);
+    }
     convert(node) {
         return this.unwrap(node, this.convertNode(node));
     }

package/build/lib/src/LanguageWriters/convertors/InteropConvertors.js

@@ -60,11 +60,11 @@ export class InteropReturnTypeConvertor {
             case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
             case idl.IDLBigintType: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLAnyType:
-            case idl.IDLBufferType:
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLBufferType: return KInteropReturnBuffer; /* ArkTS can not return buffer as language object yet */
             case idl.IDLStringType: return PrimitiveTypesInstance.String.getText();
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
         }

package/build/lib/src/LanguageWriters/writers/CJLanguageWriter.js

@@ -152,7 +152,7 @@ class CJMapForEachStatement {
         this.op = op;
     }
     write(writer) {
-        writer.print(`for ((key, value) in ${this.map}) {`);
+        writer.print(`for ((${this.key}, ${this.value}) in ${this.map}) {`);
         writer.pushIndent();
         this.op();
         writer.popIndent();
@@ -266,7 +266,9 @@ export class CJLanguageWriter extends LanguageWriter {
         return new CJLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.typeForeignConvertor);
     }
     getNodeName(type) {
-        return this.typeConvertor.convert(type);
+        // rework for proper namespace logic
+        let name = this.typeConvertor.convert(type).split('.');
+        return name[name.length - 1];
     }
     writeClass(name, op, superClass, interfaces, generics) {
         let extendsClause = superClass ? `${superClass}` : undefined;
@@ -417,7 +419,7 @@ export class CJLanguageWriter extends LanguageWriter {
         throw new Error(`makeClassInit`);
     }
     makeArrayInit(type, size) {
-        return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
+        return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(Int64(${size !== null && size !== void 0 ? size : ''}))`);
     }
     makeMapInit(type) {
         throw new Error(`TBD`);
@@ -491,7 +493,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString("Option.None");
     }
     makeUnwrapOptional(expression) {
-        return new CJMatchExpression(expression, [this.makeString('Some(serializer)')], [this.makeString('serializer')], this.indentDepth());
+        return new CJMatchExpression(expression, [this.makeString(`Some(unwrap_value)`)], [this.makeString(`unwrap_value`)], this.indentDepth());
     }
     makeValueFromOption(value, destinationConvertor) {
         return this.makeString(`${value}`);

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.d.ts

@@ -50,7 +50,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
-    makeCallIsResource(value: string): LanguageExpression;
+    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js

@@ -210,8 +210,8 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         return super.makeValueFromOption(value, destinationConvertor);
     }
-    makeCallIsResource(value) {
-        return this.makeString(`isResource(${value})`);
+    makeIsTypeCall(value, decl) {
+        return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
     }
     makeEnumEntity(enumEntity, isExport) {
         return new ArkTSEnumEntityStatement(enumEntity, isExport);
@@ -234,7 +234,8 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         if (!idl.isEnum(decl)) {
             throwException(`Declaration type must be Enum`);
         }
-        return this.makeCast(this.makeString(`${value}${idl.isStringEnum(decl) ? "" : ".valueOf()"}`), IDLI32Type).asString();
+        // ((value as Axis) as int) - in case when Axis was casted to Object in Map<Axis, Smth>
+        return this.makeCast(this.makeCast(this.makeString(value), convertor.idlType), IDLI32Type).asString();
     }
     makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
         if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
@@ -315,18 +316,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return new TSCastExpression(value, `${this.getNodeName(type)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
 }
-const builtInInterfaceTypes = new Map([
-    ["Resource",
-        (writer, value) => writer.makeCallIsResource(value)],
-    ["Object",
-        (writer, value) => writer.makeCallIsObject(value)],
-    ["ArrayBuffer",
-        (writer, value) => writer.makeCallIsArrayBuffer(value)]
-]);
 function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
-    if (builtInInterfaceTypes.has(interfaceName)) {
-        return builtInInterfaceTypes.get(interfaceName)(writer, valueAccessor);
-    }
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
         ...allFields.map(it => {
             return writer.makeString(duplicates.has(it) ? "true" : "false");

package/build/lib/src/LanguageWriters/writers/TsLanguageWriter.js

@@ -364,7 +364,7 @@ export class TSLanguageWriter extends LanguageWriter {
         return this.makeAssign(receiver, undefined, this.makeString(`[${fields.map(it => `${it}!`).join(",")}]`), false);
     }
     get supportedModifiers() {
-        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.STATIC];
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.PROTECTED, MethodModifier.STATIC];
     }
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];

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

@@ -8,6 +8,7 @@ export interface CoreConfiguration {
     readonly ignoreMaterialized: string[];
     readonly builderClasses: string[];
     readonly forceMaterialized: string[];
+    readonly forceCallback: string[];
 }
 export declare const defaultCoreConfuguration: CoreConfiguration;
 export declare function setDefaultConfiguration<T extends CoreConfiguration>(config: T): void;

package/build/lib/src/config.js

@@ -22,6 +22,7 @@ export const defaultCoreConfuguration = {
     ignoreMaterialized: [],
     builderClasses: [],
     forceMaterialized: [],
+    forceCallback: [],
 };
 let currentConfig = defaultCoreConfuguration;
 export function setDefaultConfiguration(config) {

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

@@ -0,0 +1,2 @@
+export declare function deepMergeConfig<T extends object>(defaults: T, custom: Partial<T>): T;
+//# sourceMappingURL=configMerge.d.ts.map

package/build/lib/src/configMerge.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function isObject(i) {
+    if (typeof i !== 'object')
+        return false;
+    if (Array.isArray(i))
+        return false;
+    return true;
+}
+export function deepMergeConfig(defaults, custom) {
+    if (custom === undefined)
+        return defaults;
+    const result = Object.assign({}, defaults);
+    for (const key in custom) {
+        if (Object.prototype.hasOwnProperty.call(custom, key)) {
+            const defaultValue = result[key];
+            const customValue = custom[key];
+            if (isObject(defaultValue) && isObject(customValue)) {
+                Object.assign(result, { [key]: deepMergeConfig(defaultValue, customValue) });
+            }
+            else {
+                if (isObject(defaultValue))
+                    throw new Error("Replacing default object value with custom non-object");
+                Object.assign(result, { [key]: customValue });
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=configMerge.js.map

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

@@ -113,8 +113,6 @@ function toIDLInterface(file, node) {
         documentation: makeDocs(node),
         extendedAttributes: toExtendedAttributes(node.extAttrs),
     });
-    if (result.inheritance.length && idl.isReferenceType(result.inheritance[0]))
-        result.inheritance[0].typeArguments = extractTypeArguments(file, node.extAttrs, idl.IDLExtendedAttributes.TypeArguments);
     if (node.extAttrs.find(it => it.name === "Synthetic"))
         addSyntheticType(node.name, result);
     return result;

package/build/lib/src/peer-generation/idl/IdlNameConvertor.d.ts

@@ -20,10 +20,19 @@ export declare class ETSDeclarationNameConvertor extends DeclarationNameConverto
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: ETSDeclarationNameConvertor;
 }
+export declare class CJDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl: idl.IDLInterface): string;
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: CJDeclarationNameConvertor;
+}
 export declare class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: ETSFeatureNameConvertor;
 }
+export declare class CJFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: CJFeatureNameConvertor;
+}
 export declare function createDeclarationNameConvertor(language: Language): DeclarationNameConvertor;
 export declare function createFeatureNameConvertor(language: Language): DeclarationNameConvertor;
 //# sourceMappingURL=IdlNameConvertor.d.ts.map

package/build/lib/src/peer-generation/idl/IdlNameConvertor.js

@@ -57,6 +57,15 @@ export class ETSDeclarationNameConvertor extends DeclarationNameConvertor {
     }
 }
 ETSDeclarationNameConvertor.I = new ETSDeclarationNameConvertor();
+export class CJDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return decl.name;
+    }
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJDeclarationNameConvertor.I = new CJDeclarationNameConvertor();
 export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
         const namespace = idl.getNamespacesPathFor(decl).map(it => it.name);
@@ -66,13 +75,19 @@ export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     }
 }
 ETSFeatureNameConvertor.I = new ETSFeatureNameConvertor();
+export class CJFeatureNameConvertor extends DeclarationNameConvertor {
+    convertEnum(decl) {
+        return decl.name;
+    }
+}
+CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
 export function createDeclarationNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSDeclarationNameConvertor.I;
         case Language.JAVA:
         case Language.CPP:
-        case Language.CJ:
         case Language.TS: return DeclarationNameConvertor.I;
+        case Language.CJ: CJDeclarationNameConvertor.I;
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
@@ -81,8 +96,8 @@ export function createFeatureNameConvertor(language) {
         case Language.ARKTS: return ETSFeatureNameConvertor.I;
         case Language.JAVA:
         case Language.CPP:
-        case Language.CJ:
         case Language.TS: return TSFeatureNameConvertor.I;
+        case Language.CJ: return CJFeatureNameConvertor.I;
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }

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

@@ -24,6 +24,9 @@ export function isMaterialized(declaration, resolver) {
         if (declaration.name == forceMaterialized)
             return true;
     }
+    if (generatorConfiguration().forceCallback.includes(declaration.name)) {
+        return false;
+    }
     for (const ignore of generatorConfiguration().ignoreMaterialized) {
         if (declaration.name.endsWith(ignore))
             return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.0.37",
+  "version": "2.0.40",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {

package/webidl2.js/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Robin Berjon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/webidl2.js/README.md

@@ -0,0 +1,827 @@
+# webidl2.js
+
+[![NPM version](https://badge.fury.io/js/webidl2.svg)](http://badge.fury.io/js/webidl2) [![Known Vulnerabilities](https://snyk.io/test/github/w3c/webidl2.js/badge.svg)](https://snyk.io/test/github/w3c/webidl2.js/)
+[![Financial Contributors on Open Collective](https://opencollective.com/webidl2js/all/badge.svg?label=financial+contributors)](https://opencollective.com/webidl2js)
+
+## Purpose
+
+This is a parser for [Web IDL](https://heycam.github.io/webidl/), a language
+[to specify web APIs in interoperable way](https://heycam.github.io/webidl/#introduction).
+This library supports both Node.js and the browser environment.
+
+Try the online checker [here](https://w3c.github.io/webidl2.js/checker/).
+
+## Installation
+
+Just the usual. For Node:
+
+```Bash
+npm install webidl2
+```
+
+In the browser without module support:
+
+```HTML
+<script src='./webidl2/dist/webidl2.js'></script>
+```
+
+## Documentation
+
+WebIDL2 provides two functions: `parse` and `write`.
+
+* `parse`: Converts a WebIDL string into a syntax tree.
+* `write`: Converts a syntax tree into a WebIDL string. Useful for programmatic code
+  modification.
+
+In Node, that happens with:
+
+```JS
+const { parse, write, validate } = require("webidl2");
+const tree = parse("string of WebIDL");
+const text = write(tree);
+const validation = validate(tree);
+```
+
+In the browser:
+```HTML
+<script>
+  const tree = WebIDL2.parse("string of WebIDL");
+  const text = WebIDL2.write(tree);
+  const validation = WebIDL2.validate(tree);
+</script>
+
+<!-- Or when module is supported -->
+<script type="module">
+  import { parse, write, validate } from "./webidl2/index.js";
+  const tree = parse("string of WebIDL");
+  const text = write(tree);
+  const validation = validate(tree);
+</script>
+```
+
+`parse()` optionally takes an option bag with the following fields:
+
+* `concrete`: Boolean indicating whether the result should include [EOF](#end-of-file)
+   node or not.
+* `productions`: An array with custom production functions. See [Custom productions](docs/custom-productions.md) for more information.
+* `sourceName`: The source name, typically a filename. [Errors](#errors) and validation
+   objects can indicate their origin if you pass a value.
+
+`write()` optionally takes a "templates" object, whose properties are functions that process input in different ways (depending on what is needed for output). Every property is optional. Each property is documented below:
+
+```js
+var result = WebIDL2.write(tree, {
+  templates: {
+    /**
+     * A function that receives syntax strings plus anything the templates returned.
+     * The items are guaranteed to be ordered.
+     * The returned value may be again passed to any template functions,
+     * or it may also be the final return value of `write()`.
+     * @param {any[]} items
+     */
+    wrap: items => items.join(""),
+    /**
+     * @param {string} t A trivia string, which includes whitespaces and comments.
+     */
+    trivia: t => t,
+    /**
+     * The identifier for a container type. For example, the `Foo` part of `interface Foo {};`.
+     * @param {string} escaped The escaped raw name of the definition.
+     * @param data The definition with the name
+     * @param parent The parent of the definition, undefined if absent
+     */
+    name: (escaped, { data, parent }) => escaped,
+    /**
+     * Called for each type referece, e.g. `Window`, `DOMString`, or `unsigned long`.
+     * @param escaped The referenced name. Typically string, but may also be the return
+     *            value of `wrap()` if the name contains whitespace.
+     * @param unescaped Unescaped reference.
+     */
+    reference: (escaped, unescaped) => escaped,
+    /**
+     * Called for each generic-form syntax, e.g. `sequence`, `Promise`, or `maplike`.
+     * @param {string} name The keyword for syntax
+     */
+    generic: name => name,
+    /**
+     * Called for each nameless members, e.g. `stringifier` for `stringifier;` and `constructor` for `constructor();`
+     * @param {string} name The keyword for syntax
+     */
+    nameless: (keyword, { data, parent }) => keyword,
+    /**
+     * Called only once for each types, e.g. `Document`, `Promise<DOMString>`, or `sequence<long>`.
+     * @param type The `wrap()`ed result of references and syntatic bracket strings.
+     */
+    type: type => type,
+    /**
+     * Receives the return value of `reference()`. String if it's absent.
+     */
+    inheritance: inh => inh,
+    /**
+     * Called for each IDL type definition, e.g. an interface, an operation, or a typedef.
+     * @param content The wrapped value of everything the definition contains.
+     * @param data The original definition object
+     * @param parent The parent of the definition, undefined if absent
+     */
+    definition: (content, { data, parent }) => content,
+    /**
+     * Called for each extended attribute annotation.
+     * @param content The wrapped value of everything the annotation contains.
+     */
+    extendedAttribute: content => content,
+    /**
+     * The `Foo` part of `[Foo=Whatever]`.
+     * @param ref The name of the referenced extended attribute name.
+     */
+    extendedAttributeReference: ref => ref
+  }
+});
+```
+
+"Wrapped value" here will all be raw strings when the `wrap()` callback is absent.
+
+`validate()` receives an AST or an array of AST, and returns semantic errors as an
+array of objects. Their fields are same as [errors](#errors) have, with one addition:
+
+* `level`: `"error"` or `"warning"`.
+
+```js
+const validations = validate(tree);
+for (const validation of validations) {
+  console.log(validation.message);
+}
+// Validation error on line X: ...
+// Validation error on line Y: ...
+```
+
+The validator function may provide an autofix function that modifies AST. You can
+optionally call it to skip manual fixes, but make sure you review the result.
+
+```js
+const validations = validate(tree);
+for (const validation of validations) {
+  if (validation.autofix) {
+    validation.autofix();
+  }
+}
+write(tree); // magic!
+```
+
+### Errors
+
+When there is a syntax error in the WebIDL, it throws an exception object with the following
+properties:
+
+* `message`: the error message with its context. Below is what it looks like.
+   ```
+   Syntax error at line 1 in callback-noparen.webidl, since `callback YourCall`:
+   callback YourCall = undefined;
+                                ^ Callback lacks parentheses for arguments
+   ```
+* `bareMessage`: the error message without any context description like below.
+   ```
+   Callback lacks parentheses for arguments
+   ```
+* `line`: the line at which the error occurred.
+* `sourceName`: the source name you passed to `parse()`.
+* `level`: `"error"` by default, can be `"warning"` for some validations for e.g. potential future deprecations.
+* `ruleName`: Only for validations. Currently the followings are supported:
+   * `attr-invalid-type`: Attributes cannot have sequences, records, nor dictionaries.
+   * `dict-arg-default`: Optional dictionary type arguments must have a default value of `{}`.
+   * `dict-arg-optional`: Dictionary type arguments must be optional if the type does not include a required field.
+   * `no-nullable-dict-arg`: Dictionary arguments cannot be nullable.
+   * `no-nullable-union-dict`: Nullable unions cannot include a dictionary type.
+   * `constructor-member`: Constructors must use newer `constructor()` syntax.
+   * `no-duplicate`: Types cannot have identical names.
+   * `require-exposed`: Interfaces must explicitly expose themselves to specific contexts by `[Exposed]`.
+   * `incomplete-op`: Regular or static operations must have both a return type and an identifier.
+   * `no-cross-overload`: Overloading must be done within a single interface or namespace.
+   * `no-constructible-global`: Interfaces with `[Global]` cannot have constructors.
+   * `renamed-legacy`: Legacy extended attributes must use their new names.
+   * `replace-void`: `void` type is replaced by `undefined` type.
+   * `migrate-allowshared`: `[AllowShared] BufferSource` is replaced by `AllowSharedBufferSource`.
+* `input`: a short peek at the text at the point where the error happened
+* `tokens`: the five tokens at the point of error, as understood by the tokeniser
+  (this is the same content as `input`, but seen from the tokeniser's point of view)
+
+The exception also has a `toString()` method that hopefully should produce a decent
+error message.
+
+### AST (Abstract Syntax Tree)
+
+The `parse()` method returns a tree object representing the parse tree of the IDL.
+Comment and white space are not represented in the AST.
+
+The root of this object is always an array of definitions (where definitions are
+any of interfaces, dictionaries, callbacks, etc. — anything that can occur at the root
+of the IDL).
+
+### IDL Type
+
+This structure is used in many other places (operation return types, argument types, etc.).
+It captures a WebIDL type with a number of options. Types look like this and are typically
+attached to a field called `idlType`:
+
+```JS
+{
+  "type": "attribute-type",
+  "generic": "",
+  "idlType": "unsigned short",
+  "nullable": false,
+  "union": false,
+  "extAttrs": [...]
+}
+```
+
+Where the fields are as follows:
+
+* `type`: String indicating where this type is used. Can be `null` if not applicable.
+* `generic`: String indicating the generic type (e.g. "Promise", "sequence").
+* `idlType`: String indicating the type name, or array of subtypes if the type is
+  generic or a union.
+* `nullable`: `true` if the type is nullable.
+* `union`: Boolean indicating whether this is a union type or not.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Interface
+
+Interfaces look like this:
+
+```JS
+{
+  "type": "interface",
+  "name": "Animal",
+  "partial": false,
+  "members": [...],
+  "inheritance": null,
+  "extAttrs": [...]
+}, {
+  "type": "interface",
+  "name": "Human",
+  "partial": false,
+  "members": [...],
+  "inheritance": "Animal",
+  "extAttrs": [...]
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "interface".
+* `name`: The name of the interface.
+* `partial`: `true` if the type is a partial interface.
+* `members`: An array of interface members (attributes, operations, etc.). Empty if there are none.
+* `inheritance`: The name of an interface this one inherits from, `null` otherwise.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Interface mixins
+
+Interfaces mixins look like this:
+
+```JS
+{
+  "type": "interface mixin",
+  "name": "Animal",
+  "inheritance": null,
+  "partial": false,
+  "members": [...],
+  "extAttrs": [...]
+}, {
+  "type": "interface mixin",
+  "name": "Human",
+  "inheritance": null,
+  "partial": false,
+  "members": [...],
+  "extAttrs": [...]
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "interface mixin".
+* `name`: The name of the interface mixin.
+* `inheritance`: Always `null`.
+* `partial`: `true if the type is a partial interface mixin.
+* `members`: An array of interface members (attributes, operations, etc.). Empty if there are none.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Namespace
+
+Namespaces look like this:
+
+```JS
+{
+  "type": "namespace",
+  "name": "console",
+  "inheritance": null,
+  "partial": false,
+  "members": [...],
+  "extAttrs": [...]
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "namespace".
+* `name`: The name of the namespace.
+* `inheritance`: Always `null`.
+* `partial`: `true if the type is a partial namespace.
+* `members`: An array of namespace members (attributes, constants, and operations). Empty if there are none.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Callback Interfaces
+
+These are captured by the same structure as [Interfaces](#interface) except that
+their `type` field is "callback interface".
+
+### Callback
+
+A callback looks like this:
+
+```JS
+{
+  "type": "callback",
+  "name": "AsyncOperationCallback",
+  "idlType": {
+    "type": "return-type",
+    "generic": "",
+    "nullable": false,
+    "union": false,
+    "idlType": "undefined",
+    "extAttrs": []
+  },
+  "arguments": [...],
+  "extAttrs": []
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "callback".
+* `name`: The name of the callback.
+* `idlType`: An [IDL Type](#idl-type) describing what the callback returns.
+* `arguments`: A list of [arguments](#arguments), as in function paramters.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Dictionary
+
+A dictionary looks like this:
+
+```JS
+{
+  "type": "dictionary",
+  "name": "PaintOptions",
+  "partial": false,
+  "members": [{
+    "type": "field",
+    "name": "fillPattern",
+    "required": false,
+    "idlType": {
+      "type": "dictionary-type",
+      "generic": "",
+      "nullable": true
+      "union": false,
+      "idlType": "DOMString",
+      "extAttrs": []
+    },
+    "extAttrs": [],
+    "default": {
+      "type": "string",
+      "value": "black"
+    }
+  }],
+  "inheritance": null,
+  "extAttrs": []
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "dictionary".
+* `name`: The dictionary name.
+* `partial`: `true` if the type is a partial dictionary.
+* `members`: An array of members (see below).
+* `inheritance`: An object indicating which dictionary is being inherited from, `null` otherwise.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+All the members are fields as follows:
+
+* `type`: Always "field".
+* `name`: The name of the field.
+* `required`: `true` if the field is required.
+* `idlType`: An [IDL Type](#idl-type) describing what field's type.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+* `default`: A [default value](#default-and-const-values), or `null` if there is none.
+
+### Enum
+
+An enum looks like this:
+
+```JS
+{
+  "type": "enum",
+  "name": "MealType",
+  "values": [
+    {
+      "type": "enum-value",
+      "value": "rice"
+    },
+    {
+      "type": "enum-value",
+      "value": "noodles"
+    },
+    {
+      "type": "enum-value",
+      "value": "other"
+    }
+  ]
+  "extAttrs": []
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "enum".
+* `name`: The enum's name.
+* `values`: An array of values. The type of value is "enum-value".
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Typedef
+
+A typedef looks like this:
+
+```JS
+{
+  "type": "typedef",
+  "idlType": {
+    "type": "typedef-type",
+    "generic": "sequence",
+    "nullable": false,
+    "union": false,
+    "idlType": [
+      {
+        "type": "typedef-type",
+        "generic": "",
+        "nullable": false,
+        "union": false,
+        "idlType": "Point",
+        "extAttrs": [...]
+      }
+    ],
+    "extAttrs": [...]
+  },
+  "name": "PointSequence",
+  "extAttrs": []
+}
+```
+
+
+The fields are as follows:
+
+* `type`: Always "typedef".
+* `name`: The typedef's name.
+* `idlType`: An [IDL Type](#idl-type) describing what typedef's type.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Includes
+
+An includes definition looks like this:
+
+```JS
+{
+  "type": "includes",
+  "target": "Node",
+  "includes": "EventTarget",
+  "extAttrs": []
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "includes".
+* `target`: The interface that includes an interface mixin.
+* `includes`: The interface mixin that is being included by the target.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+
+### Operation Member
+
+An operation looks like this:
+
+```JS
+{
+  "type": "operation",
+  "special": "",
+  "idlType": {
+    "type": "return-type",
+    "generic": "",
+    "nullable": false,
+    "union": false,
+    "idlType": "undefined",
+    "extAttrs": []
+  },
+  "name": "intersection",
+  "arguments": [{
+    "default": null,
+    "optional": false,
+    "variadic": true,
+    "extAttrs": [],
+    "idlType": {
+      "type": "argument-type",
+      "generic": "",
+      "nullable": false,
+      "union": false,
+      "idlType": "long",
+      "extAttrs": [...]
+    },
+    "name": "ints"
+  }],
+  "extAttrs": [],
+  "parent": { ... }
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "operation".
+* `special`: One of `"getter"`, `"setter"`, `"deleter"`, `"static"`, `"stringifier"`, or `""`.
+* `idlType`: An [IDL Type](#idl-type) of what the operation returns, if exists.
+* `name`: The name of the operation if exists.
+* `arguments`: An array of [arguments](#arguments) for the operation.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+* `parent`: The container of this type as an Object.
+
+### Constructor Operation Member
+
+A constructor operation member looks like this:
+
+```JS
+{
+  "type": "constructor",
+  "arguments": [{
+    "default": null,
+    "optional": false,
+    "variadic": true,
+    "extAttrs": [],
+    "idlType": {
+      "type": "argument-type",
+      "generic": "",
+      "nullable": false,
+      "union": false,
+      "idlType": "long",
+      "extAttrs": [...]
+    },
+    "name": "ints"
+  }],
+  "extAttrs": [],
+  "parent": { ... }
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "constructor".
+* `arguments`: An array of [arguments](#arguments) for the constructor operation.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+* `parent`: The container of this type as an Object.
+
+### Attribute Member
+
+An attribute member looks like this:
+
+```JS
+{
+  "type": "attribute",
+  "special": "",
+  "readonly": false,
+  "idlType": {
+    "type": "attribute-type",
+    "generic": "",
+    "nullable": false,
+    "union": false,
+    "idlType": "any",
+    "extAttrs": [...]
+  },
+  "name": "regexp",
+  "extAttrs": [],
+  "parent": { ... }
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "attribute".
+* `name`: The attribute's name.
+* `special`: One of `"static"`, `"stringifier"`, `"inherit"`, or `""`.
+* `readonly`: `true` if the attribute is read-only.
+* `idlType`: An [IDL Type](#idl-type) for the attribute.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+* `parent`: The container of this type as an Object.
+
+### Constant Member
+
+A constant member looks like this:
+
+```JS
+{
+  "type": "const",
+  "idlType": {
+    "type": "const-type",
+    "generic": "",
+    "nullable": false,
+    "union": false,
+    "idlType": "boolean",
+    "extAttrs": []
+  },
+  "name": "DEBUG",
+  "value": {
+    "type": "boolean",
+    "value": false
+  },
+  "extAttrs": [],
+  "parent": { ... }
+}
+```
+
+The fields are as follows:
+
+* `type`: Always "const".
+* `idlType`: An [IDL Type](#idl-type) of the constant that represents a simple type, the type name.
+* `name`: The name of the constant.
+* `value`: The constant value as described by [Const Values](#default-and-const-values)
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+* `parent`: The container of this type as an Object.
+
+### Arguments
+
+The arguments (e.g. for an operation) look like this:
+
+```JS
+{
+  "arguments": [{
+    "type": "argument",
+    "default": null,
+    "optional": false,
+    "variadic": true
+    "extAttrs": []
+    "idlType": {
+      "type": "argument-type",
+      "generic": "",
+      "nullable": false,
+      "union": false,
+      "idlType": "float",
+      "extAttrs": [...]
+    },
+    "name": "ints",
+    "parent": { ... }
+  }]
+}
+```
+
+The fields are as follows:
+
+* `default`: A [default value](#default-and-const-values), or `null` if there is none.
+* `optional`: `true` if the argument is optional.
+* `variadic`: `true` if the argument is variadic.
+* `idlType`: An [IDL Type](#idl-type) describing the type of the argument.
+* `name`: The argument's name.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+* `parent`: The container of this type as an Object.
+
+### Extended Attributes
+
+Extended attribute container look like this:
+
+```JS
+{
+  "extAttrs": [{
+    "name": "PutForwards",
+    "arguments": [...],
+    "type": "extended-attribute",
+    "rhs": {
+      "type": "identifier",
+      "value": "foo"
+    },
+    "parent": { ... }
+  }]
+}
+```
+
+The fields are as follows:
+
+* `items`: An array of extended attributes.
+
+Extended attributes look like this:
+
+* `name`: The extended attribute's name.
+* `arguments`: An array of [arguments](#arguments), if the extended
+  attribute has a signature (e.g. `[Foo()]`) or if its right-hand side does (e.g.
+  `[LegacyFactoryFunction=Name(DOMString blah)]`).
+* `type`: Always `"extended-attribute"`.
+* `rhs`: If there is a right-hand side, this will capture its `type` and `value`. The
+  type can be one of the following:
+   * `"identifier"`
+   * `"identifier-list"`
+   * `"string"`
+   * `"string-list"`
+   * `"decimal"`
+   * `"decimal-list"`
+   * `"integer"`
+   * `"integer-list"`
+   * `"*"`
+* `parent`: The container of this type as an Object.
+
+### Default and Const Values
+
+Dictionary fields and operation arguments can take default values, and constants take
+values, all of which have the following fields:
+
+* `type`: One of `"string"`, `"number"`, `"boolean"`, `"null"`, `"Infinity"`, `"NaN"`, `"sequence"` or `"dictionary"`.
+
+For `"boolean"`, `"string"`, `"number"`, and `"sequence"`:
+
+* `value`: The value of the given type.  For string and number types, the value is given as a string.  For booleans, the possible values are `true` and `false`. For sequence, the only possible value is `[]`.
+
+For `"Infinity"`:
+
+* `negative`: Boolean indicating whether this is negative Infinity or not.
+
+### `iterable<>`, `async iterable<>`, `maplike<>`, and `setlike<>` declarations
+
+These appear as members of interfaces that look like this:
+
+```JS
+{
+  "type": "maplike", // or "iterable" / "setlike"
+  "idlType": /* One or two types */ ,
+  "readonly": false, // only for maplike and setlike
+  "async": false, // iterable can be async
+  "arguments": [], // only for async iterable
+  "extAttrs": [],
+  "parent": { ... }
+}
+```
+
+The fields are as follows:
+
+* `type`: Always one of "iterable", "maplike" or "setlike".
+* `idlType`: An array with one or more [IDL Types](#idl-type) representing the declared type arguments.
+* `readonly`: `true` if the maplike or setlike is declared as read only.
+* `async`: `true` if the type is async iterable.
+* `arguments`: An array of arguments if exists, empty otherwise. Currently only `async iterable` supports the syntax.
+* `extAttrs`: An array of [extended attributes](#extended-attributes).
+* `parent`: The container of this type as an Object.
+
+### End of file
+
+```js
+{
+  "type": "eof",
+  "value": ""
+}
+```
+
+This type only appears as the last item of parser results, only if options.concrete is `true`.
+This is needed for the writer to keep any comments or whitespaces at the end of file.
+
+The fields are as follows:
+
+* `type`: Always "eof"
+* `value`: Always an empty string.
+
+## Testing
+
+### Running
+
+The test runs with mocha and expect.js. Normally, running `npm test` in the root directory
+should be enough once you're set up.
+
+
+## Contributors
+
+### Code Contributors
+
+This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
+<a href="https://github.com/w3c/webidl2.js/graphs/contributors"><img src="https://opencollective.com/webidl2js/contributors.svg?width=890&button=false" /></a>
+
+### Financial Contributors
+
+Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/webidl2js/contribute)]
+
+#### Individuals
+
+<a href="https://opencollective.com/webidl2js"><img src="https://opencollective.com/webidl2js/individuals.svg?width=890"></a>
+
+#### Organizations
+
+Support this project with your organization. Your logo will show up here with a link to your website. [[Contribute](https://opencollective.com/webidl2js/contribute)]
+
+<a href="https://opencollective.com/webidl2js/organization/0/website"><img src="https://opencollective.com/webidl2js/organization/0/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/1/website"><img src="https://opencollective.com/webidl2js/organization/1/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/2/website"><img src="https://opencollective.com/webidl2js/organization/2/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/3/website"><img src="https://opencollective.com/webidl2js/organization/3/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/4/website"><img src="https://opencollective.com/webidl2js/organization/4/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/5/website"><img src="https://opencollective.com/webidl2js/organization/5/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/6/website"><img src="https://opencollective.com/webidl2js/organization/6/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/7/website"><img src="https://opencollective.com/webidl2js/organization/7/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/8/website"><img src="https://opencollective.com/webidl2js/organization/8/avatar.svg"></a>
+<a href="https://opencollective.com/webidl2js/organization/9/website"><img src="https://opencollective.com/webidl2js/organization/9/avatar.svg"></a>

package/webidl2.js/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}