@bluepic/embed 0.4.0-next.98 → 0.5.0

package/dist/c-B4BAHWS4.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function N(t){const n=t.regex,a=t.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),l="decltype\\(auto\\)",r="[a-zA-Z_]\\w*::",E="("+l+"|"+n.optional(r)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",f=n.concat(/\batomic_/,n.either("bool","char","schar","uchar","short","ushort","int","uint","long","ulong","llong","ullong","char16_t","char32_t","wchar_t","int_least8_t","uint_least8_t","int_least16_t","uint_least16_t","int_least32_t","uint_least32_t","int_least64_t","uint_least64_t","int_fast8_t","uint_fast8_t","int_fast16_t","uint_fast16_t","int_fast32_t","uint_fast32_t","int_fast64_t","uint_fast64_t","intptr_t","uintptr_t","size_t","ptrdiff_t","intmax_t","uintmax_t"),/\b/),i={className:"type",variants:[{begin:"\\b[a-z\\d_]*_t\\b"},{match:f}]},s={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[t.BACKSLASH_ESCAPE]},{begin:"(u8?|U|L)?'("+"\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)"+"|.)",end:"'",illegal:"."},t.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\\s"]{0,16})\(/,end:/\)([^()\\\s"]{0,16})"/})]},o={className:"number",variants:[{match:/\b(0b[01']+)/},{match:/(-?)\b([\d']+(\.[\d']*)?|\.[\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)/},{match:/(-?)\b(0[xX][a-fA-F0-9]+(?:'[a-fA-F0-9]+)*(?:\.[a-fA-F0-9]*(?:'[a-fA-F0-9]*)*)?(?:[pP][-+]?[0-9]+)?(l|L)?(u|U)?)/},{match:/(-?)\b\d+(?:'\d+)*(?:\.\d*(?:'\d*)*)?(?:[eE][-+]?\d+)?/}],relevance:0},m={scope:"meta",begin:/#\s*include\b/,end:/$/,keywords:{keyword:"include"},contains:[{begin:/\\\n/},s,{scope:"string",begin:/<.*?>/},a,t.C_BLOCK_COMMENT_MODE]},u={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef elifdef elifndef include"},contains:[{begin:/\\\n/,relevance:0},t.inherit(s,{className:"string"}),a,t.C_BLOCK_COMMENT_MODE]},c=[m,u],g={className:"title",begin:n.optional(r)+t.IDENT_RE,relevance:0},d=n.optional(r)+t.IDENT_RE+"\\s*\\(",p=12,e={keyword:["asm","auto","break","case","continue","default","do","else","enum","extern","for","fortran","goto","if","inline","register","restrict","return","sizeof","typeof","typeof_unqual","struct","switch","typedef","union","volatile","while","_Alignas","_Alignof","_Atomic","_Generic","_Noreturn","_Static_assert","_Thread_local","alignas","alignof","noreturn","static_assert","thread_local","_Pragma"],type:["float","double","signed","unsigned","int","short","long","char","void","_Bool","_BitInt","_Complex","_Imaginary","_Decimal32","_Decimal64","_Decimal96","_Decimal128","_Decimal64x","_Decimal128x","_Float16","_Float32","_Float64","_Float128","_Float32x","_Float64x","_Float128x","const","static","constexpr","complex","bool","imaginary"],literal:"true false NULL",built_in:"std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr"},_=[...c,i,a,t.C_BLOCK_COMMENT_MODE,o,s],b={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:e,contains:_.concat([{begin:/\(/,end:/\)/,keywords:e,contains:_.concat(["self"]),relevance:0}]),relevance:0},C={begin:"("+E+"[\\*&\\s]+){1,"+p+"}"+d,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:e,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:l,keywords:e,relevance:0},{begin:d,returnBegin:!0,contains:[t.inherit(g,{className:"title.function"})],relevance:0},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:e,relevance:0,contains:[a,t.C_BLOCK_COMMENT_MODE,s,o,i,{begin:/\(/,end:/\)/,keywords:e,relevance:0,contains:["self",a,t.C_BLOCK_COMMENT_MODE,s,o,i]}]},i,a,t.C_BLOCK_COMMENT_MODE,...c]};return{name:"C",aliases:["h"],keywords:e,disableAutodetect:!0,illegal:"</",contains:[].concat(b,C,_,[...c,{begin:t.IDENT_RE+"::",keywords:e},{className:"class",beginKeywords:"enum class struct union",end:/[{;:<>=]/,contains:[{beginKeywords:"final class struct"},t.TITLE_MODE]}]),exports:{preprocessor:u,strings:s,keywords:e}}}exports.default=N;

package/dist/{c-Bz1-FJiA.js → c-C0DTNf68.js}

@@ -1,30 +1,72 @@
-function C(e) {
-  const s = e.regex, n = e.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }), _ = "decltype\\(auto\\)", o = "[a-zA-Z_]\\w*::", u = "(" + _ + "|" + s.optional(o) + "[a-zA-Z_]\\w*" + s.optional("<[^<>]+>") + ")", r = {
+function S(t) {
+  const n = t.regex, a = t.COMMENT("//", "$", { contains: [{ begin: /\\\n/ }] }), l = "decltype\\(auto\\)", r = "[a-zA-Z_]\\w*::", E = "(" + l + "|" + n.optional(r) + "[a-zA-Z_]\\w*" + n.optional("<[^<>]+>") + ")", f = n.concat(/\batomic_/, n.either(
+    "bool",
+    "char",
+    "schar",
+    "uchar",
+    "short",
+    "ushort",
+    "int",
+    "uint",
+    "long",
+    "ulong",
+    "llong",
+    "ullong",
+    "char16_t",
+    "char32_t",
+    "wchar_t",
+    "int_least8_t",
+    "uint_least8_t",
+    "int_least16_t",
+    "uint_least16_t",
+    "int_least32_t",
+    "uint_least32_t",
+    "int_least64_t",
+    "uint_least64_t",
+    "int_fast8_t",
+    "uint_fast8_t",
+    "int_fast16_t",
+    "uint_fast16_t",
+    "int_fast32_t",
+    "uint_fast32_t",
+    "int_fast64_t",
+    "uint_fast64_t",
+    "intptr_t",
+    "uintptr_t",
+    "size_t",
+    "ptrdiff_t",
+    "intmax_t",
+    "uintmax_t"
+  ), /\b/), i = {
     className: "type",
     variants: [
       { begin: "\\b[a-z\\d_]*_t\\b" },
-      { match: /\batomic_[a-z]{3,6}\b/ }
+      { match: f }
     ]
-  }, a = {
+  }, s = {
     className: "string",
     variants: [
       {
         begin: '(u8?|U|L)?"',
         end: '"',
         illegal: "\\n",
-        contains: [e.BACKSLASH_ESCAPE]
+        contains: [t.BACKSLASH_ESCAPE]
       },
       {
         begin: "(u8?|U|L)?'(" + "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)" + "|.)",
         end: "'",
         illegal: "."
       },
-      e.END_SAME_AS_BEGIN({
-        begin: /(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,
-        end: /\)([^()\\ ]{0,16})"/
+      // https://en.cppreference.com/w/cpp/language/string_literal
+      // a d-char-sequence never contains parentheses, backslashes or whitespace;
+      // quotes are excluded as well so the closing delimiter cannot swallow the
+      // quote that actually terminates the literal
+      t.END_SAME_AS_BEGIN({
+        begin: /(?:u8?|U|L)?R"([^()\\\s"]{0,16})\(/,
+        end: /\)([^()\\\s"]{0,16})"/
       })
     ]
-  }, c = {
+  }, o = {
     className: "number",
     variants: [
       { match: /\b(0b[01']+)/ },
@@ -33,7 +75,25 @@ function C(e) {
       { match: /(-?)\b\d+(?:'\d+)*(?:\.\d*(?:'\d*)*)?(?:[eE][-+]?\d+)?/ }
     ],
     relevance: 0
-  }, i = {
+  }, m = {
+    scope: "meta",
+    begin: /#\s*include\b/,
+    end: /$/,
+    keywords: { keyword: "include" },
+    contains: [
+      {
+        // the `\` at the end of a line signaling continuation
+        begin: /\\\n/
+      },
+      s,
+      {
+        scope: "string",
+        begin: /<.*?>/
+      },
+      a,
+      t.C_BLOCK_COMMENT_MODE
+    ]
+  }, u = {
     className: "meta",
     begin: /#\s*[a-z]+\b/,
     end: /$/,
@@ -43,19 +103,18 @@ function C(e) {
         begin: /\\\n/,
         relevance: 0
       },
-      e.inherit(a, { className: "string" }),
-      {
-        className: "string",
-        begin: /<.*?>/
-      },
-      n,
-      e.C_BLOCK_COMMENT_MODE
+      t.inherit(s, { className: "string" }),
+      a,
+      t.C_BLOCK_COMMENT_MODE
     ]
-  }, E = {
+  }, c = [
+    m,
+    u
+  ], p = {
     className: "title",
-    begin: s.optional(o) + e.IDENT_RE,
+    begin: n.optional(r) + t.IDENT_RE,
     relevance: 0
-  }, d = s.optional(o) + e.IDENT_RE + "\\s*\\(", t = {
+  }, d = n.optional(r) + t.IDENT_RE + "\\s*\\(", g = 12, e = {
     keyword: [
       "asm",
       "auto",
@@ -139,14 +198,14 @@ function C(e) {
     literal: "true false NULL",
     // TODO: apply hinting work similar to what was done in cpp.js
     built_in: "std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr"
-  }, l = [
+  }, _ = [
+    ...c,
     i,
-    r,
-    n,
-    e.C_BLOCK_COMMENT_MODE,
-    c,
-    a
-  ], m = {
+    a,
+    t.C_BLOCK_COMMENT_MODE,
+    o,
+    s
+  ], C = {
     // This mode covers expression context where we can't expect a function
     // definition and shouldn't highlight anything that looks like one:
     // `return some()`, `else if()`, `(x*sum(1, 2))`
@@ -164,35 +223,35 @@ function C(e) {
         end: /;/
       }
     ],
-    keywords: t,
-    contains: l.concat([
+    keywords: e,
+    contains: _.concat([
       {
         begin: /\(/,
         end: /\)/,
-        keywords: t,
-        contains: l.concat(["self"]),
+        keywords: e,
+        contains: _.concat(["self"]),
         relevance: 0
       }
     ]),
     relevance: 0
-  }, p = {
-    begin: "(" + u + "[\\*&\\s]+)+" + d,
+  }, b = {
+    begin: "(" + E + "[\\*&\\s]+){1," + g + "}" + d,
     returnBegin: !0,
     end: /[{;=]/,
     excludeEnd: !0,
-    keywords: t,
+    keywords: e,
     illegal: /[^\w\s\*&:<>.]/,
     contains: [
       {
         // to prevent it from being confused as the function title
-        begin: _,
-        keywords: t,
+        begin: l,
+        keywords: e,
         relevance: 0
       },
       {
         begin: d,
         returnBegin: !0,
-        contains: [e.inherit(E, { className: "title.function" })],
+        contains: [t.inherit(p, { className: "title.function" })],
         relevance: 0
       },
       // allow for multiple declarations, e.g.:
@@ -205,54 +264,54 @@ function C(e) {
         className: "params",
         begin: /\(/,
         end: /\)/,
-        keywords: t,
+        keywords: e,
         relevance: 0,
         contains: [
-          n,
-          e.C_BLOCK_COMMENT_MODE,
           a,
-          c,
-          r,
+          t.C_BLOCK_COMMENT_MODE,
+          s,
+          o,
+          i,
           // Count matching parentheses.
           {
             begin: /\(/,
             end: /\)/,
-            keywords: t,
+            keywords: e,
             relevance: 0,
             contains: [
               "self",
-              n,
-              e.C_BLOCK_COMMENT_MODE,
               a,
-              c,
-              r
+              t.C_BLOCK_COMMENT_MODE,
+              s,
+              o,
+              i
             ]
           }
         ]
       },
-      r,
-      n,
-      e.C_BLOCK_COMMENT_MODE,
-      i
+      i,
+      a,
+      t.C_BLOCK_COMMENT_MODE,
+      ...c
     ]
   };
   return {
     name: "C",
     aliases: ["h"],
-    keywords: t,
+    keywords: e,
     // Until differentiations are added between `c` and `cpp`, `c` will
     // not be auto-detected to avoid auto-detect conflicts between C and C++
     disableAutodetect: !0,
     illegal: "</",
     contains: [].concat(
-      m,
-      p,
-      l,
+      C,
+      b,
+      _,
       [
-        i,
+        ...c,
         {
-          begin: e.IDENT_RE + "::",
-          keywords: t
+          begin: t.IDENT_RE + "::",
+          keywords: e
         },
         {
           className: "class",
@@ -260,18 +319,18 @@ function C(e) {
           end: /[{;:<>=]/,
           contains: [
             { beginKeywords: "final class struct" },
-            e.TITLE_MODE
+            t.TITLE_MODE
           ]
         }
       ]
     ),
     exports: {
-      preprocessor: i,
-      strings: a,
-      keywords: t
+      preprocessor: u,
+      strings: s,
+      keywords: e
     }
   };
 }
 export {
-  C as default
+  S as default
 };

package/dist/components/AssetViewer/AssetViewer.vue.d.ts

@@ -0,0 +1,71 @@
+import { type AssetAuth } from '../../util/assetAuth';
+/**
+ * Brand Portal — the asset viewer.
+ *
+ * Renders inside the existing overlay API (usePopup / injectPortal), the same
+ * surface as the image cropper, rather than sending the visitor to a browser
+ * tab.
+ *
+ * Efficiency rules that are load-bearing, not polish:
+ *  - page rendering is INJECTED by the host (`renderPage`) rather than importing
+ *    @bluepic/raster here. Embed ships a UMD build, and raster's root entry
+ *    carries CommonJS interop that Rollup cannot express in UMD (it emits an
+ *    invalid `var main.commonjsGlobal`). Injection also keeps the heavy engines
+ *    out of embed entirely — the host loads them only if it has documents.
+ *    Without a `renderPage`, paged types degrade to the download-only panel;
+ *  - one page is rendered at a time, at a DPR clamped to 2;
+ *  - at most PAGE_CACHE_LIMIT rendered pages are retained, so a 400-page PDF
+ *    cannot hold 400 canvases;
+ *  - in-flight work is abandoned on close/page-change — an orphaned
+ *    Ghostscript-WASM job otherwise keeps a phone warm long after the user left.
+ */
+export type ViewerAsset = {
+    id: string;
+    title: string;
+    filename: string;
+    mime: string;
+    size: number;
+    kind: 'image' | 'file';
+    previewUrl: string | null;
+    description?: string | null;
+    width?: number;
+    height?: number;
+    pageCount?: number;
+    /** Gated URL. Used both to fetch bytes for rasterization and to display media. */
+    downloadUrl: string;
+    /**
+     * A paginated, browser-renderable form: the file for a PDF, the server-made
+     * PDF derivative for Office/ODF. Its presence is what turns a .docx into
+     * something with pages instead of a download button.
+     */
+    documentUrl?: string;
+};
+type __VLS_Props = {
+    asset: ViewerAsset;
+    /**
+     * Render one page of a document into the supplied canvas. Supplied by the
+     * host (bx-template passes @bluepic/raster). Absent → no paged preview.
+     */
+    renderPage?: (bytes: ArrayBuffer, canvas: HTMLCanvasElement, opts: {
+        page: number;
+        dpi: number;
+    }) => Promise<void>;
+    /** Page count for a paged document, when the host can determine it. */
+    getPageCount?: (bytes: ArrayBuffer) => Promise<number>;
+    /**
+     * Proof of access for a PROTECTED campaign — the password it was unlocked
+     * with and/or the signed-in visitor's access token. Every `fetch()` here
+     * sends it as headers; the media elements, which cannot, get it as query
+     * parameters (see `util/assetAuth`). Absent for a public campaign, which
+     * leaves every request exactly as it was.
+     */
+    assetAuth?: AssetAuth | null;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+    download: (asset: ViewerAsset) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onDownload?: ((asset: ViewerAsset) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/BxAudioPlayButton.vue.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The round play/pause control that sits in the middle of an audio card, with
+ * its own progress ring.
+ *
+ * Lives in the embed so the studio library and the portal show the SAME control
+ * — the two surfaces render audio assets side by side in a user's mind, and a
+ * different affordance in each is how they drift apart.
+ */
+type __VLS_Props = {
+    playing?: boolean;
+    loading?: boolean;
+    /** 0–1. */
+    progress?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    toggle: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggle?: (() => any) | undefined;
+}>, {
+    progress: number;
+    playing: boolean;
+    loading: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/BxCard.vue.d.ts

@@ -9,6 +9,38 @@ type __VLS_Props = {
     coverWidth?: string;
     hoverable?: boolean;
     dividers?: boolean;
+    /**
+     * Corner rounding. `none` is for cards that tile edge to edge, where a
+     * radius reads as a gap that is not there.
+     */
+    radius?: 'none' | 'sm' | 'md' | 'lg';
+    /**
+     * Stack the content slot with a gap. Without it the content is a plain
+     * block, which is why almost every caller re-declared
+     * `display:flex; flex-direction:column; gap:…` and, from there, went on to
+     * hand-roll the whole card.
+     */
+    contentGap?: 'none' | 'sm' | 'md' | 'lg';
+    /**
+     * Let the CONTENT scroll inside the card.
+     *
+     * The wrapper sits OUTSIDE the padding and the content carries it instead,
+     * so the scrollbar rail runs along the card's edge rather than floating in
+     * the middle of a 15px gutter — and the first line of content is not
+     * clipped against the top of the scrollport when it moves.
+     *
+     * Every caller that tried this from outside got it wrong the same way: a
+     * `max-height` on a `bx-scrollbar` is inert, because the scrollbar is
+     * `height: 100%` and the percentage resolves against an auto-height parent.
+     * Here the card gives it a definite height to fill.
+     */
+    scrollable?: boolean;
+    /**
+     * The cap the content scrolls within — any CSS length. Without one the card
+     * grows to its content and nothing scrolls, which is the right behaviour
+     * for a card that fits.
+     */
+    maxContentHeight?: string;
     state?: 'default' | 'success' | 'warning' | 'error' | 'info';
 };
 type __VLS_Slots = {
@@ -27,6 +59,9 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}
     bordered: boolean;
     hoverable: boolean;
     dividers: boolean;
+    radius: "none" | "sm" | "md" | "lg";
+    contentGap: "none" | "sm" | "md" | "lg";
+    scrollable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/BxInput.vue.d.ts

@@ -27,7 +27,13 @@ type __VLS_Props = {
         noStyleLabel: Localized<string>;
         mixedStyleLabel: Localized<string>;
     };
+    /**
+     * Explicit CSS max-height for the (textarea/richtext) input. When omitted, a
+     * textarea auto-grows up to `maxRows` lines.
+     */
     maxHeight?: string;
+    /** Maximum number of visible lines a `textarea` grows to before it scrolls. */
+    maxRows?: number;
     minHeight?: string;
     readonly?: boolean;
     readonlyMessage?: string;
@@ -77,7 +83,7 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps,
     ring: boolean;
     clearable: boolean;
     resizeable: boolean;
-    maxHeight: string;
+    maxRows: number;
     readonly: boolean;
     readonlyMessage: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/BxList.vue.d.ts

@@ -1,12 +1,21 @@
 import { VNode } from 'vue';
 type __VLS_Props = {
     divider?: boolean;
+    /** Outer border and rounding, so a list can stand on its own surface. */
+    bordered?: boolean;
+    /**
+     * `plain` is a run of rows. `card` gives every row its own surface with a
+     * gap between them, for lists whose items are objects rather than lines.
+     */
+    variant?: 'plain' | 'card';
 };
 type __VLS_Slots = {
     default: () => VNode[] | VNode;
 };
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    bordered: boolean;
     divider: boolean;
+    variant: "plain" | "card";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/BxListItem.vue.d.ts

@@ -1,10 +1,22 @@
 import { VNode } from 'vue';
+type __VLS_Props = {
+    /**
+     * Whether clicking the row does something. Rows used to get a pointer
+     * cursor and a hover background unconditionally, which is why static lists
+     * were hand-rolled as <ul>s instead: a row that looks clickable and is not
+     * is worse than no component. Defaults to `true` so no existing list
+     * changes.
+     */
+    interactive?: boolean;
+};
 type __VLS_Slots = {
     default: () => VNode[] | VNode;
     prefix?: () => VNode[] | VNode;
     suffix?: () => VNode[] | VNode;
 };
-declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    interactive: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/components/BxPopover.vue.d.ts

@@ -19,6 +19,12 @@ type __VLS_Props = {
     role?: string;
     killExistingRoleEntriesOnHoverShow?: boolean;
     maxPopoverHeight?: number;
+    /**
+     * Override the scroll pass-through decision. Defaults to "on whenever there
+     * is no darkened background", which is what makes a non-modal popover stop
+     * freezing the page behind it.
+     */
+    scrollPassthrough?: boolean;
 };
 type __VLS_Slots = {
     trigger: () => VNode[] | VNode;
@@ -39,6 +45,7 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
     allowedPlacements: Placement[];
     arrow: boolean;
     overflowVisible: boolean;
+    scrollPassthrough: boolean;
     leaveLazyness: number;
     closeOnClickOutside: boolean;
     showLeazyness: number;

package/dist/components/BxPreviewLayer.vue.d.ts

@@ -0,0 +1,18 @@
+import { type AssetProxyConfig } from '../util/assetProxy';
+type __VLS_Props = {
+    /** The template's own committed preview (Cloudflare Images) — generic, shared by every viewer. */
+    basePreview?: string | null;
+    /**
+     * An individually pre-populated render (e.g. an `image.bluepic.io
+     * ?role=preview` URL). Pass this ONLY when prepopulation actually applies
+     * to what's being shown — omit it and this behaves like a plain
+     * single-image skeleton over `basePreview`.
+     */
+    personalizedSrc?: string | null;
+    assetProxy?: AssetProxyConfig;
+    alt?: string;
+    /** Width hint for `optimizePreviewUrl` on the base layer. */
+    baseWidth?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/BxScrollbar.vue.d.ts

@@ -5,6 +5,12 @@ type __VLS_Props = {
     scrollDelay?: number;
     /** Delay in ms before the scrollbar fades out after mouse leaves */
     leaveDelay?: number;
+    /**
+     * Briefly reveal the rail the first time the content turns out to be
+     * scrollable. The rails are otherwise hover/scroll-only, which on a touch
+     * screen means a clipped list gives no cue at all that there is more.
+     */
+    hintScrollable?: boolean;
 };
 declare var __VLS_1: {};
 type __VLS_Slots = {} & {
@@ -18,6 +24,7 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
     xScrollable: boolean;
     scrollDelay: number;
     leaveDelay: number;
+    hintScrollable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/components/BxSelect.vue.d.ts

@@ -14,8 +14,22 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: T) => any) | undefined;
         readonly "onUpdate:show"?: ((value: boolean) => any) | undefined;
-    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:show"> & ({
+        readonly "onUpdate:values"?: ((values: T[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onUpdate:show" | "onUpdate:values"> & ({
         modelValue?: T;
+        /**
+         * Multi-select: options toggle, the menu stays open, and the selection is
+         * carried by `values` (`v-model:values`) rather than `modelValue`.
+         *
+         * The selection deliberately lives in its OWN prop instead of overloading
+         * `modelValue` with `T | T[]`. Options may legitimately have array values
+         * (see StrokeDasharrayInput, where `T = number[]`), and a union there makes
+         * the generic ambiguous — it silently re-infers `T` and breaks unrelated
+         * callers. One extra prop is cheaper than that class of surprise.
+         */
+        multiple?: boolean;
+        /** Selected values when `multiple` is set. */
+        values?: T[];
         size?: "tiny" | "small" | "medium" | "large";
         trigger?: "click" | "hover" | "manual";
         options: BxSelectOption<T>[];
@@ -70,7 +84,7 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
             value?: T;
         }) => VNode[];
     };
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "update:show", value: boolean) => void);
+    emit: (((evt: "update:modelValue", value: T) => void) & ((evt: "update:values", values: T[]) => void)) & ((evt: "update:show", value: boolean) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };