@milaboratories/pl-model-middle-layer 1.16.2 → 1.16.4

package/dist/block_meta/block_manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_manifest.d.ts","names":[],"sources":["../../src/block_meta/block_manifest.ts"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQlB,iBAAA,GAAoB,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,cAElC,qBAAA;AAAA,iBAEG,uBAAA;EAAoC,WAAA;IAAe,EAAA,EAAI,WAAA;EAAA;AAAA,EAAA,CACrE,QAAA,EAAU,CAAA,EACV,UAAA,WACC,CAAA"}

package/dist/block_meta/block_manifest.js

@@ -4,7 +4,6 @@ import { BlockPackMeta } from "./block_meta.js";
 import { CreateBlockPackDescriptionSchema } from "./block_description.js";
 import { z } from "zod";
 import { toMerged } from "es-toolkit";
-
 //#region src/block_meta/block_manifest.ts
 const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);
 const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);
@@ -26,7 +25,7 @@ const BlockPackManifestFile = "manifest.json";
 function overrideManifestVersion(manifest, newVersion) {
 	return toMerged(manifest, { description: { id: { version: newVersion } } });
 }
-
 //#endregion
 export { BlockComponentsManifest, BlockPackDescriptionManifest, BlockPackManifest, BlockPackManifestFile, BlockPackMetaManifest, ManifestFileInfo, Sha256Schema, overrideManifestVersion };
+
 //# sourceMappingURL=block_manifest.js.map

package/dist/block_meta/block_manifest.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_manifest.js","names":[],"sources":["../../src/block_meta/block_manifest.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { BlockComponents } from \"./block_components\";\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from \"./content_types\";\nimport { CreateBlockPackDescriptionSchema } from \"./block_description\";\nimport { BlockPackMeta } from \"./block_meta\";\nimport { toMerged } from \"es-toolkit\";\nimport type { BlockPackId } from \"./block_id\";\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest,\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema,\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z\n  .object({\n    schema: z.literal(\"v2\"),\n    description: BlockPackDescriptionManifest,\n    timestamp: z.number().optional(),\n    files: z.array(ManifestFileInfo),\n  })\n  .passthrough();\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = \"manifest.json\";\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n  manifest: T,\n  newVersion: string,\n): T {\n  return toMerged(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n"],"mappings":";;;;;;;;AAQA,MAAa,0BAA0B,gBAAgB,iBAAiB,gBAAgB;AAGxF,MAAa,wBAAwB,cAAc,qBAAqB,sBAAsB;;AAI9F,MAAa,+BAA+B,iCAC1C,yBACA,sBACD;AAGD,MAAa,eAAe,EACzB,QAAQ,CACR,MAAM,cAAc,CACpB,aAAa,CACb,OAAO,GAAG;AAEb,MAAa,mBAAmB,EAAE,OAAO;CACvC,MAAM,EAAE,QAAQ;CAChB,MAAM,EAAE,QAAQ,CAAC,KAAK;CACtB,QAAQ;CACT,CAAC;AAGF,MAAa,oBAAoB,EAC9B,OAAO;CACN,QAAQ,EAAE,QAAQ,KAAK;CACvB,aAAa;CACb,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,OAAO,EAAE,MAAM,iBAAiB;CACjC,CAAC,CACD,aAAa;AAGhB,MAAa,wBAAwB;AAErC,SAAgB,wBACd,UACA,YACG;AACH,QAAO,SAAS,UAAU,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,YAAY,EAAE,EAAE,CAAC"}
+{"version":3,"file":"block_manifest.js","names":[],"sources":["../../src/block_meta/block_manifest.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { BlockComponents } from \"./block_components\";\nimport { ContentRelative, ContentRelativeBinary, ContentRelativeText } from \"./content_types\";\nimport { CreateBlockPackDescriptionSchema } from \"./block_description\";\nimport { BlockPackMeta } from \"./block_meta\";\nimport { toMerged } from \"es-toolkit\";\nimport type { BlockPackId } from \"./block_id\";\n\nexport const BlockComponentsManifest = BlockComponents(ContentRelative, ContentRelative);\nexport type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;\n\nexport const BlockPackMetaManifest = BlockPackMeta(ContentRelativeText, ContentRelativeBinary);\nexport type BlockPackMetaManifest = z.infer<typeof BlockPackMetaManifest>;\n\n/** Block description to be used in block manifest */\nexport const BlockPackDescriptionManifest = CreateBlockPackDescriptionSchema(\n  BlockComponentsManifest,\n  BlockPackMetaManifest,\n);\nexport type BlockPackDescriptionManifest = z.infer<typeof BlockPackDescriptionManifest>;\n\nexport const Sha256Schema = z\n  .string()\n  .regex(/[0-9a-fA-F]/)\n  .toUpperCase()\n  .length(64); // 256 / 4 (bits per hex register);\n\nexport const ManifestFileInfo = z.object({\n  name: z.string(),\n  size: z.number().int(),\n  sha256: Sha256Schema,\n});\nexport type ManifestFileInfo = z.infer<typeof ManifestFileInfo>;\n\nexport const BlockPackManifest = z\n  .object({\n    schema: z.literal(\"v2\"),\n    description: BlockPackDescriptionManifest,\n    timestamp: z.number().optional(),\n    files: z.array(ManifestFileInfo),\n  })\n  .passthrough();\nexport type BlockPackManifest = z.infer<typeof BlockPackManifest>;\n\nexport const BlockPackManifestFile = \"manifest.json\";\n\nexport function overrideManifestVersion<T extends { description: { id: BlockPackId } }>(\n  manifest: T,\n  newVersion: string,\n): T {\n  return toMerged(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n"],"mappings":";;;;;;;AAQA,MAAa,0BAA0B,gBAAgB,iBAAiB,gBAAgB;AAGxF,MAAa,wBAAwB,cAAc,qBAAqB,sBAAsB;;AAI9F,MAAa,+BAA+B,iCAC1C,yBACA,sBACD;AAGD,MAAa,eAAe,EACzB,QAAQ,CACR,MAAM,cAAc,CACpB,aAAa,CACb,OAAO,GAAG;AAEb,MAAa,mBAAmB,EAAE,OAAO;CACvC,MAAM,EAAE,QAAQ;CAChB,MAAM,EAAE,QAAQ,CAAC,KAAK;CACtB,QAAQ;CACT,CAAC;AAGF,MAAa,oBAAoB,EAC9B,OAAO;CACN,QAAQ,EAAE,QAAQ,KAAK;CACvB,aAAa;CACb,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,OAAO,EAAE,MAAM,iBAAiB;CACjC,CAAC,CACD,aAAa;AAGhB,MAAa,wBAAwB;AAErC,SAAgB,wBACd,UACA,YACG;AACH,QAAO,SAAS,UAAU,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,YAAY,EAAE,EAAE,CAAC"}

package/dist/block_meta/block_meta.cjs

@@ -1,7 +1,6 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_content_types = require('./content_types.cjs');
+require("../_virtual/_rolldown/runtime.cjs");
+const require_content_types = require("./content_types.cjs");
 let zod = require("zod");
-
 //#region src/block_meta/block_meta.ts
 const BlockPlatform = zod.z.enum([
 	"windows-x64",
@@ -36,11 +35,11 @@ function BlockPackMeta(longString, binary) {
 const BlockPackMetaDescriptionRaw = BlockPackMeta(require_content_types.DescriptionContentText, require_content_types.DescriptionContentBinary);
 const BlockPackMetaEmbeddedBase64 = BlockPackMeta(zod.z.string(), require_content_types.ContentExplicitBase64);
 const BlockPackMetaEmbeddedBytes = BlockPackMeta(zod.z.string(), require_content_types.ContentExplicitBytes);
-
 //#endregion
 exports.BlockPackMeta = BlockPackMeta;
 exports.BlockPackMetaDescriptionRaw = BlockPackMetaDescriptionRaw;
 exports.BlockPackMetaEmbeddedBase64 = BlockPackMetaEmbeddedBase64;
 exports.BlockPackMetaEmbeddedBytes = BlockPackMetaEmbeddedBytes;
 exports.BlockPlatform = BlockPlatform;
+
 //# sourceMappingURL=block_meta.cjs.map

package/dist/block_meta/block_meta.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_meta.cjs","names":["z","DescriptionContentText","DescriptionContentBinary","ContentExplicitBase64","ContentExplicitBytes"],"sources":["../../src/block_meta/block_meta.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText,\n} from \"./content_types\";\n\nexport const BlockPlatform = z.enum([\n  \"windows-x64\",\n  \"windows-aarch64\",\n  \"macosx-x64\",\n  \"macosx-aarch64\",\n  \"linux-x64\",\n  \"linux-aarch64\",\n]);\nexport type BlockPlatform = z.infer<typeof BlockPlatform>;\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny,\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z\n      .object({\n        name: z.string(),\n        url: z.string().url(),\n        logo: binary.optional(),\n      })\n      .passthrough(),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n    /**\n     * If true, the block is deprecated and should not be used.\n     */\n    deprecated: z.boolean().optional(),\n    /**\n     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.\n     */\n    termsOfServiceUrl: z.string().url().optional(),\n    /**\n     * Supported operating systems.\n     * If not provided, the block is supported on all operating systems.\n     */\n    supportedPlatforms: z.array(BlockPlatform).optional(),\n  });\n}\n\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary,\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(z.string(), ContentExplicitBase64);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(z.string(), ContentExplicitBytes);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"mappings":";;;;;AAQA,MAAa,gBAAgBA,MAAE,KAAK;CAClC;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAGF,SAAgB,cAGd,YAA4B,QAAoB;AAChD,QAAOA,MAAE,OAAO;EACd,OAAOA,MAAE,QAAQ;EACjB,aAAaA,MAAE,QAAQ;EACvB,iBAAiB,WAAW,UAAU;EACtC,WAAW,WAAW,UAAU;EAChC,MAAM,OAAO,UAAU;EACvB,KAAKA,MAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAChC,MAAMA,MAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EACjC,SAASA,MAAE,MAAM,CAACA,MAAE,QAAQ,CAAC,KAAK,EAAEA,MAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU;EACnE,MAAMA,MAAE,MAAMA,MAAE,QAAQ,CAAC,CAAC,UAAU;EACpC,cAAcA,MACX,OAAO;GACN,MAAMA,MAAE,QAAQ;GAChB,KAAKA,MAAE,QAAQ,CAAC,KAAK;GACrB,MAAM,OAAO,UAAU;GACxB,CAAC,CACD,aAAa;EAKhB,oBAAoBA,MAAE,QAAQ,CAAC,UAAU;EAIzC,YAAYA,MAAE,SAAS,CAAC,UAAU;EAIlC,mBAAmBA,MAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAK9C,oBAAoBA,MAAE,MAAM,cAAc,CAAC,UAAU;EACtD,CAAC;;AAGJ,MAAa,8BAA8B,cACzCC,8CACAC,+CACD;AAGD,MAAa,8BAA8B,cAAcF,MAAE,QAAQ,EAAEG,4CAAsB;AAG3F,MAAa,6BAA6B,cAAcH,MAAE,QAAQ,EAAEI,2CAAqB"}
+{"version":3,"file":"block_meta.cjs","names":["z","DescriptionContentText","DescriptionContentBinary","ContentExplicitBase64","ContentExplicitBytes"],"sources":["../../src/block_meta/block_meta.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText,\n} from \"./content_types\";\n\nexport const BlockPlatform = z.enum([\n  \"windows-x64\",\n  \"windows-aarch64\",\n  \"macosx-x64\",\n  \"macosx-aarch64\",\n  \"linux-x64\",\n  \"linux-aarch64\",\n]);\nexport type BlockPlatform = z.infer<typeof BlockPlatform>;\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny,\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z\n      .object({\n        name: z.string(),\n        url: z.string().url(),\n        logo: binary.optional(),\n      })\n      .passthrough(),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n    /**\n     * If true, the block is deprecated and should not be used.\n     */\n    deprecated: z.boolean().optional(),\n    /**\n     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.\n     */\n    termsOfServiceUrl: z.string().url().optional(),\n    /**\n     * Supported operating systems.\n     * If not provided, the block is supported on all operating systems.\n     */\n    supportedPlatforms: z.array(BlockPlatform).optional(),\n  });\n}\n\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary,\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(z.string(), ContentExplicitBase64);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(z.string(), ContentExplicitBytes);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"mappings":";;;;AAQA,MAAa,gBAAgBA,IAAAA,EAAE,KAAK;CAClC;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAGF,SAAgB,cAGd,YAA4B,QAAoB;AAChD,QAAOA,IAAAA,EAAE,OAAO;EACd,OAAOA,IAAAA,EAAE,QAAQ;EACjB,aAAaA,IAAAA,EAAE,QAAQ;EACvB,iBAAiB,WAAW,UAAU;EACtC,WAAW,WAAW,UAAU;EAChC,MAAM,OAAO,UAAU;EACvB,KAAKA,IAAAA,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAChC,MAAMA,IAAAA,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EACjC,SAASA,IAAAA,EAAE,MAAM,CAACA,IAAAA,EAAE,QAAQ,CAAC,KAAK,EAAEA,IAAAA,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU;EACnE,MAAMA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,QAAQ,CAAC,CAAC,UAAU;EACpC,cAAcA,IAAAA,EACX,OAAO;GACN,MAAMA,IAAAA,EAAE,QAAQ;GAChB,KAAKA,IAAAA,EAAE,QAAQ,CAAC,KAAK;GACrB,MAAM,OAAO,UAAU;GACxB,CAAC,CACD,aAAa;EAKhB,oBAAoBA,IAAAA,EAAE,QAAQ,CAAC,UAAU;EAIzC,YAAYA,IAAAA,EAAE,SAAS,CAAC,UAAU;EAIlC,mBAAmBA,IAAAA,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAK9C,oBAAoBA,IAAAA,EAAE,MAAM,cAAc,CAAC,UAAU;EACtD,CAAC;;AAGJ,MAAa,8BAA8B,cACzCC,sBAAAA,wBACAC,sBAAAA,yBACD;AAGD,MAAa,8BAA8B,cAAcF,IAAAA,EAAE,QAAQ,EAAEG,sBAAAA,sBAAsB;AAG3F,MAAa,6BAA6B,cAAcH,IAAAA,EAAE,QAAQ,EAAEI,sBAAAA,qBAAqB"}

package/dist/block_meta/block_meta.d.ts

@@ -44,7 +44,7 @@ declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny, const
    * If not provided, the block is supported on all operating systems.
    */
   supportedPlatforms: z.ZodOptional<z.ZodArray<z.ZodEnum<["windows-x64", "windows-aarch64", "macosx-x64", "macosx-aarch64", "linux-x64", "linux-aarch64"]>, "many">>;
-}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
   title: z.ZodString;
   description: z.ZodString;
   longDescription: z.ZodOptional<LongStringType>;
@@ -85,7 +85,7 @@ declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny, const
    * If not provided, the block is supported on all operating systems.
    */
   supportedPlatforms: z.ZodOptional<z.ZodArray<z.ZodEnum<["windows-x64", "windows-aarch64", "macosx-x64", "macosx-aarch64", "linux-x64", "linux-aarch64"]>, "many">>;
-}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+}>, any> extends infer T ? { [k in keyof T]: T[k] } : never, z.baseObjectInputType<{
   title: z.ZodString;
   description: z.ZodString;
   longDescription: z.ZodOptional<LongStringType>;
@@ -126,89 +126,7 @@ declare function BlockPackMeta<const LongStringType extends z.ZodTypeAny, const
    * If not provided, the block is supported on all operating systems.
    */
   supportedPlatforms: z.ZodOptional<z.ZodArray<z.ZodEnum<["windows-x64", "windows-aarch64", "macosx-x64", "macosx-aarch64", "linux-x64", "linux-aarch64"]>, "many">>;
-}>, any>[k] }, { [k_1 in keyof z.baseObjectInputType<{
-  title: z.ZodString;
-  description: z.ZodString;
-  longDescription: z.ZodOptional<LongStringType>;
-  changelog: z.ZodOptional<LongStringType>;
-  logo: z.ZodOptional<BinaryType>;
-  url: z.ZodOptional<z.ZodString>;
-  docs: z.ZodOptional<z.ZodString>;
-  support: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
-  tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-  organization: z.ZodObject<{
-    name: z.ZodString;
-    url: z.ZodString;
-    logo: z.ZodOptional<BinaryType>;
-  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    name: z.ZodString;
-    url: z.ZodString;
-    logo: z.ZodOptional<BinaryType>;
-  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    name: z.ZodString;
-    url: z.ZodString;
-    logo: z.ZodOptional<BinaryType>;
-  }, z.ZodTypeAny, "passthrough">>;
-  /**
-   * The order of blocks on the "marketplace" (higher values push block higher to the top of the list).
-   * `undefined` value or absent field is treated exactly the same as number `0`.
-   */
-  marketplaceRanking: z.ZodOptional<z.ZodNumber>;
-  /**
-   * If true, the block is deprecated and should not be used.
-   */
-  deprecated: z.ZodOptional<z.ZodBoolean>;
-  /**
-   * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
-   */
-  termsOfServiceUrl: z.ZodOptional<z.ZodString>;
-  /**
-   * Supported operating systems.
-   * If not provided, the block is supported on all operating systems.
-   */
-  supportedPlatforms: z.ZodOptional<z.ZodArray<z.ZodEnum<["windows-x64", "windows-aarch64", "macosx-x64", "macosx-aarch64", "linux-x64", "linux-aarch64"]>, "many">>;
-}>]: z.baseObjectInputType<{
-  title: z.ZodString;
-  description: z.ZodString;
-  longDescription: z.ZodOptional<LongStringType>;
-  changelog: z.ZodOptional<LongStringType>;
-  logo: z.ZodOptional<BinaryType>;
-  url: z.ZodOptional<z.ZodString>;
-  docs: z.ZodOptional<z.ZodString>;
-  support: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
-  tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-  organization: z.ZodObject<{
-    name: z.ZodString;
-    url: z.ZodString;
-    logo: z.ZodOptional<BinaryType>;
-  }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    name: z.ZodString;
-    url: z.ZodString;
-    logo: z.ZodOptional<BinaryType>;
-  }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    name: z.ZodString;
-    url: z.ZodString;
-    logo: z.ZodOptional<BinaryType>;
-  }, z.ZodTypeAny, "passthrough">>;
-  /**
-   * The order of blocks on the "marketplace" (higher values push block higher to the top of the list).
-   * `undefined` value or absent field is treated exactly the same as number `0`.
-   */
-  marketplaceRanking: z.ZodOptional<z.ZodNumber>;
-  /**
-   * If true, the block is deprecated and should not be used.
-   */
-  deprecated: z.ZodOptional<z.ZodBoolean>;
-  /**
-   * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.
-   */
-  termsOfServiceUrl: z.ZodOptional<z.ZodString>;
-  /**
-   * Supported operating systems.
-   * If not provided, the block is supported on all operating systems.
-   */
-  supportedPlatforms: z.ZodOptional<z.ZodArray<z.ZodEnum<["windows-x64", "windows-aarch64", "macosx-x64", "macosx-aarch64", "linux-x64", "linux-aarch64"]>, "many">>;
-}>[k_1] }>;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: T_1[k_1] } : never>;
 declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
   title: z.ZodString;
   description: z.ZodString;
@@ -484,6 +402,7 @@ declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
   };
   title: string;
   description: string;
+  url?: string | undefined;
   longDescription?: {
     type: "explicit-string";
     content: string;
@@ -515,7 +434,6 @@ declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
     type: "absolute-file";
     file: string;
   } | undefined;
-  url?: string | undefined;
   docs?: string | undefined;
   support?: string | undefined;
   tags?: string[] | undefined;
@@ -543,6 +461,7 @@ declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
   };
   title: string;
   description: string;
+  url?: string | undefined;
   longDescription?: string | {
     type: "explicit-string";
     content: string;
@@ -574,7 +493,6 @@ declare const BlockPackMetaDescriptionRaw: z.ZodObject<{
     type: "absolute-file";
     file: string;
   } | undefined;
-  url?: string | undefined;
   docs?: string | undefined;
   support?: string | undefined;
   tags?: string[] | undefined;
@@ -687,6 +605,7 @@ declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
   };
   title: string;
   description: string;
+  url?: string | undefined;
   longDescription?: string | undefined;
   changelog?: string | undefined;
   logo?: {
@@ -694,7 +613,6 @@ declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
     mimeType: string;
     content: string;
   } | undefined;
-  url?: string | undefined;
   docs?: string | undefined;
   support?: string | undefined;
   tags?: string[] | undefined;
@@ -716,6 +634,7 @@ declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
   };
   title: string;
   description: string;
+  url?: string | undefined;
   longDescription?: string | undefined;
   changelog?: string | undefined;
   logo?: {
@@ -723,7 +642,6 @@ declare const BlockPackMetaEmbeddedBase64: z.ZodObject<{
     mimeType: string;
     content: string;
   } | undefined;
-  url?: string | undefined;
   docs?: string | undefined;
   support?: string | undefined;
   tags?: string[] | undefined;
@@ -836,6 +754,7 @@ declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
   };
   title: string;
   description: string;
+  url?: string | undefined;
   longDescription?: string | undefined;
   changelog?: string | undefined;
   logo?: {
@@ -843,7 +762,6 @@ declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
     mimeType: string;
     content: Uint8Array<ArrayBuffer>;
   } | undefined;
-  url?: string | undefined;
   docs?: string | undefined;
   support?: string | undefined;
   tags?: string[] | undefined;
@@ -865,6 +783,7 @@ declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
   };
   title: string;
   description: string;
+  url?: string | undefined;
   longDescription?: string | undefined;
   changelog?: string | undefined;
   logo?: {
@@ -872,7 +791,6 @@ declare const BlockPackMetaEmbeddedBytes: z.ZodObject<{
     mimeType: string;
     content: Uint8Array<ArrayBuffer>;
   } | undefined;
-  url?: string | undefined;
   docs?: string | undefined;
   support?: string | undefined;
   tags?: string[] | undefined;

package/dist/block_meta/block_meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_meta.d.ts","names":[],"sources":["../../src/block_meta/block_meta.ts"],"mappings":";;;cAQa,aAAA,EAAa,CAAA,CAAA,OAAA;AAAA,KAQd,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,aAAA;AAAA,iBAE3B,aAAA,8BACe,CAAA,CAAE,UAAA,2BACN,CAAA,CAAE,UAAA,CAAA,CAC3B,UAAA,EAAY,cAAA,EAAgB,MAAA,EAAQ,UAAA,GAAU,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCnC,2BAAA,EAA2B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI5B,2BAAA,GAA8B,CAAA,CAAE,KAAA,QAAa,2BAAA;AAAA,cAE5C,2BAAA,EAA2B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAC5B,2BAAA,GAA8B,CAAA,CAAE,KAAA,QAAa,2BAAA;AAAA,cAE5C,0BAAA,EAA0B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAC3B,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAAa,0BAAA"}

package/dist/block_meta/block_meta.js

@@ -1,6 +1,5 @@
 import { ContentExplicitBase64, ContentExplicitBytes, DescriptionContentBinary, DescriptionContentText } from "./content_types.js";
 import { z } from "zod";
-
 //#region src/block_meta/block_meta.ts
 const BlockPlatform = z.enum([
 	"windows-x64",
@@ -35,7 +34,7 @@ function BlockPackMeta(longString, binary) {
 const BlockPackMetaDescriptionRaw = BlockPackMeta(DescriptionContentText, DescriptionContentBinary);
 const BlockPackMetaEmbeddedBase64 = BlockPackMeta(z.string(), ContentExplicitBase64);
 const BlockPackMetaEmbeddedBytes = BlockPackMeta(z.string(), ContentExplicitBytes);
-
 //#endregion
 export { BlockPackMeta, BlockPackMetaDescriptionRaw, BlockPackMetaEmbeddedBase64, BlockPackMetaEmbeddedBytes, BlockPlatform };
+
 //# sourceMappingURL=block_meta.js.map

package/dist/block_meta/block_meta.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_meta.js","names":[],"sources":["../../src/block_meta/block_meta.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText,\n} from \"./content_types\";\n\nexport const BlockPlatform = z.enum([\n  \"windows-x64\",\n  \"windows-aarch64\",\n  \"macosx-x64\",\n  \"macosx-aarch64\",\n  \"linux-x64\",\n  \"linux-aarch64\",\n]);\nexport type BlockPlatform = z.infer<typeof BlockPlatform>;\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny,\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z\n      .object({\n        name: z.string(),\n        url: z.string().url(),\n        logo: binary.optional(),\n      })\n      .passthrough(),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n    /**\n     * If true, the block is deprecated and should not be used.\n     */\n    deprecated: z.boolean().optional(),\n    /**\n     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.\n     */\n    termsOfServiceUrl: z.string().url().optional(),\n    /**\n     * Supported operating systems.\n     * If not provided, the block is supported on all operating systems.\n     */\n    supportedPlatforms: z.array(BlockPlatform).optional(),\n  });\n}\n\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary,\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(z.string(), ContentExplicitBase64);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(z.string(), ContentExplicitBytes);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"mappings":";;;;AAQA,MAAa,gBAAgB,EAAE,KAAK;CAClC;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAGF,SAAgB,cAGd,YAA4B,QAAoB;AAChD,QAAO,EAAE,OAAO;EACd,OAAO,EAAE,QAAQ;EACjB,aAAa,EAAE,QAAQ;EACvB,iBAAiB,WAAW,UAAU;EACtC,WAAW,WAAW,UAAU;EAChC,MAAM,OAAO,UAAU;EACvB,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAChC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EACjC,SAAS,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU;EACnE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;EACpC,cAAc,EACX,OAAO;GACN,MAAM,EAAE,QAAQ;GAChB,KAAK,EAAE,QAAQ,CAAC,KAAK;GACrB,MAAM,OAAO,UAAU;GACxB,CAAC,CACD,aAAa;EAKhB,oBAAoB,EAAE,QAAQ,CAAC,UAAU;EAIzC,YAAY,EAAE,SAAS,CAAC,UAAU;EAIlC,mBAAmB,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAK9C,oBAAoB,EAAE,MAAM,cAAc,CAAC,UAAU;EACtD,CAAC;;AAGJ,MAAa,8BAA8B,cACzC,wBACA,yBACD;AAGD,MAAa,8BAA8B,cAAc,EAAE,QAAQ,EAAE,sBAAsB;AAG3F,MAAa,6BAA6B,cAAc,EAAE,QAAQ,EAAE,qBAAqB"}
+{"version":3,"file":"block_meta.js","names":[],"sources":["../../src/block_meta/block_meta.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  ContentExplicitBase64,\n  ContentExplicitBytes,\n  DescriptionContentBinary,\n  DescriptionContentText,\n} from \"./content_types\";\n\nexport const BlockPlatform = z.enum([\n  \"windows-x64\",\n  \"windows-aarch64\",\n  \"macosx-x64\",\n  \"macosx-aarch64\",\n  \"linux-x64\",\n  \"linux-aarch64\",\n]);\nexport type BlockPlatform = z.infer<typeof BlockPlatform>;\n\nexport function BlockPackMeta<\n  const LongStringType extends z.ZodTypeAny,\n  const BinaryType extends z.ZodTypeAny,\n>(longString: LongStringType, binary: BinaryType) {\n  return z.object({\n    title: z.string(),\n    description: z.string(),\n    longDescription: longString.optional(),\n    changelog: longString.optional(),\n    logo: binary.optional(),\n    url: z.string().url().optional(),\n    docs: z.string().url().optional(),\n    support: z.union([z.string().url(), z.string().email()]).optional(),\n    tags: z.array(z.string()).optional(),\n    organization: z\n      .object({\n        name: z.string(),\n        url: z.string().url(),\n        logo: binary.optional(),\n      })\n      .passthrough(),\n    /**\n     * The order of blocks on the \"marketplace\" (higher values push block higher to the top of the list).\n     * `undefined` value or absent field is treated exactly the same as number `0`.\n     */\n    marketplaceRanking: z.number().optional(),\n    /**\n     * If true, the block is deprecated and should not be used.\n     */\n    deprecated: z.boolean().optional(),\n    /**\n     * The URL to the Terms of Service for the block. If provided checkbox with link to this URL should be shown in order to add block.\n     */\n    termsOfServiceUrl: z.string().url().optional(),\n    /**\n     * Supported operating systems.\n     * If not provided, the block is supported on all operating systems.\n     */\n    supportedPlatforms: z.array(BlockPlatform).optional(),\n  });\n}\n\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary,\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(z.string(), ContentExplicitBase64);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(z.string(), ContentExplicitBytes);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"mappings":";;;AAQA,MAAa,gBAAgB,EAAE,KAAK;CAClC;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAGF,SAAgB,cAGd,YAA4B,QAAoB;AAChD,QAAO,EAAE,OAAO;EACd,OAAO,EAAE,QAAQ;EACjB,aAAa,EAAE,QAAQ;EACvB,iBAAiB,WAAW,UAAU;EACtC,WAAW,WAAW,UAAU;EAChC,MAAM,OAAO,UAAU;EACvB,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAChC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EACjC,SAAS,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU;EACnE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;EACpC,cAAc,EACX,OAAO;GACN,MAAM,EAAE,QAAQ;GAChB,KAAK,EAAE,QAAQ,CAAC,KAAK;GACrB,MAAM,OAAO,UAAU;GACxB,CAAC,CACD,aAAa;EAKhB,oBAAoB,EAAE,QAAQ,CAAC,UAAU;EAIzC,YAAY,EAAE,SAAS,CAAC,UAAU;EAIlC,mBAAmB,EAAE,QAAQ,CAAC,KAAK,CAAC,UAAU;EAK9C,oBAAoB,EAAE,MAAM,cAAc,CAAC,UAAU;EACtD,CAAC;;AAGJ,MAAa,8BAA8B,cACzC,wBACA,yBACD;AAGD,MAAa,8BAA8B,cAAc,EAAE,QAAQ,EAAE,sBAAsB;AAG3F,MAAa,6BAA6B,cAAc,EAAE,QAAQ,EAAE,qBAAqB"}

package/dist/block_meta/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","names":[],"sources":["../../src/block_meta/common.ts"],"mappings":";KAAY,WAAA;AAAA,KACA,WAAA"}

package/dist/block_meta/content_conversion.cjs

@@ -1,4 +1,3 @@
-
 //#region src/block_meta/content_conversion.ts
 function mapRemoteToAbsolute(rootUrl) {
 	const rootWithSlash = rootUrl.endsWith("/") ? rootUrl : `${rootUrl}/`;
@@ -21,8 +20,8 @@ function addPrefixToRelative(prefix) {
 		path: prefixWithSlash + value.path
 	} : value;
 }
-
 //#endregion
 exports.addPrefixToRelative = addPrefixToRelative;
 exports.mapRemoteToAbsolute = mapRemoteToAbsolute;
+
 //# sourceMappingURL=content_conversion.cjs.map

package/dist/block_meta/content_conversion.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"content_conversion.cjs","names":[],"sources":["../../src/block_meta/content_conversion.ts"],"sourcesContent":["import type {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative,\n} from \"./content_types\";\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string,\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith(\"/\") ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === \"relative\"\n      ? { type: \"absolute-url\", url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relative path, slash at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string,\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith(\"/\") ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === \"relative\"\n      ? { type: \"relative\", path: prefixWithSlash + value.path }\n      : value) as T;\n}\n"],"mappings":";;AAOA,SAAgB,oBACd,SAC2F;CAC3F,MAAM,gBAAgB,QAAQ,SAAS,IAAI,GAAG,UAAU,GAAG,QAAQ;AACnE,SAAmC,UACjC,MAAM,SAAS,aACX;EAAE,MAAM;EAAgB,KAAK,gBAAgB,MAAM;EAAM,GACxD;;;;;;;;;AAUT,SAAgB,oBACd,QACsD;CACtD,MAAM,kBAAkB,OAAO,SAAS,IAAI,GAAG,SAAS,GAAG,OAAO;AAClE,SAA6C,UAC1C,MAAM,SAAS,aACZ;EAAE,MAAM;EAAY,MAAM,kBAAkB,MAAM;EAAM,GACxD"}
+{"version":3,"file":"content_conversion.cjs","names":[],"sources":["../../src/block_meta/content_conversion.ts"],"sourcesContent":["import type {\n  ContentAbsoluteUrl,\n  ContentAnyLocal,\n  ContentExplicitOrRelative,\n  ContentRelative,\n} from \"./content_types\";\n\nexport function mapRemoteToAbsolute(\n  rootUrl: string,\n): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl {\n  const rootWithSlash = rootUrl.endsWith(\"/\") ? rootUrl : `${rootUrl}/`;\n  return <T extends ContentAnyLocal>(value: T) =>\n    value.type === \"relative\"\n      ? { type: \"absolute-url\", url: rootWithSlash + value.path }\n      : (value as Exclude<T, ContentRelative>);\n}\n\n/**\n * Creates transformer of relative content paths, that adds a specific prefix to the relative path.\n *\n * If prefix = \"nested-path/\", paths like \"somefile.txt\" will be transformed to \"nested-path/somefile.txt\".\n *\n * @param prefix prefix to add to the relative path, slash at the end will be added automatically if missed\n */\nexport function addPrefixToRelative(\n  prefix: string,\n): <T extends ContentExplicitOrRelative>(value: T) => T {\n  const prefixWithSlash = prefix.endsWith(\"/\") ? prefix : `${prefix}/`;\n  return <T extends ContentExplicitOrRelative>(value: T) =>\n    (value.type === \"relative\"\n      ? { type: \"relative\", path: prefixWithSlash + value.path }\n      : value) as T;\n}\n"],"mappings":";AAOA,SAAgB,oBACd,SAC2F;CAC3F,MAAM,gBAAgB,QAAQ,SAAS,IAAI,GAAG,UAAU,GAAG,QAAQ;AACnE,SAAmC,UACjC,MAAM,SAAS,aACX;EAAE,MAAM;EAAgB,KAAK,gBAAgB,MAAM;EAAM,GACxD;;;;;;;;;AAUT,SAAgB,oBACd,QACsD;CACtD,MAAM,kBAAkB,OAAO,SAAS,IAAI,GAAG,SAAS,GAAG,OAAO;AAClE,SAA6C,UAC1C,MAAM,SAAS,aACZ;EAAE,MAAM;EAAY,MAAM,kBAAkB,MAAM;EAAM,GACxD"}

package/dist/block_meta/content_conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content_conversion.d.ts","names":[],"sources":["../../src/block_meta/content_conversion.ts"],"mappings":";;;iBAOgB,mBAAA,CACd,OAAA,sBACY,eAAA,EAAiB,KAAA,EAAO,CAAA,KAAM,OAAA,CAAQ,CAAA,EAAG,eAAA,IAAmB,kBAAA;;AAF1E;;;;;;iBAiBgB,mBAAA,CACd,MAAA,sBACY,yBAAA,EAA2B,KAAA,EAAO,CAAA,KAAM,CAAA"}

package/dist/block_meta/content_conversion.js

@@ -20,7 +20,7 @@ function addPrefixToRelative(prefix) {
 		path: prefixWithSlash + value.path
 	} : value;
 }
-
 //#endregion
 export { addPrefixToRelative, mapRemoteToAbsolute };
+
 //# sourceMappingURL=content_conversion.js.map

package/dist/block_meta/content_types.cjs

@@ -1,6 +1,5 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+require("../_virtual/_rolldown/runtime.cjs");
 let zod = require("zod");
-
 //#region src/block_meta/content_types.ts
 const ContentExplicitString = zod.z.object({
 	type: zod.z.literal("explicit-string"),
@@ -87,7 +86,6 @@ const DescriptionContentText = zod.z.union([zod.z.string().transform((value) =>
 		content: value
 	};
 }), ContentAnyTextLocal]);
-
 //#endregion
 exports.ContentAbsoluteBinaryLocal = ContentAbsoluteBinaryLocal;
 exports.ContentAbsoluteBinaryRemote = ContentAbsoluteBinaryRemote;
@@ -110,4 +108,5 @@ exports.ContentRelativeBinary = ContentRelativeBinary;
 exports.ContentRelativeText = ContentRelativeText;
 exports.DescriptionContentBinary = DescriptionContentBinary;
 exports.DescriptionContentText = DescriptionContentText;
+
 //# sourceMappingURL=content_types.cjs.map

package/dist/block_meta/content_types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"content_types.cjs","names":["z"],"sources":["../../src/block_meta/content_types.ts"],"sourcesContent":["import { z } from \"zod\";\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal(\"explicit-string\"),\n    content: z.string().describe(\"Actual string value\"),\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal(\"explicit-base64\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.string().base64().describe(\"Base64 encoded binary value\"),\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal(\"relative\"),\n    path: z\n      .string()\n      .describe(\n        \"Address of the file, in most cases relative to the file which this structure is a part of\",\n      ),\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal(\"absolute-file\"),\n    file: z\n      .string()\n      .regex(absPathRegex, \"path to file must be absolute\")\n      .describe(\"Absolute address of the file in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal(\"absolute-url\"),\n    url: z.string().url().describe(\"Global URL to reach the requested file\"),\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal(\"explicit-bytes\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.instanceof(Uint8Array).describe(\"Raw content\"),\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal(\"absolute-folder\"),\n    folder: z\n      .string()\n      .regex(absPathRegex, \"path to folder must be absolute\")\n      .describe(\"Absolute address of the folder in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith(\"file:\")\n    .transform<ContentRelativeBinary>((value) => ({ type: \"relative\", path: value.slice(5) })),\n  ContentAnyBinaryLocal,\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value) => {\n    if (value.startsWith(\"file:\")) return { type: \"relative\", path: value.slice(5) };\n    else return { type: \"explicit-string\", content: value };\n  }),\n  ContentAnyTextLocal,\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n"],"mappings":"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"}
+{"version":3,"file":"content_types.cjs","names":["z"],"sources":["../../src/block_meta/content_types.ts"],"sourcesContent":["import { z } from \"zod\";\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal(\"explicit-string\"),\n    content: z.string().describe(\"Actual string value\"),\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal(\"explicit-base64\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.string().base64().describe(\"Base64 encoded binary value\"),\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal(\"relative\"),\n    path: z\n      .string()\n      .describe(\n        \"Address of the file, in most cases relative to the file which this structure is a part of\",\n      ),\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal(\"absolute-file\"),\n    file: z\n      .string()\n      .regex(absPathRegex, \"path to file must be absolute\")\n      .describe(\"Absolute address of the file in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal(\"absolute-url\"),\n    url: z.string().url().describe(\"Global URL to reach the requested file\"),\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal(\"explicit-bytes\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.instanceof(Uint8Array).describe(\"Raw content\"),\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal(\"absolute-folder\"),\n    folder: z\n      .string()\n      .regex(absPathRegex, \"path to folder must be absolute\")\n      .describe(\"Absolute address of the folder in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith(\"file:\")\n    .transform<ContentRelativeBinary>((value) => ({ type: \"relative\", path: value.slice(5) })),\n  ContentAnyBinaryLocal,\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value) => {\n    if (value.startsWith(\"file:\")) return { type: \"relative\", path: value.slice(5) };\n    else return { type: \"explicit-string\", content: value };\n  }),\n  ContentAnyTextLocal,\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n"],"mappings":"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"}

package/dist/block_meta/content_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content_types.d.ts","names":[],"sources":["../../src/block_meta/content_types.ts"],"mappings":"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"}

package/dist/block_meta/content_types.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 //#region src/block_meta/content_types.ts
 const ContentExplicitString = z.object({
 	type: z.literal("explicit-string"),
@@ -86,7 +85,7 @@ const DescriptionContentText = z.union([z.string().transform((value) => {
 		content: value
 	};
 }), ContentAnyTextLocal]);
-
 //#endregion
 export { ContentAbsoluteBinaryLocal, ContentAbsoluteBinaryRemote, ContentAbsoluteFile, ContentAbsoluteFolder, ContentAbsoluteTextLocal, ContentAbsoluteTextRemote, ContentAbsoluteUrl, ContentAny, ContentAnyBinaryLocal, ContentAnyLocal, ContentAnyRemote, ContentAnyTextLocal, ContentExplicitBase64, ContentExplicitBytes, ContentExplicitOrRelative, ContentExplicitString, ContentRelative, ContentRelativeBinary, ContentRelativeText, DescriptionContentBinary, DescriptionContentText };
+
 //# sourceMappingURL=content_types.js.map

package/dist/block_meta/content_types.js.map

@@ -1 +1 @@
-{"version":3,"file":"content_types.js","names":[],"sources":["../../src/block_meta/content_types.ts"],"sourcesContent":["import { z } from \"zod\";\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal(\"explicit-string\"),\n    content: z.string().describe(\"Actual string value\"),\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal(\"explicit-base64\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.string().base64().describe(\"Base64 encoded binary value\"),\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal(\"relative\"),\n    path: z\n      .string()\n      .describe(\n        \"Address of the file, in most cases relative to the file which this structure is a part of\",\n      ),\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal(\"absolute-file\"),\n    file: z\n      .string()\n      .regex(absPathRegex, \"path to file must be absolute\")\n      .describe(\"Absolute address of the file in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal(\"absolute-url\"),\n    url: z.string().url().describe(\"Global URL to reach the requested file\"),\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal(\"explicit-bytes\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.instanceof(Uint8Array).describe(\"Raw content\"),\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal(\"absolute-folder\"),\n    folder: z\n      .string()\n      .regex(absPathRegex, \"path to folder must be absolute\")\n      .describe(\"Absolute address of the folder in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith(\"file:\")\n    .transform<ContentRelativeBinary>((value) => ({ type: \"relative\", path: value.slice(5) })),\n  ContentAnyBinaryLocal,\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value) => {\n    if (value.startsWith(\"file:\")) return { type: \"relative\", path: value.slice(5) };\n    else return { type: \"explicit-string\", content: value };\n  }),\n  ContentAnyTextLocal,\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n"],"mappings":"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"}
+{"version":3,"file":"content_types.js","names":[],"sources":["../../src/block_meta/content_types.ts"],"sourcesContent":["import { z } from \"zod\";\n\n//\n// Base content types\n//\n\nexport const ContentExplicitString = z\n  .object({\n    type: z.literal(\"explicit-string\"),\n    content: z.string().describe(\"Actual string value\"),\n  })\n  .strict();\nexport type ContentExplicitString = z.infer<typeof ContentExplicitString>;\n\nexport const ContentExplicitBase64 = z\n  .object({\n    type: z.literal(\"explicit-base64\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.string().base64().describe(\"Base64 encoded binary value\"),\n  })\n  .strict();\nexport type ContentExplicitBase64 = z.infer<typeof ContentExplicitBase64>;\n\nexport const ContentRelative = z\n  .object({\n    type: z.literal(\"relative\"),\n    path: z\n      .string()\n      .describe(\n        \"Address of the file, in most cases relative to the file which this structure is a part of\",\n      ),\n  })\n  .strict();\nexport type ContentRelative = z.infer<typeof ContentRelative>;\n\nconst absPathRegex = new RegExp(`^(/|[A-Z]:\\\\\\\\)`);\n\nexport const ContentAbsoluteFile = z\n  .object({\n    type: z.literal(\"absolute-file\"),\n    file: z\n      .string()\n      .regex(absPathRegex, \"path to file must be absolute\")\n      .describe(\"Absolute address of the file in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFile = z.infer<typeof ContentAbsoluteFile>;\n\nexport const ContentAbsoluteUrl = z\n  .object({\n    type: z.literal(\"absolute-url\"),\n    url: z.string().url().describe(\"Global URL to reach the requested file\"),\n  })\n  .strict();\nexport type ContentAbsoluteUrl = z.infer<typeof ContentAbsoluteUrl>;\n\n//\n// Special content types\n//\n\nexport const ContentExplicitBytes = z\n  .object({\n    type: z.literal(\"explicit-bytes\"),\n    mimeType: z\n      .string()\n      .regex(/\\w+\\/[-+.\\w]+/)\n      .describe(\"MIME type to interpret content\"),\n    content: z.instanceof(Uint8Array).describe(\"Raw content\"),\n  })\n  .strict();\nexport type ContentExplicitBytes = z.infer<typeof ContentExplicitBytes>;\n\nexport const ContentAbsoluteFolder = z\n  .object({\n    type: z.literal(\"absolute-folder\"),\n    folder: z\n      .string()\n      .regex(absPathRegex, \"path to folder must be absolute\")\n      .describe(\"Absolute address of the folder in local file system\"),\n  })\n  .strict();\nexport type ContentAbsoluteFolder = z.infer<typeof ContentAbsoluteFolder>;\n\n//\n// Unions\n//\n\nexport const ContentAny = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAny = z.infer<typeof ContentAny>;\n\nexport const ContentExplicitOrRelative = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentExplicitOrRelative = z.infer<typeof ContentExplicitOrRelative>;\n\nexport const ContentAnyLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyLocal = z.infer<typeof ContentAnyLocal>;\n\nexport const ContentAnyRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAnyRemote = z.infer<typeof ContentAnyRemote>;\n\n//\n// Narrow types with relative option\n//\n\n// export const ContentAnyBinaryRemote = z.discriminatedUnion('type', [\n//   ContentExplicitBase64,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyBinaryRemote = z.infer<typeof ContentAnyBinaryRemote>;\n\nexport const ContentAnyBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyBinaryLocal = z.infer<typeof ContentAnyBinaryLocal>;\n\n// export const ContentAnyTextRemote = z.discriminatedUnion('type', [\n//   ContentExplicitString,\n//   ContentRelative,\n//   ContentAbsoluteUrl\n// ]);\n// export type ContentAnyTextRemote = z.infer<typeof ContentAnyTextRemote>;\n\nexport const ContentAnyTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n  ContentAbsoluteFile,\n]);\nexport type ContentAnyTextLocal = z.infer<typeof ContentAnyTextLocal>;\n\n//\n// Narrow absolute types\n//\n\nexport const ContentAbsoluteBinaryRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteBinaryRemote = z.infer<typeof ContentAbsoluteBinaryRemote>;\n\nexport const ContentAbsoluteBinaryLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteBinaryLocal = z.infer<typeof ContentAbsoluteBinaryLocal>;\n\nexport const ContentAbsoluteTextRemote = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteUrl,\n]);\nexport type ContentAbsoluteTextRemote = z.infer<typeof ContentAbsoluteTextRemote>;\n\nexport const ContentAbsoluteTextLocal = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentAbsoluteFile,\n]);\nexport type ContentAbsoluteTextLocal = z.infer<typeof ContentAbsoluteTextLocal>;\n\n//\n// Narrow relative types\n//\n\nexport const ContentRelativeBinary = z.discriminatedUnion(\"type\", [\n  ContentExplicitBase64,\n  ContentRelative,\n]);\nexport type ContentRelativeBinary = z.infer<typeof ContentRelativeBinary>;\n\nexport const ContentRelativeText = z.discriminatedUnion(\"type\", [\n  ContentExplicitString,\n  ContentRelative,\n]);\nexport type ContentRelativeText = z.infer<typeof ContentRelativeText>;\n\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'local'\n// ): typeof ContentAnyTextLocal;\n// export function ConstructContent(\n//   contentType: 'text',\n//   contextType: 'remote'\n// ): typeof ContentAnyTextRemote;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'local'\n// ): typeof ContentAnyBinaryLocal;\n// export function ConstructContent(\n//   contentType: 'binary',\n//   contextType: 'remote'\n// ): typeof ContentAnyBinaryRemote;\n// export function ConstructContent(\n//   contentType: ContentType,\n//   contextType: ContextType\n// ):\n//   | typeof ContentAnyTextLocal\n//   | typeof ContentAnyTextRemote\n//   | typeof ContentAnyBinaryLocal\n//   | typeof ContentAnyBinaryRemote;\n// export function ConstructContent(contentType: ContentType, contextType: ContextType) {\n//   return contentType === 'text'\n//     ? contextType === 'local'\n//       ? ContentAnyTextLocal\n//       : ContentAnyTextRemote\n//     : contextType === 'local'\n//       ? ContentAnyBinaryLocal\n//       : ContentAnyBinaryRemote;\n// }\n\nexport const DescriptionContentBinary = z.union([\n  z\n    .string()\n    .startsWith(\"file:\")\n    .transform<ContentRelativeBinary>((value) => ({ type: \"relative\", path: value.slice(5) })),\n  ContentAnyBinaryLocal,\n]);\nexport type DescriptionContentBinary = z.infer<typeof DescriptionContentBinary>;\n\nexport const DescriptionContentText = z.union([\n  z.string().transform<ContentRelativeText>((value) => {\n    if (value.startsWith(\"file:\")) return { type: \"relative\", path: value.slice(5) };\n    else return { type: \"explicit-string\", content: value };\n  }),\n  ContentAnyTextLocal,\n]);\nexport type DescriptionContentText = z.infer<typeof DescriptionContentText>;\n"],"mappings":"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"}

package/dist/block_meta/index.cjs

@@ -1,8 +1,8 @@
-const require_content_types = require('./content_types.cjs');
-const require_semver = require('./semver.cjs');
-const require_content_conversion = require('./content_conversion.cjs');
-const require_block_id = require('./block_id.cjs');
-const require_block_components = require('./block_components.cjs');
-const require_block_meta = require('./block_meta.cjs');
-const require_block_description = require('./block_description.cjs');
-const require_block_manifest = require('./block_manifest.cjs');
+require("./content_types.cjs");
+require("./semver.cjs");
+require("./content_conversion.cjs");
+require("./block_id.cjs");
+require("./block_components.cjs");
+require("./block_meta.cjs");
+require("./block_description.cjs");
+require("./block_manifest.cjs");

package/dist/block_meta/index.js

@@ -1,8 +1,8 @@
-import { ContentAbsoluteBinaryLocal, ContentAbsoluteBinaryRemote, ContentAbsoluteFile, ContentAbsoluteFolder, ContentAbsoluteTextLocal, ContentAbsoluteTextRemote, ContentAbsoluteUrl, ContentAny, ContentAnyBinaryLocal, ContentAnyLocal, ContentAnyRemote, ContentAnyTextLocal, ContentExplicitBase64, ContentExplicitBytes, ContentExplicitOrRelative, ContentExplicitString, ContentRelative, ContentRelativeBinary, ContentRelativeText, DescriptionContentBinary, DescriptionContentText } from "./content_types.js";
-import { SemVer } from "./semver.js";
-import { addPrefixToRelative, mapRemoteToAbsolute } from "./content_conversion.js";
-import { BlockPackId, BlockPackIdNoVersion, blockPackIdEquals, blockPackIdNoVersionEquals, blockPackIdNoVersionToString, blockPackIdToString } from "./block_id.js";
-import { BlockComponents, BlockComponentsAbsoluteUrl, BlockComponentsDescriptionRaw, Workflow, WorkflowV1 } from "./block_components.js";
-import { BlockPackMeta, BlockPackMetaDescriptionRaw, BlockPackMetaEmbeddedBase64, BlockPackMetaEmbeddedBytes, BlockPlatform } from "./block_meta.js";
-import { BlockPackDescriptionFromPackageJsonRaw, BlockPackDescriptionRaw, CreateBlockPackDescriptionSchema, FeatureFlags, overrideDescriptionVersion } from "./block_description.js";
-import { BlockComponentsManifest, BlockPackDescriptionManifest, BlockPackManifest, BlockPackManifestFile, BlockPackMetaManifest, ManifestFileInfo, Sha256Schema, overrideManifestVersion } from "./block_manifest.js";
+import "./content_types.js";
+import "./semver.js";
+import "./content_conversion.js";
+import "./block_id.js";
+import "./block_components.js";
+import "./block_meta.js";
+import "./block_description.js";
+import "./block_manifest.js";

package/dist/block_meta/semver.cjs

@@ -1,9 +1,7 @@
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-let zod = require("zod");
-
+require("../_virtual/_rolldown/runtime.cjs");
 //#region src/block_meta/semver.ts
-const SemVer = zod.z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/, "Wrong version format, please use valid semver");
-
+const SemVer = require("zod").z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/, "Wrong version format, please use valid semver");
 //#endregion
 exports.SemVer = SemVer;
+
 //# sourceMappingURL=semver.cjs.map

package/dist/block_meta/semver.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"semver.cjs","names":["z"],"sources":["../../src/block_meta/semver.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    \"Wrong version format, please use valid semver\",\n  );\n"],"mappings":";;;;AAIA,MAAa,SAASA,MACnB,QAAQ,CACR,MACC,uLACA,gDACD"}
+{"version":3,"file":"semver.cjs","names":["z"],"sources":["../../src/block_meta/semver.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    \"Wrong version format, please use valid semver\",\n  );\n"],"mappings":";;AAIA,MAAa,wBAASA,EACnB,QAAQ,CACR,MACC,uLACA,gDACD"}

package/dist/block_meta/semver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semver.d.ts","names":[],"sources":["../../src/block_meta/semver.ts"],"mappings":";;;cAIa,MAAA,EAAM,CAAA,CAAA,SAAA"}

package/dist/block_meta/semver.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
-
 //#region src/block_meta/semver.ts
 const SemVer = z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/, "Wrong version format, please use valid semver");
-
 //#endregion
 export { SemVer };
+
 //# sourceMappingURL=semver.js.map

package/dist/block_meta/semver.js.map

@@ -1 +1 @@
-{"version":3,"file":"semver.js","names":[],"sources":["../../src/block_meta/semver.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    \"Wrong version format, please use valid semver\",\n  );\n"],"mappings":";;;AAIA,MAAa,SAAS,EACnB,QAAQ,CACR,MACC,uLACA,gDACD"}
+{"version":3,"file":"semver.js","names":[],"sources":["../../src/block_meta/semver.ts"],"sourcesContent":["import { z } from \"zod\";\n\n// Regex taken from here:\n//   https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nexport const SemVer = z\n  .string()\n  .regex(\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/,\n    \"Wrong version format, please use valid semver\",\n  );\n"],"mappings":";;AAIA,MAAa,SAAS,EACnB,QAAQ,CACR,MACC,uLACA,gDACD"}