@milaboratories/pl-model-middle-layer 1.8.41 → 1.8.42

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

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

package/dist/block_meta/block_description.js

@@ -9,7 +9,7 @@ import * as R from 'remeda';
  * strings are converted to explicit content type. */
 const BlockPackDescriptionFromPackageJsonRaw = z.object({
     components: BlockComponentsDescriptionRaw,
-    meta: BlockPackMetaDescriptionRaw
+    meta: BlockPackMetaDescriptionRaw,
 });
 const FeatureFlags = z.record(z.string(), z.union([z.boolean(), z.number()]))
     .transform((flags) => flags);
@@ -18,7 +18,7 @@ function CreateBlockPackDescriptionSchema(components, meta) {
         id: BlockPackId,
         components,
         meta,
-        featureFlags: FeatureFlags.optional()
+        featureFlags: FeatureFlags.optional(),
     }).passthrough();
 }
 const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(BlockComponentsDescriptionRaw, BlockPackMetaDescriptionRaw);

package/dist/block_meta/block_description.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_description.js","sources":["../../src/block_meta/block_description.ts"],"sourcesContent":["import { z, ZodTypeAny } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\nimport { BlockCodeKnownFeatureFlags } from '@milaboratories/pl-model-common';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw\n});\n\nexport const FeatureFlags = z.record(z.string(), z.union([z.boolean(), z.number()]))\n  .transform((flags) => flags as BlockCodeKnownFeatureFlags);\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta,\n    featureFlags: FeatureFlags.optional()\n  }).passthrough();\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string\n): T {\n  return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n"],"names":[],"mappings":";;;;;;AAOA;;AAEqD;AAC9C,MAAM,sCAAsC,GAAG,CAAC,CAAC,MAAM,CAAC;AAC7D,IAAA,UAAU,EAAE,6BAA6B;AACzC,IAAA,IAAI,EAAE;AACP,CAAA;AAEM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;KAChF,SAAS,CAAC,CAAC,KAAK,KAAK,KAAmC;AAErD,SAAU,gCAAgC,CAG9C,UAAsB,EAAE,IAAU,EAAA;IAClC,OAAO,CAAC,CAAC,MAAM,CAAC;AACd,QAAA,EAAE,EAAE,WAAW;QACf,UAAU;QACV,IAAI;AACJ,QAAA,YAAY,EAAE,YAAY,CAAC,QAAQ;KACpC,CAAC,CAAC,WAAW,EAAE;AAClB;AAEO,MAAM,uBAAuB,GAAG,gCAAgC,CACrE,6BAA6B,EAC7B,2BAA2B;AAIvB,SAAU,0BAA0B,CACxC,QAAW,EACX,UAAkB,EAAA;AAElB,IAAA,OAAO,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,CAAM;AACpE;;;;"}
+{"version":3,"file":"block_description.js","sources":["../../src/block_meta/block_description.ts"],"sourcesContent":["import type { ZodTypeAny } from 'zod';\nimport { z } from 'zod';\nimport { BlockComponentsDescriptionRaw } from './block_components';\nimport { BlockPackMetaDescriptionRaw } from './block_meta';\nimport { BlockPackId } from './block_id';\nimport * as R from 'remeda';\nimport type { BlockCodeKnownFeatureFlags } from '@milaboratories/pl-model-common';\n\n/** Description, as appears in root block package.json file,\n * `file:` references are parsed into relative content of corresponding type, depending on the context,\n * strings are converted to explicit content type. */\nexport const BlockPackDescriptionFromPackageJsonRaw = z.object({\n  components: BlockComponentsDescriptionRaw,\n  meta: BlockPackMetaDescriptionRaw,\n});\n\nexport const FeatureFlags = z.record(z.string(), z.union([z.boolean(), z.number()]))\n  .transform((flags) => flags as BlockCodeKnownFeatureFlags);\n\nexport function CreateBlockPackDescriptionSchema<\n  Components extends ZodTypeAny,\n  Meta extends ZodTypeAny,\n>(components: Components, meta: Meta) {\n  return z.object({\n    id: BlockPackId,\n    components,\n    meta,\n    featureFlags: FeatureFlags.optional(),\n  }).passthrough();\n}\n\nexport const BlockPackDescriptionRaw = CreateBlockPackDescriptionSchema(\n  BlockComponentsDescriptionRaw,\n  BlockPackMetaDescriptionRaw,\n);\nexport type BlockPackDescriptionRaw = z.infer<typeof BlockPackDescriptionRaw>;\n\nexport function overrideDescriptionVersion<T extends { id: BlockPackId }>(\n  manifest: T,\n  newVersion: string,\n): T {\n  return R.mergeDeep(manifest, { id: { version: newVersion } }) as T;\n}\n"],"names":[],"mappings":";;;;;;AAQA;;AAEqD;AAC9C,MAAM,sCAAsC,GAAG,CAAC,CAAC,MAAM,CAAC;AAC7D,IAAA,UAAU,EAAE,6BAA6B;AACzC,IAAA,IAAI,EAAE,2BAA2B;AAClC,CAAA;AAEM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;KAChF,SAAS,CAAC,CAAC,KAAK,KAAK,KAAmC;AAErD,SAAU,gCAAgC,CAG9C,UAAsB,EAAE,IAAU,EAAA;IAClC,OAAO,CAAC,CAAC,MAAM,CAAC;AACd,QAAA,EAAE,EAAE,WAAW;QACf,UAAU;QACV,IAAI;AACJ,QAAA,YAAY,EAAE,YAAY,CAAC,QAAQ,EAAE;KACtC,CAAC,CAAC,WAAW,EAAE;AAClB;AAEO,MAAM,uBAAuB,GAAG,gCAAgC,CACrE,6BAA6B,EAC7B,2BAA2B;AAIvB,SAAU,0BAA0B,CACxC,QAAW,EACX,UAAkB,EAAA;AAElB,IAAA,OAAO,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,CAAM;AACpE;;;;"}

package/dist/block_meta/block_id.cjs

@@ -8,7 +8,7 @@ const BlockPackId = zod.z
     .object({
     organization: zod.z.string(),
     name: zod.z.string(),
-    version: semver.SemVer
+    version: semver.SemVer,
 })
     .strict();
 const BlockPackIdNoVersion = BlockPackId.omit({ version: true });

package/dist/block_meta/block_id.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_id.cjs","sources":["../../src/block_meta/block_id.ts"],"sourcesContent":["import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n"],"names":["z","SemVer"],"mappings":";;;;;AAGA;AACO,MAAM,WAAW,GAAGA;AACxB,KAAA,MAAM,CAAC;AACN,IAAA,YAAY,EAAEA,KAAC,CAAC,MAAM,EAAE;AACxB,IAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE;AAChB,IAAA,OAAO,EAAEC;CACV;AACA,KAAA,MAAM;AAGF,MAAM,oBAAoB,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE;AAKhE,SAAU,mBAAmB,CAAC,EAA2B,EAAA;IAC7D,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;AACtC,IAAA,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,CAAA,CAAA,EAAI,EAAE,CAAC,IAAI,CAAA,CAAA,EAAI,EAAE,CAAC,OAAO,EAAE;AACtD;AAMM,SAAU,4BAA4B,CAC1C,EAAoC,EAAA;IAEpC,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;IACtC,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,IAAI,EAAE,CAAC,IAAI,CAAA,CAAE;AACxC;AAEM,SAAU,iBAAiB,CAC/B,GAA4B,EAC5B,GAA4B,EAAA;AAE5B,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;IACxD,QACE,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO;AAEjG;AAEM,SAAU,0BAA0B,CACxC,GAAqC,EACrC,GAAqC,EAAA;AAErC,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;AACxD,IAAA,OAAO,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY;AACvE;;;;;;;;;"}
+{"version":3,"file":"block_id.cjs","sources":["../../src/block_meta/block_id.ts"],"sourcesContent":["import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer,\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined,\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined,\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined,\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n"],"names":["z","SemVer"],"mappings":";;;;;AAGA;AACO,MAAM,WAAW,GAAGA;AACxB,KAAA,MAAM,CAAC;AACN,IAAA,YAAY,EAAEA,KAAC,CAAC,MAAM,EAAE;AACxB,IAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE;AAChB,IAAA,OAAO,EAAEC,aAAM;CAChB;AACA,KAAA,MAAM;AAGF,MAAM,oBAAoB,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE;AAKhE,SAAU,mBAAmB,CAAC,EAA2B,EAAA;IAC7D,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;AACtC,IAAA,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,CAAA,CAAA,EAAI,EAAE,CAAC,IAAI,CAAA,CAAA,EAAI,EAAE,CAAC,OAAO,EAAE;AACtD;AAMM,SAAU,4BAA4B,CAC1C,EAAoC,EAAA;IAEpC,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;IACtC,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,IAAI,EAAE,CAAC,IAAI,CAAA,CAAE;AACxC;AAEM,SAAU,iBAAiB,CAC/B,GAA4B,EAC5B,GAA4B,EAAA;AAE5B,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;IACxD,QACE,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO;AAEjG;AAEM,SAAU,0BAA0B,CACxC,GAAqC,EACrC,GAAqC,EAAA;AAErC,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;AACxD,IAAA,OAAO,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY;AACvE;;;;;;;;;"}

package/dist/block_meta/block_id.js

@@ -6,7 +6,7 @@ const BlockPackId = z
     .object({
     organization: z.string(),
     name: z.string(),
-    version: SemVer
+    version: SemVer,
 })
     .strict();
 const BlockPackIdNoVersion = BlockPackId.omit({ version: true });

package/dist/block_meta/block_id.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_id.js","sources":["../../src/block_meta/block_id.ts"],"sourcesContent":["import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n"],"names":[],"mappings":";;;AAGA;AACO,MAAM,WAAW,GAAG;AACxB,KAAA,MAAM,CAAC;AACN,IAAA,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;AACxB,IAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;AAChB,IAAA,OAAO,EAAE;CACV;AACA,KAAA,MAAM;AAGF,MAAM,oBAAoB,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE;AAKhE,SAAU,mBAAmB,CAAC,EAA2B,EAAA;IAC7D,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;AACtC,IAAA,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,CAAA,CAAA,EAAI,EAAE,CAAC,IAAI,CAAA,CAAA,EAAI,EAAE,CAAC,OAAO,EAAE;AACtD;AAMM,SAAU,4BAA4B,CAC1C,EAAoC,EAAA;IAEpC,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;IACtC,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,IAAI,EAAE,CAAC,IAAI,CAAA,CAAE;AACxC;AAEM,SAAU,iBAAiB,CAC/B,GAA4B,EAC5B,GAA4B,EAAA;AAE5B,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;IACxD,QACE,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO;AAEjG;AAEM,SAAU,0BAA0B,CACxC,GAAqC,EACrC,GAAqC,EAAA;AAErC,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;AACxD,IAAA,OAAO,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY;AACvE;;;;"}
+{"version":3,"file":"block_id.js","sources":["../../src/block_meta/block_id.ts"],"sourcesContent":["import { z } from 'zod';\nimport { SemVer } from './semver';\n\n/** Global identifier of the block */\nexport const BlockPackId = z\n  .object({\n    organization: z.string(),\n    name: z.string(),\n    version: SemVer,\n  })\n  .strict();\nexport type BlockPackId = z.infer<typeof BlockPackId>;\n\nexport const BlockPackIdNoVersion = BlockPackId.omit({ version: true });\nexport type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;\n\nexport function blockPackIdToString(bp: BlockPackId): string;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined;\nexport function blockPackIdToString(bp: BlockPackId | undefined): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}:${bp.version}`;\n}\n\nexport function blockPackIdNoVersionToString(bp: BlockPackIdNoVersion): string;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined\n): string | undefined;\nexport function blockPackIdNoVersionToString(\n  bp: BlockPackIdNoVersion | undefined,\n): string | undefined {\n  if (bp === undefined) return undefined;\n  return `${bp.organization}:${bp.name}`;\n}\n\nexport function blockPackIdEquals(\n  bp1: BlockPackId | undefined,\n  bp2: BlockPackId | undefined,\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return (\n    bp1.name === bp2.name && bp1.organization === bp2.organization && bp1.version === bp2.version\n  );\n}\n\nexport function blockPackIdNoVersionEquals(\n  bp1: BlockPackIdNoVersion | undefined,\n  bp2: BlockPackIdNoVersion | undefined,\n): boolean {\n  if (bp1 === undefined && bp2 === undefined) return true;\n  if (bp1 === undefined || bp2 === undefined) return false;\n  return bp1.name === bp2.name && bp1.organization === bp2.organization;\n}\n"],"names":[],"mappings":";;;AAGA;AACO,MAAM,WAAW,GAAG;AACxB,KAAA,MAAM,CAAC;AACN,IAAA,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;AACxB,IAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;AAChB,IAAA,OAAO,EAAE,MAAM;CAChB;AACA,KAAA,MAAM;AAGF,MAAM,oBAAoB,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE;AAKhE,SAAU,mBAAmB,CAAC,EAA2B,EAAA;IAC7D,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;AACtC,IAAA,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,CAAA,CAAA,EAAI,EAAE,CAAC,IAAI,CAAA,CAAA,EAAI,EAAE,CAAC,OAAO,EAAE;AACtD;AAMM,SAAU,4BAA4B,CAC1C,EAAoC,EAAA;IAEpC,IAAI,EAAE,KAAK,SAAS;AAAE,QAAA,OAAO,SAAS;IACtC,OAAO,CAAA,EAAG,EAAE,CAAC,YAAY,IAAI,EAAE,CAAC,IAAI,CAAA,CAAE;AACxC;AAEM,SAAU,iBAAiB,CAC/B,GAA4B,EAC5B,GAA4B,EAAA;AAE5B,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;IACxD,QACE,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO;AAEjG;AAEM,SAAU,0BAA0B,CACxC,GAAqC,EACrC,GAAqC,EAAA;AAErC,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,IAAI;AACvD,IAAA,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS;AAAE,QAAA,OAAO,KAAK;AACxD,IAAA,OAAO,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,KAAK,GAAG,CAAC,YAAY;AACvE;;;;"}

package/dist/block_meta/block_manifest.cjs

@@ -38,13 +38,13 @@ const Sha256Schema = zod.z
 const ManifestFileInfo = zod.z.object({
     name: zod.z.string(),
     size: zod.z.number().int(),
-    sha256: Sha256Schema
+    sha256: Sha256Schema,
 });
 const BlockPackManifest = zod.z.object({
     schema: zod.z.literal('v2'),
     description: BlockPackDescriptionManifest,
     timestamp: zod.z.number().optional(),
-    files: zod.z.array(ManifestFileInfo)
+    files: zod.z.array(ManifestFileInfo),
 }).passthrough();
 const BlockPackManifestFile = 'manifest.json';
 function overrideManifestVersion(manifest, newVersion) {

package/dist/block_meta/block_manifest.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_manifest.cjs","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 * as R from 'remeda';\nimport { 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.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo)\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 R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n"],"names":["BlockComponents","ContentRelative","BlockPackMeta","ContentRelativeText","ContentRelativeBinary","CreateBlockPackDescriptionSchema","z","R"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQO,MAAM,uBAAuB,GAAGA,gCAAe,CAACC,6BAAe,EAAEA,6BAAe;AAGhF,MAAM,qBAAqB,GAAGC,wBAAa,CAACC,iCAAmB,EAAEC,mCAAqB;AAG7F;AACO,MAAM,4BAA4B,GAAGC,kDAAgC,CAC1E,uBAAuB,EACvB,qBAAqB;AAIhB,MAAM,YAAY,GAAGC;AACzB,KAAA,MAAM;KACN,KAAK,CAAC,aAAa;AACnB,KAAA,WAAW;AACX,KAAA,MAAM,CAAC,EAAE,EAAE;AAEP,MAAM,gBAAgB,GAAGA,KAAC,CAAC,MAAM,CAAC;AACvC,IAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE;AAChB,IAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACtB,IAAA,MAAM,EAAE;AACT,CAAA;AAGM,MAAM,iBAAiB,GAAGA,KAAC,CAAC,MAAM,CAAC;AACxC,IAAA,MAAM,EAAEA,KAAC,CAAC,OAAO,CAAC,IAAI,CAAC;AACvB,IAAA,WAAW,EAAE,4BAA4B;AACzC,IAAA,SAAS,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AAChC,IAAA,KAAK,EAAEA,KAAC,CAAC,KAAK,CAAC,gBAAgB;CAChC,CAAC,CAAC,WAAW;AAGP,MAAM,qBAAqB,GAAG;AAE/B,SAAU,uBAAuB,CACrC,QAAW,EACX,UAAkB,EAAA;IAElB,OAAOC,YAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAM;AACrF;;;;;;;;;;;"}
+{"version":3,"file":"block_manifest.cjs","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 * as R from 'remeda';\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.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo),\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 R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n"],"names":["BlockComponents","ContentRelative","BlockPackMeta","ContentRelativeText","ContentRelativeBinary","CreateBlockPackDescriptionSchema","z","R"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQO,MAAM,uBAAuB,GAAGA,gCAAe,CAACC,6BAAe,EAAEA,6BAAe;AAGhF,MAAM,qBAAqB,GAAGC,wBAAa,CAACC,iCAAmB,EAAEC,mCAAqB;AAG7F;AACO,MAAM,4BAA4B,GAAGC,kDAAgC,CAC1E,uBAAuB,EACvB,qBAAqB;AAIhB,MAAM,YAAY,GAAGC;AACzB,KAAA,MAAM;KACN,KAAK,CAAC,aAAa;AACnB,KAAA,WAAW;AACX,KAAA,MAAM,CAAC,EAAE,EAAE;AAEP,MAAM,gBAAgB,GAAGA,KAAC,CAAC,MAAM,CAAC;AACvC,IAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE;AAChB,IAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACtB,IAAA,MAAM,EAAE,YAAY;AACrB,CAAA;AAGM,MAAM,iBAAiB,GAAGA,KAAC,CAAC,MAAM,CAAC;AACxC,IAAA,MAAM,EAAEA,KAAC,CAAC,OAAO,CAAC,IAAI,CAAC;AACvB,IAAA,WAAW,EAAE,4BAA4B;AACzC,IAAA,SAAS,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AAChC,IAAA,KAAK,EAAEA,KAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC;CACjC,CAAC,CAAC,WAAW;AAGP,MAAM,qBAAqB,GAAG;AAE/B,SAAU,uBAAuB,CACrC,QAAW,EACX,UAAkB,EAAA;IAElB,OAAOC,YAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAM;AACrF;;;;;;;;;;;"}

package/dist/block_meta/block_manifest.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { BlockPackId } from './block_id';
+import type { BlockPackId } from './block_id';
 export declare const BlockComponentsManifest: z.ZodObject<{
     workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<z.ZodObject<{
         type: z.ZodLiteral<"relative">;

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

@@ -1 +1 @@
-{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AACzF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4D,CAAC;AAC/F,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,qDAAqD;AACrD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGxC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAExF,eAAO,MAAM,YAAY,aAIZ,CAAC;AAEd,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAKd,CAAC;AACjB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,qBAAqB,kBAAkB,CAAC;AAErD,wBAAgB,uBAAuB,CAAC,CAAC,SAAS;IAAE,WAAW,EAAE;QAAE,EAAE,EAAE,WAAW,CAAA;KAAE,CAAA;CAAE,EACpF,QAAQ,EAAE,CAAC,EACX,UAAU,EAAE,MAAM,GACjB,CAAC,CAEH"}
+{"version":3,"file":"block_manifest.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_manifest.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAKd,CAAC;AACjB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,qBAAqB,kBAAkB,CAAC;AAErD,wBAAgB,uBAAuB,CAAC,CAAC,SAAS;IAAE,WAAW,EAAE;QAAE,EAAE,EAAE,WAAW,CAAA;KAAE,CAAA;CAAE,EACpF,QAAQ,EAAE,CAAC,EACX,UAAU,EAAE,MAAM,GACjB,CAAC,CAEH"}

package/dist/block_meta/block_manifest.js

@@ -17,13 +17,13 @@ const Sha256Schema = z
 const ManifestFileInfo = z.object({
     name: z.string(),
     size: z.number().int(),
-    sha256: Sha256Schema
+    sha256: Sha256Schema,
 });
 const BlockPackManifest = z.object({
     schema: z.literal('v2'),
     description: BlockPackDescriptionManifest,
     timestamp: z.number().optional(),
-    files: z.array(ManifestFileInfo)
+    files: z.array(ManifestFileInfo),
 }).passthrough();
 const BlockPackManifestFile = 'manifest.json';
 function overrideManifestVersion(manifest, newVersion) {

package/dist/block_meta/block_manifest.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_manifest.js","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 * as R from 'remeda';\nimport { 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.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo)\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 R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n"],"names":[],"mappings":";;;;;;;AAQO,MAAM,uBAAuB,GAAG,eAAe,CAAC,eAAe,EAAE,eAAe;AAGhF,MAAM,qBAAqB,GAAG,aAAa,CAAC,mBAAmB,EAAE,qBAAqB;AAG7F;AACO,MAAM,4BAA4B,GAAG,gCAAgC,CAC1E,uBAAuB,EACvB,qBAAqB;AAIhB,MAAM,YAAY,GAAG;AACzB,KAAA,MAAM;KACN,KAAK,CAAC,aAAa;AACnB,KAAA,WAAW;AACX,KAAA,MAAM,CAAC,EAAE,EAAE;AAEP,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;AACvC,IAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;AAChB,IAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACtB,IAAA,MAAM,EAAE;AACT,CAAA;AAGM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;AACxC,IAAA,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;AACvB,IAAA,WAAW,EAAE,4BAA4B;AACzC,IAAA,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AAChC,IAAA,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB;CAChC,CAAC,CAAC,WAAW;AAGP,MAAM,qBAAqB,GAAG;AAE/B,SAAU,uBAAuB,CACrC,QAAW,EACX,UAAkB,EAAA;IAElB,OAAO,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAM;AACrF;;;;"}
+{"version":3,"file":"block_manifest.js","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 * as R from 'remeda';\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.object({\n  schema: z.literal('v2'),\n  description: BlockPackDescriptionManifest,\n  timestamp: z.number().optional(),\n  files: z.array(ManifestFileInfo),\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 R.mergeDeep(manifest, { description: { id: { version: newVersion } } }) as T;\n}\n"],"names":[],"mappings":";;;;;;;AAQO,MAAM,uBAAuB,GAAG,eAAe,CAAC,eAAe,EAAE,eAAe;AAGhF,MAAM,qBAAqB,GAAG,aAAa,CAAC,mBAAmB,EAAE,qBAAqB;AAG7F;AACO,MAAM,4BAA4B,GAAG,gCAAgC,CAC1E,uBAAuB,EACvB,qBAAqB;AAIhB,MAAM,YAAY,GAAG;AACzB,KAAA,MAAM;KACN,KAAK,CAAC,aAAa;AACnB,KAAA,WAAW;AACX,KAAA,MAAM,CAAC,EAAE,EAAE;AAEP,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;AACvC,IAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;AAChB,IAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACtB,IAAA,MAAM,EAAE,YAAY;AACrB,CAAA;AAGM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;AACxC,IAAA,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;AACvB,IAAA,WAAW,EAAE,4BAA4B;AACzC,IAAA,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AAChC,IAAA,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC;CACjC,CAAC,CAAC,WAAW;AAGP,MAAM,qBAAqB,GAAG;AAE/B,SAAU,uBAAuB,CACrC,QAAW,EACX,UAAkB,EAAA;IAElB,OAAO,CAAC,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAM;AACrF;;;;"}

package/dist/block_meta/block_meta.cjs

@@ -9,7 +9,7 @@ const BlockPlatform = zod.z.enum([
     'macosx-x64',
     'macosx-aarch64',
     'linux-x64',
-    'linux-aarch64'
+    'linux-aarch64',
 ]);
 function BlockPackMeta(longString, binary) {
     return zod.z.object({
@@ -25,7 +25,7 @@ function BlockPackMeta(longString, binary) {
         organization: zod.z.object({
             name: zod.z.string(),
             url: zod.z.string().url(),
-            logo: binary.optional()
+            logo: binary.optional(),
         }).passthrough(),
         /**
          * The order of blocks on the "marketplace" (higher values push block higher to the top of the list).
@@ -44,7 +44,7 @@ function BlockPackMeta(longString, binary) {
          * Supported operating systems.
          * If not provided, the block is supported on all operating systems.
          */
-        supportedPlatforms: zod.z.array(BlockPlatform).optional()
+        supportedPlatforms: zod.z.array(BlockPlatform).optional(),
     });
 }
 // prettier-ignore

package/dist/block_meta/block_meta.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_meta.cjs","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.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\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\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"names":["z","DescriptionContentText","DescriptionContentBinary","ContentExplicitBase64","ContentExplicitBytes"],"mappings":";;;;;AAQO,MAAM,aAAa,GAAGA,KAAC,CAAC,IAAI,CAAC;IAClC,aAAa;IACb,iBAAiB;IACjB,YAAY;IACZ,gBAAgB;IAChB,WAAW;IACX;AACD,CAAA;AAGK,SAAU,aAAa,CAG3B,UAA0B,EAAE,MAAkB,EAAA;IAC9C,OAAOA,KAAC,CAAC,MAAM,CAAC;AACd,QAAA,KAAK,EAAEA,KAAC,CAAC,MAAM,EAAE;AACjB,QAAA,WAAW,EAAEA,KAAC,CAAC,MAAM,EAAE;AACvB,QAAA,eAAe,EAAE,UAAU,CAAC,QAAQ,EAAE;AACtC,QAAA,SAAS,EAAE,UAAU,CAAC,QAAQ,EAAE;AAChC,QAAA,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE;QACvB,GAAG,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAChC,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QACjC,OAAO,EAAEA,KAAC,CAAC,KAAK,CAAC,CAACA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;AACnE,QAAA,IAAI,EAAEA,KAAC,CAAC,KAAK,CAACA,KAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;AACpC,QAAA,YAAY,EAAEA,KAAC,CAAC,MAAM,CAAC;AACrB,YAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE;AAChB,YAAA,GAAG,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACrB,YAAA,IAAI,EAAE,MAAM,CAAC,QAAQ;SACtB,CAAC,CAAC,WAAW,EAAE;AAChB;;;AAGG;AACH,QAAA,kBAAkB,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AACzC;;AAEG;AACH,QAAA,UAAU,EAAEA,KAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;AAClC;;AAEG;QACH,iBAAiB,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;AAC9C;;;AAGG;QACH,kBAAkB,EAAEA,KAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,QAAQ;AACpD,KAAA,CAAC;AACJ;AAEA;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtDC,oCAAsB,EACtBC,sCAAwB;AAI1B;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtDF,KAAC,CAAC,MAAM,EAAE,EACVG,mCAAqB;AAIvB;AACO,MAAM,0BAA0B,GAAG,aAAa,CACrDH,KAAC,CAAC,MAAM,EAAE,EACVI,kCAAoB;;;;;;;;"}
+{"version":3,"file":"block_meta.cjs","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.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional(),\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\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary,\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64,\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes,\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"names":["z","DescriptionContentText","DescriptionContentBinary","ContentExplicitBase64","ContentExplicitBytes"],"mappings":";;;;;AAQO,MAAM,aAAa,GAAGA,KAAC,CAAC,IAAI,CAAC;IAClC,aAAa;IACb,iBAAiB;IACjB,YAAY;IACZ,gBAAgB;IAChB,WAAW;IACX,eAAe;AAChB,CAAA;AAGK,SAAU,aAAa,CAG3B,UAA0B,EAAE,MAAkB,EAAA;IAC9C,OAAOA,KAAC,CAAC,MAAM,CAAC;AACd,QAAA,KAAK,EAAEA,KAAC,CAAC,MAAM,EAAE;AACjB,QAAA,WAAW,EAAEA,KAAC,CAAC,MAAM,EAAE;AACvB,QAAA,eAAe,EAAE,UAAU,CAAC,QAAQ,EAAE;AACtC,QAAA,SAAS,EAAE,UAAU,CAAC,QAAQ,EAAE;AAChC,QAAA,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE;QACvB,GAAG,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAChC,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QACjC,OAAO,EAAEA,KAAC,CAAC,KAAK,CAAC,CAACA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;AACnE,QAAA,IAAI,EAAEA,KAAC,CAAC,KAAK,CAACA,KAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;AACpC,QAAA,YAAY,EAAEA,KAAC,CAAC,MAAM,CAAC;AACrB,YAAA,IAAI,EAAEA,KAAC,CAAC,MAAM,EAAE;AAChB,YAAA,GAAG,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACrB,YAAA,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE;SACxB,CAAC,CAAC,WAAW,EAAE;AAChB;;;AAGG;AACH,QAAA,kBAAkB,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AACzC;;AAEG;AACH,QAAA,UAAU,EAAEA,KAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;AAClC;;AAEG;QACH,iBAAiB,EAAEA,KAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;AAC9C;;;AAGG;QACH,kBAAkB,EAAEA,KAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,QAAQ,EAAE;AACtD,KAAA,CAAC;AACJ;AAEA;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtDC,oCAAsB,EACtBC,sCAAwB;AAI1B;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtDF,KAAC,CAAC,MAAM,EAAE,EACVG,mCAAqB;AAIvB;AACO,MAAM,0BAA0B,GAAG,aAAa,CACrDH,KAAC,CAAC,MAAM,EAAE,EACVI,kCAAoB;;;;;;;;"}

package/dist/block_meta/block_meta.js

@@ -7,7 +7,7 @@ const BlockPlatform = z.enum([
     'macosx-x64',
     'macosx-aarch64',
     'linux-x64',
-    'linux-aarch64'
+    'linux-aarch64',
 ]);
 function BlockPackMeta(longString, binary) {
     return z.object({
@@ -23,7 +23,7 @@ function BlockPackMeta(longString, binary) {
         organization: z.object({
             name: z.string(),
             url: z.string().url(),
-            logo: binary.optional()
+            logo: binary.optional(),
         }).passthrough(),
         /**
          * The order of blocks on the "marketplace" (higher values push block higher to the top of the list).
@@ -42,7 +42,7 @@ function BlockPackMeta(longString, binary) {
          * Supported operating systems.
          * If not provided, the block is supported on all operating systems.
          */
-        supportedPlatforms: z.array(BlockPlatform).optional()
+        supportedPlatforms: z.array(BlockPlatform).optional(),
     });
 }
 // prettier-ignore

package/dist/block_meta/block_meta.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_meta.js","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.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional()\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\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"names":[],"mappings":";;;AAQO,MAAM,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC;IAClC,aAAa;IACb,iBAAiB;IACjB,YAAY;IACZ,gBAAgB;IAChB,WAAW;IACX;AACD,CAAA;AAGK,SAAU,aAAa,CAG3B,UAA0B,EAAE,MAAkB,EAAA;IAC9C,OAAO,CAAC,CAAC,MAAM,CAAC;AACd,QAAA,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;AACjB,QAAA,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;AACvB,QAAA,eAAe,EAAE,UAAU,CAAC,QAAQ,EAAE;AACtC,QAAA,SAAS,EAAE,UAAU,CAAC,QAAQ,EAAE;AAChC,QAAA,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE;QACvB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAChC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QACjC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;AACnE,QAAA,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;AACpC,QAAA,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC;AACrB,YAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;AAChB,YAAA,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACrB,YAAA,IAAI,EAAE,MAAM,CAAC,QAAQ;SACtB,CAAC,CAAC,WAAW,EAAE;AAChB;;;AAGG;AACH,QAAA,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AACzC;;AAEG;AACH,QAAA,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;AAClC;;AAEG;QACH,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;AAC9C;;;AAGG;QACH,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,QAAQ;AACpD,KAAA,CAAC;AACJ;AAEA;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtD,sBAAsB,EACtB,wBAAwB;AAI1B;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtD,CAAC,CAAC,MAAM,EAAE,EACV,qBAAqB;AAIvB;AACO,MAAM,0BAA0B,GAAG,aAAa,CACrD,CAAC,CAAC,MAAM,EAAE,EACV,oBAAoB;;;;"}
+{"version":3,"file":"block_meta.js","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.object({\n      name: z.string(),\n      url: z.string().url(),\n      logo: binary.optional(),\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\n// prettier-ignore\nexport const BlockPackMetaDescriptionRaw = BlockPackMeta(\n  DescriptionContentText,\n  DescriptionContentBinary,\n);\nexport type BlockPackMetaDescriptionRaw = z.infer<typeof BlockPackMetaDescriptionRaw>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBase64 = BlockPackMeta(\n  z.string(),\n  ContentExplicitBase64,\n);\nexport type BlockPackMetaEmbeddedBase64 = z.infer<typeof BlockPackMetaEmbeddedBase64>;\n\n// prettier-ignore\nexport const BlockPackMetaEmbeddedBytes = BlockPackMeta(\n  z.string(),\n  ContentExplicitBytes,\n);\nexport type BlockPackMetaEmbeddedBytes = z.infer<typeof BlockPackMetaEmbeddedBytes>;\n"],"names":[],"mappings":";;;AAQO,MAAM,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC;IAClC,aAAa;IACb,iBAAiB;IACjB,YAAY;IACZ,gBAAgB;IAChB,WAAW;IACX,eAAe;AAChB,CAAA;AAGK,SAAU,aAAa,CAG3B,UAA0B,EAAE,MAAkB,EAAA;IAC9C,OAAO,CAAC,CAAC,MAAM,CAAC;AACd,QAAA,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;AACjB,QAAA,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;AACvB,QAAA,eAAe,EAAE,UAAU,CAAC,QAAQ,EAAE;AACtC,QAAA,SAAS,EAAE,UAAU,CAAC,QAAQ,EAAE;AAChC,QAAA,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE;QACvB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAChC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QACjC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;AACnE,QAAA,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;AACpC,QAAA,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC;AACrB,YAAA,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;AAChB,YAAA,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;AACrB,YAAA,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE;SACxB,CAAC,CAAC,WAAW,EAAE;AAChB;;;AAGG;AACH,QAAA,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;AACzC;;AAEG;AACH,QAAA,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;AAClC;;AAEG;QACH,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;AAC9C;;;AAGG;QACH,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,QAAQ,EAAE;AACtD,KAAA,CAAC;AACJ;AAEA;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtD,sBAAsB,EACtB,wBAAwB;AAI1B;AACO,MAAM,2BAA2B,GAAG,aAAa,CACtD,CAAC,CAAC,MAAM,EAAE,EACV,qBAAqB;AAIvB;AACO,MAAM,0BAA0B,GAAG,aAAa,CACrD,CAAC,CAAC,MAAM,EAAE,EACV,oBAAoB;;;;"}

package/dist/block_meta/content_conversion.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"content_conversion.cjs","sources":["../../src/block_meta/content_conversion.ts"],"sourcesContent":["import {\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 relaive path, slesh 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"],"names":[],"mappings":";;AAOM,SAAU,mBAAmB,CACjC,OAAe,EAAA;AAEf,IAAA,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,GAAG,CAAA,EAAG,OAAO,GAAG;IACrE,OAAO,CAA4B,KAAQ,KACzC,KAAK,CAAC,IAAI,KAAK;AACb,UAAE,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,aAAa,GAAG,KAAK,CAAC,IAAI;UACtD,KAAqC;AAC9C;AAEA;;;;;;AAMG;AACG,SAAU,mBAAmB,CACjC,MAAc,EAAA;AAEd,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,CAAA,EAAG,MAAM,GAAG;IACpE,OAAO,CAAsC,KAAQ,MAClD,KAAK,CAAC,IAAI,KAAK;AACd,UAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,IAAI;UACtD,KAAK,CAAM;AACnB;;;;;"}
+{"version":3,"file":"content_conversion.cjs","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 relaive path, slesh 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"],"names":[],"mappings":";;AAOM,SAAU,mBAAmB,CACjC,OAAe,EAAA;AAEf,IAAA,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,GAAG,CAAA,EAAG,OAAO,GAAG;IACrE,OAAO,CAA4B,KAAQ,KACzC,KAAK,CAAC,IAAI,KAAK;AACb,UAAE,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,aAAa,GAAG,KAAK,CAAC,IAAI;UACtD,KAAqC;AAC9C;AAEA;;;;;;AAMG;AACG,SAAU,mBAAmB,CACjC,MAAc,EAAA;AAEd,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,CAAA,EAAG,MAAM,GAAG;IACpE,OAAO,CAAsC,KAAQ,MAClD,KAAK,CAAC,IAAI,KAAK;AACd,UAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,IAAI;UACtD,KAAK,CAAM;AACnB;;;;;"}

package/dist/block_meta/content_conversion.d.ts

@@ -1,4 +1,4 @@
-import { ContentAbsoluteUrl, ContentAnyLocal, ContentExplicitOrRelative, ContentRelative } from './content_types';
+import type { ContentAbsoluteUrl, ContentAnyLocal, ContentExplicitOrRelative, ContentRelative } from './content_types';
 export declare function mapRemoteToAbsolute(rootUrl: string): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl;
 /**
  * Creates transformer of relative content paths, that adds a specific prefix to the relative path.

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

@@ -1 +1 @@
-{"version":3,"file":"content_conversion.d.ts","sourceRoot":"","sources":["../../src/block_meta/content_conversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,GACd,CAAC,CAAC,SAAS,eAAe,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,GAAG,kBAAkB,CAM3F;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GACb,CAAC,CAAC,SAAS,yBAAyB,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,CAMtD"}
+{"version":3,"file":"content_conversion.d.ts","sourceRoot":"","sources":["../../src/block_meta/content_conversion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EACf,yBAAyB,EACzB,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,GACd,CAAC,CAAC,SAAS,eAAe,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,GAAG,kBAAkB,CAM3F;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GACb,CAAC,CAAC,SAAS,yBAAyB,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,CAMtD"}

package/dist/block_meta/content_conversion.js.map

@@ -1 +1 @@
-{"version":3,"file":"content_conversion.js","sources":["../../src/block_meta/content_conversion.ts"],"sourcesContent":["import {\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 relaive path, slesh 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"],"names":[],"mappings":"AAOM,SAAU,mBAAmB,CACjC,OAAe,EAAA;AAEf,IAAA,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,GAAG,CAAA,EAAG,OAAO,GAAG;IACrE,OAAO,CAA4B,KAAQ,KACzC,KAAK,CAAC,IAAI,KAAK;AACb,UAAE,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,aAAa,GAAG,KAAK,CAAC,IAAI;UACtD,KAAqC;AAC9C;AAEA;;;;;;AAMG;AACG,SAAU,mBAAmB,CACjC,MAAc,EAAA;AAEd,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,CAAA,EAAG,MAAM,GAAG;IACpE,OAAO,CAAsC,KAAQ,MAClD,KAAK,CAAC,IAAI,KAAK;AACd,UAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,IAAI;UACtD,KAAK,CAAM;AACnB;;;;"}
+{"version":3,"file":"content_conversion.js","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 relaive path, slesh 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"],"names":[],"mappings":"AAOM,SAAU,mBAAmB,CACjC,OAAe,EAAA;AAEf,IAAA,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,GAAG,CAAA,EAAG,OAAO,GAAG;IACrE,OAAO,CAA4B,KAAQ,KACzC,KAAK,CAAC,IAAI,KAAK;AACb,UAAE,EAAE,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,aAAa,GAAG,KAAK,CAAC,IAAI;UACtD,KAAqC;AAC9C;AAEA;;;;;;AAMG;AACG,SAAU,mBAAmB,CACjC,MAAc,EAAA;AAEd,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,CAAA,EAAG,MAAM,GAAG;IACpE,OAAO,CAAsC,KAAQ,MAClD,KAAK,CAAC,IAAI,KAAK;AACd,UAAE,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,GAAG,KAAK,CAAC,IAAI;UACtD,KAAK,CAAM;AACnB;;;;"}

package/dist/block_meta/content_types.cjs

@@ -8,7 +8,7 @@ var zod = require('zod');
 const ContentExplicitString = zod.z
     .object({
     type: zod.z.literal('explicit-string'),
-    content: zod.z.string().describe('Actual string value')
+    content: zod.z.string().describe('Actual string value'),
 })
     .strict();
 const ContentExplicitBase64 = zod.z
@@ -18,7 +18,7 @@ const ContentExplicitBase64 = zod.z
         .string()
         .regex(/\w+\/[-+.\w]+/)
         .describe('MIME type to interpret content'),
-    content: zod.z.string().base64().describe('Base64 encoded binary value')
+    content: zod.z.string().base64().describe('Base64 encoded binary value'),
 })
     .strict();
 const ContentRelative = zod.z
@@ -26,7 +26,7 @@ const ContentRelative = zod.z
     type: zod.z.literal('relative'),
     path: zod.z
         .string()
-        .describe('Address of the file, in most cases relative to the file which this structure is a part of')
+        .describe('Address of the file, in most cases relative to the file which this structure is a part of'),
 })
     .strict();
 const absPathRegex = new RegExp(`^(/|[A-Z]:\\\\)`);
@@ -36,13 +36,13 @@ const ContentAbsoluteFile = zod.z
     file: zod.z
         .string()
         .regex(absPathRegex, 'path to file must be absolute')
-        .describe('Absolute address of the file in local file system')
+        .describe('Absolute address of the file in local file system'),
 })
     .strict();
 const ContentAbsoluteUrl = zod.z
     .object({
     type: zod.z.literal('absolute-url'),
-    url: zod.z.string().url().describe('Global URL to reach the requested file')
+    url: zod.z.string().url().describe('Global URL to reach the requested file'),
 })
     .strict();
 //
@@ -55,7 +55,7 @@ const ContentExplicitBytes = zod.z
         .string()
         .regex(/\w+\/[-+.\w]+/)
         .describe('MIME type to interpret content'),
-    content: zod.z.instanceof(Uint8Array).describe('Raw content')
+    content: zod.z.instanceof(Uint8Array).describe('Raw content'),
 })
     .strict();
 const ContentAbsoluteFolder = zod.z
@@ -64,7 +64,7 @@ const ContentAbsoluteFolder = zod.z
     folder: zod.z
         .string()
         .regex(absPathRegex, 'path to folder must be absolute')
-        .describe('Absolute address of the folder in local file system')
+        .describe('Absolute address of the folder in local file system'),
 })
     .strict();
 //
@@ -75,24 +75,24 @@ const ContentAny = zod.z.discriminatedUnion('type', [
     ContentExplicitBase64,
     ContentRelative,
     ContentAbsoluteFile,
-    ContentAbsoluteUrl
+    ContentAbsoluteUrl,
 ]);
 const ContentExplicitOrRelative = zod.z.discriminatedUnion('type', [
     ContentExplicitString,
     ContentExplicitBase64,
-    ContentRelative
+    ContentRelative,
 ]);
 const ContentAnyLocal = zod.z.discriminatedUnion('type', [
     ContentExplicitString,
     ContentExplicitBase64,
     ContentRelative,
-    ContentAbsoluteFile
+    ContentAbsoluteFile,
 ]);
 const ContentAnyRemote = zod.z.discriminatedUnion('type', [
     ContentExplicitString,
     ContentExplicitBase64,
     ContentRelative,
-    ContentAbsoluteUrl
+    ContentAbsoluteUrl,
 ]);
 //
 // Narrow types with relative option
@@ -106,7 +106,7 @@ const ContentAnyRemote = zod.z.discriminatedUnion('type', [
 const ContentAnyBinaryLocal = zod.z.discriminatedUnion('type', [
     ContentExplicitBase64,
     ContentRelative,
-    ContentAbsoluteFile
+    ContentAbsoluteFile,
 ]);
 // export const ContentAnyTextRemote = z.discriminatedUnion('type', [
 //   ContentExplicitString,
@@ -117,37 +117,37 @@ const ContentAnyBinaryLocal = zod.z.discriminatedUnion('type', [
 const ContentAnyTextLocal = zod.z.discriminatedUnion('type', [
     ContentExplicitString,
     ContentRelative,
-    ContentAbsoluteFile
+    ContentAbsoluteFile,
 ]);
 //
 // Narrow absolute types
 //
 const ContentAbsoluteBinaryRemote = zod.z.discriminatedUnion('type', [
     ContentExplicitBase64,
-    ContentAbsoluteUrl
+    ContentAbsoluteUrl,
 ]);
 const ContentAbsoluteBinaryLocal = zod.z.discriminatedUnion('type', [
     ContentExplicitBase64,
-    ContentAbsoluteFile
+    ContentAbsoluteFile,
 ]);
 const ContentAbsoluteTextRemote = zod.z.discriminatedUnion('type', [
     ContentExplicitString,
-    ContentAbsoluteUrl
+    ContentAbsoluteUrl,
 ]);
 const ContentAbsoluteTextLocal = zod.z.discriminatedUnion('type', [
     ContentExplicitString,
-    ContentAbsoluteFile
+    ContentAbsoluteFile,
 ]);
 //
 // Narrow relative types
 //
 const ContentRelativeBinary = zod.z.discriminatedUnion('type', [
     ContentExplicitBase64,
-    ContentRelative
+    ContentRelative,
 ]);
 const ContentRelativeText = zod.z.discriminatedUnion('type', [
     ContentExplicitString,
-    ContentRelative
+    ContentRelative,
 ]);
 // export function ConstructContent(
 //   contentType: 'text',
@@ -186,17 +186,17 @@ const DescriptionContentBinary = zod.z.union([
     zod.z
         .string()
         .startsWith('file:')
-        .transform((value, ctx) => ({ type: 'relative', path: value.slice(5) })),
-    ContentAnyBinaryLocal
+        .transform((value) => ({ type: 'relative', path: value.slice(5) })),
+    ContentAnyBinaryLocal,
 ]);
 const DescriptionContentText = zod.z.union([
-    zod.z.string().transform((value, ctx) => {
+    zod.z.string().transform((value) => {
         if (value.startsWith('file:'))
             return { type: 'relative', path: value.slice(5) };
         else
             return { type: 'explicit-string', content: value };
     }),
-    ContentAnyTextLocal
+    ContentAnyTextLocal,
 ]);
 
 exports.ContentAbsoluteBinaryLocal = ContentAbsoluteBinaryLocal;

package/dist/block_meta/content_types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"content_types.cjs","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, ctx) => ({ 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, ctx) => {\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"],"names":["z"],"mappings":"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"}
+{"version":3,"file":"content_types.cjs","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"],"names":["z"],"mappings":"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"}