@effect-vfs/core 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -6,7 +6,7 @@
 /**
  * Virtual filesystem contracts, schemas, errors, and constructors.
  *
- * @category exports
+ * @category re-exports
  * @since 0.1.0
  */
 export * as VirtualFileSystem from "./VirtualFileSystem.js";

package/dist/index.js

@@ -6,7 +6,7 @@
 /**
  * Virtual filesystem contracts, schemas, errors, and constructors.
  *
- * @category exports
+ * @category re-exports
  * @since 0.1.0
  */
 export * as VirtualFileSystem from "./VirtualFileSystem.js";

package/dist/internal/bytePath.d.ts

@@ -0,0 +1,10 @@
+import type { BytePath } from "../BytePath.js";
+/** @internal */
+export declare const BytePathId: "@effect-vfs/core/BytePath";
+/** @internal */
+export declare const isBytePath: (value: unknown) => value is BytePath;
+/** @internal */
+export declare const make: (bytes: Uint8Array) => BytePath;
+/** @internal */
+export declare const getBytes: (path: BytePath) => Uint8Array | undefined;
+//# sourceMappingURL=bytePath.d.ts.map

package/dist/internal/bytePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytePath.d.ts","sourceRoot":"","sources":["../../src/internal/bytePath.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAG9C,gBAAgB;AAChB,eAAO,MAAM,UAAU,EAAG,2BAAoC,CAAA;AA6B9D,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAA6D,CAAA;AAElH,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,UAAU,KAAG,QAMxC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,QAAQ,SAAU,QAAQ,KAAG,UAAU,GAAG,SAAgC,CAAA"}

package/dist/internal/bytePath.js

@@ -0,0 +1,41 @@
+// Opaque byte path representation and value protocols.
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import { pipeArguments } from "effect/Pipeable";
+import * as Predicate from "effect/Predicate";
+import { sameBytes } from "./bytes.js";
+/** @internal */
+export const BytePathId = "@effect-vfs/core/BytePath";
+const bytePaths = new WeakMap();
+const hashBytes = (bytes) => {
+    let hash = Hash.string("@effect-vfs/core/BytePath");
+    for (const byte of bytes) {
+        hash = Hash.combine(Hash.number(byte))(hash);
+    }
+    return Hash.combine(Hash.number(bytes.length))(hash);
+};
+const BytePathProto = {
+    [BytePathId]: BytePathId,
+    [Equal.symbol](that) {
+        if (!isBytePath(that))
+            return false;
+        return sameBytes(bytePaths.get(this), bytePaths.get(that));
+    },
+    [Hash.symbol]() {
+        return hashBytes(bytePaths.get(this));
+    },
+    pipe() {
+        return pipeArguments(this, arguments);
+    }
+};
+/** @internal */
+export const isBytePath = (value) => Predicate.isObject(value) && bytePaths.has(value);
+/** @internal */
+export const make = (bytes) => {
+    // SAFETY: BytePathProto implements every member of the opaque BytePath contract.
+    const path = Object.create(BytePathProto);
+    bytePaths.set(path, bytes);
+    return Object.freeze(path);
+};
+/** @internal */
+export const getBytes = (path) => bytePaths.get(path);

package/dist/internal/bytes.d.ts

@@ -0,0 +1,6 @@
+import * as Order from "effect/Order";
+/** @internal */
+export declare const bytesOrder: Order.Order<Uint8Array>;
+/** @internal */
+export declare const sameBytes: (left: Uint8Array | undefined, right: Uint8Array | undefined) => boolean;
+//# sourceMappingURL=bytes.d.ts.map

package/dist/internal/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/internal/bytes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAerC,gBAAgB;AAChB,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAA4B,CAAA;AAG3E,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,UAAU,GAAG,SAAS,SAAS,UAAU,GAAG,SAAS,KAAG,OACU,CAAA"}

package/dist/internal/bytes.js

@@ -0,0 +1,17 @@
+// Byte-array comparison shared by the overlay diff, the snapshot delta, and BytePath equality.
+import * as Order from "effect/Order";
+const compareBytes = (left, right) => {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        const l = left[index];
+        const r = right[index];
+        if (l !== r)
+            return l < r ? -1 : 1;
+    }
+    return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
+};
+/** @internal */
+export const bytesOrder = Order.make(compareBytes);
+// A plain loop: Equal.equals would hash both arrays and memoise the pair in a WeakMap first.
+/** @internal */
+export const sameBytes = (left, right) => left === right || (left !== undefined && right !== undefined && compareBytes(left, right) === 0);

package/dist/internal/canonicalBase64.d.ts

@@ -1,7 +1,15 @@
-/** Strict padded base64 check, including canonical unused pad bits and no ignored whitespace. */
-export declare const isCanonical: (value: string) => boolean;
-/** Decoded length for an already canonical base64 string, without allocating its payload. */
-export declare const decodedLength: (value: string) => number;
-/** Decodes base64 previously accepted by `isCanonical`. */
-export declare const decodeTrusted: (value: string) => Uint8Array;
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare const Encoded: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+type Encoded = typeof Encoded.Type;
+/** @internal */
+export declare const CanonicalBase64: {
+    Encoded: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    Bytes: Schema.decodeTo<Schema.Uint8Array, Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">, never, never>;
+    decode: (input: Encoded) => Effect.Effect<Uint8Array<ArrayBufferLike>, never, never>;
+    encode: (input: Uint8Array) => Encoded;
+    decodedLength: (value: Encoded) => number;
+    is: (value: string) => value is Encoded;
+};
+export {};
 //# sourceMappingURL=canonicalBase64.d.ts.map

package/dist/internal/canonicalBase64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonicalBase64.d.ts","sourceRoot":"","sources":["../../src/internal/canonicalBase64.ts"],"names":[],"mappings":"AAKA,iGAAiG;AACjG,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,OAGP,CAAA;AAErC,6FAA6F;AAC7F,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,MACmC,CAAA;AAEjF,2DAA2D;AAC3D,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,UAC4D,CAAA"}
+{"version":3,"file":"canonicalBase64.d.ts","sourceRoot":"","sources":["../../src/internal/canonicalBase64.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AA0BvC,QAAA,MAAM,OAAO,uEAGZ,CAAA;AASD,KAAK,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAElC,gBAAgB;AAChB,eAAO,MAAM,eAAe;;;oBAGV,OAAO;oBACP,UAAU,KAAG,OAAO;2BACb,OAAO,KAAG,MAAM;gBAC3B,MAAM,KAAG,KAAK,IAAI,OAAO;CACtC,CAAA"}

package/dist/internal/canonicalBase64.js

@@ -1,11 +1,33 @@
+import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
-import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
 const canonicalTail = /^(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?(?![\s\S])/;
-/** Strict padded base64 check, including canonical unused pad bits and no ignored whitespace. */
-export const isCanonical = (value) => value.length % 4 === 0 &&
+const isCanonical = (value) => value.length % 4 === 0 &&
     !/[^A-Za-z0-9+/]/.test(value.slice(0, -4)) &&
     canonicalTail.test(value.slice(-4));
-/** Decoded length for an already canonical base64 string, without allocating its payload. */
-export const decodedLength = (value) => value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
-/** Decodes base64 previously accepted by `isCanonical`. */
-export const decodeTrusted = (value) => Result.getOrThrowWith(Encoding.decodeBase64(value), () => new Error("Invalid trusted canonical base64"));
+const decodedLength = (value) => value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
+const encode = (input) => {
+    // Join bounded chunks to avoid the encoder's intermediate string chains. Three-byte
+    // boundaries keep padding in the final chunk, preserving the canonical representation.
+    const chunkBytes = 12_288;
+    const chunks = [];
+    for (let offset = 0; offset < input.length; offset += chunkBytes) {
+        chunks.push(Encoding.encodeBase64(input.subarray(offset, offset + chunkBytes)));
+    }
+    return Encoded.make(chunks.join(""));
+};
+const Encoded = Schema.String.pipe(Schema.refine((value) => isCanonical(value), { expected: "canonical padded base64" }), Schema.brand("CanonicalBase64"));
+const Bytes = Encoded.pipe(Schema.decodeTo(Schema.Uint8Array, {
+    decode: SchemaGetter.decodeBase64(),
+    encode: SchemaGetter.transform((input) => encode(input))
+}));
+/** @internal */
+export const CanonicalBase64 = {
+    Encoded,
+    Bytes,
+    decode: (input) => Schema.decodeEffect(Bytes)(input).pipe(Effect.orDie),
+    encode: (input) => encode(input),
+    decodedLength: (value) => decodedLength(value),
+    is: (value) => isCanonical(value)
+};

package/dist/internal/image.d.ts

@@ -1,128 +1,109 @@
-/**
- * Snapshot validation and serialization used by `VirtualFileSystem`.
- *
- * @internal
- */
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { ImageError, type Snapshot } from "../Snapshot.js";
-import * as CanonicalBase64 from "./canonicalBase64.js";
+import { StoredMetadata } from "./metadata.js";
 /** @internal */
-export declare const StoredMetadata: Schema.Struct<{
-    readonly uid: Schema.Finite;
-    readonly gid: Schema.Finite;
-    readonly mode: Schema.Finite;
-    readonly atimeNs: Schema.String;
-    readonly mtimeNs: Schema.String;
-    readonly ctimeNs: Schema.String;
-    readonly birthtimeNs: Schema.String;
-}>;
-/** @internal */
-export type StoredMetadata = typeof StoredMetadata.Type;
-/** @internal */
-export declare const Record: Schema.Union<readonly [Schema.Struct<{
-    readonly id: Schema.String;
-    readonly kind: Schema.Literal<"directory">;
-    readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Finite;
-        readonly gid: Schema.Finite;
-        readonly mode: Schema.Finite;
-        readonly atimeNs: Schema.String;
-        readonly mtimeNs: Schema.String;
-        readonly ctimeNs: Schema.String;
-        readonly birthtimeNs: Schema.String;
-    }>;
-    readonly entries: Schema.$Array<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly target: Schema.String;
-    }>>;
-}>, Schema.Struct<{
-    readonly id: Schema.String;
-    readonly kind: Schema.Literal<"file">;
-    readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Finite;
-        readonly gid: Schema.Finite;
-        readonly mode: Schema.Finite;
-        readonly atimeNs: Schema.String;
-        readonly mtimeNs: Schema.String;
-        readonly ctimeNs: Schema.String;
-        readonly birthtimeNs: Schema.String;
-    }>;
-    readonly data: Schema.String;
-}>, Schema.Struct<{
-    readonly id: Schema.String;
-    readonly kind: Schema.Literal<"symlink">;
-    readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Finite;
-        readonly gid: Schema.Finite;
-        readonly mode: Schema.Finite;
-        readonly atimeNs: Schema.String;
-        readonly mtimeNs: Schema.String;
-        readonly ctimeNs: Schema.String;
-        readonly birthtimeNs: Schema.String;
-    }>;
-    readonly target: Schema.String;
-}>]>;
+export { StoredMetadata };
 /** @internal */
-export type Record = typeof Record.Type;
-/** @internal */
-export declare const Document: Schema.Struct<{
-    readonly format: Schema.Literal<"effect-vfs">;
-    readonly version: Schema.Literal<1>;
-    readonly root: Schema.String;
-    readonly records: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+export declare const Record: Schema.TaggedUnion<{
+    readonly directory: Schema.TaggedStruct<"directory", {
         readonly id: Schema.String;
-        readonly kind: Schema.Literal<"directory">;
         readonly metadata: Schema.Struct<{
-            readonly uid: Schema.Finite;
-            readonly gid: Schema.Finite;
-            readonly mode: Schema.Finite;
-            readonly atimeNs: Schema.String;
-            readonly mtimeNs: Schema.String;
-            readonly ctimeNs: Schema.String;
-            readonly birthtimeNs: Schema.String;
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
         }>;
         readonly entries: Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
+            readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
             readonly target: Schema.String;
         }>>;
-    }>, Schema.Struct<{
+    }>;
+    readonly file: Schema.TaggedStruct<"file", {
         readonly id: Schema.String;
-        readonly kind: Schema.Literal<"file">;
         readonly metadata: Schema.Struct<{
-            readonly uid: Schema.Finite;
-            readonly gid: Schema.Finite;
-            readonly mode: Schema.Finite;
-            readonly atimeNs: Schema.String;
-            readonly mtimeNs: Schema.String;
-            readonly ctimeNs: Schema.String;
-            readonly birthtimeNs: Schema.String;
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
         }>;
-        readonly data: Schema.String;
-    }>, Schema.Struct<{
+        readonly data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    }>;
+    readonly symlink: Schema.TaggedStruct<"symlink", {
         readonly id: Schema.String;
-        readonly kind: Schema.Literal<"symlink">;
         readonly metadata: Schema.Struct<{
-            readonly uid: Schema.Finite;
-            readonly gid: Schema.Finite;
-            readonly mode: Schema.Finite;
-            readonly atimeNs: Schema.String;
-            readonly mtimeNs: Schema.String;
-            readonly ctimeNs: Schema.String;
-            readonly birthtimeNs: Schema.String;
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
+            readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
         }>;
-        readonly target: Schema.String;
-    }>]>>;
+        readonly target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+    }>;
 }>;
 /** @internal */
-export type Document = typeof Document.Type;
-/** @internal */
-export declare const decodedLength: typeof CanonicalBase64.decodedLength;
+export type Record = typeof Record.Type;
 /** @internal */
-export declare const base64: (input: Uint8Array) => string;
+export declare const Document: Schema.Struct<{
+    readonly format: Schema.Literal<"effect-vfs">;
+    readonly version: Schema.Literal<1>;
+    readonly root: Schema.String;
+    readonly records: Schema.$Array<Schema.TaggedUnion<{
+        readonly directory: Schema.TaggedStruct<"directory", {
+            readonly id: Schema.String;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+                readonly target: Schema.String;
+            }>>;
+        }>;
+        readonly file: Schema.TaggedStruct<"file", {
+            readonly id: Schema.String;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly data: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+        }>;
+        readonly symlink: Schema.TaggedStruct<"symlink", {
+            readonly id: Schema.String;
+            readonly metadata: Schema.Struct<{
+                readonly uid: Schema.Natural;
+                readonly gid: Schema.Natural;
+                readonly mode: Schema.Natural;
+                readonly atimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly mtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly ctimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+                readonly birthtimeNs: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
+            }>;
+            readonly target: Schema.brand<Schema.refine<string, Schema.String>, "CanonicalBase64">;
+        }>;
+    }>>;
+}>;
 /** @internal */
-export declare const bytes: (value: string) => Uint8Array;
+export type Document = typeof Document.Type;
 /** @internal */
 export declare const inspect: (snapshot: Snapshot) => Effect.Effect<Document, ImageError>;
 /** @internal */
@@ -131,7 +112,7 @@ export declare const capture: (input: unknown, limits?: {
     readonly maxRecords: number;
     readonly maxEntries: number;
     readonly maxDecodedBytes: ByteSize.ByteSize;
-} | undefined) => Effect.Effect<Snapshot, ImageError, never>;
+} | undefined, trusted?: any) => Effect.Effect<Snapshot, ImageError, never>;
 /** @internal */
 export declare const encodeSnapshot: (snapshot: Snapshot) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageError, never>;
 /** @internal */

package/dist/internal/image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AACxF,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAavD,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAA;AACF,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASjB,CAAA;AACF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AACvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAA;AACF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,gBAAgB;AAChB,eAAO,MAAM,aAAa,sCAAgC,CAAA;AAC1D,gBAAgB;AAChB,eAAO,MAAM,MAAM,UAAW,UAAU,KAAG,MAU1C,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,KAAK,UAAW,MAAM,KAAG,UAErC,CAAA;AACD,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAI3E,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;;;4DAwElB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,mFAKzB,CAAA;AACF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;gDAqB1B,CAAA"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AAExF,OAAO,EAAE,cAAc,EAAsB,MAAM,eAAe,CAAA;AAMlE,gBAAgB;AAChB,OAAO,EAAE,cAAc,EAAE,CAAA;AAIzB,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAA;AAwBF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAO3E,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;;;2EAiJlB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,mFAMzB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;gDA+B1B,CAAA"}