@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

package/node_modules/@aws-sdk/xml-builder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/xml-builder",
-  "version": "3.972.37",
+  "version": "3.972.39",
   "description": "XML utilities for the AWS SDK",
   "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages-internal/xml-builder",
   "license": "Apache-2.0",
@@ -55,7 +55,7 @@
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
     "premove": "4.0.0",
-    "typescript": "~5.8.3"
+    "typescript": "~7.0.2"
   },
   "engines": {
     "node": ">=20.0.0"

package/node_modules/@bufbuild/protobuf/README.md

@@ -8,21 +8,18 @@ code generator plugin.
 A complete implementation of [Protocol Buffers](https://protobuf.dev/) in TypeScript,
 suitable for web browsers, Node.js, Deno, and Bun, created by [Buf](https://buf.build).
 
-**Protobuf-ES** is a solid, modern alternative to existing Protobuf implementations for the JavaScript ecosystem. It's
-the first project in this space to provide a comprehensive plugin framework and decouple the base types from RPC
-functionality.
-
-Some additional features that set it apart from the others:
-
-- ECMAScript module support
-- First-class TypeScript support
-- Generation of idiomatic JavaScript and TypeScript code
-- Generation of [much smaller bundles](https://github.com/bufbuild/protobuf-es/tree/main/packages/bundle-size/)
-- Implementation of all proto3 features, including the [canonical JSON format](https://protobuf.dev/programming-guides/proto3/#json)
-- Implementation of all proto2 features, including extensions and the text format
-- Usage of standard JavaScript APIs instead of the [Closure Library](http://googlecode.blogspot.com/2009/11/introducing-closure-tools.html)
-- Compatibility is covered by the Protocol Buffers [conformance tests](https://github.com/bufbuild/protobuf-es/tree/main/packages/protobuf-conformance/)
-- Descriptor and reflection support
+**Protobuf-ES** is a solid, modern alternative to existing Protobuf implementations for the JavaScript ecosystem. It
+provides a comprehensive plugin framework and decouples the base types from RPC functionality.
+
+Some additional features:
+
+- Generates pure TypeScript
+- Plain message objects, no getters/setters
+- Reflection, registries, and custom options
+- 100% conformant against the official Protobuf test suite
+- Standard plugin-based generation, works with the Buf CLI as well as `protoc`
+- Write your own code generators with [@bufbuild/protoplugin](https://www.npmjs.com/package/@bufbuild/protoplugin)
+- Pairs with [@connectrpc/connect](https://www.npmjs.com/package/@connectrpc/connect) for RPC and [@bufbuild/protovalidate](https://www.npmjs.com/package/@bufbuild/protovalidate) for validation
 
 ## Installation
 

package/node_modules/@bufbuild/protobuf/dist/commonjs/create.js

@@ -18,7 +18,6 @@ const is_message_js_1 = require("./is-message.js");
 const descriptors_js_1 = require("./descriptors.js");
 const scalar_js_1 = require("./reflect/scalar.js");
 const guard_js_1 = require("./reflect/guard.js");
-const unsafe_js_1 = require("./reflect/unsafe.js");
 const wrappers_js_1 = require("./wkt/wrappers.js");
 // bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name = $number;
 const EDITION_PROTO3 = 999;
@@ -36,182 +35,232 @@ function create(schema, init) {
     if ((0, is_message_js_1.isMessage)(init, schema)) {
         return init;
     }
-    const message = createZeroMessage(schema);
-    if (init !== undefined) {
-        initMessage(schema, message, init);
-    }
-    return message;
+    return compiledCreate(schema)(init);
 }
+const compiledCreates = new WeakMap();
 /**
- * Sets field values from a MessageInitShape on a zero message.
- */
-function initMessage(messageDesc, message, init) {
-    for (const member of messageDesc.members) {
-        let value = init[member.localName];
-        if (value == null) {
-            // intentionally ignore undefined and null
-            continue;
+ * Return the compiled create function for a message, compiling it on first use. */
+function compiledCreate(desc) {
+    let compiled = compiledCreates.get(desc);
+    if (compiled === undefined) {
+        compiled = compileCreate(desc);
+        compiledCreates.set(desc, compiled);
+    }
+    return compiled;
+}
+/** Singular field: scalar, enum, or message. */
+const INIT_SINGULAR = 0;
+/** List field: a zero message has a fresh empty array. */
+const INIT_LIST = 1;
+/** Map field: a zero message has a fresh empty object. */
+const INIT_MAP = 2;
+/** Oneof group: the ADT is always stored, cases convert by case name. */
+const INIT_ONEOF = 3;
+/* Compile the create function for this message type. */
+function compileCreate(desc) {
+    const typeName = desc.typeName;
+    const { properties, prototype } = compileInitMessage(desc);
+    return (init) => {
+        let message;
+        if (prototype !== undefined) {
+            message = Object.create(prototype);
+            message.$typeName = typeName;
         }
-        let field;
-        if (member.kind == "oneof") {
-            const oneofField = (0, unsafe_js_1.unsafeOneofCase)(init, member);
-            if (!oneofField) {
-                continue;
+        else {
+            message = { $typeName: typeName };
+        }
+        for (let i = 0; i < properties.length; i++) {
+            const property = properties[i];
+            const name = property.name;
+            const initValue = init === null || init === void 0 ? void 0 : init[name];
+            switch (property.kind) {
+                case INIT_SINGULAR:
+                    if (initValue != null) {
+                        message[name] =
+                            property.convert !== undefined
+                                ? property.convert(initValue)
+                                : initValue;
+                    }
+                    else if (property.constant !== undefined) {
+                        message[name] = property.constant;
+                    }
+                    break;
+                case INIT_LIST:
+                    message[name] =
+                        property.convert !== undefined && Array.isArray(initValue)
+                            ? initValue.map(property.convert)
+                            : (initValue !== null && initValue !== void 0 ? initValue : []);
+                    break;
+                case INIT_MAP:
+                    // Object.create(null) would be desirable for the fresh map, but is
+                    // unsupported by React:
+                    // https://react.dev/reference/react/use-server#serializable-parameters-and-return-values
+                    if (property.convert === undefined || !(0, guard_js_1.isObject)(initValue)) {
+                        message[name] = initValue !== null && initValue !== void 0 ? initValue : {};
+                    }
+                    else {
+                        const converted = {};
+                        const keys = Object.keys(initValue);
+                        for (let k = 0; k < keys.length; k++) {
+                            converted[keys[k]] = property.convert(initValue[keys[k]]);
+                        }
+                        message[name] = converted;
+                    }
+                    break;
+                case INIT_ONEOF: {
+                    const oneofValue = initValue;
+                    if ((oneofValue === null || oneofValue === void 0 ? void 0 : oneofValue.case) != null) {
+                        const convert = property.convert.get(oneofValue.case);
+                        if (convert !== undefined) {
+                            message[name] = {
+                                case: oneofValue.case,
+                                value: convert(oneofValue.value),
+                            };
+                            break;
+                        }
+                    }
+                    message[name] = { case: undefined };
+                    break;
+                }
             }
-            field = oneofField;
-            value = (0, unsafe_js_1.unsafeGet)(init, oneofField);
         }
-        else {
-            field = member;
+        return message;
+    };
+}
+/**
+ * Classify every member once, so that creating a message is a walk over a
+ * compact list instead of a walk over the descriptor.
+ */
+function compileInitMessage(desc) {
+    var _a, _b;
+    const properties = [];
+    const prototype = {};
+    const usePrototype = needsPrototypeChain(desc);
+    for (const member of desc.members) {
+        const name = member.localName;
+        if (member.kind == "oneof") {
+            properties.push({
+                name,
+                kind: INIT_ONEOF,
+                constant: undefined,
+                convert: compileConvertOneof(member),
+            });
+            continue;
         }
-        switch (field.fieldKind) {
-            case "message":
-                value = toMessage(field, value);
+        switch (member.fieldKind) {
+            case "message": {
+                // Singular message fields are absent from a zero message.
+                properties.push({
+                    name,
+                    kind: INIT_SINGULAR,
+                    constant: undefined,
+                    convert: compileConvertMessage(member),
+                });
                 break;
-            case "scalar":
-                value = initScalar(field, value);
+            }
+            case "list": {
+                properties.push({
+                    name,
+                    kind: INIT_LIST,
+                    constant: undefined,
+                    convert: member.listKind == "message"
+                        ? ((_a = compileConvertMessage(member)) !== null && _a !== void 0 ? _a : ((value) => value))
+                        : member.scalar == descriptors_js_1.ScalarType.BYTES
+                            ? toU8Arr
+                            : undefined,
+                });
                 break;
-            case "list":
-                value = initList(field, value);
+            }
+            case "map": {
+                properties.push({
+                    name,
+                    kind: INIT_MAP,
+                    constant: undefined,
+                    convert: member.mapKind == "message"
+                        ? ((_b = compileConvertMessage(member)) !== null && _b !== void 0 ? _b : ((value) => value))
+                        : member.scalar == descriptors_js_1.ScalarType.BYTES
+                            ? toU8Arr
+                            : undefined,
+                });
                 break;
-            case "map":
-                value = initMap(field, value);
+            }
+            default: {
+                const zeroValue = createZeroValue(member);
+                properties.push({
+                    name,
+                    kind: INIT_SINGULAR,
+                    constant: member.presence == IMPLICIT ? zeroValue : undefined,
+                    convert: member.fieldKind == "scalar" && member.scalar == descriptors_js_1.ScalarType.BYTES
+                        ? toU8Arr
+                        : undefined,
+                });
+                if (usePrototype) {
+                    prototype[name] = zeroValue;
+                }
                 break;
-        }
-        (0, unsafe_js_1.unsafeSet)(message, field, value);
-    }
-    return message;
-}
-function initScalar(field, value) {
-    if (field.scalar == descriptors_js_1.ScalarType.BYTES) {
-        return toU8Arr(value);
-    }
-    return value;
-}
-function initMap(field, value) {
-    if ((0, guard_js_1.isObject)(value)) {
-        if (field.scalar == descriptors_js_1.ScalarType.BYTES) {
-            return convertObjectValues(value, toU8Arr);
-        }
-        if (field.mapKind == "message") {
-            return convertObjectValues(value, (val) => toMessage(field, val));
+            }
         }
     }
-    return value;
+    return {
+        properties,
+        prototype: usePrototype ? prototype : undefined,
+    };
 }
-function initList(field, value) {
-    if (Array.isArray(value)) {
-        if (field.scalar == descriptors_js_1.ScalarType.BYTES) {
-            return value.map(toU8Arr);
+/**
+ * Compile the conversion of each case of a oneof group, keyed by case name.
+ */
+function compileConvertOneof(oneof) {
+    const converters = new Map();
+    for (const field of oneof.fields) {
+        let convert;
+        if (field.fieldKind == "message") {
+            convert = compileConvertMessage(field);
         }
-        if (field.listKind == "message") {
-            return value.map((item) => toMessage(field, item));
+        else if (field.fieldKind == "scalar" &&
+            field.scalar == descriptors_js_1.ScalarType.BYTES) {
+            convert = toU8Arr;
         }
+        converters.set(field.localName, convert !== null && convert !== void 0 ? convert : ((value) => value));
     }
-    return value;
+    return converters;
 }
-function toMessage(field, value) {
+/**
+ * Compile the conversion of an init value for a message field, a message
+ * list item, or a message map value. Returns undefined if values are used
+ * as-is.
+ */
+function compileConvertMessage(field) {
     if (field.fieldKind == "message" &&
         !field.oneof &&
         (0, wrappers_js_1.isWrapperDesc)(field.message)) {
         // Types from google/protobuf/wrappers.proto are unwrapped when used in
         // a singular field that is not part of a oneof group.
-        return initScalar(field.message.fields[0], value);
+        return field.message.fields[0].scalar == descriptors_js_1.ScalarType.BYTES
+            ? toU8Arr
+            : undefined;
+    }
+    if (field.message.typeName == "google.protobuf.Struct" &&
+        field.parent.typeName !== "google.protobuf.Value") {
+        // google.protobuf.Struct is represented with JsonObject when used in a
+        // field, except when used in google.protobuf.Value.
+        return undefined;
     }
-    if ((0, guard_js_1.isObject)(value)) {
-        if (field.message.typeName == "google.protobuf.Struct" &&
-            field.parent.typeName !== "google.protobuf.Value") {
-            // google.protobuf.Struct is represented with JsonObject when used in a
-            // field, except when used in google.protobuf.Value.
+    const messageDesc = field.message;
+    // Resolved on first use, not here: the message type can be this very field's
+    // parent, whose create function is still being compiled.
+    let compiled;
+    return (value) => {
+        if (!(0, guard_js_1.isObject)(value) || (0, is_message_js_1.isMessage)(value, messageDesc)) {
             return value;
         }
-        if (!(0, is_message_js_1.isMessage)(value, field.message)) {
-            return create(field.message, value);
-        }
-    }
-    return value;
+        compiled !== null && compiled !== void 0 ? compiled : (compiled = compiledCreate(messageDesc));
+        return compiled(value);
+    };
 }
 // converts any ArrayLike<number> to Uint8Array if necessary.
 function toU8Arr(value) {
     return Array.isArray(value) ? new Uint8Array(value) : value;
 }
-function convertObjectValues(obj, fn) {
-    const ret = {};
-    for (const entry of Object.entries(obj)) {
-        ret[entry[0]] = fn(entry[1]);
-    }
-    return ret;
-}
-const tokenZeroMessageField = Symbol();
-const messagePrototypes = new WeakMap();
-/**
- * Create a zero message.
- */
-function createZeroMessage(desc) {
-    let msg;
-    if (!needsPrototypeChain(desc)) {
-        msg = {
-            $typeName: desc.typeName,
-        };
-        for (const member of desc.members) {
-            if (member.kind == "oneof" || member.presence == IMPLICIT) {
-                msg[member.localName] = createZeroField(member);
-            }
-        }
-    }
-    else {
-        // Support default values and track presence via the prototype chain
-        const cached = messagePrototypes.get(desc);
-        let prototype;
-        let members;
-        if (cached) {
-            ({ prototype, members } = cached);
-        }
-        else {
-            prototype = {};
-            members = new Set();
-            for (const member of desc.members) {
-                if (member.kind == "oneof") {
-                    // we can only put immutable values on the prototype,
-                    // oneof ADTs are mutable
-                    continue;
-                }
-                if (member.fieldKind != "scalar" && member.fieldKind != "enum") {
-                    // only scalar and enum values are immutable, map, list, and message
-                    // are not
-                    continue;
-                }
-                if (member.presence == IMPLICIT) {
-                    // implicit presence tracks field presence by zero values - e.g. 0, false, "", are unset, 1, true, "x" are set.
-                    // message, map, list fields are mutable, and also have IMPLICIT presence.
-                    continue;
-                }
-                members.add(member);
-                prototype[member.localName] = createZeroField(member);
-            }
-            messagePrototypes.set(desc, { prototype, members });
-        }
-        msg = Object.create(prototype);
-        msg.$typeName = desc.typeName;
-        for (const member of desc.members) {
-            if (members.has(member)) {
-                continue;
-            }
-            if (member.kind == "field") {
-                if (member.fieldKind == "message") {
-                    continue;
-                }
-                if (member.fieldKind == "scalar" || member.fieldKind == "enum") {
-                    if (member.presence != IMPLICIT) {
-                        continue;
-                    }
-                }
-            }
-            msg[member.localName] = createZeroField(member);
-        }
-    }
-    return msg;
-}
 /**
  * Do we need the prototype chain to track field presence?
  */
@@ -231,22 +280,10 @@ function needsPrototypeChain(desc) {
     }
 }
 /**
- * Returns a zero value for oneof groups, and for every field kind except
- * messages. Scalar and enum fields can have default values.
+ * Returns the zero value for a scalar or enum field. Scalar and enum fields
+ * can have default values.
  */
-function createZeroField(field) {
-    if (field.kind == "oneof") {
-        return { case: undefined };
-    }
-    if (field.fieldKind == "list") {
-        return [];
-    }
-    if (field.fieldKind == "map") {
-        return {}; // Object.create(null) would be desirable here, but is unsupported by react https://react.dev/reference/react/use-server#serializable-parameters-and-return-values
-    }
-    if (field.fieldKind == "message") {
-        return tokenZeroMessageField;
-    }
+function createZeroValue(field) {
     const defaultValue = field.getDefaultValue();
     if (defaultValue !== undefined) {
         return field.fieldKind == "scalar" && field.longAsString