@idlizer/core 2.1.9-arktscgen-6 → 2.1.9-arktscgen-9

package/build/lib/src/config.js

@@ -19,11 +19,13 @@ const T = {
 };
 export const ModuleConfigurationSchema = D.object({
     name: D.string(),
+    external: D.maybe(D.boolean()),
     packages: T.stringArray(),
     useFoldersLayout: D.maybe(D.boolean()),
 });
 export const HookMethodSchema = D.object({
     hookName: D.string(),
+    replaceImplementation: D.boolean()
 });
 export const CoreConfigurationSchema = D.object({
     TypePrefix: D.string(),
@@ -33,16 +35,16 @@ export const CoreConfigurationSchema = D.object({
     standaloneComponents: T.stringArray(),
     parameterized: T.stringArray(),
     ignoreMaterialized: T.stringArray(),
+    ignoreGenerics: T.stringArray(),
     builderClasses: T.stringArray(),
     forceMaterialized: T.stringArray(),
     forceCallback: D.map(D.string(), T.stringArray()).onMerge('replace'),
     forceResource: T.stringArray(),
     forceContext: T.stringArray(),
     hooks: D.map(D.string(), D.map(D.string(), HookMethodSchema)).onMerge('replace'),
-    externalTypes: D.map(D.string(), D.string()).onMerge('replace'),
-    externalPackages: T.stringArray(),
     moduleName: D.string(),
     modules: D.map(D.string(), ModuleConfigurationSchema).onMerge('replace'),
+    libraryNameMapping: D.maybe(D.map(D.string(), D.map(D.string(), D.string())).onMerge('replace')),
     globalPackages: T.stringArray()
 });
 export const defaultCoreConfiguration = {
@@ -53,16 +55,16 @@ export const defaultCoreConfiguration = {
     standaloneComponents: [],
     parameterized: [],
     ignoreMaterialized: [],
+    ignoreGenerics: [],
     builderClasses: [],
     forceMaterialized: [],
     forceCallback: new Map(),
     forceResource: [],
     forceContext: [],
     hooks: new Map(),
-    externalTypes: new Map(),
-    externalPackages: [],
     moduleName: "",
     modules: new Map(),
+    libraryNameMapping: new Map(),
     globalPackages: []
 };
 let currentConfig = defaultCoreConfiguration;
@@ -79,14 +81,18 @@ export function generatorTypePrefix() {
     const conf = generatorConfiguration();
     return `${conf.TypePrefix}${conf.LibraryPrefix}`;
 }
-export function generatorHookName(className, methodName) {
-    var _a;
+export function getHookMethod(className, methodName) {
+    var _a, _b;
     const hookMethods = generatorConfiguration().hooks.get(className);
     if (!hookMethods)
         return undefined;
     const hook = hookMethods.get(methodName);
     if (!hook)
         return undefined;
-    return (_a = hook.hookName) !== null && _a !== void 0 ? _a : `hook${className}${capitalize(methodName)}`;
+    const method = {
+        hookName: (_a = hook.hookName) !== null && _a !== void 0 ? _a : `hook${className}${capitalize(methodName)}`,
+        replaceImplementation: (_b = hook.replaceImplementation) !== null && _b !== void 0 ? _b : true
+    };
+    return method;
 }
 //# sourceMappingURL=config.js.map

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

@@ -0,0 +1,45 @@
+import { MessageSeverity, DiagnosticMessage, Location, DiagnosticResults } from "./diagnostictypes";
+/**
+ * Template for registering different kinds of messages
+ */
+export declare class DiagnosticMessageEntry {
+    /**
+     * Index for DiagnosticMessageEntry by code
+     */
+    static diagnosticMessageByCode: Map<number, DiagnosticMessageEntry>;
+    static collectedResults: DiagnosticResults;
+    /**
+     * Severity of the diagnostic.
+     */
+    severity: MessageSeverity;
+    /**
+     * Unsigned integer code of the diagnostic.
+     */
+    code: number;
+    /**
+     * Description of the diagnostic.
+     */
+    codeDescription: string;
+    /**
+     * An URI to open with more information about the diagnostic.
+     */
+    codeURI?: string;
+    /**
+     * Template for main part
+     */
+    mainMessageTemplate: string;
+    /**
+     * Template for additional parts
+     */
+    additionalMessageTemplate: string;
+    constructor(severity: MessageSeverity, code: number, codeDescription: string, mainMessageTemplate?: string, additionalMessageTemplate?: string);
+    generateDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): DiagnosticMessage;
+    reportDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): void;
+    throwDiagnosticMessage(locations: Location[], mainMessage?: string, additionalMessage?: string): void;
+    static reportCatched(diagnosticMessage: DiagnosticMessage): void;
+}
+export declare const UnknownErrorMessage: DiagnosticMessageEntry;
+export declare const LoadingErrorMessage: DiagnosticMessageEntry;
+export declare const ParsingErrorMessage: DiagnosticMessageEntry;
+export declare const ProcessingErrorMessage: DiagnosticMessageEntry;
+//# sourceMappingURL=diagnosticmessages.d.ts.map

package/build/lib/src/diagnosticmessages.js

@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+import { DiagnosticException, DiagnosticResults } from "./diagnostictypes";
+/**
+ * Template for registering different kinds of messages
+ */
+export class DiagnosticMessageEntry {
+    constructor(severity, code, codeDescription, mainMessageTemplate, additionalMessageTemplate) {
+        this.severity = severity;
+        this.code = code;
+        this.codeDescription = codeDescription;
+        // No cases of codeUri for now, can be embedded into codeDescription later if needed
+        this.mainMessageTemplate = mainMessageTemplate !== null && mainMessageTemplate !== void 0 ? mainMessageTemplate : codeDescription;
+        this.additionalMessageTemplate = additionalMessageTemplate !== null && additionalMessageTemplate !== void 0 ? additionalMessageTemplate : "See";
+        if (DiagnosticMessageEntry.diagnosticMessageByCode.has(code)) {
+            throw new Error(`Duplicate message code ${code}`);
+        }
+        DiagnosticMessageEntry.diagnosticMessageByCode.set(code, this);
+    }
+    generateDiagnosticMessage(locations, mainMessage, additionalMessage) {
+        let msg = {
+            severity: this.severity,
+            code: this.code,
+            codeDescription: this.codeDescription,
+            codeURI: this.codeURI,
+            parts: []
+        };
+        let first = true;
+        for (const l of locations) {
+            msg.parts.push({ location: l, message: first ? (mainMessage !== null && mainMessage !== void 0 ? mainMessage : this.mainMessageTemplate) : (additionalMessage !== null && additionalMessage !== void 0 ? additionalMessage : this.additionalMessageTemplate) });
+            first = false;
+        }
+        return msg;
+    }
+    reportDiagnosticMessage(locations, mainMessage, additionalMessage) {
+        DiagnosticMessageEntry.collectedResults.push(this.generateDiagnosticMessage(locations, mainMessage, additionalMessage));
+    }
+    throwDiagnosticMessage(locations, mainMessage, additionalMessage) {
+        throw new DiagnosticException(this.generateDiagnosticMessage(locations, mainMessage, additionalMessage));
+    }
+    static reportCatched(diagnosticMessage) {
+        this.collectedResults.push(diagnosticMessage);
+    }
+}
+/**
+ * Index for DiagnosticMessageEntry by code
+ */
+DiagnosticMessageEntry.diagnosticMessageByCode = new Map();
+DiagnosticMessageEntry.collectedResults = new DiagnosticResults();
+export const UnknownErrorMessage = new DiagnosticMessageEntry("fatal", 0, "Unknown error");
+export const LoadingErrorMessage = new DiagnosticMessageEntry("fatal", 100, "Loading error");
+export const ParsingErrorMessage = new DiagnosticMessageEntry("fatal", 101, "Parsing error");
+export const ProcessingErrorMessage = new DiagnosticMessageEntry("fatal", 102, "Processing error");
+//# sourceMappingURL=diagnosticmessages.js.map

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

@@ -0,0 +1,140 @@
+/**
+ * Diagnostic message severity.
+ * LSP note: Corresponds directly.
+ */
+export type MessageSeverity = "fatal" | "error" | "warning" | "information" | "hint";
+/**
+ * Diagnostic message severity values.
+ */
+export declare let MessageSeverityList: MessageSeverity[];
+/**
+ * Message that reports specific error/warning, contains multiple parts and fixes.
+ * LSP note:
+ * DiagnosticMessage is designed to be easily convertible to LSP data structures.
+ * The main fields and first DiagnosticComponent can be mapped to LSP Diagnostic.
+ * Rest of `parts` - to `relatedInformation` in it.
+ * Fields like `fixes` - to other LSP API.
+ */
+export interface DiagnosticMessage {
+    /**
+     * Severity of the diagnostic.
+     */
+    severity: MessageSeverity;
+    /**
+     * Unsigned integer code of the diagnostic.
+     */
+    code: number;
+    /**
+     * Description of the diagnostic.
+     */
+    codeDescription: string;
+    /**
+     * An URI to open with more information about the diagnostic.
+     */
+    codeURI?: string;
+    /**
+     * Main and clarifying components of the diagnostic with locations.
+     */
+    parts: DiagnosticComponent[];
+    /**
+     * List of diffs that can be applied to source files to fix the problem reported in diagnostic. Optional.
+     */
+    fixes?: DiagnosticDiffComponent[];
+}
+/**
+ * Component of diagnostic message related to specific file/location.
+ */
+export interface DiagnosticComponent {
+    /**
+     * Location (document path and optional range)
+     */
+    location: Location;
+    /**
+     * Message related to specific character range or the document as a whole.
+     */
+    message: string;
+}
+/**
+ * Location, consisting of document path and optional range
+ */
+export interface Location {
+    /**
+     * Path to correspondent document.
+     */
+    documentPath: string;
+    /**
+     * Character range in that document, optional.
+     */
+    range?: Range;
+    /**
+     * Document content for pretty formatted output, optional.
+     */
+    lines?: string[];
+}
+/**
+ * Location, consisting two inclusive in-document positions.
+ */
+export interface Range {
+    /**
+     * Start position (inclusive).
+     */
+    start: Position;
+    /**
+     * End position (exclusive).
+     */
+    end: Position;
+}
+export declare function commonRange(range1: Range, range2: Range): Range;
+/**
+ * Position in a document.
+ * LSP note: In LSP positions are zero-based (that needs conversion) and UTF-16 by default.
+ */
+export interface Position {
+    /**
+     * Line position in a document (one-based).
+     */
+    line: number;
+    /**
+     * Character offset on a line in a document (one-based) in UTF-16 code points.
+     */
+    character: number;
+}
+export declare function comparePositions(a: Position, b: Position): number;
+export declare function minPosition(a: Position, b: Position): Position;
+export declare function maxPosition(a: Position, b: Position): Position;
+/**
+ * Diff component of diagnostic message related to specific file/location.
+ */
+export interface DiagnosticDiffComponent {
+    /**
+     * Location (document path and optional range)
+     */
+    location: Location;
+    /**
+     * Replacement content. Can be omitted for the "whole document" case, meaning that document needs to be deleted.
+     */
+    replacement?: string;
+}
+/**
+ * Receiver of diagnostic messages.
+ */
+export interface DiagnosticReceiver {
+    push(message: DiagnosticMessage): void;
+}
+/**
+ * Collection of diagnostic messages with calculated statistics.
+ */
+export declare class DiagnosticResults implements DiagnosticReceiver {
+    entries: DiagnosticMessage[];
+    totals: Record<MessageSeverity, number>;
+    push(message: DiagnosticMessage): void;
+    get hasErrors(): boolean;
+}
+/**
+ * Exception for delivering prepared DiagnosticMessage through processing
+ */
+export declare class DiagnosticException extends Error {
+    diagnosticMessage: DiagnosticMessage;
+    constructor(diagnosticMessage: DiagnosticMessage, cause?: any);
+}
+//# sourceMappingURL=diagnostictypes.d.ts.map

package/build/lib/src/diagnostictypes.js

@@ -0,0 +1,72 @@
+/*
+ * 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.
+ */
+/**
+ * Diagnostic message severity values.
+ */
+export let MessageSeverityList = ["fatal", "error", "warning", "information", "hint"];
+export function commonRange(range1, range2) {
+    let start = minPosition(range1.start, range2.start);
+    let end = maxPosition(range1.end, range2.end);
+    return { start, end };
+}
+export function comparePositions(a, b) {
+    if (a.line < b.line) {
+        return -1;
+    }
+    if (a.line > b.line) {
+        return 1;
+    }
+    if (a.character < b.character) {
+        return -1;
+    }
+    if (a.character > b.character) {
+        return 1;
+    }
+    return 0;
+}
+export function minPosition(a, b) {
+    return comparePositions(a, b) == -1 ? a : b;
+}
+export function maxPosition(a, b) {
+    return comparePositions(a, b) == 1 ? a : b;
+}
+/**
+ * Collection of diagnostic messages with calculated statistics.
+ */
+export class DiagnosticResults {
+    constructor() {
+        this.entries = [];
+        this.totals = { "fatal": 0, "error": 0, "warning": 0, "information": 0, "hint": 0 };
+    }
+    push(message) {
+        this.entries.push(message);
+        this.totals[message.severity] += 1;
+    }
+    get hasErrors() {
+        return this.totals.fatal != 0 || this.totals.error != 0;
+    }
+}
+/**
+ * Exception for delivering prepared DiagnosticMessage through processing
+ */
+export class DiagnosticException extends Error {
+    constructor(diagnosticMessage, cause) {
+        super();
+        this.message = diagnosticMessage.parts[0].message;
+        this.diagnosticMessage = diagnosticMessage;
+        this.cause = cause;
+    }
+}
+//# sourceMappingURL=diagnostictypes.js.map

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

@@ -0,0 +1,3 @@
+import { DiagnosticResults } from "./diagnostictypes";
+export declare function outputDiagnosticResultsFormatted(result: DiagnosticResults): void;
+//# sourceMappingURL=formatter.d.ts.map

package/build/lib/src/formatter.js

@@ -0,0 +1,98 @@
+/*
+ * 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.
+ */
+import { MessageSeverityList } from "./diagnostictypes";
+export function outputDiagnosticResultsFormatted(result) {
+    for (let message of result.entries) {
+        outputReadableMessage(message);
+    }
+    outputReadableTotals(result);
+}
+function outputReadableTotals(result) {
+    let totals = [];
+    for (let k of MessageSeverityList) {
+        totals.push(`${k}: ${result.totals[k]}`);
+    }
+    console.log(totals.join(", "));
+}
+function lineDigitCount(message) {
+    let count = 0;
+    for (let part of message.parts) {
+        let range = part.location.range;
+        if (range == null) {
+            continue;
+        }
+        count = Math.max(count, range.start.line.toString().length, range.end.line.toString().length);
+    }
+    return count;
+}
+function paddedLineNo(digits, line) {
+    let s = line.toString();
+    if (s.length < digits) {
+        return " ".repeat(digits - s.length) + s;
+    }
+    return s;
+}
+function formatLine(digits, lines, lineNo) {
+    return `${paddedLineNo(digits, lineNo)} | ${lines[lineNo - 1]}`;
+}
+function formatUnderline(indent, lines, lineNo, range, edgeChar, midChar, message) {
+    if (lineNo == range.start.line && lineNo == range.end.line) {
+        let len = range.end.character - range.start.character + 1;
+        return `${indent} | ${" ".repeat(range.start.character - 1)}${edgeChar}${len > 2 ? midChar.repeat(len - 2) : ""}${len > 1 ? edgeChar : ""} ${message}`;
+    }
+    if (lineNo == range.start.line) {
+        let len = lines[lineNo - 1].length - range.start.character;
+        return `${indent} | ${" ".repeat(range.start.character - 1)}${edgeChar}${len > 1 ? midChar.repeat(len - 1) : ""}`;
+    }
+    if (lineNo == range.end.line) {
+        let len = range.end.character;
+        return `${indent} | ${len > 1 ? midChar.repeat(len - 1) : ""}${edgeChar} ${message}`;
+    }
+    return `${indent} | ${midChar.repeat(lines[lineNo - 1].length)}`;
+}
+function outputReadableMessage(message) {
+    if (message.parts.length == 0) {
+        return;
+    }
+    console.log(`${message.severity}[E${message.code}]: ${message.codeDescription}`);
+    let digits = lineDigitCount(message);
+    let indent = " ".repeat(digits);
+    let first = true;
+    let lastPath = "";
+    for (let part of message.parts) {
+        const location = part.location;
+        if (location.range != null && location.lines != null) {
+            let range = location.range;
+            let lines = location.lines;
+            console.log(`${indent}${lastPath != part.location.documentPath ? "-->" : ":::"} ${part.location.documentPath}:${range.start.line}:${range.start.character}`);
+            console.log(`${indent} |`);
+            for (let i = range.start.line; i <= range.end.line; ++i) {
+                console.log(formatLine(digits, lines, i));
+                console.log(formatUnderline(indent, lines, i, range, "^", first ? "-" : "~", part.message));
+            }
+        }
+        else {
+            console.log(`${indent}--> ${part.location.documentPath}`);
+            if (message.parts.length > 1) {
+                console.log(`${indent} # ${part.message}`);
+            }
+        }
+        first = false;
+        lastPath = part.location.documentPath;
+    }
+    console.log(`${indent} = ${message.parts[0].message}`);
+    console.log();
+}
+//# sourceMappingURL=formatter.js.map

package/build/lib/src/from-idl/deserialize.d.ts

@@ -9,6 +9,7 @@ interface ToIDLFileProps {
     inheritanceMode?: IDLInheritanceMode;
     content?: string;
 }
+export declare function toIdlType(fileName: string, content: string): idl.IDLType;
 export declare function toIDLFile(fileName: string, { content, inheritanceMode }?: ToIDLFileProps): [idl.IDLFile, IDLTokenInfoMap];
 export {};
 //# sourceMappingURL=deserialize.d.ts.map

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

@@ -19,6 +19,8 @@ import { toString } from "./toString";
 import * as idl from "../idl";
 import { isDefined, warn } from "../util";
 import { collapseTypes, generateSyntheticUnionName } from "../peer-generation/idl/common";
+import { commonRange } from "../diagnostictypes";
+import { LoadingErrorMessage, ParsingErrorMessage, UnknownErrorMessage } from "../diagnosticmessages";
 function getTokens(node) {
     return node.tokens;
 }
@@ -512,13 +514,42 @@ class IDLDeserializer {
         return attr ? this.toExtendedAttributeValue(attr) : undefined;
     }
 }
+export function toIdlType(fileName, content) {
+    const lexicalInfo = new Map();
+    const deserializer = new IDLDeserializer(lexicalInfo, 'multiple');
+    return deserializer.toIDLType(fileName, webidl2.parseType(content, fileName));
+}
 export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } = {}) {
+    var _a, _b, _c;
     const lexicalInfo = new Map();
     const deserializer = new IDLDeserializer(lexicalInfo, inheritanceMode);
-    if (undefined === content)
-        content = fs.readFileSync(fileName).toString();
+    if (undefined === content) {
+        try {
+            content = fs.readFileSync(fileName).toString();
+        }
+        catch (e) {
+            content = "";
+            LoadingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName }], (_a = e.message) !== null && _a !== void 0 ? _a : "");
+        }
+    }
+    let lines = (_b = content.match(/[^\r\n]*(\n|\r\n)?/g)) !== null && _b !== void 0 ? _b : [];
+    const offsets = prepareOffsets(lines);
+    lines = lines.map((s) => s.replace(/(\n|\r\n)$/, ""));
+    const parsed = { fileName, lines, offsets, lexicalInfo };
     let packageClause = [];
-    const entries = webidl2.parse(content)
+    let rawParsingResults;
+    try {
+        rawParsingResults = webidl2.parse(content);
+    }
+    catch (e) {
+        if (e.name == "WebIDLParseError") {
+            let tokens = e.tokens;
+            let range = tokens.length > 0 ? rangeForToken(offsets, tokens[0]) : undefined;
+            ParsingErrorMessage.throwDiagnosticMessage([{ documentPath: fileName, range, lines }], e.bareMessage);
+        }
+        UnknownErrorMessage.throwDiagnosticMessage([{ documentPath: fileName }], (_c = e.message) !== null && _c !== void 0 ? _c : "");
+    }
+    const entries = rawParsingResults
         .filter(it => {
         if (!it.type)
             return false;
@@ -530,8 +561,79 @@ export function toIDLFile(fileName, { content, inheritanceMode = 'multiple' } =
         return true;
     })
         .map(it => deserializer.toIDLNode(fileName, it));
-    const file = idl.createFile(entries, fileName, packageClause);
+    let file = idl.createFile(entries, fileName, packageClause);
     file.text = content;
-    return [idl.linkParentBack(file), lexicalInfo];
+    file = idl.linkParentBack(file);
+    idl.forEachChild(file, (node) => {
+        node.nodeLocation = locationForNode(parsed, node);
+        const nameLocation = locationForNode(parsed, node, "name");
+        if (nameLocation.range) {
+            node.nameLocation = nameLocation;
+        }
+    });
+    return [file, lexicalInfo];
+}
+function prepareOffsets(lines) {
+    let offsets = [];
+    let offset = 0;
+    for (let line of lines) {
+        let plus = line.length;
+        offsets.push(offset);
+        offset += plus;
+    }
+    return offsets;
+}
+function locationForNode(parsed, node, component) {
+    if (node.kind == idl.IDLKind.File) {
+        return { documentPath: parsed.fileName, lines: parsed.lines };
+    }
+    return { documentPath: parsed.fileName, range: rangeForNode(parsed, node, component), lines: parsed.lines };
+}
+function rangeForNode(parsed, node, component) {
+    var _a;
+    let info = parsed.lexicalInfo.get(node);
+    if (info == null) {
+        // Proper solution will require fixes with inheritance tokens in Idlize/core and custom webidl2.js
+        // So now we are extracting from what we have
+        if (node.parent) {
+            return (_a = rangeForNode(parsed, node.parent, "inheritance")) !== null && _a !== void 0 ? _a : rangeForNode(parsed, node.parent);
+        }
+        return;
+    }
+    let range;
+    for (let k of Object.keys(info)) {
+        if (component && k != component) {
+            continue;
+        }
+        let named = info[k];
+        if (named == null) {
+            continue;
+        }
+        if (named.value == null) {
+            if (k == "inheritance" && Array.isArray(named)) {
+                for (let inh of named) {
+                    if (inh.inheritance == null) {
+                        continue;
+                    }
+                    let newRange = rangeForToken(parsed.offsets, inh.inheritance);
+                    range = range ? commonRange(range, newRange) : newRange;
+                }
+            }
+            continue;
+        }
+        let newRange = rangeForToken(parsed.offsets, named);
+        range = range ? commonRange(range, newRange) : newRange;
+    }
+    return range;
+}
+function rangeForToken(offsets, token) {
+    let dif = token.value.length - 1;
+    if (dif < 0) {
+        dif = 0;
+    }
+    let endline = token.line + (token.value.match(/\n/g) || []).length;
+    let character = token.position - offsets[token.line - 1] + 1;
+    let endcharacter = token.position + dif - offsets[endline - 1] + 1;
+    return { start: { line: token.line, character: character }, end: { line: endline, character: endcharacter } };
 }
 //# sourceMappingURL=deserialize.js.map

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

@@ -1,4 +1,5 @@
 import { stringOrNone } from "./util";
+import { Location } from "./diagnostictypes";
 export declare enum IDLKind {
     Interface = "Interface",
     Import = "Import",
@@ -45,6 +46,7 @@ export declare enum IDLExtendedAttributes {
     DtsTag = "DtsTag",
     Entity = "Entity",
     Extends = "Extends",
+    ExtensionMethod = "ExtensionMethod",
     Import = "Import",
     DefaultExport = "DefaultExport",
     IndexSignature = "IndexSignature",
@@ -52,6 +54,7 @@ export declare enum IDLExtendedAttributes {
     NativeModule = "NativeModule",
     Optional = "Optional",
     OriginalEnumMemberName = "OriginalEnumMemberName",
+    OriginalGenericName = "OriginalGenericName",
     Predefined = "Predefined",
     Protected = "Protected",
     Synthetic = "Synthetic",
@@ -78,6 +81,9 @@ export interface IDLNode {
     fileName?: string;
     extendedAttributes?: IDLExtendedAttribute[];
     documentation?: string;
+    nodeLocation?: Location;
+    nameLocation?: Location;
+    valueLocation?: Location;
 }
 export interface IDLFile extends IDLNode {
     packageClause: string[];
@@ -223,6 +229,8 @@ type IDLNodeVisitorVoid = (node: IDLNode) => void;
 type IDLNodeVisitorValue = (node: IDLNode) => () => void;
 type IDLNodeVisitor = IDLNodeVisitorVoid | IDLNodeVisitorValue;
 export declare function forEachChild(node: IDLNode, cbEnter: IDLNodeVisitor, cbLeave?: (entry: IDLNode) => void): void;
+/** Updates tree in place! */
+export declare function updateEachChild(node: IDLNode, op: (node: IDLNode) => IDLNode, cbLeave?: (entry: IDLNode) => void): IDLNode;
 export declare function isNamedNode(type: IDLNode): type is IDLNamedNode;
 export declare function forceAsNamedNode(type: IDLNode): IDLNamedNode;
 export declare function isFile(node: IDLNode): node is IDLFile;