@scalar/blocks 0.4.2 → 0.5.0

package/dist/schema/localization/translations.d.ts

@@ -0,0 +1,460 @@
+/** Built-in schema translations, also composed into API Reference's public dictionary. */
+export declare const schemaTranslations: {
+    en: {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+    de: {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+    es: {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+    fr: {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+    pt: {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+    ru: {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+    ar: {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+    'zh-CN': {
+        schema: {
+            noAllowedValues: string;
+            example: string;
+            examples: string;
+            default: string;
+            schema: string;
+            emptyObject: string;
+            showAdditionalProperties: string;
+            showOneMoreProperty: string;
+            showMoreProperties: string;
+            forName: string;
+            showSchemaDetails: string;
+            oneOf: string;
+            anyOf: string;
+            allOf: string;
+            not: string;
+            unknownType: string;
+            propertyCount: string;
+            headerCount: string;
+            recursiveReference: string;
+            recursive: string;
+            additionalProperties: string;
+            const: string;
+            deprecated: string;
+            discriminator: string;
+            enum: string;
+            format: string;
+            greaterThan: string;
+            keys: string;
+            lessThan: string;
+            max: string;
+            min: string;
+            maxLength: string;
+            minLength: string;
+            multipleOf: string;
+            nullable: string;
+            propertyNames: string;
+            pattern: string;
+            copyPattern: string;
+            readOnly: string;
+            required: string;
+            hideValues: string;
+            showAllValues: string;
+            type: string;
+            unique: string;
+            values: string;
+            writeOnly: string;
+        };
+        common: {
+            copyDefault: string;
+            copyExample: string;
+        };
+        actions: {
+            copyLinkTo: string;
+        };
+    };
+};
+//# sourceMappingURL=translations.d.ts.map

package/dist/schema/localization/translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/schema/localization/translations.ts"],"names":[],"mappings":"AASA,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgD,CAAA"}

package/dist/schema/localization/translations.js

@@ -0,0 +1,23 @@
+import { ar as e } from "./locales/ar.js";
+import { de as t } from "./locales/de.js";
+import { en as n } from "./locales/en.js";
+import { es as r } from "./locales/es.js";
+import { fr as i } from "./locales/fr.js";
+import { pt as a } from "./locales/pt.js";
+import { ru as o } from "./locales/ru.js";
+import { zhCn as s } from "./locales/zh-cn.js";
+//#region src/schema/localization/translations.ts
+var c = {
+	en: n,
+	de: t,
+	es: r,
+	fr: i,
+	pt: a,
+	ru: o,
+	ar: e,
+	"zh-CN": s
+};
+//#endregion
+export { c as schemaTranslations };
+
+//# sourceMappingURL=translations.js.map

package/dist/schema/localization/translations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.js","names":[],"sources":["../../../src/schema/localization/translations.ts"],"sourcesContent":["import { ar } from './locales/ar'\nimport { de } from './locales/de'\nimport { en } from './locales/en'\nimport { es } from './locales/es'\nimport { fr } from './locales/fr'\nimport { pt } from './locales/pt'\nimport { ru } from './locales/ru'\nimport { zhCn } from './locales/zh-cn'\n\n/** Built-in schema translations, also composed into API Reference's public dictionary. */\nexport const schemaTranslations = { en, de, es, fr, pt, ru, ar, 'zh-CN': zhCn }\n"],"mappings":";;;;;;;;;AAUA,IAAa,IAAqB;CAAE;CAAI;CAAI;CAAI;CAAI;CAAI;CAAI;CAAI,SAAS;AAAK"}

package/dist/schema/request-body-composition-index.d.ts

@@ -0,0 +1,8 @@
+import type { InjectionKey, Ref } from 'vue';
+export type RequestBodyCompositionSelection = Record<string, number>;
+/**
+ * Shares the selected request-body composition variants between the schema
+ * dropdowns and the generated request snippet for a single operation layout.
+ */
+export declare const REQUEST_BODY_COMPOSITION_INDEX_SYMBOL: InjectionKey<Ref<RequestBodyCompositionSelection>>;
+//# sourceMappingURL=request-body-composition-index.d.ts.map

package/dist/schema/request-body-composition-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body-composition-index.d.ts","sourceRoot":"","sources":["../../src/schema/request-body-composition-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE5C,MAAM,MAAM,+BAA+B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEpE;;;GAGG;AACH,eAAO,MAAM,qCAAqC,EAAE,YAAY,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAY,CAAA"}

package/dist/schema/request-body-composition-index.js

@@ -0,0 +1,6 @@
+//#region src/schema/request-body-composition-index.ts
+var e = Symbol();
+//#endregion
+export { e as REQUEST_BODY_COMPOSITION_INDEX_SYMBOL };
+
+//# sourceMappingURL=request-body-composition-index.js.map

package/dist/schema/request-body-composition-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-body-composition-index.js","names":[],"sources":["../../src/schema/request-body-composition-index.ts"],"sourcesContent":["import type { InjectionKey, Ref } from 'vue'\n\nexport type RequestBodyCompositionSelection = Record<string, number>\n\n/**\n * Shares the selected request-body composition variants between the schema\n * dropdowns and the generated request snippet for a single operation layout.\n */\nexport const REQUEST_BODY_COMPOSITION_INDEX_SYMBOL: InjectionKey<Ref<RequestBodyCompositionSelection>> = Symbol()\n"],"mappings":";AAQA,IAAa,IAA4F,OAAO"}

package/dist/schema/schema-tree.bench.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema-tree.bench.d.ts.map

package/dist/schema/schema-tree.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-tree.bench.d.ts","sourceRoot":"","sources":["../../src/schema/schema-tree.bench.ts"],"names":[],"mappings":""}

package/dist/schema/types.d.ts

@@ -0,0 +1,51 @@
+import type { ApiReferenceConfiguration } from '@scalar/types/api-reference';
+import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document';
+import type { Component } from 'vue';
+import type { SchemaExpansionStore } from './helpers/schema-expansion';
+/**
+ * Options for the schema component tree
+ *
+ * These options should be prop drilled through the Schema component tree and shouldn't be changed
+ */
+export type SchemaOptions = {
+    /** Hide read-only properties */
+    hideReadOnly?: boolean;
+    /** Hide write-only properties */
+    hideWriteOnly?: boolean;
+    /** Order schema properties, defaults to 'alpha' */
+    orderSchemaPropertiesBy?: ApiReferenceConfiguration['orderSchemaPropertiesBy'];
+    /** Order required properties first */
+    orderRequiredPropertiesFirst?: ApiReferenceConfiguration['orderRequiredPropertiesFirst'];
+    /** Expand all nested schema properties by default while keeping the toggle available */
+    expandAllSchemaProperties?: ApiReferenceConfiguration['expandAllSchemaProperties'];
+    /** Selected extensions to display on schema fields. */
+    showExtensions?: ApiReferenceConfiguration['showExtensions'];
+    /** Arrow-key navigation over the row toggles */
+    schemaKeyboardNav?: ApiReferenceConfiguration['schemaKeyboardNav'];
+    /**
+     * Whether the models section is hidden.
+     *
+     * Model names stay visible, but there is no models section to scroll to, so they
+     * render as plain text instead of links.
+     */
+    hideModels?: ApiReferenceConfiguration['hideModels'];
+    /** Show structural types instead of model names in type labels */
+    hideModelNames?: ApiReferenceConfiguration['hideModelNames'];
+    /**
+     * The document the schema belongs to.
+     *
+     * Used purely for display, e.g. to resolve discriminator `mapping` references into
+     * their component schemas when inferring composition variants.
+     */
+    document?: OpenApiDocument;
+};
+/** Host integrations passed explicitly through schema rows and their parents. */
+export type SchemaRenderingProps = {
+    /** Active deep-link target; only disclosures on its path open automatically. */
+    scrollTargetId?: string;
+    /** Renderer for the host's registered specification extensions. */
+    specificationExtension?: Component;
+    /** One expansion store shared by the host's schema trees, headers, and callbacks. */
+    expansion?: SchemaExpansionStore;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/schema/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AACnG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAEtE;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gCAAgC;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,iCAAiC;IACjC,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,mDAAmD;IACnD,uBAAuB,CAAC,EAAE,yBAAyB,CAAC,yBAAyB,CAAC,CAAA;IAC9E,sCAAsC;IACtC,4BAA4B,CAAC,EAAE,yBAAyB,CAAC,8BAA8B,CAAC,CAAA;IACxF,wFAAwF;IACxF,yBAAyB,CAAC,EAAE,yBAAyB,CAAC,2BAA2B,CAAC,CAAA;IAClF,uDAAuD;IACvD,cAAc,CAAC,EAAE,yBAAyB,CAAC,gBAAgB,CAAC,CAAA;IAC5D,gDAAgD;IAChD,iBAAiB,CAAC,EAAE,yBAAyB,CAAC,mBAAmB,CAAC,CAAA;IAClE;;;;;OAKG;IACH,UAAU,CAAC,EAAE,yBAAyB,CAAC,YAAY,CAAC,CAAA;IACpD,kEAAkE;IAClE,cAAc,CAAC,EAAE,yBAAyB,CAAC,gBAAgB,CAAC,CAAA;IAC5D;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAA;CAC3B,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,oBAAoB,GAAG;IACjC,gFAAgF;IAChF,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,mEAAmE;IACnE,sBAAsB,CAAC,EAAE,SAAS,CAAA;IAClC,qFAAqF;IACrF,SAAS,CAAC,EAAE,oBAAoB,CAAA;CACjC,CAAA"}

package/dist/shared/Badge.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    color?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: 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>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Badge.vue.d.ts.map

package/dist/shared/Badge.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Badge.vue.d.ts","sourceRoot":"","sources":["../../src/shared/Badge.vue"],"names":[],"mappings":"AAgFA,KAAK,WAAW,GAAG;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAC;AA0DF,QAAA,IAAI,OAAO,IAAW,CAAE;AACxB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAK/C,QAAA,MAAM,UAAU,kSAEd,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AACzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/shared/Badge.vue.js

@@ -0,0 +1,9 @@
+import e from "../_virtual/_plugin-vue_export-helper.js";
+import t from "./Badge.vue.script.js";
+/* empty css                    */
+//#region src/shared/Badge.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-2a7101e8"]]);
+//#endregion
+export { n as default };
+
+//# sourceMappingURL=Badge.vue.js.map

package/dist/shared/Badge.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Badge.vue.js","names":[],"sources":["../../src/shared/Badge.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport { useBindCx } from '@scalar/use-hooks/useBindCx'\nimport { computed } from 'vue'\n\nconst { color } = defineProps<{\n  color?: string\n}>()\n\n// Merge fallthrough classes via `cx` so consumer classes can override the base styles.\ndefineOptions({ inheritAttrs: false })\n\nconst { cx } = useBindCx()\n\n// The color only goes in as a custom property; the text color is derived from\n// it in CSS below, where the browser can read lightness out of any color format.\nconst badgeStyle = computed(() =>\n  color ? { '--badge-color': color } : undefined,\n)\n</script>\n\n<template>\n  <div\n    v-bind=\"\n      cx(\n        'badge inline-block rounded-2xl border bg-b-2 px-1.5 py-0.5 text-c-2 text-sm',\n        { 'badge-colored': Boolean(color) },\n      )\n    \"\n    :style=\"badgeStyle\">\n    <slot />\n  </div>\n</template>\n\n<style scoped>\n.badge-colored {\n  background-color: var(--badge-color);\n  /* Fallback for browsers without relative color syntax: a darker shade of the\n     background, which is readable on pale colors but muddy on mid-tones. */\n  color: color-mix(in srgb, var(--badge-color), black 40%);\n}\n\n/* Black text on a light background, white on a dark one. `l` is the background's\n   lightness in LCH (0-100); multiplying its distance from the midpoint by infinity\n   and letting the channel clamp turns that into 0 or 100, with no color parsing\n   in JavaScript and no opinion about which format the color was written in. */\n@supports (color: lch(from red calc((50 - l) * infinity) 0 0)) {\n  .badge-colored {\n    /* Keep text opaque even when the background color is transparent. */\n    color: lch(from var(--badge-color) calc((50 - l) * infinity) 0 0 / 1);\n  }\n}\n\n/* Colour variants are keyed on the `text-*` class a consumer passes in. */\n.badge.text-orange {\n  background: color-mix(in srgb, var(--scalar-color-orange), transparent 90%);\n  border: transparent;\n}\n.badge.text-yellow {\n  background: color-mix(in srgb, var(--scalar-color-yellow), transparent 90%);\n  border: transparent;\n}\n.badge.text-red {\n  background: color-mix(in srgb, var(--scalar-color-red), transparent 90%);\n  border: transparent;\n}\n.badge.text-purple {\n  background: color-mix(in srgb, var(--scalar-color-purple), transparent 90%);\n  border: transparent;\n}\n.badge.text-green {\n  background: color-mix(in srgb, var(--scalar-color-green), transparent 90%);\n  border: transparent;\n}\n</style>\n"],"mappings":""}

package/dist/shared/Badge.vue.script.js

@@ -0,0 +1,16 @@
+import { computed as e, createElementBlock as t, defineComponent as n, mergeProps as r, openBlock as i, renderSlot as a, unref as o } from "vue";
+import { useBindCx as s } from "@scalar/use-hooks/useBindCx";
+//#region src/shared/Badge.vue?vue&type=script&setup=true&lang.ts
+var c = /*@__PURE__*/ n({
+	inheritAttrs: !1,
+	__name: "Badge",
+	props: { color: {} },
+	setup(n) {
+		let { cx: c } = s(), l = e(() => n.color ? { "--badge-color": n.color } : void 0);
+		return (e, s) => (i(), t("div", r(o(c)("badge inline-block rounded-2xl border bg-b-2 px-1.5 py-0.5 text-c-2 text-sm", { "badge-colored": !!n.color }), { style: l.value }), [a(e.$slots, "default", {}, void 0, !0)], 16));
+	}
+});
+//#endregion
+export { c as default };
+
+//# sourceMappingURL=Badge.vue.script.js.map

package/dist/shared/Badge.vue.script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Badge.vue.script.js","names":[],"sources":["../../src/shared/Badge.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport { useBindCx } from '@scalar/use-hooks/useBindCx'\nimport { computed } from 'vue'\n\nconst { color } = defineProps<{\n  color?: string\n}>()\n\n// Merge fallthrough classes via `cx` so consumer classes can override the base styles.\ndefineOptions({ inheritAttrs: false })\n\nconst { cx } = useBindCx()\n\n// The color only goes in as a custom property; the text color is derived from\n// it in CSS below, where the browser can read lightness out of any color format.\nconst badgeStyle = computed(() =>\n  color ? { '--badge-color': color } : undefined,\n)\n</script>\n\n<template>\n  <div\n    v-bind=\"\n      cx(\n        'badge inline-block rounded-2xl border bg-b-2 px-1.5 py-0.5 text-c-2 text-sm',\n        { 'badge-colored': Boolean(color) },\n      )\n    \"\n    :style=\"badgeStyle\">\n    <slot />\n  </div>\n</template>\n\n<style scoped>\n.badge-colored {\n  background-color: var(--badge-color);\n  /* Fallback for browsers without relative color syntax: a darker shade of the\n     background, which is readable on pale colors but muddy on mid-tones. */\n  color: color-mix(in srgb, var(--badge-color), black 40%);\n}\n\n/* Black text on a light background, white on a dark one. `l` is the background's\n   lightness in LCH (0-100); multiplying its distance from the midpoint by infinity\n   and letting the channel clamp turns that into 0 or 100, with no color parsing\n   in JavaScript and no opinion about which format the color was written in. */\n@supports (color: lch(from red calc((50 - l) * infinity) 0 0)) {\n  .badge-colored {\n    /* Keep text opaque even when the background color is transparent. */\n    color: lch(from var(--badge-color) calc((50 - l) * infinity) 0 0 / 1);\n  }\n}\n\n/* Colour variants are keyed on the `text-*` class a consumer passes in. */\n.badge.text-orange {\n  background: color-mix(in srgb, var(--scalar-color-orange), transparent 90%);\n  border: transparent;\n}\n.badge.text-yellow {\n  background: color-mix(in srgb, var(--scalar-color-yellow), transparent 90%);\n  border: transparent;\n}\n.badge.text-red {\n  background: color-mix(in srgb, var(--scalar-color-red), transparent 90%);\n  border: transparent;\n}\n.badge.text-purple {\n  background: color-mix(in srgb, var(--scalar-color-purple), transparent 90%);\n  border: transparent;\n}\n.badge.text-green {\n  background: color-mix(in srgb, var(--scalar-color-green), transparent 90%);\n  border: transparent;\n}\n</style>\n"],"mappings":";;;;;;;;EAWA,IAAM,EAAE,UAAO,EAAU,GAInB,IAAa,QACjB,EAAA,QAAQ,EAAE,iBAAiB,EAAA,MAAM,IAAI,KAAA,CACvC;yBAIE,EASM,OATN,EACiB,EAAA,CAAA,CAAE,CAAA,+EAAA,EAAA,iBAAoH,EAAQ,EAAA,MAAK,CAAA,GAAA,EAMjJ,OAAO,EAAA,MAAU,CAAA,GAAA,CAClB,EAAQ,EAAA,QAAA,WAAA,CAAA,GAAA,KAAA,GAAA,EAAA,CAAA,GAAA,EAAA"}

package/dist/shared/ScreenReader.vue.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    if?: boolean;
+};
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    if: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=ScreenReader.vue.d.ts.map

package/dist/shared/ScreenReader.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenReader.vue.d.ts","sourceRoot":"","sources":["../../src/shared/ScreenReader.vue"],"names":[],"mappings":"AA0BA,KAAK,WAAW,GAAG;IACf,EAAE,CAAC,EAAE,OAAO,CAAA;CACb,CAAC;AAqCJ,QAAA,IAAI,OAAO,IAAU,EAAE,OAAO,IAAW,CAAE;AAC3C,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,GAC5C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAK/C,QAAA,MAAM,UAAU;QA9CP,OAAO;6EAiDd,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}