@typespec/html-program-viewer 0.67.0-dev.4 → 0.67.0-dev.5

package/dist/{manifest-DRAJnEGG.js → manifest-CrFWPTea.js}

@@ -1,6 +1,6 @@
 const manifest = {
   "version": "0.66.0",
-  "commit": "b4b7705c61f186590c6a6d086a131cd71ee4c48c"
+  "commit": "32ca22f9d14ae0c73f965270330f0e1b81d78b0b"
 };
 
 export { manifest as default };

package/dist/react/index.js

@@ -17882,202 +17882,6 @@ function normalizeSlashes(path) {
     return path.replace(backslashRegExp, directorySeparator);
 }
 
-function createSourceFile(text, path) {
-    let lineStarts = undefined;
-    return {
-        text,
-        path,
-        getLineStarts,
-        getLineAndCharacterOfPosition,
-    };
-    function getLineStarts() {
-        return (lineStarts = lineStarts ?? scanLineStarts(text));
-    }
-    function getLineAndCharacterOfPosition(position) {
-        const starts = getLineStarts();
-        let line = binarySearch(starts, position);
-        // When binarySearch returns < 0 indicating that the value was not found, it
-        // returns the bitwise complement of the index where the value would need to
-        // be inserted to keep the array sorted. So flipping the bits back to this
-        // positive index tells us what the line number would be if we were to
-        // create a new line starting at the given position, and subtracting 1 from
-        // that therefore gives us the line number we're after.
-        if (line < 0) {
-            line = ~line - 1;
-        }
-        return {
-            line,
-            character: position - starts[line],
-        };
-    }
-}
-function scanLineStarts(text) {
-    const starts = [];
-    let start = 0;
-    let pos = 0;
-    while (pos < text.length) {
-        const ch = text.charCodeAt(pos);
-        pos++;
-        switch (ch) {
-            case 13 /* CharCode.CarriageReturn */:
-                if (text.charCodeAt(pos) === 10 /* CharCode.LineFeed */) {
-                    pos++;
-                }
-            // fallthrough
-            case 10 /* CharCode.LineFeed */:
-                starts.push(start);
-                start = pos;
-                break;
-        }
-    }
-    starts.push(start);
-    return starts;
-}
-/**
- * Search sorted array of numbers for the given value. If found, return index
- * in array where value was found. If not found, return a negative number that
- * is the bitwise complement of the index where value would need to be inserted
- * to keep the array sorted.
- */
-function binarySearch(array, value) {
-    let low = 0;
-    let high = array.length - 1;
-    while (low <= high) {
-        const middle = low + ((high - low) >> 1);
-        const v = array[middle];
-        if (v < value) {
-            low = middle + 1;
-        }
-        else if (v > value) {
-            high = middle - 1;
-        }
-        else {
-            return middle;
-        }
-    }
-    return ~low;
-}
-
-var ResolutionResultFlags;
-(function (ResolutionResultFlags) {
-    ResolutionResultFlags[ResolutionResultFlags["None"] = 0] = "None";
-    ResolutionResultFlags[ResolutionResultFlags["Resolved"] = 2] = "Resolved";
-    ResolutionResultFlags[ResolutionResultFlags["Unknown"] = 4] = "Unknown";
-    ResolutionResultFlags[ResolutionResultFlags["Ambiguous"] = 8] = "Ambiguous";
-    ResolutionResultFlags[ResolutionResultFlags["NotFound"] = 16] = "NotFound";
-    ResolutionResultFlags[ResolutionResultFlags["ResolutionFailed"] = 28] = "ResolutionFailed";
-})(ResolutionResultFlags || (ResolutionResultFlags = {}));
-/**
- * AST types
- */
-var SyntaxKind;
-(function (SyntaxKind) {
-    SyntaxKind[SyntaxKind["TypeSpecScript"] = 0] = "TypeSpecScript";
-    SyntaxKind[SyntaxKind["JsSourceFile"] = 1] = "JsSourceFile";
-    SyntaxKind[SyntaxKind["ImportStatement"] = 2] = "ImportStatement";
-    SyntaxKind[SyntaxKind["Identifier"] = 3] = "Identifier";
-    SyntaxKind[SyntaxKind["AugmentDecoratorStatement"] = 4] = "AugmentDecoratorStatement";
-    SyntaxKind[SyntaxKind["DecoratorExpression"] = 5] = "DecoratorExpression";
-    SyntaxKind[SyntaxKind["DirectiveExpression"] = 6] = "DirectiveExpression";
-    SyntaxKind[SyntaxKind["MemberExpression"] = 7] = "MemberExpression";
-    SyntaxKind[SyntaxKind["NamespaceStatement"] = 8] = "NamespaceStatement";
-    SyntaxKind[SyntaxKind["UsingStatement"] = 9] = "UsingStatement";
-    SyntaxKind[SyntaxKind["OperationStatement"] = 10] = "OperationStatement";
-    SyntaxKind[SyntaxKind["OperationSignatureDeclaration"] = 11] = "OperationSignatureDeclaration";
-    SyntaxKind[SyntaxKind["OperationSignatureReference"] = 12] = "OperationSignatureReference";
-    SyntaxKind[SyntaxKind["ModelStatement"] = 13] = "ModelStatement";
-    SyntaxKind[SyntaxKind["ModelExpression"] = 14] = "ModelExpression";
-    SyntaxKind[SyntaxKind["ModelProperty"] = 15] = "ModelProperty";
-    SyntaxKind[SyntaxKind["ModelSpreadProperty"] = 16] = "ModelSpreadProperty";
-    SyntaxKind[SyntaxKind["ScalarStatement"] = 17] = "ScalarStatement";
-    SyntaxKind[SyntaxKind["InterfaceStatement"] = 18] = "InterfaceStatement";
-    SyntaxKind[SyntaxKind["UnionStatement"] = 19] = "UnionStatement";
-    SyntaxKind[SyntaxKind["UnionVariant"] = 20] = "UnionVariant";
-    SyntaxKind[SyntaxKind["EnumStatement"] = 21] = "EnumStatement";
-    SyntaxKind[SyntaxKind["EnumMember"] = 22] = "EnumMember";
-    SyntaxKind[SyntaxKind["EnumSpreadMember"] = 23] = "EnumSpreadMember";
-    SyntaxKind[SyntaxKind["AliasStatement"] = 24] = "AliasStatement";
-    SyntaxKind[SyntaxKind["DecoratorDeclarationStatement"] = 25] = "DecoratorDeclarationStatement";
-    SyntaxKind[SyntaxKind["FunctionDeclarationStatement"] = 26] = "FunctionDeclarationStatement";
-    SyntaxKind[SyntaxKind["FunctionParameter"] = 27] = "FunctionParameter";
-    SyntaxKind[SyntaxKind["UnionExpression"] = 28] = "UnionExpression";
-    SyntaxKind[SyntaxKind["IntersectionExpression"] = 29] = "IntersectionExpression";
-    SyntaxKind[SyntaxKind["TupleExpression"] = 30] = "TupleExpression";
-    SyntaxKind[SyntaxKind["ArrayExpression"] = 31] = "ArrayExpression";
-    SyntaxKind[SyntaxKind["StringLiteral"] = 32] = "StringLiteral";
-    SyntaxKind[SyntaxKind["NumericLiteral"] = 33] = "NumericLiteral";
-    SyntaxKind[SyntaxKind["BooleanLiteral"] = 34] = "BooleanLiteral";
-    SyntaxKind[SyntaxKind["StringTemplateExpression"] = 35] = "StringTemplateExpression";
-    SyntaxKind[SyntaxKind["StringTemplateHead"] = 36] = "StringTemplateHead";
-    SyntaxKind[SyntaxKind["StringTemplateMiddle"] = 37] = "StringTemplateMiddle";
-    SyntaxKind[SyntaxKind["StringTemplateTail"] = 38] = "StringTemplateTail";
-    SyntaxKind[SyntaxKind["StringTemplateSpan"] = 39] = "StringTemplateSpan";
-    SyntaxKind[SyntaxKind["ExternKeyword"] = 40] = "ExternKeyword";
-    SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
-    SyntaxKind[SyntaxKind["NeverKeyword"] = 42] = "NeverKeyword";
-    SyntaxKind[SyntaxKind["UnknownKeyword"] = 43] = "UnknownKeyword";
-    SyntaxKind[SyntaxKind["ValueOfExpression"] = 44] = "ValueOfExpression";
-    SyntaxKind[SyntaxKind["TypeReference"] = 45] = "TypeReference";
-    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 46] = "TemplateParameterDeclaration";
-    SyntaxKind[SyntaxKind["EmptyStatement"] = 47] = "EmptyStatement";
-    SyntaxKind[SyntaxKind["InvalidStatement"] = 48] = "InvalidStatement";
-    SyntaxKind[SyntaxKind["LineComment"] = 49] = "LineComment";
-    SyntaxKind[SyntaxKind["BlockComment"] = 50] = "BlockComment";
-    SyntaxKind[SyntaxKind["Doc"] = 51] = "Doc";
-    SyntaxKind[SyntaxKind["DocText"] = 52] = "DocText";
-    SyntaxKind[SyntaxKind["DocParamTag"] = 53] = "DocParamTag";
-    SyntaxKind[SyntaxKind["DocPropTag"] = 54] = "DocPropTag";
-    SyntaxKind[SyntaxKind["DocReturnsTag"] = 55] = "DocReturnsTag";
-    SyntaxKind[SyntaxKind["DocErrorsTag"] = 56] = "DocErrorsTag";
-    SyntaxKind[SyntaxKind["DocTemplateTag"] = 57] = "DocTemplateTag";
-    SyntaxKind[SyntaxKind["DocUnknownTag"] = 58] = "DocUnknownTag";
-    SyntaxKind[SyntaxKind["Return"] = 59] = "Return";
-    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 60] = "JsNamespaceDeclaration";
-    SyntaxKind[SyntaxKind["TemplateArgument"] = 61] = "TemplateArgument";
-    SyntaxKind[SyntaxKind["TypeOfExpression"] = 62] = "TypeOfExpression";
-    SyntaxKind[SyntaxKind["ObjectLiteral"] = 63] = "ObjectLiteral";
-    SyntaxKind[SyntaxKind["ObjectLiteralProperty"] = 64] = "ObjectLiteralProperty";
-    SyntaxKind[SyntaxKind["ObjectLiteralSpreadProperty"] = 65] = "ObjectLiteralSpreadProperty";
-    SyntaxKind[SyntaxKind["ArrayLiteral"] = 66] = "ArrayLiteral";
-    SyntaxKind[SyntaxKind["ConstStatement"] = 67] = "ConstStatement";
-    SyntaxKind[SyntaxKind["CallExpression"] = 68] = "CallExpression";
-    SyntaxKind[SyntaxKind["ScalarConstructor"] = 69] = "ScalarConstructor";
-})(SyntaxKind || (SyntaxKind = {}));
-var IdentifierKind;
-(function (IdentifierKind) {
-    IdentifierKind[IdentifierKind["TypeReference"] = 0] = "TypeReference";
-    IdentifierKind[IdentifierKind["TemplateArgument"] = 1] = "TemplateArgument";
-    IdentifierKind[IdentifierKind["Decorator"] = 2] = "Decorator";
-    IdentifierKind[IdentifierKind["Function"] = 3] = "Function";
-    IdentifierKind[IdentifierKind["Using"] = 4] = "Using";
-    IdentifierKind[IdentifierKind["Declaration"] = 5] = "Declaration";
-    IdentifierKind[IdentifierKind["ModelExpressionProperty"] = 6] = "ModelExpressionProperty";
-    IdentifierKind[IdentifierKind["ModelStatementProperty"] = 7] = "ModelStatementProperty";
-    IdentifierKind[IdentifierKind["ObjectLiteralProperty"] = 8] = "ObjectLiteralProperty";
-    IdentifierKind[IdentifierKind["Other"] = 9] = "Other";
-})(IdentifierKind || (IdentifierKind = {}));
-/** Used to explicitly specify that a diagnostic has no target. */
-const NoTarget = Symbol.for("NoTarget");
-var ListenerFlow;
-(function (ListenerFlow) {
-    /**
-     * Do not navigate any containing or referenced type.
-     */
-    ListenerFlow[ListenerFlow["NoRecursion"] = 1] = "NoRecursion";
-})(ListenerFlow || (ListenerFlow = {}));
-
-let manifest;
-try {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    manifest = (await import('../manifest-DRAJnEGG.js')).default;
-}
-catch {
-    const name = "../dist/manifest.js";
-    manifest = (await import(/* @vite-ignore */ /* webpackIgnore: true */ name)).default;
-}
-manifest.version;
-
 /**
  * Recursively calls Object.freeze such that all objects and arrays
  * referenced are frozen.
@@ -18426,6 +18230,7 @@ const diagnostics = {
         severity: "error",
         messages: {
             default: "Keyword cannot be used as identifier.",
+            future: paramMessage `${"name"} is a reserved keyword`,
         },
     },
     "invalid-directive-location": {
@@ -18634,7 +18439,8 @@ const diagnostics = {
         messages: {
             default: paramMessage `${"name"} refers to a type, but is being used as a value here.`,
             model: paramMessage `${"name"} refers to a model type, but is being used as a value here. Use #{} to create an object value.`,
-            tuple: paramMessage `${"name"} refers to a tuple type, but is being used as a value here. Use #[] to create an array value.`,
+            modelExpression: `Is a model expression type, but is being used as a value here. Use #{} to create an object value.`,
+            tuple: `Is a tuple type, but is being used as a value here. Use #[] to create an array value.`,
             templateConstraint: paramMessage `${"name"} template parameter can be a type but is being used as a value here.`,
         },
     },
@@ -28236,6 +28042,190 @@ function findYamlNode(file, path, kind = "value") {
     return current ?? undefined;
 }
 
+function createSourceFile(text, path) {
+    let lineStarts = undefined;
+    return {
+        text,
+        path,
+        getLineStarts,
+        getLineAndCharacterOfPosition,
+    };
+    function getLineStarts() {
+        return (lineStarts = lineStarts ?? scanLineStarts(text));
+    }
+    function getLineAndCharacterOfPosition(position) {
+        const starts = getLineStarts();
+        let line = binarySearch(starts, position);
+        // When binarySearch returns < 0 indicating that the value was not found, it
+        // returns the bitwise complement of the index where the value would need to
+        // be inserted to keep the array sorted. So flipping the bits back to this
+        // positive index tells us what the line number would be if we were to
+        // create a new line starting at the given position, and subtracting 1 from
+        // that therefore gives us the line number we're after.
+        if (line < 0) {
+            line = ~line - 1;
+        }
+        return {
+            line,
+            character: position - starts[line],
+        };
+    }
+}
+function scanLineStarts(text) {
+    const starts = [];
+    let start = 0;
+    let pos = 0;
+    while (pos < text.length) {
+        const ch = text.charCodeAt(pos);
+        pos++;
+        switch (ch) {
+            case 13 /* CharCode.CarriageReturn */:
+                if (text.charCodeAt(pos) === 10 /* CharCode.LineFeed */) {
+                    pos++;
+                }
+            // fallthrough
+            case 10 /* CharCode.LineFeed */:
+                starts.push(start);
+                start = pos;
+                break;
+        }
+    }
+    starts.push(start);
+    return starts;
+}
+/**
+ * Search sorted array of numbers for the given value. If found, return index
+ * in array where value was found. If not found, return a negative number that
+ * is the bitwise complement of the index where value would need to be inserted
+ * to keep the array sorted.
+ */
+function binarySearch(array, value) {
+    let low = 0;
+    let high = array.length - 1;
+    while (low <= high) {
+        const middle = low + ((high - low) >> 1);
+        const v = array[middle];
+        if (v < value) {
+            low = middle + 1;
+        }
+        else if (v > value) {
+            high = middle - 1;
+        }
+        else {
+            return middle;
+        }
+    }
+    return ~low;
+}
+
+var ResolutionResultFlags;
+(function (ResolutionResultFlags) {
+    ResolutionResultFlags[ResolutionResultFlags["None"] = 0] = "None";
+    ResolutionResultFlags[ResolutionResultFlags["Resolved"] = 2] = "Resolved";
+    ResolutionResultFlags[ResolutionResultFlags["Unknown"] = 4] = "Unknown";
+    ResolutionResultFlags[ResolutionResultFlags["Ambiguous"] = 8] = "Ambiguous";
+    ResolutionResultFlags[ResolutionResultFlags["NotFound"] = 16] = "NotFound";
+    ResolutionResultFlags[ResolutionResultFlags["ResolutionFailed"] = 28] = "ResolutionFailed";
+})(ResolutionResultFlags || (ResolutionResultFlags = {}));
+/**
+ * AST types
+ */
+var SyntaxKind;
+(function (SyntaxKind) {
+    SyntaxKind[SyntaxKind["TypeSpecScript"] = 0] = "TypeSpecScript";
+    SyntaxKind[SyntaxKind["JsSourceFile"] = 1] = "JsSourceFile";
+    SyntaxKind[SyntaxKind["ImportStatement"] = 2] = "ImportStatement";
+    SyntaxKind[SyntaxKind["Identifier"] = 3] = "Identifier";
+    SyntaxKind[SyntaxKind["AugmentDecoratorStatement"] = 4] = "AugmentDecoratorStatement";
+    SyntaxKind[SyntaxKind["DecoratorExpression"] = 5] = "DecoratorExpression";
+    SyntaxKind[SyntaxKind["DirectiveExpression"] = 6] = "DirectiveExpression";
+    SyntaxKind[SyntaxKind["MemberExpression"] = 7] = "MemberExpression";
+    SyntaxKind[SyntaxKind["NamespaceStatement"] = 8] = "NamespaceStatement";
+    SyntaxKind[SyntaxKind["UsingStatement"] = 9] = "UsingStatement";
+    SyntaxKind[SyntaxKind["OperationStatement"] = 10] = "OperationStatement";
+    SyntaxKind[SyntaxKind["OperationSignatureDeclaration"] = 11] = "OperationSignatureDeclaration";
+    SyntaxKind[SyntaxKind["OperationSignatureReference"] = 12] = "OperationSignatureReference";
+    SyntaxKind[SyntaxKind["ModelStatement"] = 13] = "ModelStatement";
+    SyntaxKind[SyntaxKind["ModelExpression"] = 14] = "ModelExpression";
+    SyntaxKind[SyntaxKind["ModelProperty"] = 15] = "ModelProperty";
+    SyntaxKind[SyntaxKind["ModelSpreadProperty"] = 16] = "ModelSpreadProperty";
+    SyntaxKind[SyntaxKind["ScalarStatement"] = 17] = "ScalarStatement";
+    SyntaxKind[SyntaxKind["InterfaceStatement"] = 18] = "InterfaceStatement";
+    SyntaxKind[SyntaxKind["UnionStatement"] = 19] = "UnionStatement";
+    SyntaxKind[SyntaxKind["UnionVariant"] = 20] = "UnionVariant";
+    SyntaxKind[SyntaxKind["EnumStatement"] = 21] = "EnumStatement";
+    SyntaxKind[SyntaxKind["EnumMember"] = 22] = "EnumMember";
+    SyntaxKind[SyntaxKind["EnumSpreadMember"] = 23] = "EnumSpreadMember";
+    SyntaxKind[SyntaxKind["AliasStatement"] = 24] = "AliasStatement";
+    SyntaxKind[SyntaxKind["DecoratorDeclarationStatement"] = 25] = "DecoratorDeclarationStatement";
+    SyntaxKind[SyntaxKind["FunctionDeclarationStatement"] = 26] = "FunctionDeclarationStatement";
+    SyntaxKind[SyntaxKind["FunctionParameter"] = 27] = "FunctionParameter";
+    SyntaxKind[SyntaxKind["UnionExpression"] = 28] = "UnionExpression";
+    SyntaxKind[SyntaxKind["IntersectionExpression"] = 29] = "IntersectionExpression";
+    SyntaxKind[SyntaxKind["TupleExpression"] = 30] = "TupleExpression";
+    SyntaxKind[SyntaxKind["ArrayExpression"] = 31] = "ArrayExpression";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 32] = "StringLiteral";
+    SyntaxKind[SyntaxKind["NumericLiteral"] = 33] = "NumericLiteral";
+    SyntaxKind[SyntaxKind["BooleanLiteral"] = 34] = "BooleanLiteral";
+    SyntaxKind[SyntaxKind["StringTemplateExpression"] = 35] = "StringTemplateExpression";
+    SyntaxKind[SyntaxKind["StringTemplateHead"] = 36] = "StringTemplateHead";
+    SyntaxKind[SyntaxKind["StringTemplateMiddle"] = 37] = "StringTemplateMiddle";
+    SyntaxKind[SyntaxKind["StringTemplateTail"] = 38] = "StringTemplateTail";
+    SyntaxKind[SyntaxKind["StringTemplateSpan"] = 39] = "StringTemplateSpan";
+    SyntaxKind[SyntaxKind["ExternKeyword"] = 40] = "ExternKeyword";
+    SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword";
+    SyntaxKind[SyntaxKind["NeverKeyword"] = 42] = "NeverKeyword";
+    SyntaxKind[SyntaxKind["UnknownKeyword"] = 43] = "UnknownKeyword";
+    SyntaxKind[SyntaxKind["ValueOfExpression"] = 44] = "ValueOfExpression";
+    SyntaxKind[SyntaxKind["TypeReference"] = 45] = "TypeReference";
+    SyntaxKind[SyntaxKind["TemplateParameterDeclaration"] = 46] = "TemplateParameterDeclaration";
+    SyntaxKind[SyntaxKind["EmptyStatement"] = 47] = "EmptyStatement";
+    SyntaxKind[SyntaxKind["InvalidStatement"] = 48] = "InvalidStatement";
+    SyntaxKind[SyntaxKind["LineComment"] = 49] = "LineComment";
+    SyntaxKind[SyntaxKind["BlockComment"] = 50] = "BlockComment";
+    SyntaxKind[SyntaxKind["Doc"] = 51] = "Doc";
+    SyntaxKind[SyntaxKind["DocText"] = 52] = "DocText";
+    SyntaxKind[SyntaxKind["DocParamTag"] = 53] = "DocParamTag";
+    SyntaxKind[SyntaxKind["DocPropTag"] = 54] = "DocPropTag";
+    SyntaxKind[SyntaxKind["DocReturnsTag"] = 55] = "DocReturnsTag";
+    SyntaxKind[SyntaxKind["DocErrorsTag"] = 56] = "DocErrorsTag";
+    SyntaxKind[SyntaxKind["DocTemplateTag"] = 57] = "DocTemplateTag";
+    SyntaxKind[SyntaxKind["DocUnknownTag"] = 58] = "DocUnknownTag";
+    SyntaxKind[SyntaxKind["Return"] = 59] = "Return";
+    SyntaxKind[SyntaxKind["JsNamespaceDeclaration"] = 60] = "JsNamespaceDeclaration";
+    SyntaxKind[SyntaxKind["TemplateArgument"] = 61] = "TemplateArgument";
+    SyntaxKind[SyntaxKind["TypeOfExpression"] = 62] = "TypeOfExpression";
+    SyntaxKind[SyntaxKind["ObjectLiteral"] = 63] = "ObjectLiteral";
+    SyntaxKind[SyntaxKind["ObjectLiteralProperty"] = 64] = "ObjectLiteralProperty";
+    SyntaxKind[SyntaxKind["ObjectLiteralSpreadProperty"] = 65] = "ObjectLiteralSpreadProperty";
+    SyntaxKind[SyntaxKind["ArrayLiteral"] = 66] = "ArrayLiteral";
+    SyntaxKind[SyntaxKind["ConstStatement"] = 67] = "ConstStatement";
+    SyntaxKind[SyntaxKind["CallExpression"] = 68] = "CallExpression";
+    SyntaxKind[SyntaxKind["ScalarConstructor"] = 69] = "ScalarConstructor";
+})(SyntaxKind || (SyntaxKind = {}));
+var IdentifierKind;
+(function (IdentifierKind) {
+    IdentifierKind[IdentifierKind["TypeReference"] = 0] = "TypeReference";
+    IdentifierKind[IdentifierKind["TemplateArgument"] = 1] = "TemplateArgument";
+    IdentifierKind[IdentifierKind["Decorator"] = 2] = "Decorator";
+    IdentifierKind[IdentifierKind["Function"] = 3] = "Function";
+    IdentifierKind[IdentifierKind["Using"] = 4] = "Using";
+    IdentifierKind[IdentifierKind["Declaration"] = 5] = "Declaration";
+    IdentifierKind[IdentifierKind["ModelExpressionProperty"] = 6] = "ModelExpressionProperty";
+    IdentifierKind[IdentifierKind["ModelStatementProperty"] = 7] = "ModelStatementProperty";
+    IdentifierKind[IdentifierKind["ObjectLiteralProperty"] = 8] = "ObjectLiteralProperty";
+    IdentifierKind[IdentifierKind["Other"] = 9] = "Other";
+})(IdentifierKind || (IdentifierKind = {}));
+/** Used to explicitly specify that a diagnostic has no target. */
+const NoTarget = Symbol.for("NoTarget");
+var ListenerFlow;
+(function (ListenerFlow) {
+    /**
+     * Do not navigate any containing or referenced type.
+     */
+    ListenerFlow[ListenerFlow["NoRecursion"] = 1] = "NoRecursion";
+})(ListenerFlow || (ListenerFlow = {}));
+
 function getSourceLocation(target, options = {}) {
     if (target === NoTarget || target === undefined) {
         return undefined;
@@ -29325,18 +29315,7 @@ const [getDiscriminatedOptions, setDiscriminatedOptions] = useStateMap(createSta
 // #endregion
 
 function getDiscriminatedUnion(typeOrProgram, typeOrDiscriminator) {
-    if ("propertyName" in typeOrDiscriminator) {
-        const type = typeOrProgram;
-        switch (type.kind) {
-            case "Model":
-                return getDiscriminatedUnionFromInheritance(type, typeOrDiscriminator);
-            case "Union":
-                return getDiscriminatedUnionForUnionLegacy(type, typeOrDiscriminator);
-        }
-    }
-    else {
-        return getDiscriminatedUnionForUnion(typeOrProgram, typeOrDiscriminator);
-    }
+    return getDiscriminatedUnionForUnion(typeOrProgram, typeOrDiscriminator);
 }
 function getDiscriminatedUnionForUnion(program, type) {
     const options = getDiscriminatedOptions(program, type);
@@ -29400,51 +29379,6 @@ function getDiscriminatedUnionForUnion(program, type) {
         diagnostics,
     ];
 }
-function getDiscriminatedUnionForUnionLegacy(type, discriminator) {
-    const variants = new Map();
-    const diagnostics = [];
-    const duplicates = new DuplicateTracker();
-    for (const variant of type.variants.values()) {
-        if (variant.type.kind !== "Model") {
-            diagnostics.push(createDiagnostic({
-                code: "invalid-discriminated-union-variant",
-                format: { name: variant.name.toString() },
-                target: variant,
-            }));
-            continue;
-        }
-        const prop = getDiscriminatorProperty(variant.type, discriminator, diagnostics);
-        if (prop === undefined) {
-            diagnostics.push(createDiagnostic({
-                code: "invalid-discriminated-union-variant",
-                messageId: "noDiscriminant",
-                format: { name: variant.name.toString(), discriminant: discriminator.propertyName },
-                target: variant,
-            }));
-            continue;
-        }
-        const key = getStringValue(prop.type);
-        if (key) {
-            duplicates.track(key, variant.type);
-            variants.set(key, variant.type);
-        }
-        else {
-            diagnostics.push(createDiagnostic({
-                code: "invalid-discriminated-union-variant",
-                messageId: "wrongDiscriminantType",
-                format: { name: variant.name.toString(), discriminant: discriminator.propertyName },
-                target: variant.type,
-            }));
-        }
-    }
-    reportDuplicateDiscriminatorValues(duplicates, diagnostics);
-    const discriminatedUnion = {
-        kind: "legacy",
-        propertyName: discriminator.propertyName,
-        variants,
-    };
-    return [discriminatedUnion, diagnostics];
-}
 function getDiscriminatedUnionFromInheritance(type, discriminator) {
     const variants = new Map();
     const diagnostics = [];
@@ -30432,7 +30366,42 @@ var Token;
     // Add new non-statement keyword above
     /** @internal */ Token[Token["__EndKeyword"] = 80] = "__EndKeyword";
     ///////////////////////////////////////////////////////////////
-    /** @internal */ Token[Token["__Count"] = 80] = "__Count";
+    /** @internal */ Token[Token["__StartReservedKeyword"] = 80] = "__StartReservedKeyword";
+    ///////////////////////////////////////////////////////////////
+    // List of keywords that have special meaning in the language but are reserved for future use
+    Token[Token["StatemachineKeyword"] = 80] = "StatemachineKeyword";
+    Token[Token["MacroKeyword"] = 81] = "MacroKeyword";
+    Token[Token["PackageKeyword"] = 82] = "PackageKeyword";
+    Token[Token["MetadataKeyword"] = 83] = "MetadataKeyword";
+    Token[Token["EnvKeyword"] = 84] = "EnvKeyword";
+    Token[Token["ArgKeyword"] = 85] = "ArgKeyword";
+    Token[Token["DeclareKeyword"] = 86] = "DeclareKeyword";
+    Token[Token["ArrayKeyword"] = 87] = "ArrayKeyword";
+    Token[Token["StructKeyword"] = 88] = "StructKeyword";
+    Token[Token["RecordKeyword"] = 89] = "RecordKeyword";
+    Token[Token["ModuleKeyword"] = 90] = "ModuleKeyword";
+    Token[Token["TraitKeyword"] = 91] = "TraitKeyword";
+    Token[Token["ThisKeyword"] = 92] = "ThisKeyword";
+    Token[Token["SelfKeyword"] = 93] = "SelfKeyword";
+    Token[Token["SuperKeyword"] = 94] = "SuperKeyword";
+    Token[Token["KeyofKeyword"] = 95] = "KeyofKeyword";
+    Token[Token["WithKeyword"] = 96] = "WithKeyword";
+    Token[Token["ImplementsKeyword"] = 97] = "ImplementsKeyword";
+    Token[Token["ImplKeyword"] = 98] = "ImplKeyword";
+    Token[Token["SatisfiesKeyword"] = 99] = "SatisfiesKeyword";
+    Token[Token["FlagKeyword"] = 100] = "FlagKeyword";
+    Token[Token["AutoKeyword"] = 101] = "AutoKeyword";
+    Token[Token["PartialKeyword"] = 102] = "PartialKeyword";
+    Token[Token["PrivateKeyword"] = 103] = "PrivateKeyword";
+    Token[Token["PublicKeyword"] = 104] = "PublicKeyword";
+    Token[Token["ProtectedKeyword"] = 105] = "ProtectedKeyword";
+    Token[Token["InternalKeyword"] = 106] = "InternalKeyword";
+    Token[Token["SealedKeyword"] = 107] = "SealedKeyword";
+    Token[Token["LocalKeyword"] = 108] = "LocalKeyword";
+    Token[Token["AsyncKeyword"] = 109] = "AsyncKeyword";
+    /** @internal */ Token[Token["__EndReservedKeyword"] = 110] = "__EndReservedKeyword";
+    ///////////////////////////////////////////////////////////////
+    /** @internal */ Token[Token["__Count"] = 110] = "__Count";
 })(Token || (Token = {}));
 /** @internal */
 getTokenDisplayTable([
@@ -30516,6 +30485,37 @@ getTokenDisplayTable([
     [Token.NeverKeyword, "'never'"],
     [Token.UnknownKeyword, "'unknown'"],
     [Token.ExternKeyword, "'extern'"],
+    // Reserved keywords
+    [Token.StatemachineKeyword, "'statemachine'"],
+    [Token.MacroKeyword, "'macro'"],
+    [Token.PackageKeyword, "'package'"],
+    [Token.MetadataKeyword, "'metadata'"],
+    [Token.EnvKeyword, "'env'"],
+    [Token.ArgKeyword, "'arg'"],
+    [Token.DeclareKeyword, "'declare'"],
+    [Token.ArrayKeyword, "'array'"],
+    [Token.StructKeyword, "'struct'"],
+    [Token.RecordKeyword, "'record'"],
+    [Token.ModuleKeyword, "'module'"],
+    [Token.TraitKeyword, "'trait'"],
+    [Token.ThisKeyword, "'this'"],
+    [Token.SelfKeyword, "'self'"],
+    [Token.SuperKeyword, "'super'"],
+    [Token.KeyofKeyword, "'keyof'"],
+    [Token.WithKeyword, "'with'"],
+    [Token.ImplementsKeyword, "'implements'"],
+    [Token.ImplKeyword, "'impl'"],
+    [Token.SatisfiesKeyword, "'satisfies'"],
+    [Token.FlagKeyword, "'flag'"],
+    [Token.AutoKeyword, "'auto'"],
+    [Token.PartialKeyword, "'partial'"],
+    [Token.PrivateKeyword, "'private'"],
+    [Token.PublicKeyword, "'public'"],
+    [Token.ProtectedKeyword, "'protected'"],
+    [Token.InternalKeyword, "'internal'"],
+    [Token.SealedKeyword, "'sealed'"],
+    [Token.LocalKeyword, "'local'"],
+    [Token.AsyncKeyword, "'async'"],
 ]);
 /** @internal */
 const Keywords = new Map([
@@ -30547,6 +30547,71 @@ const Keywords = new Map([
     ["never", Token.NeverKeyword],
     ["unknown", Token.UnknownKeyword],
     ["extern", Token.ExternKeyword],
+    // Reserved keywords
+    ["statemachine", Token.StatemachineKeyword],
+    ["macro", Token.MacroKeyword],
+    ["package", Token.PackageKeyword],
+    ["metadata", Token.MetadataKeyword],
+    ["env", Token.EnvKeyword],
+    ["arg", Token.ArgKeyword],
+    ["declare", Token.DeclareKeyword],
+    ["array", Token.ArrayKeyword],
+    ["struct", Token.StructKeyword],
+    ["record", Token.RecordKeyword],
+    ["module", Token.ModuleKeyword],
+    ["trait", Token.TraitKeyword],
+    ["this", Token.ThisKeyword],
+    ["self", Token.SelfKeyword],
+    ["super", Token.SuperKeyword],
+    ["keyof", Token.KeyofKeyword],
+    ["with", Token.WithKeyword],
+    ["implements", Token.ImplementsKeyword],
+    ["impl", Token.ImplKeyword],
+    ["satisfies", Token.SatisfiesKeyword],
+    ["flag", Token.FlagKeyword],
+    ["auto", Token.AutoKeyword],
+    ["partial", Token.PartialKeyword],
+    ["private", Token.PrivateKeyword],
+    ["public", Token.PublicKeyword],
+    ["protected", Token.ProtectedKeyword],
+    ["internal", Token.InternalKeyword],
+    ["sealed", Token.SealedKeyword],
+    ["local", Token.LocalKeyword],
+    ["async", Token.AsyncKeyword],
+]);
+/** @internal */
+const ReservedKeywords = new Map([
+    // Reserved keywords
+    ["statemachine", Token.StatemachineKeyword],
+    ["macro", Token.MacroKeyword],
+    ["package", Token.PackageKeyword],
+    ["metadata", Token.MetadataKeyword],
+    ["env", Token.EnvKeyword],
+    ["arg", Token.ArgKeyword],
+    ["declare", Token.DeclareKeyword],
+    ["array", Token.ArrayKeyword],
+    ["struct", Token.StructKeyword],
+    ["record", Token.RecordKeyword],
+    ["module", Token.ModuleKeyword],
+    ["trait", Token.TraitKeyword],
+    ["this", Token.ThisKeyword],
+    ["self", Token.SelfKeyword],
+    ["super", Token.SuperKeyword],
+    ["keyof", Token.KeyofKeyword],
+    ["with", Token.WithKeyword],
+    ["implements", Token.ImplementsKeyword],
+    ["impl", Token.ImplKeyword],
+    ["satisfies", Token.SatisfiesKeyword],
+    ["flag", Token.FlagKeyword],
+    ["auto", Token.AutoKeyword],
+    ["partial", Token.PartialKeyword],
+    ["private", Token.PrivateKeyword],
+    ["public", Token.PublicKeyword],
+    ["protected", Token.ProtectedKeyword],
+    ["internal", Token.InternalKeyword],
+    ["sealed", Token.SealedKeyword],
+    ["local", Token.LocalKeyword],
+    ["async", Token.AsyncKeyword],
 ]);
 var TokenFlags;
 (function (TokenFlags) {
@@ -30582,8 +30647,9 @@ function getTokenDisplayTable(entries) {
  * printIdentifier("foo bar") // `foo bar`
  * ```
  */
-function printIdentifier(sv) {
-    if (needBacktick(sv)) {
+function printIdentifier(sv, 
+/** @internal */ context = "disallow-reserved") {
+    if (needBacktick(sv, context)) {
         const escapedString = sv
             .replace(/\\/g, "\\\\")
             .replace(/\n/g, "\\n")
@@ -30596,10 +30662,13 @@ function printIdentifier(sv) {
         return sv;
     }
 }
-function needBacktick(sv) {
+function needBacktick(sv, context) {
     if (sv.length === 0) {
         return false;
     }
+    if (context === "allow-reserved" && ReservedKeywords.has(sv)) {
+        return false;
+    }
     if (Keywords.has(sv)) {
         return true;
     }
@@ -31035,6 +31104,13 @@ defineKit({
             }
             return undefined;
         },
+        getDiscriminatedUnion(model) {
+            const discriminator = getDiscriminator(this.program, model);
+            if (!discriminator) {
+                return undefined;
+            }
+            return ignoreDiagnostics(getDiscriminatedUnionFromInheritance(model, discriminator));
+        },
     },
 });
 
@@ -31286,11 +31362,18 @@ defineKit({
             return getPlausibleName(type);
         },
         getDiscriminator(type) {
-            return getDiscriminator(this.program, type);
-        },
-        getDiscriminatedUnion(type) {
-            const [union] = getDiscriminatedUnion(this.program, type);
-            return union;
+            let discriminator;
+            if ($$1.model.is(type)) {
+                discriminator = getDiscriminator(this.program, type);
+            }
+            else {
+                const unionDiscriminator = ignoreDiagnostics(getDiscriminatedUnion(this.program, type));
+                const propertyName = unionDiscriminator?.options.discriminatorPropertyName;
+                if (propertyName) {
+                    discriminator = { propertyName };
+                }
+            }
+            return discriminator;
         },
         maxValue(type) {
             return getMaxValue(this.program, type);
@@ -31414,6 +31497,9 @@ defineKit({
         isExpression(type) {
             return type.name === undefined || type.name === "";
         },
+        getDiscriminatedUnion(type) {
+            return ignoreDiagnostics(getDiscriminatedUnion(this.program, type));
+        },
     },
 });
 
@@ -33482,6 +33568,18 @@ if (globalThis[globalLibraryUrlsLoadedSym] === undefined) {
 
 const CompilerPackageRoot = undefined;
 
+let manifest;
+try {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    manifest = (await import('../manifest-CrFWPTea.js')).default;
+}
+catch {
+    const name = "../dist/manifest.js";
+    manifest = (await import(/* @vite-ignore */ /* webpackIgnore: true */ name)).default;
+}
+manifest.version;
+
 var main$4 = {};
 
 var api$2 = {};
@@ -44777,7 +44875,7 @@ function computeReferences(node) {
   return { pathToNode, typeToPath };
 }
 function computeTree(program) {
-  const root = program.checker.getGlobalNamespaceType();
+  const root = program.getGlobalNamespaceType();
   const namespaces = expandNamespaces(root);
   return {
     kind: "list",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/html-program-viewer",
-  "version": "0.67.0-dev.4",
+  "version": "0.67.0-dev.5",
   "author": "Microsoft Corporation",
   "description": "TypeSpec library for emitting an html view of the program.",
   "homepage": "https://typespec.io",

package/dist/emitter.d.ts

@@ -1,20 +0,0 @@
-import { EmitContext, JSONSchemaType, Program } from '@typespec/compiler';
-export interface HtmlProgramViewerOptions {
-    /**
-     * Override compiler output-dir
-     */
-    "output-dir"?: string;
-}
-export declare function renderProgram(program: Program): string;
-export declare const libDef: {
-    readonly name: "@typespec/html-program-viewer";
-    readonly diagnostics: {};
-    readonly emitter: {
-        readonly options: JSONSchemaType<HtmlProgramViewerOptions>;
-    };
-};
-export declare const $lib: import('@typespec/compiler').TypeSpecLibrary<{
-    [code: string]: import('@typespec/compiler').DiagnosticMessages;
-}, HtmlProgramViewerOptions, never>;
-export declare function $onEmit(context: EmitContext<HtmlProgramViewerOptions>): Promise<void>;
-//# sourceMappingURL=emitter.d.ts.map

package/dist/emitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,OAAO,EACb,MAAM,oBAAoB,CAAC;AAO5B,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAWD,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,UAQ7C;AAED,eAAO,MAAM,MAAM;;;;0BAIkB,cAAc,CAAC,wBAAwB,CAAC;;CAEnE,CAAC;AAEX,eAAO,MAAM,IAAI;;mCAAgC,CAAC;AAElD,wBAAsB,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,wBAAwB,CAAC,iBAgB3E"}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from './emitter.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}