@code-yeongyu/senpi 2026.8.16 → 2026.8.18

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js

@@ -0,0 +1,109 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// 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.
+/**
+ * Return a fully-qualified name for a Protobuf descriptor.
+ * For a file descriptor, return the original file path.
+ *
+ * See https://protobuf.com/docs/language-spec#fully-qualified-names
+ */
+export function qualifiedName(desc) {
+    switch (desc.kind) {
+        case "field":
+        case "oneof":
+        case "rpc":
+            return desc.parent.typeName + "." + desc.name;
+        case "enum_value": {
+            const p = desc.parent.parent
+                ? desc.parent.parent.typeName
+                : desc.parent.file.proto.package;
+            return p + (p.length > 0 ? "." : "") + desc.name;
+        }
+        case "service":
+        case "message":
+        case "enum":
+        case "extension":
+            return desc.typeName;
+        case "file":
+            return desc.proto.name;
+    }
+}
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ *
+ * See https://protobuf.com/docs/language-spec#default-json-names
+ *
+ * The function protoSnakeCase provides the reverse.
+ */
+export function protoCamelCase(snakeCase) {
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
+        }
+    }
+    return b.join("");
+}
+/**
+ * Converts protoCamelCase to snake_case.
+ *
+ * This function is the reverse of function protoCamelCase. Note that some names
+ * are not reversible - for example, "foo__bar" -> "fooBar" -> "foo_bar".
+ */
+export function protoSnakeCase(lowerCamelCase) {
+    return lowerCamelCase.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase());
+}
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const reservedObjectProperties = new Set([
+    // names reserved by JavaScript
+    "constructor",
+    "toString",
+    "toJSON",
+    "valueOf",
+]);
+/**
+ * Escapes names that are reserved for ECMAScript built-in object properties.
+ *
+ * Also see safeIdentifier() from @bufbuild/protoplugin.
+ */
+export function safeObjectProperty(name) {
+    return reservedObjectProperties.has(name) ? name + "$" : name;
+}

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.d.ts

@@ -0,0 +1,35 @@
+import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../descriptors.js";
+/**
+ * Iterate over all types - enumerations, extensions, services, messages -
+ * and enumerations, extensions and messages nested in messages.
+ */
+export declare function nestedTypes(desc: DescFile | DescMessage): Iterable<DescMessage | DescEnum | DescExtension | DescService>;
+/**
+ * Iterate over types referenced by fields of the given message.
+ *
+ * For example:
+ *
+ * ```proto
+ * syntax="proto3";
+ *
+ * message Example {
+ *   Msg singular = 1;
+ *   repeated Level list = 2;
+ * }
+ *
+ * message Msg {}
+ *
+ * enum Level {
+ *   LEVEL_UNSPECIFIED = 0;
+ * }
+ * ```
+ *
+ * The message Example references the message Msg, and the enum Level.
+ */
+export declare function usedTypes(descMessage: DescMessage): Iterable<DescMessage | DescEnum>;
+/**
+ * Returns the ancestors of a given Protobuf element, up to the file.
+ */
+export declare function parentTypes(desc: AnyDesc): Parent[];
+type Parent = DescFile | DescEnum | DescMessage | DescService;
+export {};

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js

@@ -0,0 +1,105 @@
+// Copyright 2021-2026 Buf Technologies, Inc.
+//
+// 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.
+/**
+ * Iterate over all types - enumerations, extensions, services, messages -
+ * and enumerations, extensions and messages nested in messages.
+ */
+export function* nestedTypes(desc) {
+    switch (desc.kind) {
+        case "file":
+            for (const message of desc.messages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.enums;
+            yield* desc.services;
+            yield* desc.extensions;
+            break;
+        case "message":
+            for (const message of desc.nestedMessages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.nestedEnums;
+            yield* desc.nestedExtensions;
+            break;
+    }
+}
+/**
+ * Iterate over types referenced by fields of the given message.
+ *
+ * For example:
+ *
+ * ```proto
+ * syntax="proto3";
+ *
+ * message Example {
+ *   Msg singular = 1;
+ *   repeated Level list = 2;
+ * }
+ *
+ * message Msg {}
+ *
+ * enum Level {
+ *   LEVEL_UNSPECIFIED = 0;
+ * }
+ * ```
+ *
+ * The message Example references the message Msg, and the enum Level.
+ */
+export function usedTypes(descMessage) {
+    return usedTypesInternal(descMessage, new Set());
+}
+function* usedTypesInternal(descMessage, seen) {
+    var _a, _b;
+    for (const field of descMessage.fields) {
+        const ref = (_b = (_a = field.enum) !== null && _a !== void 0 ? _a : field.message) !== null && _b !== void 0 ? _b : undefined;
+        if (!ref || seen.has(ref.typeName)) {
+            continue;
+        }
+        seen.add(ref.typeName);
+        yield ref;
+        if (ref.kind == "message") {
+            yield* usedTypesInternal(ref, seen);
+        }
+    }
+}
+/**
+ * Returns the ancestors of a given Protobuf element, up to the file.
+ */
+export function parentTypes(desc) {
+    const parents = [];
+    while (desc.kind !== "file") {
+        const p = parent(desc);
+        desc = p;
+        parents.push(p);
+    }
+    return parents;
+}
+function parent(desc) {
+    var _a;
+    switch (desc.kind) {
+        case "enum_value":
+        case "field":
+        case "oneof":
+        case "rpc":
+            return desc.parent;
+        case "service":
+            return desc.file;
+        case "extension":
+        case "enum":
+        case "message":
+            return (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file;
+    }
+}

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.d.ts

@@ -0,0 +1,107 @@
+import { type DescExtension, type DescField, type DescMessage, type DescOneof } from "../descriptors.js";
+import type { Registry } from "../registry.js";
+/**
+ * A path to a (nested) member of a Protobuf message, such as a field, oneof,
+ * extension, list element, or map entry.
+ *
+ * Note that we may add additional types to this union in the future to support
+ * more use cases.
+ */
+export type Path = (DescField | DescExtension | DescOneof | {
+    kind: "list_sub";
+    index: number;
+} | {
+    kind: "map_sub";
+    key: string | number | bigint | boolean;
+})[];
+/**
+ * Builds a Path.
+ */
+export type PathBuilder = {
+    /**
+     * The root message of the path.
+     */
+    readonly schema: DescMessage;
+    /**
+     * Add field access.
+     *
+     * Throws an InvalidPathError if the field cannot be added to the path.
+     */
+    field(field: DescField): PathBuilder;
+    /**
+     * Access a oneof.
+     *
+     * Throws an InvalidPathError if the oneof cannot be added to the path.
+     *
+     */
+    oneof(oneof: DescOneof): PathBuilder;
+    /**
+     * Access an extension.
+     *
+     * Throws an InvalidPathError if the extension cannot be added to the path.
+     */
+    extension(extension: DescExtension): PathBuilder;
+    /**
+     * Access a list field by index.
+     *
+     * Throws an InvalidPathError if the list access cannot be added to the path.
+     */
+    list(index: number): PathBuilder;
+    /**
+     * Access a map field by key.
+     *
+     * Throws an InvalidPathError if the map access cannot be added to the path.
+     */
+    map(key: string | number | bigint | boolean): PathBuilder;
+    /**
+     * Append a path.
+     *
+     * Throws an InvalidPathError if the path cannot be added.
+     */
+    add(path: Path | PathBuilder): PathBuilder;
+    /**
+     * Return the path.
+     */
+    toPath(): Path;
+    /**
+     * Create a copy of this builder.
+     */
+    clone(): PathBuilder;
+    /**
+     * Get the current container - a list, map, or message.
+     */
+    getLeft(): DescMessage | (DescField & {
+        fieldKind: "list";
+    }) | (DescField & {
+        fieldKind: "map";
+    }) | undefined;
+};
+/**
+ * Create a PathBuilder.
+ */
+export declare function buildPath(schema: DescMessage): PathBuilder;
+/**
+ * Parse a Path from a string.
+ *
+ * Throws an InvalidPathError if the path is invalid.
+ *
+ * Note that a Registry must be provided via the options argument to parse
+ * paths that refer to an extension.
+ */
+export declare function parsePath(schema: DescMessage, path: string, options?: {
+    registry?: Registry | undefined;
+}): Path;
+/**
+ * Stringify a path.
+ */
+export declare function pathToString(path: Path): string;
+/**
+ * InvalidPathError is thrown for invalid Paths, for example during parsing from
+ * a string, or when a new Path is built.
+ */
+export declare class InvalidPathError extends Error {
+    name: string;
+    readonly schema: DescMessage;
+    readonly path: Path | string;
+    constructor(schema: DescMessage, message: string, path: string | Path);
+}