@code-yeongyu/senpi 2026.8.16 → 2026.8.18

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/scalar.js

@@ -0,0 +1,129 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scalarEquals = scalarEquals;
+exports.scalarZeroValue = scalarZeroValue;
+exports.isScalarZeroValue = isScalarZeroValue;
+const proto_int64_js_1 = require("../proto-int64.js");
+const descriptors_js_1 = require("../descriptors.js");
+/**
+ * Returns true if both scalar values are equal.
+ *
+ * For float and double, values are compared following IEEE semantics: -0
+ * equals 0, and NaN does not equal NaN. This is value equality, not identity.
+ *
+ * It deliberately differs from isScalarZeroValue, which treats -0 as distinct
+ * from 0. A value can equal the zero value without being a zero value
+ * (scalarEquals(DOUBLE, -0, 0) is true while isScalarZeroValue(DOUBLE, -0) is
+ * false) so this function must not be used to derive implicit presence.
+ */
+function scalarEquals(type, a, b) {
+    if (a === b) {
+        // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
+        return true;
+    }
+    // Special case BYTES - we need to compare each byte individually
+    if (type == descriptors_js_1.ScalarType.BYTES) {
+        if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
+            return false;
+        }
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Special case 64-bit integers - we support number, string and bigint representation.
+    switch (type) {
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            // Loose comparison will match between 0n, 0 and "0".
+            return a == b;
+    }
+    // Anything that hasn't been caught by strict comparison or special cased
+    // BYTES and 64-bit integers is not equal.
+    return false;
+}
+/**
+ * Returns the zero value for the given scalar type, the value a field of this
+ * type has when unset: 0 for numeric types, "" for strings, false for
+ * booleans, and an empty Uint8Array for bytes. For 64-bit integer types, the
+ * result is "0" when longAsString is true, otherwise 0n.
+ *
+ * This is the type's zero value, not a proto2 custom field default. For float
+ * and double it is +0; isScalarZeroValue treats only +0, not -0, as this value.
+ */
+function scalarZeroValue(type, longAsString) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.STRING:
+            return "";
+        case descriptors_js_1.ScalarType.BOOL:
+            return false;
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FLOAT:
+            return 0.0;
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            return (longAsString ? "0" : proto_int64_js_1.protoInt64.zero);
+        case descriptors_js_1.ScalarType.BYTES:
+            return new Uint8Array(0);
+        default:
+            // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
+            // We do not use individual cases to save a few bytes code size.
+            return 0;
+    }
+}
+/**
+ * Returns true if the value is the zero value for the given scalar type: `0`
+ * for numeric types, `false` for booleans, `""` for strings, and an empty
+ * Uint8Array for bytes.
+ *
+ * This is the implicit-presence default check. A singular field with implicit
+ * presence is treated as unset, and omitted from the wire, when its value is
+ * the zero value. With explicit presence, or in repeated and map fields,
+ * presence is structural and this function does not apply.
+ *
+ * Note that -0 is NOT a zero value for float and double: under implicit
+ * presence, +0 is omitted from the wire but -0 is written, following the
+ * proto3 specification. As a result this can disagree with scalarEquals, which
+ * compares by value and treats -0 as equal to 0.
+ */
+function isScalarZeroValue(type, value) {
+    switch (type) {
+        case descriptors_js_1.ScalarType.BOOL:
+            return value === false;
+        case descriptors_js_1.ScalarType.STRING:
+            return value === "";
+        case descriptors_js_1.ScalarType.BYTES:
+            return value instanceof Uint8Array && !value.byteLength;
+        case descriptors_js_1.ScalarType.DOUBLE:
+        case descriptors_js_1.ScalarType.FLOAT:
+            // Object.is distinguishes -0 from 0.
+            return Object.is(value, 0);
+        default:
+            // Loose comparison matches 0n, 0 and "0".
+            return value == 0;
+    }
+}

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/unsafe.d.ts

@@ -0,0 +1,39 @@
+import type { DescField, DescOneof } from "../descriptors.js";
+export declare const unsafeLocal: unique symbol;
+/**
+ * Return the selected field of a oneof group.
+ *
+ * @private
+ */
+export declare function unsafeOneofCase(target: Record<string, any>, oneof: DescOneof): DescField | undefined;
+/**
+ * Returns true if the field is set.
+ *
+ * @private
+ */
+export declare function unsafeIsSet(target: Record<string, any>, field: DescField): boolean;
+/**
+ * Returns true if the field is set, but only for singular fields with explicit
+ * presence (proto2).
+ *
+ * @private
+ */
+export declare function unsafeIsSetExplicit(target: object, localName: string): boolean;
+/**
+ * Return a field value, respecting oneof groups.
+ *
+ * @private
+ */
+export declare function unsafeGet(target: Record<string, unknown>, field: DescField): unknown;
+/**
+ * Set a field value, respecting oneof groups.
+ *
+ * @private
+ */
+export declare function unsafeSet(target: Record<string, unknown>, field: DescField, value: unknown): void;
+/**
+ * Resets the field, so that unsafeIsSet() will return false.
+ *
+ * @private
+ */
+export declare function unsafeClear(target: Record<string, any>, field: DescField): void;

package/node_modules/@bufbuild/protobuf/dist/commonjs/reflect/unsafe.js

@@ -0,0 +1,149 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsafeLocal = void 0;
+exports.unsafeOneofCase = unsafeOneofCase;
+exports.unsafeIsSet = unsafeIsSet;
+exports.unsafeIsSetExplicit = unsafeIsSetExplicit;
+exports.unsafeGet = unsafeGet;
+exports.unsafeSet = unsafeSet;
+exports.unsafeClear = unsafeClear;
+const scalar_js_1 = require("./scalar.js");
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name = $number;
+const IMPLICIT = 2;
+exports.unsafeLocal = Symbol.for("reflect unsafe local");
+/**
+ * Return the selected field of a oneof group.
+ *
+ * @private
+ */
+function unsafeOneofCase(
+// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access
+target, oneof) {
+    const c = target[oneof.localName].case;
+    if (c === undefined) {
+        return c;
+    }
+    return oneof.fields.find((f) => f.localName === c);
+}
+/**
+ * Returns true if the field is set.
+ *
+ * @private
+ */
+function unsafeIsSet(
+// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access
+target, field) {
+    const name = field.localName;
+    if (field.oneof) {
+        return target[field.oneof.localName].case === name;
+    }
+    if (field.presence != IMPLICIT) {
+        // Fields with explicit presence have properties on the prototype chain
+        // for default / zero values (except for proto3).
+        return (target[name] !== undefined &&
+            Object.prototype.hasOwnProperty.call(target, name));
+    }
+    switch (field.fieldKind) {
+        case "list":
+            return target[name].length > 0;
+        case "map":
+            return Object.keys(target[name]).length > 0;
+        case "scalar":
+            return !(0, scalar_js_1.isScalarZeroValue)(field.scalar, target[name]);
+        case "enum":
+            return target[name] !== field.enum.values[0].number;
+    }
+    throw new Error("message field with implicit presence");
+}
+/**
+ * Returns true if the field is set, but only for singular fields with explicit
+ * presence (proto2).
+ *
+ * @private
+ */
+function unsafeIsSetExplicit(target, localName) {
+    return (Object.prototype.hasOwnProperty.call(target, localName) &&
+        target[localName] !== undefined);
+}
+/**
+ * Return a field value, respecting oneof groups.
+ *
+ * @private
+ */
+function unsafeGet(target, field) {
+    if (field.oneof) {
+        const oneof = target[field.oneof.localName];
+        if (oneof.case === field.localName) {
+            return oneof.value;
+        }
+        return undefined;
+    }
+    return target[field.localName];
+}
+/**
+ * Set a field value, respecting oneof groups.
+ *
+ * @private
+ */
+function unsafeSet(target, field, value) {
+    if (field.oneof) {
+        target[field.oneof.localName] = {
+            case: field.localName,
+            value: value,
+        };
+    }
+    else {
+        target[field.localName] = value;
+    }
+}
+/**
+ * Resets the field, so that unsafeIsSet() will return false.
+ *
+ * @private
+ */
+function unsafeClear(
+// biome-ignore lint/suspicious/noExplicitAny: `any` is the best choice for dynamic access
+target, field) {
+    const name = field.localName;
+    if (field.oneof) {
+        const oneofLocalName = field.oneof.localName;
+        if (target[oneofLocalName].case === name) {
+            target[oneofLocalName] = { case: undefined };
+        }
+    }
+    else if (field.presence != IMPLICIT) {
+        // Fields with explicit presence have properties on the prototype chain
+        // for default / zero values (except for proto3). By deleting their own
+        // property, the field is reset.
+        delete target[name];
+    }
+    else {
+        switch (field.fieldKind) {
+            case "map":
+                target[name] = {};
+                break;
+            case "list":
+                target[name] = [];
+                break;
+            case "enum":
+                target[name] = field.enum.values[0].number;
+                break;
+            case "scalar":
+                target[name] = (0, scalar_js_1.scalarZeroValue)(field.scalar, field.longAsString);
+                break;
+        }
+    }
+}

package/node_modules/@bufbuild/protobuf/dist/commonjs/registry.d.ts

@@ -0,0 +1,98 @@
+import type { FileDescriptorProto, FileDescriptorSet } from "./wkt/gen/google/protobuf/descriptor_pb.js";
+import { type DescEnum, type DescExtension, type DescFile, type DescMessage, type DescService, type SupportedEdition } from "./descriptors.js";
+/**
+ * A set of descriptors for messages, enumerations, extensions,
+ * and services.
+ */
+export interface Registry {
+    readonly kind: "registry";
+    /**
+     * All types (message, enumeration, extension, or service) contained
+     * in this registry.
+     */
+    [Symbol.iterator](): IterableIterator<DescMessage | DescEnum | DescExtension | DescService>;
+    /**
+     * Look up a type (message, enumeration, extension, or service) by
+     * its fully qualified name.
+     */
+    get(typeName: string): DescMessage | DescEnum | DescExtension | DescService | undefined;
+    /**
+     * Look up a message descriptor by its fully qualified name.
+     */
+    getMessage(typeName: string): DescMessage | undefined;
+    /**
+     * Look up an enumeration descriptor by its fully qualified name.
+     */
+    getEnum(typeName: string): DescEnum | undefined;
+    /**
+     * Look up an extension descriptor by its fully qualified name.
+     */
+    getExtension(typeName: string): DescExtension | undefined;
+    /**
+     * Look up an extension by the extendee - the message it extends - and
+     * the extension number.
+     */
+    getExtensionFor(extendee: DescMessage, no: number): DescExtension | undefined;
+    /**
+     * Look up a service descriptor by its fully qualified name.
+     */
+    getService(typeName: string): DescService | undefined;
+}
+/**
+ * A registry that allows adding and removing descriptors.
+ */
+export interface MutableRegistry extends Registry {
+    /**
+     * Adds the given descriptor - but not types nested within - to the registry.
+     */
+    add(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+    /**
+     * Remove the given descriptor - but not types nested within - from the registry.
+     */
+    remove(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+}
+/**
+ * A registry that includes files.
+ */
+export interface FileRegistry extends Registry {
+    /**
+     * All files in this registry.
+     */
+    readonly files: Iterable<DescFile>;
+    /**
+     * Look up a file descriptor by file name.
+     */
+    getFile(fileName: string): DescFile | undefined;
+}
+/**
+ * Create a registry from the given inputs.
+ *
+ * An input can be:
+ * - Any message, enum, service, or extension descriptor, which adds just the
+ *   descriptor for this type.
+ * - A file descriptor, which adds all typed defined in this file.
+ * - A registry, which adds all types from the registry.
+ *
+ * For duplicate descriptors (same type name), the one given last wins.
+ */
+export declare function createRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): Registry;
+/**
+ * Create a registry that allows adding and removing descriptors.
+ */
+export declare function createMutableRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): MutableRegistry;
+/**
+ * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorSet
+ * message.
+ */
+export declare function createFileRegistry(fileDescriptorSet: FileDescriptorSet): FileRegistry;
+/**
+ * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorProto
+ * message. For every import, the given resolver function is called.
+ */
+export declare function createFileRegistry(fileDescriptorProto: FileDescriptorProto, resolve: (protoFileName: string) => FileDescriptorProto | DescFile | undefined): FileRegistry;
+/**
+ * Create a registry (including file descriptors) from one or more registries,
+ * merging them.
+ */
+export declare function createFileRegistry(...registries: FileRegistry[]): FileRegistry;
+export declare const minimumEdition: SupportedEdition, maximumEdition: SupportedEdition;