From 6efbdd9448e1f4df056021f3d44b2ec41f7ddb8a Mon Sep 17 00:00:00 2001 From: Nathan Courtney Date: Thu, 7 Sep 2023 16:54:38 +0000 Subject: [PATCH] Release 1.3.0 --- main.js | 1014 +++++++++++++++++++++++++++++++++++++++++++------ manifest.json | 2 +- styles.css | 2 +- 3 files changed, 895 insertions(+), 123 deletions(-) diff --git a/main.js b/main.js index 0a6eb0c..18eeec7 100644 --- a/main.js +++ b/main.js @@ -2717,7 +2717,7 @@ __export(main_exports, { theme: () => theme }); module.exports = __toCommonJS(main_exports); -var import_obsidian22 = require("obsidian"); +var import_obsidian23 = require("obsidian"); // PiecesSDK/connector/runtime.ts var BASE_PATH = "http://localhost:1000".replace(/\/+$/, ""); @@ -8564,7 +8564,13 @@ function TrackedAssetEventIdentifierDescriptionPairsFromJSONTyped2(json, ignoreD "suggestedAssetReferenced": !exists(json, "suggested_asset_referenced") ? void 0 : json["suggested_asset_referenced"], "searchedAssetReferenced": !exists(json, "searched_asset_referenced") ? void 0 : json["searched_asset_referenced"], "assetReferenced": !exists(json, "asset_referenced") ? void 0 : json["asset_referenced"], - "activityAssetReferenced": !exists(json, "activity_asset_referenced") ? void 0 : json["activity_asset_referenced"] + "activityAssetReferenced": !exists(json, "activity_asset_referenced") ? void 0 : json["activity_asset_referenced"], + "assetAnnotationAdded": !exists(json, "asset_annotation_added") ? void 0 : json["asset_annotation_added"], + "assetAnnotationDeleted": !exists(json, "asset_annotation_deleted") ? void 0 : json["asset_annotation_deleted"], + "assetAnnotationUpdated": !exists(json, "asset_annotation_updated") ? void 0 : json["asset_annotation_updated"], + "assetHintAdded": !exists(json, "asset_hint_added") ? void 0 : json["asset_hint_added"], + "assetHintDeleted": !exists(json, "asset_hint_deleted") ? void 0 : json["asset_hint_deleted"], + "assetHintUpdated": !exists(json, "asset_hint_updated") ? void 0 : json["asset_hint_updated"] }; } function TrackedAssetEventIdentifierDescriptionPairsToJSON(value) { @@ -8602,7 +8608,13 @@ function TrackedAssetEventIdentifierDescriptionPairsToJSON(value) { "suggested_asset_referenced": value.suggestedAssetReferenced, "searched_asset_referenced": value.searchedAssetReferenced, "asset_referenced": value.assetReferenced, - "activity_asset_referenced": value.activityAssetReferenced + "activity_asset_referenced": value.activityAssetReferenced, + "asset_annotation_added": value.assetAnnotationAdded, + "asset_annotation_deleted": value.assetAnnotationDeleted, + "asset_annotation_updated": value.assetAnnotationUpdated, + "asset_hint_added": value.assetHintAdded, + "asset_hint_deleted": value.assetHintDeleted, + "asset_hint_updated": value.assetHintUpdated }; } @@ -8623,7 +8635,9 @@ function TrackedAssetEventMetadataFromJSONTyped2(json, ignoreDiscriminator) { "person": !exists(json, "person") ? void 0 : ReferencedPersonFromJSON(json["person"]), "sensitive": !exists(json, "sensitive") ? void 0 : ReferencedSensitiveFromJSON(json["sensitive"]), "share": !exists(json, "share") ? void 0 : ReferencedShareFromJSON(json["share"]), - "search": !exists(json, "search") ? void 0 : TrackedAssetsEventSearchMetadataFromJSON(json["search"]) + "search": !exists(json, "search") ? void 0 : TrackedAssetsEventSearchMetadataFromJSON(json["search"]), + "annotation": !exists(json, "annotation") ? void 0 : ReferencedAnnotationFromJSON(json["annotation"]), + "hint": !exists(json, "hint") ? void 0 : ReferencedHintFromJSON(json["hint"]) }; } function TrackedAssetEventMetadataToJSON(value) { @@ -8642,7 +8656,9 @@ function TrackedAssetEventMetadataToJSON(value) { "person": ReferencedPersonToJSON(value.person), "sensitive": ReferencedSensitiveToJSON(value.sensitive), "share": ReferencedShareToJSON(value.share), - "search": TrackedAssetsEventSearchMetadataToJSON(value.search) + "search": TrackedAssetsEventSearchMetadataToJSON(value.search), + "annotation": ReferencedAnnotationToJSON(value.annotation), + "hint": ReferencedHintToJSON(value.hint) }; } @@ -9911,14 +9927,14 @@ function AnnotationToJSON2(value) { } // PiecesSDK/core/models/AnnotationTypeEnum.ts -var AnnotationTypeEnum5 = /* @__PURE__ */ ((AnnotationTypeEnum12) => { - AnnotationTypeEnum12["Description"] = "DESCRIPTION"; - AnnotationTypeEnum12["Comment"] = "COMMENT"; - AnnotationTypeEnum12["Documentation"] = "DOCUMENTATION"; - AnnotationTypeEnum12["Summary"] = "SUMMARY"; - AnnotationTypeEnum12["Explanation"] = "EXPLANATION"; - AnnotationTypeEnum12["GitCommit"] = "GIT_COMMIT"; - return AnnotationTypeEnum12; +var AnnotationTypeEnum5 = /* @__PURE__ */ ((AnnotationTypeEnum14) => { + AnnotationTypeEnum14["Description"] = "DESCRIPTION"; + AnnotationTypeEnum14["Comment"] = "COMMENT"; + AnnotationTypeEnum14["Documentation"] = "DOCUMENTATION"; + AnnotationTypeEnum14["Summary"] = "SUMMARY"; + AnnotationTypeEnum14["Explanation"] = "EXPLANATION"; + AnnotationTypeEnum14["GitCommit"] = "GIT_COMMIT"; + return AnnotationTypeEnum14; })(AnnotationTypeEnum5 || {}); function AnnotationTypeEnumFromJSON2(json) { return AnnotationTypeEnumFromJSONTyped6(json, false); @@ -10083,6 +10099,90 @@ function AssetToJSON2(value) { }; } +// PiecesSDK/core/models/AssetFilter.ts +function AssetFilterToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "schema": EmbeddedModelSchemaToJSON2(value.schema), + "classification": ClassificationSpecificEnumToJSON2(value.classification), + "tags": value.tags, + "websites": value.websites, + "persons": value.persons, + "phrase": AssetFilterPhraseToJSON(value.phrase), + "created": AssetFilterTimestampToJSON(value.created), + "updated": AssetFilterTimestampToJSON(value.updated), + "operations": AssetFiltersToJSON(value.operations) + }; +} + +// PiecesSDK/core/models/AssetFilterPhrase.ts +function AssetFilterPhraseToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "schema": EmbeddedModelSchemaToJSON2(value.schema), + "value": value.value, + "annotation": value.annotation, + "title": value.title, + "content": value.content, + "options": AssetFilterPhraseOptionsToJSON(value.options) + }; +} + +// PiecesSDK/core/models/AssetFilterPhraseOptions.ts +function AssetFilterPhraseOptionsToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "schema": EmbeddedModelSchemaToJSON2(value.schema), + "annotation": AnnotationTypeEnumToJSON2(value.annotation) + }; +} + +// PiecesSDK/core/models/AssetFilterTimestamp.ts +function AssetFilterTimestampToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "schema": EmbeddedModelSchemaToJSON2(value.schema), + "from": GroupedTimestampToJSON2(value.from), + "to": GroupedTimestampToJSON2(value.to), + "between": value.between + }; +} + +// PiecesSDK/core/models/AssetFilters.ts +function AssetFiltersToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "schema": EmbeddedModelSchemaToJSON2(value.schema), + "iterable": value.iterable.map(AssetFilterToJSON), + "type": FilterOperationTypeEnumToJSON(value.type) + }; +} + // PiecesSDK/core/models/AssetFormats.ts function AssetFormatsFromJSON2(json) { return AssetFormatsFromJSONTyped4(json, false); @@ -10126,6 +10226,20 @@ function AssetReclassificationToJSON(value) { }; } +// PiecesSDK/core/models/AssetSearchSpace.ts +function AssetSearchSpaceToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "schema": EmbeddedModelSchemaToJSON2(value.schema), + "identifers": FlattenedAssetsToJSON2(value.identifers) + }; +} + // PiecesSDK/core/models/Assets.ts function AssetsFromJSON2(json) { return AssetsFromJSONTyped5(json, false); @@ -10154,6 +10268,37 @@ function AssetsToJSON2(value) { }; } +// PiecesSDK/core/models/AssetsSearchWithFiltersInput.ts +function AssetsSearchWithFiltersInputToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "schema": EmbeddedModelSchemaToJSON2(value.schema), + "query": value.query, + "space": AssetSearchSpaceToJSON(value.space), + "filters": AssetFiltersToJSON(value.filters), + "casing": value.casing + }; +} + +// PiecesSDK/core/models/AssetsSearchWithFiltersOutput.ts +function AssetsSearchWithFiltersOutputFromJSON(json) { + return AssetsSearchWithFiltersOutputFromJSONTyped(json, false); +} +function AssetsSearchWithFiltersOutputFromJSONTyped(json, ignoreDiscriminator) { + if (json === void 0 || json === null) { + return json; + } + return { + "schema": !exists2(json, "schema") ? void 0 : EmbeddedModelSchemaFromJSON2(json["schema"]), + "results": SearchedAssetsFromJSON2(json["results"]) + }; +} + // PiecesSDK/core/models/Auth0Identity.ts function Auth0IdentityToJSON(value) { if (value === void 0) { @@ -10382,9 +10527,9 @@ function ClassificationRenderingEnumToJSON2(value) { // PiecesSDK/core/models/ClassificationSpecificEnum.ts function ClassificationSpecificEnumFromJSON2(json) { - return ClassificationSpecificEnumFromJSONTyped8(json, false); + return ClassificationSpecificEnumFromJSONTyped9(json, false); } -function ClassificationSpecificEnumFromJSONTyped8(json, ignoreDiscriminator) { +function ClassificationSpecificEnumFromJSONTyped9(json, ignoreDiscriminator) { return json; } function ClassificationSpecificEnumToJSON2(value) { @@ -10647,9 +10792,9 @@ function EdgesToJSON2(value) { // PiecesSDK/core/models/EmbeddedModelSchema.ts function EmbeddedModelSchemaFromJSON2(json) { - return EmbeddedModelSchemaFromJSONTyped219(json, false); + return EmbeddedModelSchemaFromJSONTyped227(json, false); } -function EmbeddedModelSchemaFromJSONTyped219(json, ignoreDiscriminator) { +function EmbeddedModelSchemaFromJSONTyped227(json, ignoreDiscriminator) { if (json === void 0 || json === null) { return json; } @@ -11011,6 +11156,11 @@ function FileMetadataToJSON2(value) { }; } +// PiecesSDK/core/models/FilterOperationTypeEnum.ts +function FilterOperationTypeEnumToJSON(value) { + return value; +} + // PiecesSDK/core/models/FlattenedActivities.ts function FlattenedActivitiesFromJSON2(json) { return FlattenedActivitiesFromJSONTyped4(json, false); @@ -11267,9 +11417,9 @@ function FlattenedAssetToJSON2(value) { // PiecesSDK/core/models/FlattenedAssets.ts function FlattenedAssetsFromJSON2(json) { - return FlattenedAssetsFromJSONTyped7(json, false); + return FlattenedAssetsFromJSONTyped8(json, false); } -function FlattenedAssetsFromJSONTyped7(json, ignoreDiscriminator) { +function FlattenedAssetsFromJSONTyped8(json, ignoreDiscriminator) { if (json === void 0 || json === null) { return json; } @@ -12512,9 +12662,9 @@ function GraphicalSVGStatisticsToJSON2(value) { // PiecesSDK/core/models/GroupedTimestamp.ts function GroupedTimestampFromJSON2(json) { - return GroupedTimestampFromJSONTyped55(json, false); + return GroupedTimestampFromJSONTyped56(json, false); } -function GroupedTimestampFromJSONTyped55(json, ignoreDiscriminator) { +function GroupedTimestampFromJSONTyped56(json, ignoreDiscriminator) { if (json === void 0 || json === null) { return json; } @@ -13456,6 +13606,46 @@ function QGPTRepromptOutputFromJSONTyped(json, ignoreDiscriminator) { }; } +// PiecesSDK/core/models/QGPTStreamEnum.ts +function QGPTStreamEnumFromJSON(json) { + return QGPTStreamEnumFromJSONTyped(json, false); +} +function QGPTStreamEnumFromJSONTyped(json, ignoreDiscriminator) { + return json; +} + +// PiecesSDK/core/models/QGPTStreamInput.ts +function QGPTStreamInputToJSON(value) { + if (value === void 0) { + return void 0; + } + if (value === null) { + return null; + } + return { + "relevance": QGPTRelevanceInputToJSON(value.relevance), + "question": QGPTQuestionInputToJSON(value.question), + "request": value.request, + "stop": value.stop + }; +} + +// PiecesSDK/core/models/QGPTStreamOutput.ts +function QGPTStreamOutputFromJSON(json) { + return QGPTStreamOutputFromJSONTyped(json, false); +} +function QGPTStreamOutputFromJSONTyped(json, ignoreDiscriminator) { + if (json === void 0 || json === null) { + return json; + } + return { + "request": !exists2(json, "request") ? void 0 : json["request"], + "relevance": !exists2(json, "relevance") ? void 0 : QGPTRelevanceOutputFromJSON(json["relevance"]), + "question": !exists2(json, "question") ? void 0 : QGPTQuestionOutputFromJSON(json["question"]), + "status": !exists2(json, "status") ? void 0 : QGPTStreamEnumFromJSON(json["status"]) + }; +} + // PiecesSDK/core/models/Recipients.ts function RecipientsFromJSON2(json) { return RecipientsFromJSONTyped6(json, false); @@ -13512,9 +13702,9 @@ function ReferencedActivityToJSON2(value) { // PiecesSDK/core/models/ReferencedAnnotation.ts function ReferencedAnnotationFromJSON2(json) { - return ReferencedAnnotationFromJSONTyped4(json, false); + return ReferencedAnnotationFromJSONTyped5(json, false); } -function ReferencedAnnotationFromJSONTyped4(json, ignoreDiscriminator) { +function ReferencedAnnotationFromJSONTyped5(json, ignoreDiscriminator) { if (json === void 0 || json === null) { return json; } @@ -13624,9 +13814,9 @@ function ReferencedFormatToJSON2(value) { // PiecesSDK/core/models/ReferencedHint.ts function ReferencedHintFromJSON2(json) { - return ReferencedHintFromJSONTyped4(json, false); + return ReferencedHintFromJSONTyped5(json, false); } -function ReferencedHintFromJSONTyped4(json, ignoreDiscriminator) { +function ReferencedHintFromJSONTyped5(json, ignoreDiscriminator) { if (json === void 0 || json === null) { return json; } @@ -13984,9 +14174,9 @@ function SearchedAssetFromJSONTyped3(json, ignoreDiscriminator) { // PiecesSDK/core/models/SearchedAssets.ts function SearchedAssetsFromJSON2(json) { - return SearchedAssetsFromJSONTyped3(json, false); + return SearchedAssetsFromJSONTyped4(json, false); } -function SearchedAssetsFromJSONTyped3(json, ignoreDiscriminator) { +function SearchedAssetsFromJSONTyped4(json, ignoreDiscriminator) { if (json === void 0 || json === null) { return json; } @@ -16424,7 +16614,13 @@ function TrackedAssetEventIdentifierDescriptionPairsFromJSONTyped4(json, ignoreD "suggestedAssetReferenced": !exists2(json, "suggested_asset_referenced") ? void 0 : json["suggested_asset_referenced"], "searchedAssetReferenced": !exists2(json, "searched_asset_referenced") ? void 0 : json["searched_asset_referenced"], "assetReferenced": !exists2(json, "asset_referenced") ? void 0 : json["asset_referenced"], - "activityAssetReferenced": !exists2(json, "activity_asset_referenced") ? void 0 : json["activity_asset_referenced"] + "activityAssetReferenced": !exists2(json, "activity_asset_referenced") ? void 0 : json["activity_asset_referenced"], + "assetAnnotationAdded": !exists2(json, "asset_annotation_added") ? void 0 : json["asset_annotation_added"], + "assetAnnotationDeleted": !exists2(json, "asset_annotation_deleted") ? void 0 : json["asset_annotation_deleted"], + "assetAnnotationUpdated": !exists2(json, "asset_annotation_updated") ? void 0 : json["asset_annotation_updated"], + "assetHintAdded": !exists2(json, "asset_hint_added") ? void 0 : json["asset_hint_added"], + "assetHintDeleted": !exists2(json, "asset_hint_deleted") ? void 0 : json["asset_hint_deleted"], + "assetHintUpdated": !exists2(json, "asset_hint_updated") ? void 0 : json["asset_hint_updated"] }; } function TrackedAssetEventIdentifierDescriptionPairsToJSON2(value) { @@ -16462,7 +16658,13 @@ function TrackedAssetEventIdentifierDescriptionPairsToJSON2(value) { "suggested_asset_referenced": value.suggestedAssetReferenced, "searched_asset_referenced": value.searchedAssetReferenced, "asset_referenced": value.assetReferenced, - "activity_asset_referenced": value.activityAssetReferenced + "activity_asset_referenced": value.activityAssetReferenced, + "asset_annotation_added": value.assetAnnotationAdded, + "asset_annotation_deleted": value.assetAnnotationDeleted, + "asset_annotation_updated": value.assetAnnotationUpdated, + "asset_hint_added": value.assetHintAdded, + "asset_hint_deleted": value.assetHintDeleted, + "asset_hint_updated": value.assetHintUpdated }; } @@ -16483,7 +16685,9 @@ function TrackedAssetEventMetadataFromJSONTyped4(json, ignoreDiscriminator) { "person": !exists2(json, "person") ? void 0 : ReferencedPersonFromJSON2(json["person"]), "sensitive": !exists2(json, "sensitive") ? void 0 : ReferencedSensitiveFromJSON2(json["sensitive"]), "share": !exists2(json, "share") ? void 0 : ReferencedShareFromJSON2(json["share"]), - "search": !exists2(json, "search") ? void 0 : TrackedAssetsEventSearchMetadataFromJSON2(json["search"]) + "search": !exists2(json, "search") ? void 0 : TrackedAssetsEventSearchMetadataFromJSON2(json["search"]), + "annotation": !exists2(json, "annotation") ? void 0 : ReferencedAnnotationFromJSON2(json["annotation"]), + "hint": !exists2(json, "hint") ? void 0 : ReferencedHintFromJSON2(json["hint"]) }; } function TrackedAssetEventMetadataToJSON2(value) { @@ -16502,7 +16706,9 @@ function TrackedAssetEventMetadataToJSON2(value) { "person": ReferencedPersonToJSON2(value.person), "sensitive": ReferencedSensitiveToJSON2(value.sensitive), "share": ReferencedShareToJSON2(value.share), - "search": TrackedAssetsEventSearchMetadataToJSON2(value.search) + "search": TrackedAssetsEventSearchMetadataToJSON2(value.search), + "annotation": ReferencedAnnotationToJSON2(value.annotation), + "hint": ReferencedHintToJSON2(value.hint) }; } @@ -17651,7 +17857,7 @@ var AssetsApi = class extends BaseAPI2 { } /** * This function will search your pieces and will return Assets(the results) based on your query! Eventually** /assets/search?query=string [GET] Scoped to Asset Currently just send along your query in the body. Required to pass searchable_tags (csv of tags) or a query string. if a query is passed we will run through fuzzy search. if searchable_tags are passed we will run through tag_based_search. if neither are passed in we will return a 500. - * /assets/search?query=string + * /assets/search?query=string [GET] */ async assetsSearchAssetsRaw(requestParameters) { const queryParameters = {}; @@ -17678,12 +17884,43 @@ var AssetsApi = class extends BaseAPI2 { } /** * This function will search your pieces and will return Assets(the results) based on your query! Eventually** /assets/search?query=string [GET] Scoped to Asset Currently just send along your query in the body. Required to pass searchable_tags (csv of tags) or a query string. if a query is passed we will run through fuzzy search. if searchable_tags are passed we will run through tag_based_search. if neither are passed in we will return a 500. - * /assets/search?query=string + * /assets/search?query=string [GET] */ async assetsSearchAssets(requestParameters) { const response = await this.assetsSearchAssetsRaw(requestParameters); return await response.value(); } + /** + * This function will search your pieces and will return Assets(the results) based on your query! /assets/search [POST] Scoped to Asset Currently just send along your query in the body. if a query is passed we will run through fuzzy search. The Post Body will also accept a search space, being either a list of uuids.(in the future potentially Seeds.) The Post Body will also accept optional filters, which is an iterable of filters all will be AND operations for now. + * /assets/search [POST] + */ + async assetsSearchWithFiltersRaw(requestParameters) { + const queryParameters = {}; + if (requestParameters.transferables !== void 0) { + queryParameters["transferables"] = requestParameters.transferables; + } + if (requestParameters.pseudo !== void 0) { + queryParameters["pseudo"] = requestParameters.pseudo; + } + const headerParameters = {}; + headerParameters["Content-Type"] = "application/json"; + const response = await this.request({ + path: `/assets/search`, + method: "POST", + headers: headerParameters, + query: queryParameters, + body: AssetsSearchWithFiltersInputToJSON(requestParameters.assetsSearchWithFiltersInput) + }); + return new JSONApiResponse2(response, (jsonValue) => AssetsSearchWithFiltersOutputFromJSON(jsonValue)); + } + /** + * This function will search your pieces and will return Assets(the results) based on your query! /assets/search [POST] Scoped to Asset Currently just send along your query in the body. if a query is passed we will run through fuzzy search. The Post Body will also accept a search space, being either a list of uuids.(in the future potentially Seeds.) The Post Body will also accept optional filters, which is an iterable of filters all will be AND operations for now. + * /assets/search [POST] + */ + async assetsSearchWithFilters(requestParameters) { + const response = await this.assetsSearchWithFiltersRaw(requestParameters); + return await response.value(); + } /** * Get all of the users Assets. * /assets [GET] Scoped to Assets @@ -18329,6 +18566,31 @@ var QGPTApi = class extends BaseAPI2 { const response = await this.personsRelatedRaw(requestParameters); return await response.value(); } + /** + * This is a version of qGPT stream that will stream the inputs. This will handle relevance. This will handle question. This will throw an error if both are passed in. That being said if you want to utalize question && relevant, you can get stream results by passing in relevance with options.question:true. This will handle multiple conversations. This is a Websocket. + * /qgpt/stream [GET] + */ + async qgptStreamRaw(requestParameters) { + const queryParameters = {}; + const headerParameters = {}; + headerParameters["Content-Type"] = "application/json"; + const response = await this.request({ + path: `/qgpt/stream`, + method: "GET", + headers: headerParameters, + query: queryParameters, + body: QGPTStreamInputToJSON(requestParameters.qGPTStreamInput) + }); + return new JSONApiResponse2(response, (jsonValue) => QGPTStreamOutputFromJSON(jsonValue)); + } + /** + * This is a version of qGPT stream that will stream the inputs. This will handle relevance. This will handle question. This will throw an error if both are passed in. That being said if you want to utalize question && relevant, you can get stream results by passing in relevance with options.question:true. This will handle multiple conversations. This is a Websocket. + * /qgpt/stream [GET] + */ + async qgptStream(requestParameters) { + const response = await this.qgptStreamRaw(requestParameters); + return await response.value(); + } /** * This is going to accept, relevant code snippets or uuids returned from the /qgpt/relevance endpoint, as well as a question query and we will return possible results to answer your question. NOTE: - The relevant seeds, must require either an id, that was used within the /qgpt/relevance endpoint or a seed with afragment/string. or else we will throw and error. This endpoint will take your query and your relevant snippets and use them to answer your question, returning multiple answers to your question all of which with scores. * /qgpt/question [POST] @@ -18738,7 +19000,7 @@ var WellKnownApi = class extends BaseAPI2 { }; // package.json -var version = "1.2.2"; +var version = "1.3.0"; // src/connection/notification_handler.ts var import_obsidian = require("obsidian"); @@ -19080,10 +19342,10 @@ Constants.askQGPTTitle = "Ask copilot about your selection"; var import_crypto = __toESM(require("crypto")); // src/database/pieces_database.ts -var import_obsidian13 = require("obsidian"); +var import_obsidian14 = require("obsidian"); // src/ui/views/DisplayController.ts -var import_obsidian12 = require("obsidian"); +var import_obsidian13 = require("obsidian"); // assets/classifications/batchfile-white.png var batchfile_white_default = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAH/SURBVHgB7ZiLccIwDIaVXgeADcIGjAAbsAFhgmQD6AYwAbBBmACYADZINoANXMk95ZyHctCEntvqu9Mp59hGin/LCQCKoiiKoii/B2NMjJYZv8jQomeSiIzfJNWYAyGRDF0I/pIHQTByG6REDHgOJlKK/Q3+CJqIb/y/REajEW2wkg2HQ5hOp7Df78Vxi8Wi6Hu/34v20+lUm6/JaPy3aSrcYRhSJRNtvV7XxmRZJvY5Ho+t87FFUfOR1jkRd2IKlNvJV9lut6WgJpOJkaB5pXkeSaTTHsEfBQxOvM+SwyCtJzldr1d4BZ0SyfPcBkdUE3LvxXFc3D8cDvBjmBZpDQYDe+3umfF4bGXmkiRJSSqr1aoY7420SFJsBMnlfD6X+qRpav1sNrN+Pp9bT5WLV6pPnk6EAsOKYw1XAfDJ23byXF4pUJIWgSsAu93OtnHibeW6V9qkVS2H+OQLibG8WCaSkbxut1uv0nqHjrCECHr6tCrcRhvcLQJ0D88S62lVqAi8lLYVcTc7XUPl4HLPjsvlUpuHzhJoOFO6rsjTiUCDTJbLZSEVDlQKiKsXOFLsI5GHP6x487qQlMikfry5pbnc8SQ3LhbSOJfqh5V+IfqGJuIbUiKveUXtj1p8UiIf4DebakMg9TRff03Sm14I/pCjbbBgpaAoiqIoiuI/nzQheYPhf7t6AAAAAElFTkSuQmCC"; @@ -19378,10 +19640,6 @@ var LangSpecificEnum = { var searchLangSpecificEnum = { asp: "Asp", bat: "Batch", - sh: "Bash", - cc: "C++ Source", - hh: "C++ H-Header", - h: "C++ Header", c: "C", cs: "C#", cpp: "C++", @@ -19397,7 +19655,6 @@ var searchLangSpecificEnum = { groovy: "Groovy", hs: "Haskell", html: "HTML", - htm: "HTM", java: "Java", js: "JavaScript", json: "JSON", @@ -19411,23 +19668,21 @@ var searchLangSpecificEnum = { text: "PlainTextGrammar", ps1: "PowerShell", py: "Python", - pyc: "Python-C", rb: "Ruby", r: "R", rs: "Rust", scala: "Scala", + sh: "Shell", sol: "Solidity", sql: "SQL", swift: "Swift", sv: "SystemVerilog", tex: "TeX", - tml: "TOML", toml: "TOML", ts: "TypeScript", txt: "PlainTextGrammar", xml: "XML", - yaml: "YAML", - yml: "YAML" + yaml: "YAML" }; var SearchLangToClassificationEnum = { Batch: "bat" /* Bat */, @@ -19440,14 +19695,10 @@ var SearchLangToClassificationEnum = { "Objective-C": "m" /* M */, C: "c" /* C */, "C++": "cpp" /* Cpp */, - "C++ Source": "cc" /* Cc */, - "C++ Header": "h" /* H */, - "C++ H-Header": "hh" /* Hh */, "C#": "cs" /* Cs */, CSS: "css" /* Css */, Go: "go" /* Go */, HTML: "html" /* Html */, - HTM: "htm" /* Htm */, Java: "java" /* Java */, JavaScript: "js" /* Js */, TypeScript: "ts" /* Ts */, @@ -19457,10 +19708,9 @@ var SearchLangToClassificationEnum = { Perl: "pl" /* Pl */, PHP: "php" /* Php */, Python: "py" /* Py */, - "Python-C": "pyc" /* Pyc */, PowerShell: "ps1" /* Ps1 */, R: "r" /* R */, - Bash: "sh" /* Sh */, + Shell: "sh" /* Sh */, Swift: "swift" /* Swift */, Ruby: "rb" /* Rb */, TeX: "tex" /* Tex */, @@ -19468,7 +19718,7 @@ var SearchLangToClassificationEnum = { Rust: "rs" /* Rs */, JSON: "json" /* Json */, YAML: "yaml" /* Yaml */, - TOML: "tml" /* Tml */, + TOML: "toml" /* Toml */, XML: "xml" /* Xml */, Groovy: "groovy" /* Groovy */, Kotlin: "kt" /* Kt */, @@ -19535,8 +19785,10 @@ var displayPiecesView = async ({ await leaf.open(view); leaf.view.inlineTitleEl.innerHTML = inlineTitle; leaf.view.inlineTitleEl.contentEditable = "false"; + leaf.view.inlineTitleEl.style.userSelect = "text"; const editor = view.editor.cm; editor.contentDOM.contentEditable = "false"; + editor.contentDOM.style.userSelect = "text"; let inView = true; while (inView) { if (view.file) { @@ -20641,7 +20893,7 @@ var AnnotationHandler = class { // src/ui/modals/edit-asset-modal.ts var EditModal = class extends import_obsidian5.Modal { - constructor(app2, snippetObject, snippetEl) { + constructor(app2, snippetObject) { super(app2); this.snippetTitle = snippetObject.title; this.snippetId = snippetObject.id; @@ -20649,7 +20901,6 @@ var EditModal = class extends import_obsidian5.Modal { this.snippetLanguage = snippetObject.language; this.seperatedRaw = (snippetObject.raw || "").split("\n"); this.snippetAnnotations = snippetObject.annotations || []; - this.snippetEl = snippetEl; } onOpen() { var _a; @@ -21176,7 +21427,7 @@ function renderSnippet({ buttonDiv.createEl("div").addClass("vertBreak"); if (!newSnippet && !discovery) { new import_obsidian8.ButtonComponent(buttonDiv).setIcon("pencil").setTooltip("Edit snippet").onClick(async () => { - new EditModal(this.app, snippetObject, contentEl).open(); + new EditModal(this.app, snippetObject).open(); }).setClass("button"); buttonDiv.createEl("div").addClass("vertBreak"); new import_obsidian8.ButtonComponent(buttonDiv).setIcon("sticky-note").setTooltip("Edit annotations").onClick(async () => { @@ -22427,12 +22678,485 @@ var ProgressBar = class { } }; +// src/ui/modals/search-filters-modal.ts +var import_obsidian12 = require("obsidian"); +var FilterTypeEnum = /* @__PURE__ */ ((FilterTypeEnum2) => { + FilterTypeEnum2["Language"] = "Language"; + FilterTypeEnum2["Tags"] = "Tags"; + FilterTypeEnum2["Phrase"] = "Phrase"; + return FilterTypeEnum2; +})(FilterTypeEnum || {}); +var SearchFiltersModal = class extends import_obsidian12.Modal { + constructor(app2) { + super(app2); + this.filtersRan = false; + this.addedFilters = []; + this.filters = { Tags: [], casing: false }; + this.titleEl.setText("Filter Snippets"); + const container = this.contentEl.createDiv(); + container.classList.add("flex", "flex-col", "w-full", "h-full"); + const description = container.createDiv(); + description.classList.add( + "text-sm", + "flex", + "flex-row", + "w-full", + "mt-[-8px]", + "mb-1", + "text-[var(--text-faint)]" + ); + description.setText( + "Use filters to narrow your search scope & refine results" + ); + const filtersRow = container.createDiv(); + filtersRow.classList.add("flex", "flex-row", "w-full", "h-full"); + const filtersCol = filtersRow.createDiv(); + filtersCol.classList.add("flex", "flex-col", "w-full", "h-full"); + const actionRow = container.createDiv(); + actionRow.classList.add("flex", "flex-row", "w-full", "mt-2"); + const addCol = actionRow.createDiv(); + addCol.classList.add("flex", "flex-col", "min-h-[32px]"); + const addButton = new import_obsidian12.ButtonComponent(addCol); + addButton.setButtonText("Add Filter").onClick(() => { + this.addFilter(addCol, filtersCol, addButton); + addButton.buttonEl.classList.add("hidden"); + }).buttonEl.classList.add("w-fit", "mr-2"); + this.addButton = addButton.buttonEl; + const caseCol = actionRow.createDiv(); + caseCol.classList.add("flex", "flex-col", "hidden", "w-full"); + const caseRow = caseCol.createDiv(); + caseRow.classList.add( + "flex", + "flex-row", + "w-full", + "items-center", + "h-full" + ); + const caseCheckBox = caseRow.createEl("input", { type: "checkbox" }); + caseCheckBox.onchange = () => { + this.filters.casing = caseCheckBox.checked; + }; + const caseLabel = caseRow.createDiv(); + caseLabel.classList.add("w-full"); + caseLabel.setText("Case Sensitive"); + this.caseDiv = caseCol; + const actionCol = actionRow.createDiv(); + actionCol.classList.add("flex", "flex-col", "w-full", "hidden"); + this.actionCol = actionCol; + const actionBtnRow = actionCol.createDiv(); + actionBtnRow.classList.add("flex", "flex-row", "justify-end", "w-full"); + const clearBtn = new import_obsidian12.ButtonComponent(actionBtnRow); + clearBtn.onClick(() => { + var _a; + (_a = document.getElementById("pieces-filters-options")) == null ? void 0 : _a.remove(); + filtersCol.empty(); + this.addedFilters = []; + this.filters = { Tags: [], casing: false }; + actionCol.classList.add("hidden"); + this.addButton.classList.remove("hidden"); + this.caseDiv.classList.add("hidden"); + this.handleClear(); + }); + clearBtn.setButtonText("Clear Filters"); + clearBtn.buttonEl.classList.add("mr-2"); + const runBtn = new import_obsidian12.ButtonComponent(actionBtnRow); + runBtn.onClick(() => { + this.runFilters(); + }); + runBtn.setButtonText("Run"); + } + handleClear() { + if (this.filtersRan) { + this.filtersRan = false; + DisplayController.triggerUIRedraw({ searching: false, fetch: false }); + DisplayController.filterModalBtn.buttonEl.classList.remove( + "text-[var(--text-accent)]" + ); + } + } + /* + Creates a delete button + - @param parent is the element that should be removed when the delete button is clicked + - @param container is the element the delete button should be appended to + */ + buildDeleteBtn(parent, container, filter) { + const delDiv = container.createDiv(); + delDiv.innerHTML = (0, import_obsidian12.getIcon)("trash-2").outerHTML; + delDiv.classList.add( + "hover:text-red-600", + "cursor-pointer", + "ml-2", + "mr-2" + ); + delDiv.onclick = () => { + var _a; + parent.remove(); + (_a = document.getElementById("pieces-filters-options")) == null ? void 0 : _a.remove(); + this.addedFilters.remove(filter); + this.addButton.classList.remove("hidden"); + if (this.addedFilters.length === 0) { + this.actionCol.classList.add("hidden"); + this.handleClear(); + } + delete this.filters[filter]; + if (!this.addedFilters.contains("Tags") && !this.addedFilters.contains("Phrase")) { + this.caseDiv.classList.add("hidden"); + this.filters.casing = false; + } + }; + return delDiv; + } + /* + Runs the filter request, and renders the results. + */ + async runFilters() { + var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j; + const config2 = ConnectorSingleton.getInstance(); + const params = { + transferables: false, + pseudo: false, + assetsSearchWithFiltersInput: { + filters: { + iterable: [] + }, + casing: this.filters.casing + } + }; + if ((_a = this.filters.Language) == null ? void 0 : _a.length) { + (_c = (_b = params.assetsSearchWithFiltersInput) == null ? void 0 : _b.filters) == null ? void 0 : _c.iterable.push({ + classification: this.filters.Language + }); + } + if (this.filters.Tags.filter((el) => el.length).length) { + (_e = (_d = params.assetsSearchWithFiltersInput) == null ? void 0 : _d.filters) == null ? void 0 : _e.iterable.push({ + tags: this.filters.Tags + }); + } + if ((_f = this.filters.Phrase) == null ? void 0 : _f.string.length) { + const operations = { + iterable: [], + type: "OR" /* Or */ + }; + const value = this.filters.Phrase.string; + if (this.filters.Phrase.annotations) { + operations.iterable.push({ + phrase: { value, annotation: true } + }); + } + if (this.filters.Phrase.content) { + operations.iterable.push({ + phrase: { value, content: true } + }); + } + if (this.filters.Phrase.titles) { + operations.iterable.push({ + phrase: { value, title: true } + }); + } + if (operations.iterable.length) { + (_h = (_g = params.assetsSearchWithFiltersInput) == null ? void 0 : _g.filters) == null ? void 0 : _h.iterable.push({ + operations + }); + } + } + if (!((_j = (_i = params.assetsSearchWithFiltersInput) == null ? void 0 : _i.filters) == null ? void 0 : _j.iterable.length)) { + Notifications.getInstance().error({ + message: "Filters were empty, skipping." + }); + return; + } + const assets = await config2.assetsApi.assetsSearchWithFilters(params).catch(() => { + Notifications.getInstance().error({ + message: "Something went wrong with filtering your snippets. Please make sure that Pieces OS is installed, updated, and running. If the issue persists please contact support@pieces.app" + }); + }); + if (!assets) + return; + if (!assets.results.iterable.length) { + Notifications.getInstance().error({ + message: "No results found! Try again with a different set of filters." + }); + return; + } else { + Notifications.getInstance().information({ + message: `${assets.results.iterable.length} results found!` + }); + } + this.filtersRan = true; + const cache2 = PiecesCacheSingleton.getInstance(); + const snippets = cache2.assets.filter( + (el) => assets.results.iterable.some((asset) => asset.identifier === el.id) + ); + DisplayController.defaultView = "newest" /* RECENT */; + DisplayController.createSnippetListView({ + containerVar: DisplayController.defaultContainer, + snippets + }); + DisplayController.filterModalBtn.buttonEl.classList.add( + "text-[var(--text-accent)]" + ); + this.close(); + } + /* + Builder for classification filter element + */ + buildClassificationEl(container) { + const clsRow = container.createDiv(); + clsRow.classList.add("flex", "flex-row", "my-2"); + const clsCol = clsRow.createDiv(); + clsCol.classList.add("flex", "flex-col"); + const labelRow = clsCol.createDiv(); + labelRow.classList.add( + "flex", + "flex-row", + "text-sm", + "text-[var(--text-faint)]" + ); + labelRow.setText("LANGUAGE"); + const filterRow = clsCol.createDiv(); + filterRow.classList.add("flex", "flex-row", "items-center"); + const classificationDropdown = new import_obsidian12.DropdownComponent(filterRow); + classificationDropdown.selectEl.classList.add("w-fit", "text-center"); + classificationDropdown.addOptions(searchLangSpecificEnum); + classificationDropdown.onChange((value) => { + this.filters["Language" /* Language */] = langExtToClassificationSpecificEnum(value); + }); + this.filters["Language" /* Language */] = langExtToClassificationSpecificEnum( + classificationDropdown.getValue() + ); + this.buildDeleteBtn(clsRow, filterRow, "Language" /* Language */); + } + /* + Builder for phrase filter element + */ + buildPhraseEl(container) { + this.filters["Phrase" /* Phrase */] = { + string: "", + annotations: true, + titles: true, + content: true + }; + const phraseRow = container.createDiv(); + phraseRow.classList.add("flex", "flex-row", "my-2", "w-full"); + const phraseCol = phraseRow.createDiv(); + phraseCol.classList.add("flex", "flex-col", "w-full"); + const phraseLabel = phraseCol.createDiv(); + phraseLabel.classList.add( + "flex-row", + "flex", + "text-sm", + "text-[var(--text-faint)]" + ); + phraseLabel.setText("PHRASE"); + const inputRow = phraseCol.createDiv(); + inputRow.classList.add( + "flex", + "flex-row", + "my-1", + "w-full", + "items-center" + ); + const inputEl = new import_obsidian12.TextComponent(inputRow); + inputEl.setPlaceholder("Filter for an exact text match"); + inputEl.inputEl.classList.add("w-1/2"); + inputEl.onChange((value) => { + this.filters["Phrase" /* Phrase */].string = value; + }); + const optionRow = phraseCol.createDiv(); + optionRow.classList.add( + "flex", + "flex-row", + "w-full", + "items-center", + "my-1" + ); + const annotationCheckBox = optionRow.createEl("input", { + type: "checkbox" + }); + annotationCheckBox.checked = true; + annotationCheckBox.onchange = () => { + this.filters["Phrase" /* Phrase */].annotations = annotationCheckBox.checked; + }; + const annotationLabel = optionRow.createDiv(); + annotationLabel.setText("Match Annotations"); + annotationLabel.classList.add("mx-1"); + const seperatorEl = optionRow.createDiv(); + seperatorEl.classList.add( + "ml-2", + "mr-3", + "text-xs", + "text-[var(--text-faint)]" + ); + seperatorEl.setText("OR"); + const titleCheckbox = optionRow.createEl("input", { type: "checkbox" }); + titleCheckbox.checked = true; + titleCheckbox.onchange = () => { + this.filters["Phrase" /* Phrase */].titles = titleCheckbox.checked; + }; + const titleLabel = optionRow.createDiv(); + titleLabel.setText("Match Titles"); + titleLabel.classList.add("mx-1"); + optionRow.appendChild(seperatorEl.cloneNode(true)); + const contentCheckbox = optionRow.createEl("input", { type: "checkbox" }); + contentCheckbox.checked = true; + contentCheckbox.onchange = () => { + this.filters.Phrase.content = contentCheckbox.checked; + }; + const contentLabel = optionRow.createDiv(); + contentLabel.setText("Match Content"); + contentLabel.classList.add("mx-1"); + this.buildDeleteBtn(phraseRow, inputRow, "Phrase" /* Phrase */); + } + buildTagEl(container) { + const tagRow = container.createDiv(); + tagRow.classList.add("flex", "flex-row", "my-2"); + const tagCol = tagRow.createDiv(); + tagCol.classList.add("flex", "flex-col"); + const tagLabel = tagCol.createDiv(); + tagLabel.classList.add( + "flex", + "flex-row", + "my-1", + "text-sm", + "text-[var(--text-faint)]" + ); + tagLabel.setText("TAGS"); + const filtersRow = tagCol.createDiv(); + filtersRow.classList.add( + "flex", + "flex-row", + "my-1", + "items-center", + "flex-wrap" + ); + let tagInputCount = 0; + const buildTagInput = () => { + const tagIndx = tagInputCount.valueOf(); + tagInputCount++; + this.filters["Tags" /* Tags */].push(""); + filtersRow.empty(); + for (const tag of this.filters["Tags" /* Tags */]) { + const tagFilterCol = filtersRow.createDiv(); + tagFilterCol.classList.add("flex", "flex-col"); + const tagFilterRow = tagFilterCol.createDiv(); + tagFilterRow.classList.add("flex", "flex-row", "items-center", "my-1"); + const tagFilterEl = new import_obsidian12.TextComponent(tagFilterRow); + tagFilterEl.setValue(tag); + tagFilterEl.onChange((value) => { + this.filters["Tags" /* Tags */][tagIndx] = value; + }); + tagFilterEl.setPlaceholder("Add tag..."); + tagFilterEl.inputEl.classList.add("mr-1"); + const deleteBtn = this.buildDeleteBtn( + tagFilterCol, + tagFilterRow, + "Tags" /* Tags */ + ); + deleteBtn.onclick = () => { + var _a, _b; + (_a = document.getElementById("pieces-filters-options")) == null ? void 0 : _a.remove(); + tagInputCount--; + (_b = this.filters["Tags" /* Tags */]) == null ? void 0 : _b.remove(tagFilterEl.getValue()); + tagFilterCol.remove(); + if (tagInputCount <= 0) { + tagRow.remove(); + this.addButton.classList.remove("hidden"); + this.addedFilters.remove("Tags" /* Tags */); + if (this.addedFilters.length === 0) { + this.actionCol.classList.add("hidden"); + this.handleClear(); + } + if (!this.addedFilters.contains("Tags") && !this.addedFilters.contains("Phrase")) { + this.caseDiv.classList.add("hidden"); + this.filters.casing = false; + } + } + }; + } + const plusEl = filtersRow.createDiv(); + plusEl.classList.add( + "mx-1", + "cursor-pointer", + "hover:text-[var(--text-accent-hover)]" + ); + plusEl.innerHTML = (0, import_obsidian12.getIcon)("plus").outerHTML; + plusEl.onclick = () => { + buildTagInput(); + }; + }; + buildTagInput(); + } + buildFilterEl(type, container) { + if (type === "Language" /* Language */) { + return this.buildClassificationEl(container); + } else if (type === "Phrase" /* Phrase */) { + return this.buildPhraseEl(container); + } else if (type === "Tags" /* Tags */) { + return this.buildTagEl(container); + } + throw new Error("Invalid filter type"); + } + /* + Shows the available filter options to the user, + and when an option is clicked it will build a filter element + */ + addFilter(container, filterCol, addButton) { + const options2 = Object.keys(FilterTypeEnum).filter( + (el) => !this.addedFilters.includes(el) + ); + const optionDiv = document.createElement("div"); + optionDiv.id = "pieces-filters-options"; + optionDiv.classList.add( + "flex", + "flex-row", + "items-center", + "filter-grow-animation", + "h-full", + "mr-1" + ); + for (let i = 0; i < options2.length; i++) { + const option = options2[i]; + if (i !== 0) { + const split = optionDiv.createDiv(); + split.classList.add("mx-1", "text-[var(--text-faint)]"); + split.setText("|"); + } + const curOption = optionDiv.createDiv(); + curOption.classList.add( + "underline", + "cursor-pointer", + "mx-1", + "hover:text-[var(--text-accent-hover)]", + "text-[var(--text-faint)]" + ); + curOption.setText(option); + curOption.onclick = () => { + this.addedFilters.push(option); + this.buildFilterEl( + FilterTypeEnum[option], + filterCol + ); + optionDiv.remove(); + this.actionCol.classList.remove("hidden"); + if (this.addedFilters.length !== Object.keys(FilterTypeEnum).length) { + addButton.buttonEl.classList.remove("hidden"); + } + if (option === "Tags" || option === "Phrase") { + this.caseDiv.classList.remove("hidden"); + } + }; + } + container.appendChild(optionDiv); + } +}; + // src/ui/views/DisplayController.ts var _DisplayController = class { constructor() { } }; var DisplayController = _DisplayController; +DisplayController.searchFiltersModal = new SearchFiltersModal(app); DisplayController.defaultView = "newest" /* RECENT */; DisplayController.discoveryCheckboxArray = []; DisplayController.snippetsFetched = false; @@ -22507,7 +23231,7 @@ DisplayController.createSnippetListView = async ({ renderSearchBox({ containerVar: searchDiv }); const titleDiv = searchDiv.createDiv(); titleDiv.addClass("title_div"); - new import_obsidian12.DropdownComponent(titleDiv).addOption("newest" /* RECENT */, "\u{1F553} RECENT").addOption("language" /* LANGUAGE */, "\u{1F310} LANGUAGE").addOption("discovery" /* DISCOVERY */, "\u{1F50D} DISCOVER").onChange(async (value) => { + new import_obsidian13.DropdownComponent(titleDiv).addOption("newest" /* RECENT */, "\u{1F553} RECENT").addOption("language" /* LANGUAGE */, "\u{1F310} LANGUAGE").addOption("discovery" /* DISCOVERY */, "\u{1F50D} DISCOVER").onChange(async (value) => { _DisplayController.defaultView = value; _DisplayController.createSnippetListView({ containerVar, @@ -22515,6 +23239,21 @@ DisplayController.createSnippetListView = async ({ viewType: value }); }).setValue(viewType).selectEl.addClass("sort-dropdown"); + if (_DisplayController.defaultView !== "discovery" /* DISCOVERY */) { + const disableFilters = versionCheck({ minVersion: "6.1.0" }); + _DisplayController.filterModalBtn = new import_obsidian13.ButtonComponent(titleDiv); + _DisplayController.filterModalBtn.setIcon("filter").onClick(() => { + disableFilters.then((val) => { + if (val) { + _DisplayController.searchFiltersModal.open(); + } else { + Notifications.getInstance().error({ + message: "Please update to Pieces OS 6.1.0 or higher to use the snippet filtering feature." + }); + } + }).catch(_DisplayController.searchFiltersModal.open); + }).setTooltip("Filter your snippets").buttonEl.addClass("cursor-pointer"); + } if (_DisplayController.defaultView === "discovery" /* DISCOVERY */) { const saveAllDiv = titleDiv.createDiv(); saveAllDiv.addClasses(["discovery-div"]); @@ -22540,7 +23279,7 @@ DisplayController.createSnippetListView = async ({ selectAllLabel.innerText = "Select all"; selectAllLabel.addClasses(["discovery-title"]); saveAllDiv.createEl("div").addClass("discovery-break"); - const saveallButton = new import_obsidian12.ButtonComponent(saveAllDiv).setButtonText("Save all selected snippets").onClick(async () => { + const saveallButton = new import_obsidian13.ButtonComponent(saveAllDiv).setButtonText("Save all selected snippets").onClick(async () => { _DisplayController.defaultView = "discovery" /* DISCOVERY */; const loading = saveAllDiv.createEl("div"); loading.addClass("bouncing-loader"); @@ -22751,7 +23490,7 @@ var PiecesDatabase = class { } return vault.create(dbPath, '{"assets":[]}'); } - if (dataFile instanceof import_obsidian13.TFolder) { + if (dataFile instanceof import_obsidian14.TFolder) { await vault.delete(dataFile); return vault.create(dbPath, '{"assets":[]}'); } @@ -23126,7 +23865,7 @@ var fetchFormatTransferable = async ({ }; // src/settings/index.ts -var import_obsidian14 = require("obsidian"); +var import_obsidian15 = require("obsidian"); // src/actions/login.ts var login = async () => { @@ -23178,7 +23917,7 @@ var youtube_default = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAADwAAAAhwCAM var twitter_default = "data:image/png;base64,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"; // src/settings/index.ts -var PiecesSettingTab = class extends import_obsidian14.PluginSettingTab { +var PiecesSettingTab = class extends import_obsidian15.PluginSettingTab { constructor(app2, plugin) { super(app2, plugin); this.cloud = CloudService.getInstance(); @@ -23189,36 +23928,36 @@ var PiecesSettingTab = class extends import_obsidian14.PluginSettingTab { const config2 = ConnectorSingleton.getInstance(); containerEl.empty(); containerEl.createEl("h1", { text: "Pieces Settings" }); - new import_obsidian14.Setting(containerEl).setName(Constants.SHOW_TUTORIAL).setDesc(Constants.TUTORIAL_DESCRIPTION).addButton( + new import_obsidian15.Setting(containerEl).setName(Constants.SHOW_TUTORIAL).setDesc(Constants.TUTORIAL_DESCRIPTION).addButton( (comp) => comp.setButtonText("Show").onClick(() => { this.plugin.showOnboarding(); }).setClass("button") ); - new import_obsidian14.Setting(containerEl).setName(Constants.TOGGLE_AUTOOPEN).setDesc(Constants.TOGGLE_AUTOOPEN_DESC).addToggle( + new import_obsidian15.Setting(containerEl).setName(Constants.TOGGLE_AUTOOPEN).setDesc(Constants.TOGGLE_AUTOOPEN_DESC).addToggle( (comp) => comp.setValue(this.plugin.settings.autoOpen).onChange((value) => { this.plugin.settings.autoOpen = value; this.plugin.saveSettings(); }) ); - new import_obsidian14.Setting(containerEl).setName(Constants.ENRICH_PERSISTENCE).setDesc(Constants.ENRICH_PERSISTENCE_DESC).addToggle((comp) => { + new import_obsidian15.Setting(containerEl).setName(Constants.ENRICH_PERSISTENCE).setDesc(Constants.ENRICH_PERSISTENCE_DESC).addToggle((comp) => { comp.setValue(this.plugin.settings.enrich_confirmation).onChange((value) => { this.plugin.settings.enrich_confirmation = value; this.plugin.saveSettings(); }); }); - new import_obsidian14.Setting(containerEl).setName(Constants.TOGGLE_AUTODISCOVER).setDesc(Constants.TOGGLE_AUTODISCOVER_DESC).addToggle( + new import_obsidian15.Setting(containerEl).setName(Constants.TOGGLE_AUTODISCOVER).setDesc(Constants.TOGGLE_AUTODISCOVER_DESC).addToggle( (comp) => comp.setValue(this.plugin.settings.autoDiscover).onChange(async (value) => { this.plugin.settings.autoDiscover = value; this.plugin.saveSettings(); }) ); - new import_obsidian14.Setting(containerEl).setName(Constants.TOGGLE_USE_NOTE_TITLE).setDesc(Constants.TOGGLE_USE_NOTE_TITLE_DESC).addToggle((comp) => { + new import_obsidian15.Setting(containerEl).setName(Constants.TOGGLE_USE_NOTE_TITLE).setDesc(Constants.TOGGLE_USE_NOTE_TITLE_DESC).addToggle((comp) => { comp.setValue(this.plugin.settings.use_note_title).onChange(async (value) => { this.plugin.settings.use_note_title = value; this.plugin.saveSettings(); }); }); - new import_obsidian14.Setting(containerEl).setName(Constants.TOGGLE_AUTODISCOVER_MAX).setDesc(Constants.TOGGLE_AUTODISCOVER_DESC_MAX).addSlider( + new import_obsidian15.Setting(containerEl).setName(Constants.TOGGLE_AUTODISCOVER_MAX).setDesc(Constants.TOGGLE_AUTODISCOVER_DESC_MAX).addSlider( (comp) => comp.setLimits(1, 200, 1).setDynamicTooltip().setValue(this.plugin.settings.autoDiscoverMaximum).onChange(async (value) => { this.plugin.settings.autoDiscoverMaximum = value; if (DisplayController.discoveryProgressBar) @@ -23226,7 +23965,7 @@ var PiecesSettingTab = class extends import_obsidian14.PluginSettingTab { await this.plugin.saveSettings(); }) ); - new import_obsidian14.Setting(containerEl).setName(Constants.CLOUD_SELECT).setDesc(Constants.CLOUD_SELECT_DESC).addDropdown( + new import_obsidian15.Setting(containerEl).setName(Constants.CLOUD_SELECT).setDesc(Constants.CLOUD_SELECT_DESC).addDropdown( (comp) => comp.addOptions({ blended: "Blended", local: "Local", @@ -23239,10 +23978,10 @@ var PiecesSettingTab = class extends import_obsidian14.PluginSettingTab { } ) ); - new import_obsidian14.Setting(containerEl).setName(Constants.PORT_PROMPT).addText((comp) => comp.setValue(Constants.PORT_VALUE).setDisabled(true)).setDesc(Constants.PORT_DESCRIPTION); + new import_obsidian15.Setting(containerEl).setName(Constants.PORT_PROMPT).addText((comp) => comp.setValue(Constants.PORT_VALUE).setDisabled(true)).setDesc(Constants.PORT_DESCRIPTION); let user = (await config2.userApi.userSnapshot()).user; if (user) { - new import_obsidian14.Setting(containerEl).setName(Constants.LOGOUT_TITLE).setDesc(Constants.LOGOUT_DESC).addButton( + new import_obsidian15.Setting(containerEl).setName(Constants.LOGOUT_TITLE).setDesc(Constants.LOGOUT_DESC).addButton( (comp) => comp.setButtonText("Logout").onClick(async () => { const success = await logout(); if (success) { @@ -23251,7 +23990,7 @@ var PiecesSettingTab = class extends import_obsidian14.PluginSettingTab { }).setClass("button") ); } else { - new import_obsidian14.Setting(containerEl).setName(Constants.LOGIN_TITLE).setDesc(Constants.LOGIN_DESC).addButton( + new import_obsidian15.Setting(containerEl).setName(Constants.LOGIN_TITLE).setDesc(Constants.LOGIN_DESC).addButton( (comp) => comp.setButtonText("Login").onClick(async () => { const success = await login(); user = (await config2.userApi.userSnapshot()).user; @@ -23399,10 +24138,10 @@ var DEFAULT_SETTINGS = { }; // src/ui/views/pieces-snippet-list-view.ts -var import_obsidian20 = require("obsidian"); +var import_obsidian21 = require("obsidian"); // src/ui/views/GPTController.ts -var import_obsidian19 = require("obsidian"); +var import_obsidian20 = require("obsidian"); // src/actions/qgpt.ts var QGPT = class { @@ -25792,7 +26531,7 @@ var lexer = Lexer.lex; // src/ui/plugins/SaveToPiecesWidget.ts var import_view = require("@codemirror/view"); -var import_obsidian16 = require("obsidian"); +var import_obsidian17 = require("obsidian"); // src/actions/auto_link.ts var AutoLinker = class { @@ -25975,7 +26714,7 @@ var DebounceNCS = class { }; // src/ui/modals/enriched-modal.ts -var import_obsidian15 = require("obsidian"); +var import_obsidian16 = require("obsidian"); // assets/Robot_Enrich.png var Robot_Enrich_default = "data:image/png;base64,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"; @@ -25984,7 +26723,7 @@ var Robot_Enrich_default = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAChAAAA var Robot_Enrich_DM_default = "data:image/png;base64,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"; // src/ui/modals/enriched-modal.ts -var EnrichedModal = class extends import_obsidian15.Modal { +var EnrichedModal = class extends import_obsidian16.Modal { constructor(app2, enrichButton, code) { super(app2); this.code = code; @@ -26004,14 +26743,14 @@ var EnrichedModal = class extends import_obsidian15.Modal { enrichConfirmImg.setAttr("width", "auto"); const btnRow = this.contentEl.createDiv(); btnRow.addClass("enrich-btn-row"); - new import_obsidian15.ButtonComponent(btnRow).setButtonText("Yes").setIcon("check").onClick(() => { + new import_obsidian16.ButtonComponent(btnRow).setButtonText("Yes").setIcon("check").onClick(() => { const clickEvent = new Event("click"); const cache2 = PiecesCacheSingleton.getInstance(); cache2.setIsEnriched(this.code, false); this.enrichButton.buttonEl.dispatchEvent(clickEvent); this.close(); }).setClass("enrich-confirm-btn").setTooltip("Continue enrichment"); - new import_obsidian15.ButtonComponent(btnRow).setButtonText("No").onClick(() => { + new import_obsidian16.ButtonComponent(btnRow).setButtonText("No").onClick(() => { this.close(); }).setIcon("x").setClass("enrich-deny-btn").setTooltip("Cancel enrichment"); } @@ -26047,7 +26786,7 @@ var SaveToPiecesWidget = class extends import_view.WidgetType { } }; this.enrichButton = (container, holderDiv) => { - const enrichBtn = new import_obsidian16.ButtonComponent(container).onClick(async () => { + const enrichBtn = new import_obsidian17.ButtonComponent(container).onClick(async () => { var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k; const cache2 = PiecesCacheSingleton.getInstance(); if (cache2.getIsEnriched(this.codeBlock) && pluginSettings.enrich_confirmation) { @@ -26112,7 +26851,7 @@ var SaveToPiecesWidget = class extends import_view.WidgetType { }).setTooltip("Enrich code snippet").setClass("save-to-pieces-btn").setIcon("sparkles"); }; this.expandButton = (container, ID) => { - const expandButton = new import_obsidian16.ButtonComponent(container).onClick(async () => { + const expandButton = new import_obsidian17.ButtonComponent(container).onClick(async () => { if (!ID) { this.notifications.error({ message: Constants.EXPAND_ERROR @@ -26127,7 +26866,7 @@ var SaveToPiecesWidget = class extends import_view.WidgetType { return expandButton; }; this.shareButton = (container, holderDiv) => { - const shareButton = new import_obsidian16.ButtonComponent(container).onClick(async () => { + const shareButton = new import_obsidian17.ButtonComponent(container).onClick(async () => { const loading = holderDiv.createEl("div"); loading.addClass("share-code-bouncing-loader"); loading.createEl("div"); @@ -26172,18 +26911,36 @@ var SaveToPiecesWidget = class extends import_view.WidgetType { return shareButton; }; this.copyButton = (container) => { - const copyButton = new import_obsidian16.ButtonComponent(container).onClick(async () => { + const copyButton = new import_obsidian17.ButtonComponent(container).onClick(async () => { var _a; if (this.lang && this.codeBlock && this.codeBlock.substring(0, 3) !== "```\n") { this.codeBlock = "```" + this.lang + "\n" + this.codeBlock + "```"; } copyToClipboard((_a = this.codeBlock) != null ? _a : this.codeRaw); - new import_obsidian16.Notice("Snippet copied to clipboard!"); + new import_obsidian17.Notice("Snippet copied to clipboard!"); }).setTooltip("Copy code to clipboard").setClass("save-to-pieces-btn").setIcon("copy"); return copyButton; }; + this.editButton = (container, id) => { + const editBtn = new import_obsidian17.ButtonComponent(container).setIcon("pencil").setTooltip("Edit snippet").onClick(async () => { + new EditModal( + app, + PiecesCacheSingleton.getInstance().mappedAssets[id] + ).open(); + }).setClass("button"); + editBtn.buttonEl.classList.add("mr-1"); + }; + this.annotationsButton = (container, id) => { + const annotationButton = new import_obsidian17.ButtonComponent(container).setIcon("sticky-note").setTooltip("Edit annotations").onClick(async () => { + new AnnotationsModal( + app, + PiecesCacheSingleton.getInstance().mappedAssets[id] + ).open(); + }).setClass("button"); + annotationButton.buttonEl.classList.add("mr-1"); + }; this.saveButton = (container, holderDiv) => { - const saveButton = new import_obsidian16.ButtonComponent(container).onClick(async () => { + const saveButton = new import_obsidian17.ButtonComponent(container).onClick(async () => { const loading = holderDiv.createEl("div"); loading.addClass("share-code-bouncing-loader"); loading.createEl("div"); @@ -26237,7 +26994,7 @@ var SaveToPiecesWidget = class extends import_view.WidgetType { const { id } = this; const collapsedHolder = holderDiv.createDiv(); collapsedHolder.addClasses(["collapsed-pieces-holder", "collapsed"]); - const collapseControlButton = new import_obsidian16.ButtonComponent(holderDiv).onClick(async () => { + const collapseControlButton = new import_obsidian17.ButtonComponent(holderDiv).onClick(async () => { clearTimeout(this.tempCollapseTimer); if (collapsedHolder.classList.contains("collapsed")) { if (!this.piecesPreview) { @@ -26248,16 +27005,20 @@ var SaveToPiecesWidget = class extends import_view.WidgetType { if (id && this.cache.mappedAssets[id]) { this.expandButton(collapsedHolder, id); } else if (this.score > 0.97 && this.identifier && this.cache.mappedAssets[this.identifier]) { - this.expandButton(collapsedHolder, this.identifier); + this.expandButton(collapsedHolder, id != null ? id : this.identifier); + this.editButton(collapsedHolder, id != null ? id : this.identifier); + this.annotationsButton(collapsedHolder, id != null ? id : this.identifier); } else { this.saveButton(collapsedHolder, holderDiv); } } else { this.copyButton(collapsedHolder); + this.editButton(collapsedHolder, id != null ? id : this.identifier); + this.annotationsButton(collapsedHolder, id != null ? id : this.identifier); } this.shareButton(collapsedHolder, holderDiv); collapsedHolder.classList.remove("collapsed"); - const computedWidth = (5 + 42) * collapsedHolder.childElementCount; + const computedWidth = 47 * collapsedHolder.childElementCount; collapsedHolder.style.width = computedWidth + "px"; this.tempCollapseTimer = setTimeout(() => { this.tempCollapseTimer = void 0; @@ -26317,7 +27078,7 @@ var PlaceHolderWidget = class extends import_view.WidgetType { }; // src/actions/open_vault_note.ts -var import_obsidian17 = require("obsidian"); +var import_obsidian18 = require("obsidian"); var openVaultNote = (myPath) => { const cleanedPath = myPath.substring(myPath.lastIndexOf("/") + 1); const vaultFiles = app.vault.getFiles(); @@ -26332,7 +27093,7 @@ var openVaultNote = (myPath) => { console.error(`Target file error: ${targetFile}`); } } catch (e) { - new import_obsidian17.Notice(`Error opening ${myPath}, the file may not exist.`); + new import_obsidian18.Notice(`Error opening ${myPath}, the file may not exist.`); } }; @@ -26343,8 +27104,8 @@ var piecesCopilotW_default = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABvgA var piecesCopilotB_default = "data:image/png;base64,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"; // src/ui/modals/context-modal.ts -var import_obsidian18 = require("obsidian"); -var ContextModal = class extends import_obsidian18.Modal { +var import_obsidian19 = require("obsidian"); +var ContextModal = class extends import_obsidian19.Modal { constructor(app2) { super(app2); this.cache = PiecesCacheSingleton.getInstance(); @@ -26380,12 +27141,23 @@ var ContextModal = class extends import_obsidian18.Modal { }; currentNode.children.push(childNode); } - currentNode.children = currentNode.children.sort((a, b) => { - return b.children.length - a.children.length; - }); currentNode = childNode; } }); + const sortNodes = (node) => { + node.children = node.children.sort((a, b) => { + if (a.children.length && !b.children.length) { + return -1; + } else if (b.children.length && !a.children.length) { + return 1; + } + return a.name.localeCompare(b.name); + }); + for (const child of node.children) { + sortNodes(child); + } + }; + sortNodes(root); this.tree = root; return root; } @@ -26710,7 +27482,7 @@ GPTController.getProfile = async () => { img.src = profilePic; _GPTController.userSVG = img; } else { - _GPTController.userSVG = (0, import_obsidian19.getIcon)("userSVG"); + _GPTController.userSVG = (0, import_obsidian20.getIcon)("userSVG"); } }; GPTController.createGPTView = async ({ @@ -26729,7 +27501,7 @@ GPTController.createGPTView = async ({ const contextSpan = textDiv.createDiv(); contextSpan.addClasses(["gpt-context"]); contextSpan.title = "Select context"; - (0, import_obsidian19.setIcon)(contextSpan, "settings"); + (0, import_obsidian20.setIcon)(contextSpan, "settings"); contextSpan.onmouseup = async () => { _GPTController.contextModal.open(); }; @@ -26797,7 +27569,7 @@ GPTController.createGPTView = async ({ inputText.spellcheck = true; _GPTController.inputBox = inputText; const sendDiv = inputDiv.createEl("div"); - (0, import_obsidian19.setIcon)(sendDiv, "sendSVG"); + (0, import_obsidian20.setIcon)(sendDiv, "sendSVG"); sendDiv.addClasses(["gpt-img-small", "col-reverse", "justify-between"]); const sendSVG = sendDiv.firstChild; sendSVG.addClass("gpt-send-unactive"); @@ -26899,14 +27671,14 @@ GPTController.handleChat = async ({ _GPTController.userSVG.addClasses(["gpt-user-image"]); userDiv.appendChild(_GPTController.userSVG.cloneNode(true)); } else { - (0, import_obsidian19.setIcon)(userDiv, "userSVG"); + (0, import_obsidian20.setIcon)(userDiv, "userSVG"); } userDiv.addClasses(["gpt-img"]); textAreaDiv.prepend(queryDiv); const answerDiv = document.createElement("div"); answerDiv.addClasses(["gpt-row", "gpt-left-align"]); const aiDiv = answerDiv.createEl("div"); - (0, import_obsidian19.setIcon)(aiDiv, "aiSVG"); + (0, import_obsidian20.setIcon)(aiDiv, "aiSVG"); aiDiv.addClasses(["gpt-img"]); const answerEl = answerDiv.createEl("p"); answerEl.addClasses(["gpt-text-response", "gpt-response", "gpt-col"]); @@ -27013,14 +27785,14 @@ GPTController.buildCurrentConversation = (textAreaDiv) => { _GPTController.userSVG.addClasses(["gpt-user-image"]); userDiv.appendChild(_GPTController.userSVG.cloneNode(true)); } else { - (0, import_obsidian19.setIcon)(userDiv, "userSVG"); + (0, import_obsidian20.setIcon)(userDiv, "userSVG"); } userDiv.addClasses(["gpt-img"]); textAreaDiv.prepend(queryDiv); const answerDiv = document.createElement("div"); answerDiv.addClasses(["gpt-row", "gpt-left-align"]); const aiDiv = answerDiv.createEl("div"); - (0, import_obsidian19.setIcon)(aiDiv, "aiSVG"); + (0, import_obsidian20.setIcon)(aiDiv, "aiSVG"); aiDiv.addClasses(["gpt-img"]); const answerEl = answerDiv.createEl("p"); answerEl.addClasses(["gpt-text-response", "gpt-response", "gpt-col"]); @@ -27082,7 +27854,7 @@ GPTController.renderHints = ({ hintButtonText.textContent = hints.answers.iterable[i].text; const hintIcon = hintButton.createEl("div"); hintIcon.addClasses(["gpt-icon", "gpt-icon-drift"]); - (0, import_obsidian19.setIcon)(hintIcon, "sendSVG"); + (0, import_obsidian20.setIcon)(hintIcon, "sendSVG"); } }; /** @@ -27160,11 +27932,11 @@ GPTController.createNotePill = (note, noteListRow) => { noteButtonText.textContent = noteName != null ? noteName : ""; const noteButtonIcon = noteButton.createEl("div"); noteButtonIcon.addClass("gpt-icon", "gpt-icon-note"); - (0, import_obsidian19.setIcon)(noteButtonIcon, "openNote"); + (0, import_obsidian20.setIcon)(noteButtonIcon, "openNote"); }; // src/ui/views/pieces-snippet-list-view.ts -var PiecesSnippetListView = class extends import_obsidian20.ItemView { +var PiecesSnippetListView = class extends import_obsidian21.ItemView { // Current Tab that is selected constructor(leaf) { super(leaf); @@ -27912,8 +28684,8 @@ var findSimilarity = async (codeBlock) => { }; // src/ui/modals/ask-qgpt-modal.ts -var import_obsidian21 = require("obsidian"); -var AskQGPTModal = class extends import_obsidian21.Modal { +var import_obsidian22 = require("obsidian"); +var AskQGPTModal = class extends import_obsidian22.Modal { constructor(app2, selection) { super(app2); this.text = selection; @@ -27946,7 +28718,7 @@ var AskQGPTModal = class extends import_obsidian21.Modal { sendCol.classList.add("ask-col"); inputCol.classList.add("ask-col", "ask-col-input"); const sendDiv = sendCol.createEl("div"); - (0, import_obsidian21.setIcon)(sendDiv, "sendSVG"); + (0, import_obsidian22.setIcon)(sendDiv, "sendSVG"); sendDiv.addClasses(["gpt-img", "ask-send-svg"]); const sendSVG = sendDiv.firstChild; sendSVG.addClass("gpt-send-unactive"); @@ -27984,7 +28756,7 @@ var AskQGPTModal = class extends import_obsidian21.Modal { await PiecesPlugin.activateView(); const query = this.inputText.innerText; if (!query) { - new import_obsidian21.Notice("Please enter a question for the Copilot!"); + new import_obsidian22.Notice("Please enter a question for the Copilot!"); return; } const gptTab = document.getElementById("gpt-tab"); @@ -28010,7 +28782,7 @@ ${this.text.trim()}` var pluginSettings; var theme = "dark"; var Prism; -var _PiecesPlugin = class extends import_obsidian22.Plugin { +var _PiecesPlugin = class extends import_obsidian23.Plugin { constructor() { super(...arguments); this.notifications = Notifications.getInstance(); @@ -28025,7 +28797,7 @@ var _PiecesPlugin = class extends import_obsidian22.Plugin { }) => { var _a, _b; const markdownView = this.app.workspace.activeEditor; - if (markdownView instanceof import_obsidian22.MarkdownView) { + if (markdownView instanceof import_obsidian23.MarkdownView) { const editor = markdownView.editor; const selection = editor.getSelection(); if (selection.length < 5) { @@ -28080,7 +28852,7 @@ var _PiecesPlugin = class extends import_obsidian22.Plugin { this.notifications.error({ message: Constants.UPDATE_OS }); } }); - Prism = await (0, import_obsidian22.loadPrism)(); + Prism = await (0, import_obsidian23.loadPrism)(); theme = document.body.classList.contains("theme-dark") ? "dark" : "light"; document.body.addEventListener("change", () => { this.themeChange(); @@ -28215,7 +28987,7 @@ var _PiecesPlugin = class extends import_obsidian22.Plugin { }; this.askQGPT = () => { const markdownView = this.app.workspace.activeEditor; - if (markdownView instanceof import_obsidian22.MarkdownView) { + if (markdownView instanceof import_obsidian23.MarkdownView) { const editor = markdownView.editor; const selection = editor.getSelection(); if (selection.length < 5) { @@ -28355,16 +29127,16 @@ var _PiecesPlugin = class extends import_obsidian22.Plugin { theme = temptheme; }; this.addIcons = () => { - (0, import_obsidian22.addIcon)("pieces_logo", Constants.PIECES_LOGO); - (0, import_obsidian22.addIcon)("codeSVG", Constants.CODE_ICON); - (0, import_obsidian22.addIcon)("aiSVG", Constants.AI_ICON); - (0, import_obsidian22.addIcon)("save-all", Constants.SAVE_ALL_ICON); - (0, import_obsidian22.addIcon)("sparkles", Constants.ENRICH_ICON); - (0, import_obsidian22.addIcon)("openNote", Constants.OPEN_ICON); - (0, import_obsidian22.addIcon)("aiSVG", Constants.AI_ICON); - (0, import_obsidian22.addIcon)("userSVG", Constants.USER_ICON); - (0, import_obsidian22.addIcon)("sendSVG", Constants.SEND_ICON); - (0, import_obsidian22.addIcon)("sendSVG2", Constants.SEND_ICON); + (0, import_obsidian23.addIcon)("pieces_logo", Constants.PIECES_LOGO); + (0, import_obsidian23.addIcon)("codeSVG", Constants.CODE_ICON); + (0, import_obsidian23.addIcon)("aiSVG", Constants.AI_ICON); + (0, import_obsidian23.addIcon)("save-all", Constants.SAVE_ALL_ICON); + (0, import_obsidian23.addIcon)("sparkles", Constants.ENRICH_ICON); + (0, import_obsidian23.addIcon)("openNote", Constants.OPEN_ICON); + (0, import_obsidian23.addIcon)("aiSVG", Constants.AI_ICON); + (0, import_obsidian23.addIcon)("userSVG", Constants.USER_ICON); + (0, import_obsidian23.addIcon)("sendSVG", Constants.SEND_ICON); + (0, import_obsidian23.addIcon)("sendSVG2", Constants.SEND_ICON); }; } }; diff --git a/manifest.json b/manifest.json index e55b277..6f468d8 100644 --- a/manifest.json +++ b/manifest.json @@ -1,7 +1,7 @@ { "id": "pieces-for-developers", "name": "Pieces for Developers", - "version": "1.2.2", + "version": "1.3.0", "minAppVersion": "0.15.0", "description": "Streamline your coding workflow in Obsidian with the Pieces For Developers plugin, offering powerful features for capturing, managing, translating, and enhancing code snippets. (Closed Source) ", "author": "Pieces For Developers", diff --git a/styles.css b/styles.css index d2fb0cb..8fded77 100644 --- a/styles.css +++ b/styles.css @@ -1 +1 @@ -*,::backdrop,:after,:before{--tw-border-spacing-x:0;--tw-border-spacing-y:0;--tw-translate-x:0;--tw-translate-y:0;--tw-rotate:0;--tw-skew-x:0;--tw-skew-y:0;--tw-scale-x:1;--tw-scale-y:1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness:proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:#3b82f680;--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: }.container{width:100%}@media (min-width:640px){.container{max-width:640px}}@media (min-width:768px){.container{max-width:768px}}@media (min-width:1024px){.container{max-width:1024px}}@media (min-width:1280px){.container{max-width:1280px}}@media (min-width:1536px){.container{max-width:1536px}}.collapse{visibility:collapse}.static{position:static}.absolute{position:absolute}.block{display:block}.flex{display:flex}.table{display:table}.hidden{display:none}.justify-between{justify-content:space-between}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.search-background{position:sticky;top:-21px;left:0;z-index:998;margin-top:-145px;margin-bottom:-14px;height:131px;flex-grow:1;background-color:var(--background-secondary)}.code-view{z-index:-1;height:auto;border-bottom-width:var(--background-modifier-border);border-bottom-color:solid}.code-view:last-child{border-bottom-color:none}.code-title-div{position:relative;margin-top:0;margin-bottom:0;display:flex;height:50px;flex-wrap:wrap;vertical-align:middle;justify-content:left}.code-title-div h1{position:absolute;left:38px;top:13.2px;margin-top:.125rem;height:30px;font-size:15px}.code-title-div img{position:absolute;left:7px;top:17.3px;margin-top:-3px;margin-right:.625rem;height:22px;width:22px}.code-title-div span{position:absolute;right:-1rem;margin-right:1.75rem;margin-top:.875rem;height:30px;font-size:17px}.code-button-input{z-index:997;order:-1;margin:0!important;display:block;height:49px!important;flex-grow:1;cursor:pointer;opacity:0}.code-title-div:hover{background:var(--background-primary)!important}.save-to-pieces-btn{margin-right:5px;margin-bottom:5px;height:29px;width:42px;cursor:pointer;align-items:left;background:none}.save-to-pieces-holder{margin-bottom:-11px;margin-right:.625rem;margin-top:-.75rem;display:flex;flex-wrap:wrap-reverse;justify-content:flex-end}.collapsed-pieces-holder{margin-right:0;margin-top:0;display:flex;--tw-rotate:0deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));overflow:hidden;overflow-y:visible}.collapsed-pieces-holder,.collapsed-pieces-holder.collapsed{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:.5s}.collapsed-pieces-holder.collapsed{width:0;flex-wrap:nowrap}.collapsed-pieces-holder.expanded{flex-wrap:wrap}.collapsed-pieces-holder+button svg{--tw-rotate:0deg}.collapsed-pieces-holder+button svg,.collapsed-pieces-holder.collapsed+button svg{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:.5s}.collapsed-pieces-holder.collapsed+button svg{--tw-rotate:360deg}.snippet{margin:.625rem .625rem .625rem 5px;overflow:hidden;border-radius:5px;background-color:var(--background-primary-alt);padding:.625rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.snippet-content-parent{cursor:pointer}.snippet_line_number{color:var(--text-faint);font-family:Consolas,monospace}.gpt-input-textarea::-webkit-scrollbar,.snippet_pre::-webkit-scrollbar{display:none}.snippet_pre{margin-top:0;display:inline-block;-webkit-user-select:text;-moz-user-select:text;user-select:text;overflow-x:scroll}.pieces-parent::-webkit-scrollbar{display:none}.pieces-parent{position:relative;height:auto;max-height:210px;overflow:hidden;overflow-y:scroll;white-space:nowrap;border-radius:5px;font-size:var(--code-size)}#editParent{max-height:400px}.rawCode::-webkit-scrollbar{display:none}.rawCode{z-index:0;margin-left:35px;margin-right:1px;overflow-x:scroll;padding-right:25px}.lineNums{position:absolute;top:0;z-index:1;width:-moz-fit-content;width:fit-content;white-space:nowrap;padding-left:7px;text-align:right}.vertBreak{padding-left:5px}.buttonDiv{margin-top:15.5px;display:flex;flex-wrap:nowrap;justify-content:flex-end}.footerDiv{display:flex;justify-content:space-between}.button,.button_copy,.button_delete,.button_delete_modal,.button_refresh{cursor:pointer;padding-left:.75rem;padding-right:.75rem}.button_delete{margin-top:15.5px;--tw-text-opacity:1;color:rgb(244 67 54/var(--tw-text-opacity));opacity:.9;background:none!important;pointer-events:painted}.button_delete_modal{margin-right:0;margin-top:-.5rem;height:2.5rem;width:5rem;border-radius:10%;--tw-bg-opacity:1!important;background-color:rgb(244 67 54/var(--tw-bg-opacity))!important;font-size:medium;--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity));pointer-events:painted}.button_delete_modal_title{--tw-text-opacity:1;color:rgb(244 67 54/var(--tw-text-opacity))}.button_refresh{right:-7px;top:30px;margin-right:0;margin-top:0;cursor:pointer;align-self:flex-end;border-style:none;background-color:initial;font-size:1.25rem;line-height:1.75rem;font-weight:700;outline:2px solid #0000;outline-offset:2px;pointer-events:painted}.title_div{position:sticky;z-index:999;margin-bottom:5px;display:flex;align-content:center;justify-content:space-between;overflow:hidden}.sort-dropdown{margin:0;width:121px;cursor:pointer}.sort-dropdown:focus{border-color:none;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow);background:var(--interactive-normal)!important}.search-box-div{position:sticky;left:0;top:30px;z-index:999;margin-bottom:6px;display:flex}.input-search{margin-right:.5rem;margin-top:3px;height:46px;flex-grow:1;overflow-x:hidden;border-radius:.375rem;border-bottom:1px #ffffff80;border-style:none;padding:.625rem 2.5rem .625rem .625rem;font-size:1.125rem;line-height:1.75rem;letter-spacing:0;--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity))}.input-search,.input-search:hover{background-color:initial;transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.5s;transition-timing-function:cubic-bezier(0,.11,.35,1.3)}.input-search:hover{width:250px;border-radius:.375rem;border-bottom:1px #ffffff80;border-style:solid}.input-search{outline:none;font:caption!important}.input-search::-moz-placeholder{font-size:1.125rem;line-height:1.75rem;font-size:small;font-weight:100;letter-spacing:0;color:#ffffff80}.input-search::placeholder{font-size:1.125rem;line-height:1.75rem;font-size:small;font-weight:100;letter-spacing:0;color:#ffffff80}.settings_divider{margin-top:5px;margin-bottom:1.25rem}.settings_external_links_section{display:flex;justify-content:space-around;padding:0 .625rem}.settings_external_links_section img{width:auto;cursor:pointer}.onboarding_image,.settings_external_links{-webkit-user-select:none;-moz-user-select:none;user-select:none;-webkit-user-drag:none}.onboarding_image{pointer-events:none;margin-top:0;margin-bottom:0;margin-left:15px;height:800px;width:500px}.opening-div{margin-left:0;margin-top:0;height:-moz-fit-content;height:fit-content}.button-div{margin-top:0;margin-bottom:0;display:flex;justify-content:center}.snippet-container{background-color:var(--background-modifier)}.last-snippet{border-bottom-right-radius:5%;border-bottom-left-radius:5%;padding-bottom:3px;border-bottom:none!important}.first-snippet,.only-snippet{border-top-left-radius:5%;border-top-right-radius:5%}.only-snippet{border-bottom-right-radius:5%;border-bottom-left-radius:5%;border-bottom-color:none;padding-bottom:3px}.list-view{display:flex;flex-direction:column;background-color:var(--background-modifier)}.list-view,.list-view:hover{border-bottom-width:1px;border-bottom-color:var(--background-modifier-border)}.list-view:hover{background-color:var(--background-primary)}.list-view{border-bottom-style:solid}.list-title-div{margin:.375rem .375rem -.375rem;display:flex;justify-content:space-between;align-items:top}.list-title-div img{margin-right:.125rem;margin-top:.875rem;margin-bottom:0;height:1.25rem;width:1.25rem}.list-title-wrapper{display:flex;overflow:auto}.list-title-div h4{margin-top:.75rem;margin-bottom:.75rem;font-size:medium;color:var(--text-primary);-webkit-line-clamp:2}.list-body,.list-title-div h4{overflow:hidden;text-overflow:ellipsis;display:-webkit-box;-webkit-box-orient:vertical}.list-body{margin-bottom:.625rem;max-height:4rem;padding-left:.875rem;padding-right:.875rem;font-size:small;color:var(--text-muted);-webkit-line-clamp:3}.list-button-container{margin-left:11px;display:flex;align-items:center}.list-button-input{position:absolute;top:-7px;left:.5rem;z-index:-1;margin-top:-29.5px;margin-left:.125rem;display:block;height:22px;width:87px;cursor:pointer;opacity:0}.list-button-container span{z-index:1;margin-left:.25rem;cursor:pointer;font-size:small;color:var(--text-primary)}.settings-div{margin-top:.75rem;display:flex;align-items:center;justify-content:center}.settings-div img{pointer-events:none;height:auto;width:auto;max-width:300px;flex-basis:100%;-webkit-user-select:none;-moz-user-select:none;user-select:none;-webkit-user-drag:none}.loading-div{flex-direction:column}.loading-div,.loading-div-row{margin-top:30px;display:flex;align-items:center;justify-content:center}.loading-div-row{flex-direction:row}.loading-div-col{display:flex;flex-direction:column;align-items:center;justify-content:center}.loading-div-button{display:flex;width:100%;flex-direction:row;justify-content:center;text-align:center}.loading-div-button button{cursor:pointer}.loading-div img{height:auto;width:auto;max-width:200px;flex-basis:100%}.loading-div h4{margin-top:.75rem;height:auto;width:auto;text-align:center;font-size:small}.new-div{margin-top:50px;display:flex;align-items:center;justify-content:center}.new-div img{height:auto;width:auto;max-width:200px;flex-basis:100%}.new-div h4{margin-top:-.625rem;margin-bottom:26px;height:auto;width:auto;max-width:219px;text-align:left;font-size:small}.expand-icon{position:absolute;right:0;top:0;height:22px;width:22px;cursor:pointer;border-radius:7px;background-color:var(--background-primary-alt);padding:.125rem}.expand-wrapper{position:sticky;top:0}@keyframes bouncing-loader{to{opacity:.1;transform:translate3d(0,-4px,0)}}.bouncing-loader,.refresh-bouncing-loader,.share-code-bouncing-loader{margin-top:-5px;margin-left:.125rem;display:flex;height:31px;width:39px;justify-content:center}.refresh-bouncing-loader{margin-top:-.125rem}.share-code-bouncing-loader{margin-right:5px}.bouncing-loader>div,.refresh-bouncing-loader>div,.share-code-bouncing-loader>div{margin:18px .1rem 0;height:.5rem;width:.5rem;animation:bouncing-loader .5s infinite alternate;border-radius:50%;background:var(--background-modifier-border-focus)}.bouncing-loader>div:nth-child(2),.refresh-bouncing-loader>div:nth-child(2),.share-code-bouncing-loader>div:nth-child(2){animation-delay:.2s}.bouncing-loader>div:nth-child(3),.refresh-bouncing-loader>div:nth-child(3),.share-code-bouncing-loader>div:nth-child(3){animation-delay:.4s}div[theme=dark] button{--tw-bg-opacity:1;background-color:rgb(255 255 255/var(--tw-bg-opacity));--tw-text-opacity:1;color:rgb(0 0 0/var(--tw-text-opacity))}div[theme=light] button{--tw-bg-opacity:1;background-color:rgb(0 0 0/var(--tw-bg-opacity));--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity))}.edit-form-row{display:flex;width:100%;flex-direction:row;justify-content:center}.edit-form-desc{padding-left:5px;padding-right:.5rem}.justify-left{justify-content:left}.edit-form-col{margin:.5rem;display:flex;width:100%;flex-direction:column}.col-small{width:-moz-fit-content;width:fit-content}.edit-form{display:flex;width:100%;max-width:550px;flex-direction:column}.edit-title-input{font-weight:600;background:#0000!important}.edit-dropdown{max-height:50px;cursor:pointer;overflow-y:scroll;text-align:center}.edit-dropdown,.edit-dropdown:focus{border-width:var(--input-border-width);border-style:solid;border-color:var(--background-modifier-border)}.edit-dropdown:focus{--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.edit-dropdown,.edit-dropdown:focus{background:#0000!important}.edit-text,.edit-text-title{margin-top:.625rem;margin-bottom:.625rem;font-size:smaller;opacity:.8}.edit-text-title{margin-bottom:0;font-size:x-large;opacity:.9}.verticalAlign{align-items:center}.delTitle{color:rgb(244 67 54/var(--tw-text-opacity));opacity:.8}.delTitle,nav{--tw-text-opacity:1}nav{position:absolute;left:0;top:0;z-index:99999999;display:flex;height:2.5rem;width:100%;justify-content:space-evenly;color:rgb(150 240 177/var(--tw-text-opacity));background:#0000}nav a{padding:.625rem;font-size:1.4rem;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity));text-decoration-line:none}.content{height:100%;width:750px}.content,.item{display:flex}.item{width:250px;flex-direction:column;align-items:center;justify-content:center;row-gap:25px;font-family:bolder;font-size:3rem;line-height:1;--tw-text-opacity:1;color:rgb(0 0 0/var(--tw-text-opacity));background:var(--background-secondary)}.link{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:.3s}.wrapper{position:absolute;z-index:9999999;margin-top:-5px;margin-bottom:1.25rem;display:flex;width:-webkit-fill-available;justify-content:center;padding-right:15.5px}:root{--primary-color:#111;--secondary-color:#a8adb3}.tabs{position:relative;display:flex;height:1.75rem;width:100px;border-radius:.375rem;background-color:var(--interactive-normal);--tw-shadow-color:var(--input-shadow);--tw-shadow:var(--tw-shadow-colored)}.tabs .aiSVG{margin-left:.75rem;height:1.75rem;width:1.75rem}.tabs *{z-index:2}input[type=radio]{display:none}.tab{display:flex;height:100%;width:100%;cursor:pointer;align-items:center;justify-content:center;border-radius:.375rem;letter-spacing:.01em;transition-property:color;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-timing-function:ease-in;vertical-align:center}input[type=radio]+.tab svg,input[type=radio]:checked+.tab{--tw-text-opacity:1;color:rgb(107 107 107/var(--tw-text-opacity))}input[id=radio-1]:checked~.glider{--tw-translate-x:0px}input[id=radio-1]:checked~.glider,input[id=radio-2]:checked~.glider{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}input[id=radio-2]:checked~.glider{--tw-translate-x:101%}.glider{position:absolute;left:0;top:0;z-index:1;display:flex;height:100%;width:50%;border-radius:.375rem;border-width:1px;border-style:solid;border-color:var(--text-faint);background-color:var(--text-muted);--tw-shadow-color:var(--input-shadow);--tw-shadow:var(--tw-shadow-colored);transition-property:.25s;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:ease-out}.glider-light{background-color:var(--background-modifier-box-shadow)}.tabs svg{pointer-events:none;color:var(--text-normal)}.gpt-row,.gpt-row-full,.gpt-row-response,.gpt-row-small{display:flex;max-width:100%;flex-direction:row}.gpt-col,.gpt-col-reverse,.gpt-col-small{display:flex;min-width:100%;max-width:100%;flex-direction:column}.gpt-col-small{min-width:0}.gpt-col-reverse{flex-direction:column-reverse}.gpt-container{margin:0;display:flex;height:100%}.gpt-input{margin-top:1rem;margin-bottom:25px;height:-moz-fit-content;height:fit-content;align-items:flex-start;justify-content:center;border-radius:10px;border-width:1px;background-color:var(--background-secondary);padding-top:1rem;padding-bottom:1rem;padding-left:1rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.gpt-input-textarea{display:block;max-height:100px;width:100%;cursor:text;resize:none;overflow:hidden;overflow-y:scroll;overflow-wrap:break-word;padding-right:3rem;text-align:start;line-height:1.25rem;color:inherit;font-family:inherit}.gpt-input-textarea[contenteditable]:empty:before{--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity));--tw-content:"Paste some code or ask a technical question...";content:var(--tw-content)}.gpt-text-content{margin-top:-18px;min-height:50%;flex:1 1 0%;overflow-y:scroll;border-radius:10px;padding:26px 26px 0;word-wrap:break-word}.gpt-text-area{height:100%;max-height:none;overflow-y:scroll}.gpt-text-div{margin-top:34px;display:flex;flex-basis:100%;flex-direction:column;overflow-y:scroll;border-radius:10px;background-color:var(--background-secondary);--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color)}.gpt-text-div,.gpt-text-div-light{box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.gpt-text-div-light{--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color)}.gpt-text-area::-webkit-scrollbar,.gpt-text-content::-webkit-scrollbar,.gpt-text-div::-webkit-scrollbar{display:none}.gpt-text-response{margin-top:0;margin-bottom:.625rem;width:-moz-fit-content;width:fit-content;-webkit-user-select:text;-moz-user-select:text;user-select:text;border-radius:10px;padding:.75rem;text-align:left;font-size:.875rem;line-height:1.25rem;word-break:break-word}.gpt-right-align{justify-content:flex-end}.gpt-left-align{justify-content:flex-start}.gpt-query{margin-right:.5rem;background-color:var(--interactive-accent)}.gpt-response{min-width:0;background-color:var(--interactive-normal)}.gpt-img,.gpt-img-small{display:flex;min-height:30px;min-width:30px;justify-content:center}.gpt-icon{display:flex;height:30px;width:30px;align-items:center}.gpt-icon-note{height:.875rem;width:.875rem}.gpt-icon-drift{margin-right:-.75rem}.gpt-icon-drift svg{position:static}.aiSVG,.userSVG{margin-top:7px;color:var(--text-muted);width:30px!important;height:30px!important}.sendSVG{right:23px;bottom:54px;height:25px;width:25px;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.gpt-img-small{margin-bottom:19px;margin-top:auto;height:0;min-height:0;width:0;cursor:pointer}.gpt-cancel{right:0;bottom:0;margin-right:.625rem;margin-top:5px;margin-bottom:7px;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.gpt-cancel,.gpt-context{position:sticky;width:-moz-fit-content;width:fit-content;cursor:pointer;align-self:flex-end;font-size:smaller}.gpt-context{margin-right:7px;margin-top:.625rem;color:var(--text-normal)}.gpt-text-intro{display:flex;height:100%;width:100%;align-items:center;justify-content:center;padding-left:.375rem;padding-right:.375rem}.gpt-text-intro-content{margin-top:0;text-align:center;color:var(--text-muted)}.gpt-text-intro-title{margin-bottom:.5rem;font-size:32px;font-weight:600;color:var(--text-normal)}.gpt-text-intro-title-div{padding-left:10%;padding-right:10%}.gpt-parent{height:100%}.hint-btn,.hint-btn-note{margin:.25rem .125rem;display:inline-flex;cursor:pointer;align-items:center;overflow:hidden;white-space:normal;border-radius:1rem;border-color:none;padding:1rem .375rem;text-align:center;font-size:.75rem;line-height:1rem;color:var(--text-normal);text-decoration-line:none;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow);word-break:break-word}.hint-btn-note{background-color:var(--background-modifier-border-hover)}.hint-btn-note:hover{background-color:var(--background-modifier-hover)}.hint-btn{background-color:var(--interactive-normal)}.hint-btn:hover{background-color:var(--interactive-hover)}#gpt-hints-container{justify-content:center;padding-left:1.25rem;padding-right:1.25rem}.hint-title{margin:.125rem .125rem .125rem .625rem;justify-content:center;align-self:flex-start;font-size:.75rem;line-height:1rem;color:var(--text-muted)}.hint-list{margin-left:.5rem;margin-right:.5rem;max-height:77px}.hint-list,.hint-list-note{overflow:hidden;overflow-y:scroll;border-radius:5px}.hint-list-note{margin-top:-.75rem;margin-bottom:-.5rem;max-height:82px;border-color:var(--background-modifier-border)}.hint-list-note::-webkit-scrollbar,.hint-list::-webkit-scrollbar{display:none}.hint-btn-text{margin-right:.25rem;text-overflow:ellipsis;padding-left:1px;text-align:center;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical}.gpt-query pre code,.gpt-response pre code,.hint-btn-text{width:100%}.gpt-query pre code,.gpt-response pre code{margin-top:.5rem;margin-bottom:.75rem;min-height:20px;-webkit-user-select:text;-moz-user-select:text;user-select:text;overflow:hidden;white-space:pre-wrap;border-radius:5px;background-color:var(--background-primary-alt);padding-left:.25rem;padding-right:.25rem;--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.gpt-response-margin-delete{margin:0}.gpt-response-button-div{margin-right:-14px;margin-bottom:-13px}.gpt-img-logo{height:4rem;padding-bottom:.5rem;opacity:.8}p.gpt-response-margin-delete code{display:inline;white-space:pre-line;border-radius:5px;background-color:var(--background-modifier-active-hover);padding-left:.25rem;padding-right:.25rem}.gpt-user-image{margin-top:5px;height:1.5rem;width:1.5rem;border-radius:50%}.hint-title-note{font-size:.75rem;line-height:1rem;font-weight:400;color:var(--text-muted)}.gpt-rel-wrap{flex-wrap:wrap}.gpt-hint-col{border-radius:5px}.gpt-hint-row{padding-top:7px}.gpt-send-active{color:var(--interactive-accent)}.gpt-send-unactive{--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.discovery-div{margin-left:.25rem;justify-content:flex-end;white-space:nowrap}.discovery-div,.discovery-div-inner{display:flex;flex-wrap:nowrap;align-items:center;overflow:hidden}.discovery-title{color:var(--text-muted)}.discovery-break{padding-left:.5rem}.discovery-checkbox{margin-left:13px!important;margin-right:0!important;margin-top:22px!important}.discovery-seperator{margin-left:26px;margin-right:0;margin-top:1rem}.discovery-div-parent{position:sticky;height:0;width:0}.context-row{display:flex;width:100%;flex-direction:row;justify-content:space-between}.context-col{display:flex;height:100%;flex-direction:column}.context-parent{margin-top:.875rem;display:flex;max-height:600px;min-height:600px;width:100%;flex-direction:row;overflow:hidden}.context-preview{margin-top:-9px;overflow:hidden;overflow-x:scroll;overflow-y:scroll;padding:0 .5rem .5rem;color:var(--text-muted)}.context-list-container::-webkit-scrollbar,.context-preview::-webkit-scrollbar{display:none}.context-preview-title{margin:0;font-size:1.25rem;line-height:1.75rem;color:var(--text-muted)}.context-preview-title-parent{margin-bottom:.625rem;border-bottom-width:1px;border-bottom-color:var(--text-faint);padding:.25rem;border-bottom-style:solid}.context-list-container{margin-right:.25rem;max-height:592px;min-width:40%;max-width:40%;overflow:hidden;overflow-y:scroll;color:var(--text-muted)}.context-preview-container{margin-top:22px;margin-right:5px;margin-bottom:.5rem;max-height:570px;min-height:570px;min-width:60%;max-width:60%;border-radius:.5rem;padding:.5rem;font-size:smaller;--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}#parentFileUL,ul{list-style-type:none!important}#parentFileUL{margin:0;width:-webkit-fill-available;padding:0}.caret{cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;font-weight:300;color:var(--text-accent)}.caret:before{margin-right:3px;display:inline-block;color:var(--text-muted);opacity:.9;--tw-content:"\25B6";content:var(--tw-content)}.caret:hover{color:var(--text-accent-hover)}.caret-down:before{--tw-rotate:90deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.nested{margin-left:-30px;display:none}.active{display:block}.context-list-div{display:flex;flex-direction:row;justify-content:space-between;white-space:pre}.context-list-checkbox{margin-left:.25rem!important;margin-top:3px!important;border-width:.5px!important;border-style:dashed!important;border-color:var(--checkbox-border-color)!important}.context-list-checkbox:hover{cursor:pointer!important;border-width:1px!important;border-style:solid!important;border-color:var(--text-accent-hover)!important}.context-title{margin:-1px 0 -1.5rem;padding:0;font-size:x-large;font-weight:500;color:var(--text-normal)}.context-list-div span:hover{cursor:pointer;color:var(--text-accent-hover)}.context-list-span{display:inline-block;max-width:170px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-weight:100}.context-background{position:absolute;z-index:2;height:1.25rem;width:206px;overflow:hidden;background-color:var(--modal-background)}.context-root{position:absolute;z-index:3;font-weight:200}.context-root span{font-weight:500}.context-hide{padding-top:18px}.context-list-item{padding-top:1px;padding-bottom:1px}.context-display-width{width:inherit}.context-shadow{--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.context-preview-default{display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center}.enrich-btn-row{display:flex;flex-direction:row;justify-content:space-between;padding-left:12rem;padding-right:12rem}.enrich-img{margin-bottom:30px;display:flex;flex-direction:row;justify-content:center}.enrich-confirm-btn,.enrich-deny-btn{cursor:pointer}.search-div{position:sticky;top:30px;left:0;z-index:9999;margin-bottom:3.5rem}.loading-bar{z-index:9999;margin-top:0;display:flex;height:5px;border-radius:5px;background-color:var(--interactive-accent)}.loading-bar:after{top:0;left:0;display:block;height:100%;width:0;content:"";transition:width 2s ease}.ask-row{display:flex;flex-direction:row;border-radius:.25rem}.ask-col{display:flex;flex-direction:column}.ask-input{width:100%;word-wrap:break-word;word-break:break-all}.ask-send-svg{margin-top:1px;margin-right:.5rem}.ask-selection{margin-top:0;margin-bottom:.5rem;max-height:300px;overflow-y:scroll;white-space:pre-wrap;border-radius:.25rem;padding:.5rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow);color:var(--text-muted);word-wrap:break-word;width:-webkit-fill-available}.ask-modal-title{margin:0}.ask-input-row{margin-top:.5rem;max-height:150px;min-height:25px;border-radius:5px;padding-top:.5rem;padding-left:1rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.ask-col-input{flex-grow:1;overflow-y:scroll;padding-top:1.5px}.ask-col-input::-webkit-scrollbar,.ask-selection::-webkit-scrollbar{display:none}.row{flex-direction:row}.col,.row{display:flex}.col{flex-direction:column}.width-full{width:100%}.width-max{min-width:100%;max-width:100%}.v-align-center{align-items:center}.h-align-center{justify-content:center}.annotation-form::-webkit-scrollbar,.annotation-text-body::-webkit-scrollbar{display:none}.annotation-form{display:flex;max-height:550px;width:100%;max-width:550px;flex-direction:column;overflow-y:scroll}.annotation-body{padding:.75rem}.annotation-add-body,.annotation-body{display:flex;border-radius:.5rem;border-width:1.5px;border-style:solid;border-color:var(--background-secondary-alt);background-color:var(--background-secondary)}.annotation-add-body{padding:.25rem}.annotation-text-body{margin-bottom:1rem;cursor:text;resize:none;overflow:hidden;overflow-y:scroll;text-align:start}.annotation-add-text-body,.annotation-text-body{display:block;border-style:none;background-color:initial;overflow-wrap:break-word}.annotation-add-text-body{cursor:pointer;text-align:center;font-weight:500}.annotation-text-body[contenteditable]:empty:before{--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity));--tw-content:"Add a description or a comment...";content:var(--tw-content)}.annotation-text-height-max{max-height:100px}.annotation-text-height-min{min-height:-moz-fit-content;min-height:fit-content}.annotation-metadata{align-items:center;justify-content:space-between;font-size:.75rem;line-height:1rem;font-weight:500;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.annotation-metadata-left{display:flex;align-items:center}.annotation-metadata-left svg{margin-right:.25rem;height:.75rem;width:auto}.annotation-metadata-left-btn{margin-left:.5rem;display:flex;--tw-scale-x:1.1;--tw-scale-y:1.1;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));cursor:pointer}.annotation-delete svg{color:#ff4343}.annotation-seperator{margin-left:1rem}.annotation-seperator div{height:1rem;border-color:var(--background-secondary-alt);border-left-style:solid;border-left-width:1.5px}.annotation-action-row{display:flex;flex-direction:row}@keyframes enterAnimation{0%{opacity:0}to{opacity:1}}@keyframes exitAnimation{0%{opacity:1}to{opacity:0}}.hidden-in{animation:enterAnimation .3s ease forwards}.hidden-out{animation:exitAnimation .3s ease backwards}.actions-hidden{opacity:0} \ No newline at end of file +*,::backdrop,:after,:before{--tw-border-spacing-x:0;--tw-border-spacing-y:0;--tw-translate-x:0;--tw-translate-y:0;--tw-rotate:0;--tw-skew-x:0;--tw-skew-y:0;--tw-scale-x:1;--tw-scale-y:1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness:proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:#3b82f680;--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: }.container{width:100%}@media (min-width:640px){.container{max-width:640px}}@media (min-width:768px){.container{max-width:768px}}@media (min-width:1024px){.container{max-width:1024px}}@media (min-width:1280px){.container{max-width:1280px}}@media (min-width:1536px){.container{max-width:1536px}}.collapse{visibility:collapse}.static{position:static}.absolute{position:absolute}.mx-1{margin-left:.25rem;margin-right:.25rem}.my-1{margin-top:.25rem;margin-bottom:.25rem}.my-2{margin-top:.5rem;margin-bottom:.5rem}.mb-1{margin-bottom:.25rem}.ml-2{margin-left:.5rem}.mr-1{margin-right:.25rem}.mr-2{margin-right:.5rem}.mr-3{margin-right:.75rem}.mt-2{margin-top:.5rem}.mt-\[-8px\]{margin-top:-8px}.block{display:block}.flex{display:flex}.table{display:table}.hidden{display:none}.h-full{height:100%}.min-h-\[32px\]{min-height:32px}.w-1\/2{width:50%}.w-fit{width:-moz-fit-content;width:fit-content}.w-full{width:100%}.cursor-pointer{cursor:pointer}.flex-row{flex-direction:row}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.justify-end{justify-content:flex-end}.justify-between{justify-content:space-between}.text-center{text-align:center}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xs{font-size:.75rem;line-height:1rem}.text-\[var\(--text-accent\)\]{color:var(--text-accent)}.text-\[var\(--text-faint\)\]{color:var(--text-faint)}.underline{text-decoration-line:underline}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.search-background{position:sticky;top:-21px;left:0;z-index:998;margin-top:-145px;margin-bottom:-14px;height:131px;flex-grow:1;background-color:var(--background-secondary)}.code-view{z-index:-1;height:auto;border-bottom-width:var(--background-modifier-border);border-bottom-color:solid}.code-view:last-child{border-bottom-color:none}.code-title-div{position:relative;margin-top:0;margin-bottom:0;display:flex;height:50px;flex-wrap:wrap;vertical-align:middle;justify-content:left}.code-title-div h1{position:absolute;left:38px;top:13.2px;margin-top:.125rem;height:30px;font-size:15px}.code-title-div img{position:absolute;left:7px;top:17.3px;margin-top:-3px;margin-right:.625rem;height:22px;width:22px}.code-title-div span{position:absolute;right:-1rem;margin-right:1.75rem;margin-top:.875rem;height:30px;font-size:17px}.code-button-input{z-index:997;order:-1;margin:0!important;display:block;height:49px!important;flex-grow:1;cursor:pointer;opacity:0}.code-title-div:hover{background:var(--background-primary)!important}.save-to-pieces-btn{margin-right:5px;margin-bottom:5px;height:29px;width:42px;cursor:pointer;align-items:left;background:none}.save-to-pieces-holder{margin-bottom:-11px;margin-right:.625rem;margin-top:-.75rem;display:flex;flex-wrap:wrap-reverse;justify-content:flex-end}.collapsed-pieces-holder{margin-right:0;margin-top:0;display:flex;--tw-rotate:0deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));overflow:hidden;overflow-y:visible}.collapsed-pieces-holder,.collapsed-pieces-holder.collapsed{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:.5s}.collapsed-pieces-holder.collapsed{width:0;flex-wrap:nowrap}.collapsed-pieces-holder.expanded{flex-wrap:wrap}.collapsed-pieces-holder+button svg{--tw-rotate:0deg}.collapsed-pieces-holder+button svg,.collapsed-pieces-holder.collapsed+button svg{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:.5s}.collapsed-pieces-holder.collapsed+button svg{--tw-rotate:360deg}.snippet{margin:.625rem .625rem .625rem 5px;overflow:hidden;border-radius:5px;background-color:var(--background-primary-alt);padding:.625rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.snippet-content-parent{cursor:pointer}.snippet_line_number{color:var(--text-faint);font-family:Consolas,monospace}.gpt-input-textarea::-webkit-scrollbar,.snippet_pre::-webkit-scrollbar{display:none}.snippet_pre{margin-top:0;display:inline-block;-webkit-user-select:text;-moz-user-select:text;user-select:text;overflow-x:scroll}.pieces-parent::-webkit-scrollbar{display:none}.pieces-parent{position:relative;height:auto;max-height:210px;overflow:hidden;overflow-y:scroll;white-space:nowrap;border-radius:5px;font-size:var(--code-size)}#editParent{max-height:400px}.rawCode::-webkit-scrollbar{display:none}.rawCode{z-index:0;margin-left:35px;margin-right:1px;overflow-x:scroll;padding-right:25px}.lineNums{position:absolute;top:0;z-index:1;width:-moz-fit-content;width:fit-content;white-space:nowrap;padding-left:7px;text-align:right}.vertBreak{padding-left:5px}.buttonDiv{margin-top:15.5px;display:flex;flex-wrap:nowrap;justify-content:flex-end}.footerDiv{display:flex;justify-content:space-between}.button,.button_copy,.button_delete,.button_delete_modal,.button_refresh{cursor:pointer;padding-left:.75rem;padding-right:.75rem}.button_delete{margin-top:15.5px;--tw-text-opacity:1;color:rgb(244 67 54/var(--tw-text-opacity));opacity:.9;background:none!important;pointer-events:painted}.button_delete_modal{margin-right:0;margin-top:-.5rem;height:2.5rem;width:5rem;border-radius:10%;--tw-bg-opacity:1!important;background-color:rgb(244 67 54/var(--tw-bg-opacity))!important;font-size:medium;--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity));pointer-events:painted}.button_delete_modal_title{--tw-text-opacity:1;color:rgb(244 67 54/var(--tw-text-opacity))}.button_refresh{right:-7px;top:30px;margin-right:0;margin-top:0;cursor:pointer;align-self:flex-end;border-style:none;background-color:initial;font-size:1.25rem;line-height:1.75rem;font-weight:700;outline:2px solid #0000;outline-offset:2px;pointer-events:painted}.title_div{position:sticky;z-index:999;margin-bottom:5px;display:flex;align-content:center;justify-content:space-between;overflow:hidden}.sort-dropdown{margin:0;width:121px;cursor:pointer}.sort-dropdown:focus{border-color:none;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow);background:var(--interactive-normal)!important}.search-box-div{position:sticky;left:0;top:30px;z-index:999;margin-bottom:6px;display:flex}.input-search{margin-right:.5rem;margin-top:3px;height:46px;flex-grow:1;overflow-x:hidden;border-radius:.375rem;border-bottom:1px #ffffff80;border-style:none;padding:.625rem 2.5rem .625rem .625rem;font-size:1.125rem;line-height:1.75rem;letter-spacing:0;--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity))}.input-search,.input-search:hover{background-color:initial;transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.5s;transition-timing-function:cubic-bezier(0,.11,.35,1.3)}.input-search:hover{width:250px;border-radius:.375rem;border-bottom:1px #ffffff80;border-style:solid}.input-search{outline:none;font:caption!important}.input-search::-moz-placeholder{font-size:1.125rem;line-height:1.75rem;font-size:small;font-weight:100;letter-spacing:0;color:#ffffff80}.input-search::placeholder{font-size:1.125rem;line-height:1.75rem;font-size:small;font-weight:100;letter-spacing:0;color:#ffffff80}.settings_divider{margin-top:5px;margin-bottom:1.25rem}.settings_external_links_section{display:flex;justify-content:space-around;padding:0 .625rem}.settings_external_links_section img{width:auto;cursor:pointer}.onboarding_image,.settings_external_links{-webkit-user-select:none;-moz-user-select:none;user-select:none;-webkit-user-drag:none}.onboarding_image{pointer-events:none;margin-top:0;margin-bottom:0;margin-left:15px;height:800px;width:500px}.opening-div{margin-left:0;margin-top:0;height:-moz-fit-content;height:fit-content}.button-div{margin-top:0;margin-bottom:0;display:flex;justify-content:center}.snippet-container{background-color:var(--background-modifier)}.last-snippet{border-bottom-right-radius:5%;border-bottom-left-radius:5%;padding-bottom:3px;border-bottom:none!important}.first-snippet,.only-snippet{border-top-left-radius:5%;border-top-right-radius:5%}.only-snippet{border-bottom-right-radius:5%;border-bottom-left-radius:5%;border-bottom-color:none;padding-bottom:3px}.list-view{display:flex;flex-direction:column;background-color:var(--background-modifier)}.list-view,.list-view:hover{border-bottom-width:1px;border-bottom-color:var(--background-modifier-border)}.list-view:hover{background-color:var(--background-primary)}.list-view{border-bottom-style:solid}.list-title-div{margin:.375rem .375rem -.375rem;display:flex;justify-content:space-between;align-items:top}.list-title-div img{margin-right:.125rem;margin-top:.875rem;margin-bottom:0;height:1.25rem;width:1.25rem}.list-title-wrapper{display:flex;overflow:auto}.list-title-div h4{margin-top:.75rem;margin-bottom:.75rem;font-size:medium;color:var(--text-primary);-webkit-line-clamp:2}.list-body,.list-title-div h4{overflow:hidden;text-overflow:ellipsis;display:-webkit-box;-webkit-box-orient:vertical}.list-body{margin-bottom:.625rem;max-height:4rem;padding-left:.875rem;padding-right:.875rem;font-size:small;color:var(--text-muted);-webkit-line-clamp:3}.list-button-container{margin-left:11px;display:flex;align-items:center}.list-button-input{position:absolute;top:-7px;left:.5rem;z-index:-1;margin-top:-29.5px;margin-left:.125rem;display:block;height:22px;width:87px;cursor:pointer;opacity:0}.list-button-container span{z-index:1;margin-left:.25rem;cursor:pointer;font-size:small;color:var(--text-primary)}.settings-div{margin-top:.75rem;display:flex;align-items:center;justify-content:center}.settings-div img{pointer-events:none;height:auto;width:auto;max-width:300px;flex-basis:100%;-webkit-user-select:none;-moz-user-select:none;user-select:none;-webkit-user-drag:none}.loading-div{flex-direction:column}.loading-div,.loading-div-row{margin-top:30px;display:flex;align-items:center;justify-content:center}.loading-div-row{flex-direction:row}.loading-div-col{display:flex;flex-direction:column;align-items:center;justify-content:center}.loading-div-button{display:flex;width:100%;flex-direction:row;justify-content:center;text-align:center}.loading-div-button button{cursor:pointer}.loading-div img{height:auto;width:auto;max-width:200px;flex-basis:100%}.loading-div h4{margin-top:.75rem;height:auto;width:auto;text-align:center;font-size:small}.new-div{margin-top:50px;display:flex;align-items:center;justify-content:center}.new-div img{height:auto;width:auto;max-width:200px;flex-basis:100%}.new-div h4{margin-top:-.625rem;margin-bottom:26px;height:auto;width:auto;max-width:219px;text-align:left;font-size:small}.expand-icon{position:absolute;right:0;top:0;height:22px;width:22px;cursor:pointer;border-radius:7px;background-color:var(--background-primary-alt);padding:.125rem}.expand-wrapper{position:sticky;top:0}@keyframes bouncing-loader{to{opacity:.1;transform:translate3d(0,-4px,0)}}.bouncing-loader,.refresh-bouncing-loader,.share-code-bouncing-loader{margin-top:-5px;margin-left:.125rem;display:flex;height:31px;width:39px;justify-content:center}.refresh-bouncing-loader{margin-top:-.125rem}.share-code-bouncing-loader{margin-right:5px}.bouncing-loader>div,.refresh-bouncing-loader>div,.share-code-bouncing-loader>div{margin:18px .1rem 0;height:.5rem;width:.5rem;animation:bouncing-loader .5s infinite alternate;border-radius:50%;background:var(--background-modifier-border-focus)}.bouncing-loader>div:nth-child(2),.refresh-bouncing-loader>div:nth-child(2),.share-code-bouncing-loader>div:nth-child(2){animation-delay:.2s}.bouncing-loader>div:nth-child(3),.refresh-bouncing-loader>div:nth-child(3),.share-code-bouncing-loader>div:nth-child(3){animation-delay:.4s}div[theme=dark] button{--tw-bg-opacity:1;background-color:rgb(255 255 255/var(--tw-bg-opacity));--tw-text-opacity:1;color:rgb(0 0 0/var(--tw-text-opacity))}div[theme=light] button{--tw-bg-opacity:1;background-color:rgb(0 0 0/var(--tw-bg-opacity));--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity))}.edit-form-row{display:flex;width:100%;flex-direction:row;justify-content:center}.edit-form-desc{padding-left:5px;padding-right:.5rem}.justify-left{justify-content:left}.edit-form-col{margin:.5rem;display:flex;width:100%;flex-direction:column}.col-small{width:-moz-fit-content;width:fit-content}.edit-form{display:flex;width:100%;max-width:550px;flex-direction:column}.edit-title-input{font-weight:600;background:#0000!important}.edit-dropdown{max-height:50px;cursor:pointer;overflow-y:scroll;text-align:center}.edit-dropdown,.edit-dropdown:focus{border-width:var(--input-border-width);border-style:solid;border-color:var(--background-modifier-border)}.edit-dropdown:focus{--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.edit-dropdown,.edit-dropdown:focus{background:#0000!important}.edit-text,.edit-text-title{margin-top:.625rem;margin-bottom:.625rem;font-size:smaller;opacity:.8}.edit-text-title{margin-bottom:0;font-size:x-large;opacity:.9}.verticalAlign{align-items:center}.delTitle{color:rgb(244 67 54/var(--tw-text-opacity));opacity:.8}.delTitle,nav{--tw-text-opacity:1}nav{position:absolute;left:0;top:0;z-index:99999999;display:flex;height:2.5rem;width:100%;justify-content:space-evenly;color:rgb(150 240 177/var(--tw-text-opacity));background:#0000}nav a{padding:.625rem;font-size:1.4rem;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity));text-decoration-line:none}.content{height:100%;width:750px}.content,.item{display:flex}.item{width:250px;flex-direction:column;align-items:center;justify-content:center;row-gap:25px;font-family:bolder;font-size:3rem;line-height:1;--tw-text-opacity:1;color:rgb(0 0 0/var(--tw-text-opacity));background:var(--background-secondary)}.link{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:.3s}.wrapper{position:absolute;z-index:9999999;margin-top:-5px;margin-bottom:1.25rem;display:flex;width:-webkit-fill-available;justify-content:center;padding-right:15.5px}:root{--primary-color:#111;--secondary-color:#a8adb3}.tabs{position:relative;display:flex;height:1.75rem;width:100px;border-radius:.375rem;background-color:var(--interactive-normal);--tw-shadow-color:var(--input-shadow);--tw-shadow:var(--tw-shadow-colored)}.tabs .aiSVG{margin-left:.75rem;height:1.75rem;width:1.75rem}.tabs *{z-index:2}input[type=radio]{display:none}.tab{display:flex;height:100%;width:100%;cursor:pointer;align-items:center;justify-content:center;border-radius:.375rem;letter-spacing:.01em;transition-property:color;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-timing-function:ease-in;vertical-align:center}input[type=radio]+.tab svg,input[type=radio]:checked+.tab{--tw-text-opacity:1;color:rgb(107 107 107/var(--tw-text-opacity))}input[id=radio-1]:checked~.glider{--tw-translate-x:0px}input[id=radio-1]:checked~.glider,input[id=radio-2]:checked~.glider{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}input[id=radio-2]:checked~.glider{--tw-translate-x:101%}.glider{position:absolute;left:0;top:0;z-index:1;display:flex;height:100%;width:50%;border-radius:.375rem;border-width:1px;border-style:solid;border-color:var(--text-faint);background-color:var(--text-muted);--tw-shadow-color:var(--input-shadow);--tw-shadow:var(--tw-shadow-colored);transition-property:.25s;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s;transition-duration:ease-out}.glider-light{background-color:var(--background-modifier-box-shadow)}.tabs svg{pointer-events:none;color:var(--text-normal)}.gpt-row,.gpt-row-full,.gpt-row-response,.gpt-row-small{display:flex;max-width:100%;flex-direction:row}.gpt-col,.gpt-col-reverse,.gpt-col-small{display:flex;min-width:100%;max-width:100%;flex-direction:column}.gpt-col-small{min-width:0}.gpt-col-reverse{flex-direction:column-reverse}.gpt-container{margin:0;display:flex;height:100%}.gpt-input{margin-top:1rem;margin-bottom:25px;height:-moz-fit-content;height:fit-content;align-items:flex-start;justify-content:center;border-radius:10px;border-width:1px;background-color:var(--background-secondary);padding-top:1rem;padding-bottom:1rem;padding-left:1rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.gpt-input-textarea{display:block;max-height:100px;width:100%;cursor:text;resize:none;overflow:hidden;overflow-y:scroll;overflow-wrap:break-word;padding-right:3rem;text-align:start;line-height:1.25rem;color:inherit;font-family:inherit}.gpt-input-textarea[contenteditable]:empty:before{--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity));--tw-content:"Paste some code or ask a technical question...";content:var(--tw-content)}.gpt-text-content{margin-top:-18px;min-height:50%;flex:1 1 0%;overflow-y:scroll;border-radius:10px;padding:26px 26px 0;word-wrap:break-word}.gpt-text-area{height:100%;max-height:none;overflow-y:scroll}.gpt-text-div{margin-top:34px;display:flex;flex-basis:100%;flex-direction:column;overflow-y:scroll;border-radius:10px;background-color:var(--background-secondary);--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color)}.gpt-text-div,.gpt-text-div-light{box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.gpt-text-div-light{--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color)}.gpt-text-area::-webkit-scrollbar,.gpt-text-content::-webkit-scrollbar,.gpt-text-div::-webkit-scrollbar{display:none}.gpt-text-response{margin-top:0;margin-bottom:.625rem;width:-moz-fit-content;width:fit-content;-webkit-user-select:text;-moz-user-select:text;user-select:text;border-radius:10px;padding:.75rem;text-align:left;font-size:.875rem;line-height:1.25rem;word-break:break-word}.gpt-right-align{justify-content:flex-end}.gpt-left-align{justify-content:flex-start}.gpt-query{margin-right:.5rem;background-color:var(--interactive-accent)}.gpt-response{min-width:0;background-color:var(--interactive-normal)}.gpt-img,.gpt-img-small{display:flex;min-height:30px;min-width:30px;justify-content:center}.gpt-icon{display:flex;height:30px;width:30px;align-items:center}.gpt-icon-note{height:.875rem;width:.875rem}.gpt-icon-drift{margin-right:-.75rem}.gpt-icon-drift svg{position:static}.aiSVG,.userSVG{margin-top:7px;color:var(--text-muted);width:30px!important;height:30px!important}.sendSVG{right:23px;bottom:54px;height:25px;width:25px;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.gpt-img-small{margin-bottom:19px;margin-top:auto;height:0;min-height:0;width:0;cursor:pointer}.gpt-cancel{right:0;bottom:0;margin-right:.625rem;margin-top:5px;margin-bottom:7px;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.gpt-cancel,.gpt-context{position:sticky;width:-moz-fit-content;width:fit-content;cursor:pointer;align-self:flex-end;font-size:smaller}.gpt-context{margin-right:7px;margin-top:.625rem;color:var(--text-normal)}.gpt-text-intro{display:flex;height:100%;width:100%;align-items:center;justify-content:center;padding-left:.375rem;padding-right:.375rem}.gpt-text-intro-content{margin-top:0;text-align:center;color:var(--text-muted)}.gpt-text-intro-title{margin-bottom:.5rem;font-size:32px;font-weight:600;color:var(--text-normal)}.gpt-text-intro-title-div{padding-left:10%;padding-right:10%}.gpt-parent{height:100%}.hint-btn,.hint-btn-note{margin:.25rem .125rem;display:inline-flex;cursor:pointer;align-items:center;overflow:hidden;white-space:normal;border-radius:1rem;border-color:none;padding:1rem .375rem;text-align:center;font-size:.75rem;line-height:1rem;color:var(--text-normal);text-decoration-line:none;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow);word-break:break-word}.hint-btn-note{background-color:var(--background-modifier-border-hover)}.hint-btn-note:hover{background-color:var(--background-modifier-hover)}.hint-btn{background-color:var(--interactive-normal)}.hint-btn:hover{background-color:var(--interactive-hover)}#gpt-hints-container{justify-content:center;padding-left:1.25rem;padding-right:1.25rem}.hint-title{margin:.125rem .125rem .125rem .625rem;justify-content:center;align-self:flex-start;font-size:.75rem;line-height:1rem;color:var(--text-muted)}.hint-list{margin-left:.5rem;margin-right:.5rem;max-height:77px}.hint-list,.hint-list-note{overflow:hidden;overflow-y:scroll;border-radius:5px}.hint-list-note{margin-top:-.75rem;margin-bottom:-.5rem;max-height:82px;border-color:var(--background-modifier-border)}.hint-list-note::-webkit-scrollbar,.hint-list::-webkit-scrollbar{display:none}.hint-btn-text{margin-right:.25rem;text-overflow:ellipsis;padding-left:1px;text-align:center;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical}.gpt-query pre code,.gpt-response pre code,.hint-btn-text{width:100%}.gpt-query pre code,.gpt-response pre code{margin-top:.5rem;margin-bottom:.75rem;min-height:20px;-webkit-user-select:text;-moz-user-select:text;user-select:text;overflow:hidden;white-space:pre-wrap;border-radius:5px;background-color:var(--background-primary-alt);padding-left:.25rem;padding-right:.25rem;--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.gpt-response-margin-delete{margin:0}.gpt-response-button-div{margin-right:-14px;margin-bottom:-13px}.gpt-img-logo{height:4rem;padding-bottom:.5rem;opacity:.8}p.gpt-response-margin-delete code{display:inline;white-space:pre-line;border-radius:5px;background-color:var(--background-modifier-active-hover);padding-left:.25rem;padding-right:.25rem}.gpt-user-image{margin-top:5px;height:1.5rem;width:1.5rem;border-radius:50%}.hint-title-note{font-size:.75rem;line-height:1rem;font-weight:400;color:var(--text-muted)}.gpt-rel-wrap{flex-wrap:wrap}.gpt-hint-col{border-radius:5px}.gpt-hint-row{padding-top:7px}.gpt-send-active{color:var(--interactive-accent)}.gpt-send-unactive{--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.discovery-div{margin-left:.25rem;justify-content:flex-end;white-space:nowrap}.discovery-div,.discovery-div-inner{display:flex;flex-wrap:nowrap;align-items:center;overflow:hidden}.discovery-title{color:var(--text-muted)}.discovery-break{padding-left:.5rem}.discovery-checkbox{margin-left:13px!important;margin-right:0!important;margin-top:22px!important}.discovery-seperator{margin-left:26px;margin-right:0;margin-top:1rem}.discovery-div-parent{position:sticky;height:0;width:0}.context-row{display:flex;width:100%;flex-direction:row;justify-content:space-between}.context-col{display:flex;height:100%;flex-direction:column}.context-parent{margin-top:.875rem;display:flex;max-height:600px;min-height:600px;width:100%;flex-direction:row;overflow:hidden}.context-preview{margin-top:-9px;overflow:hidden;overflow-x:scroll;overflow-y:scroll;padding:0 .5rem .5rem;color:var(--text-muted)}.context-list-container::-webkit-scrollbar,.context-preview::-webkit-scrollbar{display:none}.context-preview-title{margin:0;font-size:1.25rem;line-height:1.75rem;color:var(--text-muted)}.context-preview-title-parent{margin-bottom:.625rem;border-bottom-width:1px;border-bottom-color:var(--text-faint);padding:.25rem;border-bottom-style:solid}.context-list-container{margin-right:.25rem;max-height:592px;min-width:40%;max-width:40%;overflow:hidden;overflow-y:scroll;color:var(--text-muted)}.context-preview-container{margin-top:22px;margin-right:5px;margin-bottom:.5rem;max-height:570px;min-height:570px;min-width:60%;max-width:60%;border-radius:.5rem;padding:.5rem;font-size:smaller;--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}#parentFileUL,ul{list-style-type:none!important}#parentFileUL{margin:0;width:-webkit-fill-available;padding:0}.caret{cursor:pointer;-webkit-user-select:none;-moz-user-select:none;user-select:none;font-weight:300;color:var(--text-accent)}.caret:before{margin-right:3px;display:inline-block;color:var(--text-muted);opacity:.9;--tw-content:"\25B6";content:var(--tw-content)}.caret:hover{color:var(--text-accent-hover)}.caret-down:before{--tw-rotate:90deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.nested{margin-left:-30px;display:none}.active{display:block}.context-list-div{display:flex;flex-direction:row;justify-content:space-between;white-space:pre}.context-list-checkbox{margin-left:.25rem!important;margin-top:3px!important;border-width:.5px!important;border-style:dashed!important;border-color:var(--checkbox-border-color)!important}.context-list-checkbox:hover{cursor:pointer!important;border-width:1px!important;border-style:solid!important;border-color:var(--text-accent-hover)!important}.context-title{margin:-1px 0 -1.5rem;padding:0;font-size:x-large;font-weight:500;color:var(--text-normal)}.context-list-div span:hover{cursor:pointer;color:var(--text-accent-hover)}.context-list-span{display:inline-block;max-width:170px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-weight:100}.context-background{position:absolute;z-index:2;height:1.25rem;width:206px;overflow:hidden;background-color:var(--modal-background)}.context-root{position:absolute;z-index:3;font-weight:200}.context-root span{font-weight:500}.context-hide{padding-top:18px}.context-list-item{padding-top:1px;padding-bottom:1px}.context-display-width{width:inherit}.context-shadow{--tw-shadow:0px 2px 4px 0px #000c;--tw-shadow-colored:0px 2px 4px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.context-preview-default{display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center}.enrich-btn-row{display:flex;flex-direction:row;justify-content:space-between;padding-left:12rem;padding-right:12rem}.enrich-img{margin-bottom:30px;display:flex;flex-direction:row;justify-content:center}.enrich-confirm-btn,.enrich-deny-btn{cursor:pointer}.search-div{position:sticky;top:30px;left:0;z-index:9999;margin-bottom:3.5rem}.loading-bar{z-index:9999;margin-top:0;display:flex;height:5px;border-radius:5px;background-color:var(--interactive-accent)}.loading-bar:after{top:0;left:0;display:block;height:100%;width:0;content:"";transition:width 2s ease}.ask-row{display:flex;flex-direction:row;border-radius:.25rem}.ask-col{display:flex;flex-direction:column}.ask-input{width:100%;word-wrap:break-word;word-break:break-all}.ask-send-svg{margin-top:1px;margin-right:.5rem}.ask-selection{margin-top:0;margin-bottom:.5rem;max-height:300px;overflow-y:scroll;white-space:pre-wrap;border-radius:.25rem;padding:.5rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow);color:var(--text-muted);word-wrap:break-word;width:-webkit-fill-available}.ask-modal-title{margin:0}.ask-input-row{margin-top:.5rem;max-height:150px;min-height:25px;border-radius:5px;padding-top:.5rem;padding-left:1rem;--tw-shadow:0px 4px 8px 0px #000c;--tw-shadow-colored:0px 4px 8px 0px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.ask-col-input{flex-grow:1;overflow-y:scroll;padding-top:1.5px}.ask-col-input::-webkit-scrollbar,.ask-selection::-webkit-scrollbar{display:none}.row{flex-direction:row}.col,.row{display:flex}.col{flex-direction:column}.width-full{width:100%}.width-max{min-width:100%;max-width:100%}.v-align-center{align-items:center}.h-align-center{justify-content:center}.annotation-form::-webkit-scrollbar,.annotation-text-body::-webkit-scrollbar{display:none}.annotation-form{display:flex;max-height:550px;width:100%;max-width:550px;flex-direction:column;overflow-y:scroll}.annotation-body{padding:.75rem}.annotation-add-body,.annotation-body{display:flex;border-radius:.5rem;border-width:1.5px;border-style:solid;border-color:var(--background-secondary-alt);background-color:var(--background-secondary)}.annotation-add-body{padding:.25rem}.annotation-text-body{margin-bottom:1rem;cursor:text;resize:none;overflow:hidden;overflow-y:scroll;text-align:start}.annotation-add-text-body,.annotation-text-body{display:block;border-style:none;background-color:initial;overflow-wrap:break-word}.annotation-add-text-body{cursor:pointer;text-align:center;font-weight:500}.annotation-text-body[contenteditable]:empty:before{--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity));--tw-content:"Add a description or a comment...";content:var(--tw-content)}.annotation-text-height-max{max-height:100px}.annotation-text-height-min{min-height:-moz-fit-content;min-height:fit-content}.annotation-metadata{align-items:center;justify-content:space-between;font-size:.75rem;line-height:1rem;font-weight:500;--tw-text-opacity:1;color:rgb(128 128 128/var(--tw-text-opacity))}.annotation-metadata-left{display:flex;align-items:center}.annotation-metadata-left svg{margin-right:.25rem;height:.75rem;width:auto}.annotation-metadata-left-btn{margin-left:.5rem;display:flex;--tw-scale-x:1.1;--tw-scale-y:1.1;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));cursor:pointer}.annotation-delete svg{color:#ff4343}.annotation-seperator{margin-left:1rem}.annotation-seperator div{height:1rem;border-color:var(--background-secondary-alt);border-left-style:solid;border-left-width:1.5px}.annotation-action-row{display:flex;flex-direction:row}@keyframes enterAnimation{0%{opacity:0}to{opacity:1}}@keyframes exitAnimation{0%{opacity:1}to{opacity:0}}.hidden-in{animation:enterAnimation .3s ease forwards}.hidden-out{animation:exitAnimation .3s ease backwards}.actions-hidden{opacity:0}.filter-grow-animation{opacity:0;animation:growFromLeft .25s forwards}@keyframes growFromLeft{to{opacity:100%}}.hover\:text-\[var\(--text-accent-hover\)\]:hover{color:var(--text-accent-hover)}.hover\:text-red-600:hover{--tw-text-opacity:1;color:rgb(220 38 38/var(--tw-text-opacity))} \ No newline at end of file