@img/sharp-libvips-dev-wasm32 1.3.0-rc.1 → 1.3.0-rc.10

package/include/glib-2.0/glib/gvarianttype.h

@@ -302,7 +302,7 @@ typedef struct _GVariantType GVariantType;
 
 /* type string checking */
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_string_is_valid          (const gchar         *type_string) G_GNUC_CONST;
+gboolean                        g_variant_type_string_is_valid          (const gchar         *type_string) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
 gboolean                        g_variant_type_string_scan              (const gchar         *string,
                                                                          const gchar         *limit,
@@ -326,21 +326,21 @@ gchar *                         g_variant_type_dup_string               (const G
 
 /* classification */
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_definite              (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_definite              (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_container             (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_container             (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_basic                 (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_basic                 (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_maybe                 (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_maybe                 (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_array                 (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_array                 (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_tuple                 (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_tuple                 (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_dict_entry            (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_dict_entry            (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gboolean                        g_variant_type_is_variant               (const GVariantType  *type) G_GNUC_CONST;
+gboolean                        g_variant_type_is_variant               (const GVariantType  *type) G_GNUC_PURE;
 
 /* for hash tables */
 GLIB_AVAILABLE_IN_ALL
@@ -352,21 +352,21 @@ gboolean                        g_variant_type_equal                    (gconstp
 /* subtypes */
 GLIB_AVAILABLE_IN_ALL
 gboolean                        g_variant_type_is_subtype_of            (const GVariantType  *type,
-                                                                         const GVariantType  *supertype) G_GNUC_CONST;
+                                                                         const GVariantType  *supertype) G_GNUC_PURE;
 
 /* type iterator interface */
 GLIB_AVAILABLE_IN_ALL
-const GVariantType *            g_variant_type_element                  (const GVariantType  *type) G_GNUC_CONST;
+const GVariantType *            g_variant_type_element                  (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-const GVariantType *            g_variant_type_first                    (const GVariantType  *type) G_GNUC_CONST;
+const GVariantType *            g_variant_type_first                    (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-const GVariantType *            g_variant_type_next                     (const GVariantType  *type) G_GNUC_CONST;
+const GVariantType *            g_variant_type_next                     (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-gsize                           g_variant_type_n_items                  (const GVariantType  *type) G_GNUC_CONST;
+gsize                           g_variant_type_n_items                  (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-const GVariantType *            g_variant_type_key                      (const GVariantType  *type) G_GNUC_CONST;
+const GVariantType *            g_variant_type_key                      (const GVariantType  *type) G_GNUC_PURE;
 GLIB_AVAILABLE_IN_ALL
-const GVariantType *            g_variant_type_value                    (const GVariantType  *type) G_GNUC_CONST;
+const GVariantType *            g_variant_type_value                    (const GVariantType  *type) G_GNUC_PURE;
 
 /* constructors */
 GLIB_AVAILABLE_IN_ALL

package/include/glib-2.0/glib/gversionmacros.h

@@ -33,6 +33,19 @@
 
 /* Version boundaries checks */
 
+/**
+ * G_ENCODE_VERSION:
+ * @major: major version number
+ * @minor: minor version number
+ *
+ * Encode a major.minor version as a single integer.
+ *
+ * This is the encoding used by macros such as `GLIB_VERSION_2_84` and
+ * `GLIB_VERSION_CUR_STABLE`, and is intended to be used when (for example)
+ * setting the value of `GLIB_VERSION_MAX_ALLOWED`.
+ *
+ * Since: 2.32
+ */
 #define G_ENCODE_VERSION(major, minor) ((major) << 16 | (minor) << 8)
 
 /**
@@ -431,6 +444,15 @@
 * Since: 2.88
 */
 #define GLIB_VERSION_2_88       (G_ENCODE_VERSION (2, 88))
+/**
+* GLIB_VERSION_2_90:
+*
+* A macro that evaluates to the 2.90 version of GLib, in a format
+* that can be used by the C pre-processor.
+*
+* Since: 2.90
+*/
+#define GLIB_VERSION_2_90       (G_ENCODE_VERSION (2, 90))
 
 /**
  * GLIB_VERSION_CUR_STABLE:

package/include/glib-2.0/gmodule/gmodule-visibility.h

@@ -1120,3 +1120,37 @@
 #define GMODULE_AVAILABLE_ENUMERATOR_IN_2_88
 #define GMODULE_AVAILABLE_TYPE_IN_2_88
 #endif
+
+#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_90
+#define GMODULE_DEPRECATED_IN_2_90 GMODULE_DEPRECATED
+#define GMODULE_DEPRECATED_IN_2_90_FOR(f) GMODULE_DEPRECATED_FOR (f)
+#define GMODULE_DEPRECATED_MACRO_IN_2_90 GLIB_DEPRECATED_MACRO
+#define GMODULE_DEPRECATED_MACRO_IN_2_90_FOR(f) GLIB_DEPRECATED_MACRO_FOR (f)
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_90 GLIB_DEPRECATED_ENUMERATOR
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_90_FOR(f) GLIB_DEPRECATED_ENUMERATOR_FOR (f)
+#define GMODULE_DEPRECATED_TYPE_IN_2_90 GLIB_DEPRECATED_TYPE
+#define GMODULE_DEPRECATED_TYPE_IN_2_90_FOR(f) GLIB_DEPRECATED_TYPE_FOR (f)
+#else
+#define GMODULE_DEPRECATED_IN_2_90 _GMODULE_EXTERN
+#define GMODULE_DEPRECATED_IN_2_90_FOR(f) _GMODULE_EXTERN
+#define GMODULE_DEPRECATED_MACRO_IN_2_90
+#define GMODULE_DEPRECATED_MACRO_IN_2_90_FOR(f)
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_90
+#define GMODULE_DEPRECATED_ENUMERATOR_IN_2_90_FOR(f)
+#define GMODULE_DEPRECATED_TYPE_IN_2_90
+#define GMODULE_DEPRECATED_TYPE_IN_2_90_FOR(f)
+#endif
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_90
+#define GMODULE_AVAILABLE_IN_2_90 GMODULE_UNAVAILABLE (2, 90)
+#define GMODULE_AVAILABLE_STATIC_INLINE_IN_2_90 GLIB_UNAVAILABLE_STATIC_INLINE (2, 90)
+#define GMODULE_AVAILABLE_MACRO_IN_2_90 GLIB_UNAVAILABLE_MACRO (2, 90)
+#define GMODULE_AVAILABLE_ENUMERATOR_IN_2_90 GLIB_UNAVAILABLE_ENUMERATOR (2, 90)
+#define GMODULE_AVAILABLE_TYPE_IN_2_90 GLIB_UNAVAILABLE_TYPE (2, 90)
+#else
+#define GMODULE_AVAILABLE_IN_2_90 _GMODULE_EXTERN
+#define GMODULE_AVAILABLE_STATIC_INLINE_IN_2_90
+#define GMODULE_AVAILABLE_MACRO_IN_2_90
+#define GMODULE_AVAILABLE_ENUMERATOR_IN_2_90
+#define GMODULE_AVAILABLE_TYPE_IN_2_90
+#endif

package/include/glib-2.0/gmodule.h

@@ -65,7 +65,7 @@ typedef enum
   G_MODULE_BIND_LAZY	= 1 << 0,
   G_MODULE_BIND_LOCAL	= 1 << 1,
   G_MODULE_BIND_MASK	= 0x03
-} GModuleFlags;
+} G_GNUC_FLAG_ENUM GModuleFlags;
 
 typedef	struct _GModule			 GModule;
 typedef const gchar* (*GModuleCheckInit) (GModule	*module);

package/include/glib-2.0/gobject/gbinding.h

@@ -94,7 +94,7 @@ typedef enum { /*< prefix=G_BINDING >*/
   G_BINDING_BIDIRECTIONAL  = 1 << 0,
   G_BINDING_SYNC_CREATE    = 1 << 1,
   G_BINDING_INVERT_BOOLEAN = 1 << 2
-} GBindingFlags;
+} G_GNUC_FLAG_ENUM GBindingFlags;
 
 GOBJECT_AVAILABLE_IN_ALL
 GType                 g_binding_flags_get_type      (void) G_GNUC_CONST;

package/include/glib-2.0/gobject/gobject-visibility.h

@@ -1120,3 +1120,37 @@
 #define GOBJECT_AVAILABLE_ENUMERATOR_IN_2_88
 #define GOBJECT_AVAILABLE_TYPE_IN_2_88
 #endif
+
+#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_90
+#define GOBJECT_DEPRECATED_IN_2_90 GOBJECT_DEPRECATED
+#define GOBJECT_DEPRECATED_IN_2_90_FOR(f) GOBJECT_DEPRECATED_FOR (f)
+#define GOBJECT_DEPRECATED_MACRO_IN_2_90 GLIB_DEPRECATED_MACRO
+#define GOBJECT_DEPRECATED_MACRO_IN_2_90_FOR(f) GLIB_DEPRECATED_MACRO_FOR (f)
+#define GOBJECT_DEPRECATED_ENUMERATOR_IN_2_90 GLIB_DEPRECATED_ENUMERATOR
+#define GOBJECT_DEPRECATED_ENUMERATOR_IN_2_90_FOR(f) GLIB_DEPRECATED_ENUMERATOR_FOR (f)
+#define GOBJECT_DEPRECATED_TYPE_IN_2_90 GLIB_DEPRECATED_TYPE
+#define GOBJECT_DEPRECATED_TYPE_IN_2_90_FOR(f) GLIB_DEPRECATED_TYPE_FOR (f)
+#else
+#define GOBJECT_DEPRECATED_IN_2_90 _GOBJECT_EXTERN
+#define GOBJECT_DEPRECATED_IN_2_90_FOR(f) _GOBJECT_EXTERN
+#define GOBJECT_DEPRECATED_MACRO_IN_2_90
+#define GOBJECT_DEPRECATED_MACRO_IN_2_90_FOR(f)
+#define GOBJECT_DEPRECATED_ENUMERATOR_IN_2_90
+#define GOBJECT_DEPRECATED_ENUMERATOR_IN_2_90_FOR(f)
+#define GOBJECT_DEPRECATED_TYPE_IN_2_90
+#define GOBJECT_DEPRECATED_TYPE_IN_2_90_FOR(f)
+#endif
+
+#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_90
+#define GOBJECT_AVAILABLE_IN_2_90 GOBJECT_UNAVAILABLE (2, 90)
+#define GOBJECT_AVAILABLE_STATIC_INLINE_IN_2_90 GLIB_UNAVAILABLE_STATIC_INLINE (2, 90)
+#define GOBJECT_AVAILABLE_MACRO_IN_2_90 GLIB_UNAVAILABLE_MACRO (2, 90)
+#define GOBJECT_AVAILABLE_ENUMERATOR_IN_2_90 GLIB_UNAVAILABLE_ENUMERATOR (2, 90)
+#define GOBJECT_AVAILABLE_TYPE_IN_2_90 GLIB_UNAVAILABLE_TYPE (2, 90)
+#else
+#define GOBJECT_AVAILABLE_IN_2_90 _GOBJECT_EXTERN
+#define GOBJECT_AVAILABLE_STATIC_INLINE_IN_2_90
+#define GOBJECT_AVAILABLE_MACRO_IN_2_90
+#define GOBJECT_AVAILABLE_ENUMERATOR_IN_2_90
+#define GOBJECT_AVAILABLE_TYPE_IN_2_90
+#endif

package/include/glib-2.0/gobject/gobject.h

@@ -356,7 +356,7 @@ struct  _GObjectClass
   /*< private >*/
   gsize		flags;
 
-  gsize         n_construct_properties;
+  gsize         n_construct_properties;  /* functionally this is limited to UINT_MAX */
 
   gpointer pspecs;
   gsize n_pspecs;

package/include/glib-2.0/gobject/gparam.h

@@ -169,7 +169,7 @@ typedef enum
   G_PARAM_EXPLICIT_NOTIFY     = 1 << 30,
   /* Avoid warning with -Wpedantic for gcc6 */
   G_PARAM_DEPRECATED          = (gint)(1u << 31)
-} GParamFlags;
+} G_GNUC_FLAG_ENUM GParamFlags;
 
 /**
  * G_PARAM_STATIC_STRINGS:

package/include/glib-2.0/gobject/gsignal.h

@@ -109,16 +109,16 @@ typedef gboolean (*GSignalAccumulator)	(GSignalInvocationHint *ihint,
 /* --- run, match and connect types --- */
 /**
  * GSignalFlags:
- * @G_SIGNAL_RUN_FIRST: Invoke the object method handler in the first emission stage.
- * @G_SIGNAL_RUN_LAST: Invoke the object method handler in the third emission stage.
- * @G_SIGNAL_RUN_CLEANUP: Invoke the object method handler in the last emission stage.
+ * @G_SIGNAL_RUN_FIRST: Invoke the default signal handler in the first emission stage
+ * @G_SIGNAL_RUN_LAST: Invoke the default signal handler in the third emission stage
+ * @G_SIGNAL_RUN_CLEANUP: Invoke the default signal handler in the last emission stage
  * @G_SIGNAL_NO_RECURSE: Signals being emitted for an object while currently being in
  *  emission for this very object will not be emitted recursively,
  *  but instead cause the first emission to be restarted.
- * @G_SIGNAL_DETAILED: This signal supports "::detail" appendices to the signal name
+ * @G_SIGNAL_DETAILED: This signal supports `::detail` appendices to the signal name
  *  upon handler connections and emissions.
  * @G_SIGNAL_ACTION: Action signals are signals that may freely be emitted on alive
- *  objects from user code via g_signal_emit() and friends, without
+ *  objects from user code via [func@GObject.signal_emit] and friends, without
  *  the need of being embedded into extra code that performs pre or
  *  post emission adjustments on the object. They can also be thought
  *  of as object methods which can be called generically by 
@@ -140,7 +140,7 @@ typedef enum
   G_SIGNAL_DEPRECATED   = 1 << 8,
   /* normal signal flags until 1 << 16 */
   G_SIGNAL_ACCUMULATOR_FIRST_RUN    = 1 << 17,
-} GSignalFlags;
+} G_GNUC_FLAG_ENUM GSignalFlags;
 
 /**
  * G_SIGNAL_MUST_COLLECT:
@@ -197,7 +197,7 @@ typedef enum
   G_CONNECT_DEFAULT GOBJECT_AVAILABLE_ENUMERATOR_IN_2_74 = 0,
   G_CONNECT_AFTER	= 1 << 0,
   G_CONNECT_SWAPPED	= 1 << 1
-} GConnectFlags;
+} G_GNUC_FLAG_ENUM GConnectFlags;
 /**
  * GSignalMatchType:
  * @G_SIGNAL_MATCH_ID: The signal id must be equal.
@@ -219,7 +219,7 @@ typedef enum
   G_SIGNAL_MATCH_FUNC	   = 1 << 3,
   G_SIGNAL_MATCH_DATA	   = 1 << 4,
   G_SIGNAL_MATCH_UNBLOCKED = 1 << 5
-} GSignalMatchType;
+} G_GNUC_FLAG_ENUM GSignalMatchType;
 /**
  * G_SIGNAL_MATCH_MASK:
  * 

package/include/glib-2.0/gobject/gtype.h

@@ -728,7 +728,7 @@ typedef enum	/*< skip >*/
   G_TYPE_DEBUG_SIGNALS	= 1 << 1,
   G_TYPE_DEBUG_INSTANCE_COUNT = 1 << 2,
   G_TYPE_DEBUG_MASK	= 0x07
-} GTypeDebugFlags GOBJECT_DEPRECATED_TYPE_IN_2_36;
+} G_GNUC_FLAG_ENUM GTypeDebugFlags GOBJECT_DEPRECATED_TYPE_IN_2_36;
 
 
 /* --- prototypes --- */
@@ -1067,7 +1067,7 @@ typedef enum    /*< skip >*/
   G_TYPE_FLAG_INSTANTIATABLE    = (1 << 1),
   G_TYPE_FLAG_DERIVABLE         = (1 << 2),
   G_TYPE_FLAG_DEEP_DERIVABLE    = (1 << 3)
-} GTypeFundamentalFlags;
+} G_GNUC_FLAG_ENUM GTypeFundamentalFlags;
 /**
  * GTypeFlags:
  * @G_TYPE_FLAG_NONE: No special flags. Since: 2.74
@@ -1091,7 +1091,7 @@ typedef enum    /*< skip >*/
   G_TYPE_FLAG_VALUE_ABSTRACT = (1 << 5),
   G_TYPE_FLAG_FINAL GOBJECT_AVAILABLE_ENUMERATOR_IN_2_70 = (1 << 6),
   G_TYPE_FLAG_DEPRECATED GOBJECT_AVAILABLE_ENUMERATOR_IN_2_76 = (1 << 7)
-} GTypeFlags;
+} G_GNUC_FLAG_ENUM GTypeFlags;
 /**
  * GTypeInfo:
  * @class_size: Size of the class structure (required for interface, classed and instantiatable types)
@@ -1574,7 +1574,7 @@ guint     g_type_get_type_registration_serial (void);
  * - the usual `my_app_window_get_type()` function is declared with a return type of #GType
  *
  * - the `MyAppWindow` type is defined as a `typedef` of `struct _MyAppWindow`.  The struct itself is not
- *   defined and should be defined from the .c file before G_DEFINE_TYPE() is used.
+ *   defined and should be defined from the `.c` file before `G_DEFINE_TYPE()` is used.
  *
  * - the `MY_APP_WINDOW()` cast is emitted as `static inline` function along with the `MY_APP_IS_WINDOW()` type
  *   checking function
@@ -1585,9 +1585,9 @@ guint     g_type_get_type_registration_serial (void);
  *   and therefore the fact that the size of the class structure is exposed is not a concern and it can be
  *   freely changed at any point in the future.
  *
- * - g_autoptr() support being added for your type, based on the type of your parent class
+ * - `g_autoptr()` support being added for your type, based on the type of your parent class
  *
- * You can only use this function if your parent type also supports g_autoptr().
+ * You can only use this function if your parent type also supports `g_autoptr()`.
  *
  * Because the type macro (`MY_APP_TYPE_WINDOW` in the above example) is not a callable, you must continue to
  * manually define this as a macro for yourself.
@@ -1595,11 +1595,11 @@ guint     g_type_get_type_registration_serial (void);
  * The declaration of the `_get_type()` function is the first thing emitted by the macro.  This allows this macro
  * to be used in the usual way with export control and API versioning macros.
  *
- * If you want to declare your own class structure, use G_DECLARE_DERIVABLE_TYPE().
+ * If you want to declare your own class structure, use [func@GObject.DECLARE_DERIVABLE_TYPE].
  *
  * If you are writing a library, it is important to note that it is possible to convert a type from using
- * G_DECLARE_FINAL_TYPE() to G_DECLARE_DERIVABLE_TYPE() without breaking API or ABI.  As a precaution, you
- * should therefore use G_DECLARE_FINAL_TYPE() until you are sure that it makes sense for your class to be
+ * `G_DECLARE_FINAL_TYPE()` to `G_DECLARE_DERIVABLE_TYPE()` without breaking API or ABI.  As a precaution, you
+ * should therefore use `G_DECLARE_FINAL_TYPE()` until you are sure that it makes sense for your class to be
  * subclassed.  Once a class structure has been exposed it is not possible to change its size or remove or
  * reorder items without breaking the API and/or ABI.
  *
@@ -1687,7 +1687,7 @@ guint     g_type_get_type_registration_serial (void);
  *
  * - g_autoptr() support being added for your type, based on the type of your parent class
  *
- * You can only use this function if your parent type also supports g_autoptr().
+ * You can only use this function if your parent type also supports `g_autoptr()`.
  *
  * Because the type macro (`GTK_TYPE_FROBBER` in the above example) is not a callable, you must continue to
  * manually define this as a macro for yourself.
@@ -1696,14 +1696,14 @@ guint     g_type_get_type_registration_serial (void);
  * to be used in the usual way with export control and API versioning macros.
  *
  * If you are writing a library, it is important to note that it is possible to convert a type from using
- * G_DECLARE_FINAL_TYPE() to G_DECLARE_DERIVABLE_TYPE() without breaking API or ABI.  As a precaution, you
- * should therefore use G_DECLARE_FINAL_TYPE() until you are sure that it makes sense for your class to be
+ * [func@GObject.DECLARE_FINAL_TYPE] to `G_DECLARE_DERIVABLE_TYPE()` without breaking API or ABI.  As a precaution, you
+ * should therefore use `G_DECLARE_FINAL_TYPE()` until you are sure that it makes sense for your class to be
  * subclassed.  Once a class structure has been exposed it is not possible to change its size or remove or
  * reorder items without breaking the API and/or ABI.  If you want to declare your own class structure, use
- * G_DECLARE_DERIVABLE_TYPE().  If you want to declare a class without exposing the class or instance
- * structures, use G_DECLARE_FINAL_TYPE().
+ * `G_DECLARE_DERIVABLE_TYPE()`.  If you want to declare a class without exposing the class or instance
+ * structures, use `G_DECLARE_FINAL_TYPE()`.
  *
- * If you must use G_DECLARE_DERIVABLE_TYPE() you should be sure to include some padding at the bottom of your
+ * If you must use `G_DECLARE_DERIVABLE_TYPE()` you should be sure to include some padding at the bottom of your
  * class structure to leave space for the addition of future virtual functions.
  *
  * Since: 2.44
@@ -1931,9 +1931,9 @@ guint     g_type_get_type_registration_serial (void);
  *
  * A convenience macro for type implementations.
  *
- * Similar to G_DEFINE_TYPE(), but defines a final type.
+ * Similar to [func@GObject.DEFINE_TYPE], but defines a final type.
  *
- * See G_DEFINE_TYPE_EXTENDED() for an example.
+ * See [func@GObject.DEFINE_TYPE_EXTENDED] for an example.
  *
  * Since: 2.70
  */

package/include/hwy/aligned_allocator.h

@@ -119,8 +119,21 @@ template <typename T, typename... Args>
 AlignedUniquePtr<T> MakeUniqueAlignedWithAlloc(AllocPtr alloc, FreePtr free,
                                                void* opaque, Args&&... args) {
   T* ptr = static_cast<T*>(AllocateAlignedBytes(sizeof(T), alloc, opaque));
+  if (HWY_UNLIKELY(ptr == nullptr)) {
+    return AlignedUniquePtr<T>(nullptr, AlignedDeleter(free, opaque));
+  }
+#ifdef HWY_EXCEPTIONS_ENABLED
+  try {
+    return AlignedUniquePtr<T>(new (ptr) T(std::forward<Args>(args)...),
+                               AlignedDeleter(free, opaque));
+  } catch (...) {
+    FreeAlignedBytes(ptr, free, opaque);
+    throw;
+  }
+#else
   return AlignedUniquePtr<T>(new (ptr) T(std::forward<Args>(args)...),
                              AlignedDeleter(free, opaque));
+#endif
 }
 
 // Similar to MakeUniqueAlignedWithAlloc but using the default alloc/free
@@ -128,8 +141,21 @@ AlignedUniquePtr<T> MakeUniqueAlignedWithAlloc(AllocPtr alloc, FreePtr free,
 template <typename T, typename... Args>
 AlignedUniquePtr<T> MakeUniqueAligned(Args&&... args) {
   T* ptr = static_cast<T*>(AllocateAlignedBytes(sizeof(T)));
+  if (HWY_UNLIKELY(ptr == nullptr)) {
+    return AlignedUniquePtr<T>(nullptr, AlignedDeleter());
+  }
+#ifdef HWY_EXCEPTIONS_ENABLED
+  try {
+    return AlignedUniquePtr<T>(new (ptr) T(std::forward<Args>(args)...),
+                               AlignedDeleter());
+  } catch (...) {
+    FreeAlignedBytes(ptr, nullptr, nullptr);
+    throw;
+  }
+#else
   return AlignedUniquePtr<T>(new (ptr) T(std::forward<Args>(args)...),
                              AlignedDeleter());
+#endif
 }
 
 template <class T>
@@ -147,8 +173,13 @@ struct AlignedAllocator {
                   "AlignedAllocator only supports integer types");
     static_assert(sizeof(V) <= sizeof(std::size_t),
                   "V n must be smaller or equal size_t to avoid overflow");
+    const size_t count = static_cast<std::size_t>(n);
+    if (HWY_LIKELY(count != 0) && sizeof(value_type) > SIZE_MAX / count) {
+      HWY_ABORT("AlignedAllocator: allocation size overflow "
+                 "(%zu * %zu exceeds size_t)", count, sizeof(value_type));
+    }
     return static_cast<value_type*>(
-        AllocateAlignedBytes(static_cast<std::size_t>(n) * sizeof(value_type)));
+        AllocateAlignedBytes(count * sizeof(value_type)));
   }
 
   template <class V>
@@ -208,7 +239,7 @@ AlignedUniquePtr<T[]> MakeUniqueAlignedArrayWithAlloc(
   T* ptr = detail::AllocateAlignedItems<T>(items, alloc, opaque);
   if (ptr != nullptr) {
     for (size_t i = 0; i < items; i++) {
-      new (ptr + i) T(std::forward<Args>(args)...);
+      new (ptr + i) T(args...);
     }
   }
   return AlignedUniquePtr<T[]>(ptr, AlignedDeleter(free, opaque));
@@ -399,6 +430,10 @@ class AlignedNDArray {
     size_t offset = 0;
     size_t shape_index = 0;
     for (const size_t axis_index : indices) {
+      if (HWY_UNLIKELY(axis_index >= shape_[shape_index])) {
+        HWY_ABORT("AlignedNDArray index %zu out of bounds (axis %zu, size %zu)",
+                   axis_index, shape_index, shape_[shape_index]);
+      }
       offset += memory_sizes_[shape_index + 1] * axis_index;
       shape_index++;
     }
@@ -417,6 +452,13 @@ class AlignedNDArray {
     sizes[axis] = 1;
     while (axis > 0) {
       --axis;
+      // Check for integer overflow in dimension multiplication.
+      if (HWY_LIKELY(shape[axis] != 0) &&
+          sizes[axis + 1] > SIZE_MAX / shape[axis]) {
+        HWY_ABORT("AlignedNDArray: dimension overflow at axis %zu "
+                   "(%zu * %zu exceeds size_t)",
+                   axis, sizes[axis + 1], shape[axis]);
+      }
       sizes[axis] = sizes[axis + 1] * shape[axis];
     }
     return sizes;

package/include/hwy/auto_tune.h

@@ -25,7 +25,18 @@
 
 #include "hwy/aligned_allocator.h"  // Span
 #include "hwy/base.h"               // HWY_MIN
-#include "hwy/contrib/sort/vqsort.h"
+
+// configuration to allow auto_tune to use std::sort instead of VQSort
+// (also enabled in header only mode).
+#if defined(HWY_HEADER_ONLY)
+#define HWY_AUTOTUNE_STDSORT
+#endif
+
+#ifdef HWY_AUTOTUNE_STDSORT
+#include <algorithm>  // std::sort
+#else
+#include "hwy/contrib/sort/vqsort.h"  // VQSort
+#endif
 
 // Infrastructure for auto-tuning (choosing optimal parameters at runtime).
 
@@ -104,6 +115,10 @@ class CostDistribution {
  private:
   static double Median(double* to_sort, size_t n) {
     HWY_DASSERT(n >= 2);
+
+#ifdef HWY_AUTOTUNE_STDSORT
+    std::sort(to_sort, to_sort + n);
+#else
 // F64 is supported everywhere except Armv7.
 #if !HWY_ARCH_ARM_V7
     VQSort(to_sort, n, SortAscending());
@@ -112,6 +127,8 @@ class CostDistribution {
     // equivalent.
     VQSort(reinterpret_cast<uint64_t*>(to_sort), n, SortAscending());
 #endif
+#endif
+
     if (n & 1) return to_sort[n / 2];
     // Even length: average of two middle elements.
     return (to_sort[n / 2] + to_sort[n / 2 - 1]) * 0.5;
@@ -405,10 +422,9 @@ class AutoTune {
   const Config* Best() const { return best_; }
 
   // If false, caller must call `SetCandidates` before `NextConfig`.
-  bool HasCandidates() const {
-    HWY_DASSERT(!Best());
-    return !candidates_.empty();
-  }
+  // NOTE: also called after Best() is non-null.
+  bool HasCandidates() const { return !candidates_.empty(); }
+
   // WARNING: invalidates `Best()`, do not call if that is non-null.
   void SetCandidates(std::vector<Config> candidates) {
     HWY_DASSERT(!Best() && !HasCandidates());
@@ -429,7 +445,7 @@ class AutoTune {
 
   // Returns the current `Config` to measure.
   const Config& NextConfig() const {
-    HWY_DASSERT(!Best() && HasCandidates());
+    HWY_DASSERT(HasCandidates());
     return candidates_[config_idx_];
   }