@weavecode/weave 0.0.0-stage → 0.1.1

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/bytes/buffer-source.js

@@ -0,0 +1,101 @@
+const ARRAY_BUFFER_TAG = "[object ArrayBuffer]";
+const SHARED_ARRAY_BUFFER_TAG = "[object SharedArrayBuffer]";
+function tagOf(value) {
+    return Object.prototype.toString.call(value);
+}
+function isDataViewConstructor(type) {
+    return type === DataView || type.prototype instanceof DataView;
+}
+function bytesPerElement(type) {
+    if (isDataViewConstructor(type)) {
+        return 1;
+    }
+    const value = type.BYTES_PER_ELEMENT;
+    return value ?? 1;
+}
+function isArrayBufferViewLike(value) {
+    if (ArrayBuffer.isView(value)) {
+        return true;
+    }
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const view = value;
+    return typeof view.byteOffset === "number"
+        && typeof view.byteLength === "number"
+        && isArrayBufferLike(view.buffer);
+}
+function copyBytes(data) {
+    const view = toUint8Array(data);
+    const copy = new Uint8Array(view.byteLength);
+    copy.set(view);
+    return copy;
+}
+export function isArrayBuffer(value) {
+    return tagOf(value) === ARRAY_BUFFER_TAG;
+}
+export function isSharedArrayBuffer(value) {
+    return typeof SharedArrayBuffer !== "undefined" && tagOf(value) === SHARED_ARRAY_BUFFER_TAG;
+}
+export function isArrayBufferLike(value) {
+    return isArrayBuffer(value) || isSharedArrayBuffer(value);
+}
+export function isArrayBufferView(value) {
+    return isArrayBufferViewLike(value);
+}
+export function isBufferSource(value) {
+    return isArrayBufferLike(value) || isArrayBufferView(value);
+}
+export function assertBufferSource(value) {
+    if (!isBufferSource(value)) {
+        throw new TypeError("Expected ArrayBuffer, SharedArrayBuffer, or ArrayBufferView");
+    }
+}
+export function toUint8Array(data) {
+    assertBufferSource(data);
+    if (isArrayBufferLike(data)) {
+        return new Uint8Array(data);
+    }
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+export function toUint8ArrayCopy(data) {
+    return copyBytes(data);
+}
+export function toArrayBuffer(data) {
+    assertBufferSource(data);
+    if (isArrayBuffer(data)) {
+        return data;
+    }
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(toUint8Array(data));
+    return buffer;
+}
+export function toArrayBufferLike(data) {
+    assertBufferSource(data);
+    if (isArrayBufferLike(data)) {
+        return data;
+    }
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+    }
+    return copyBytes(data).buffer;
+}
+export function toView(data, type) {
+    assertBufferSource(data);
+    if (ArrayBuffer.isView(data) && data.constructor === type) {
+        return data;
+    }
+    const view = toUint8Array(data);
+    const elementSize = bytesPerElement(type);
+    if (view.byteOffset % elementSize !== 0 || view.byteLength % elementSize !== 0) {
+        throw new RangeError(`Cannot create ${type.name} over unaligned byte range`);
+    }
+    if (isDataViewConstructor(type)) {
+        return new type(view.buffer, view.byteOffset, view.byteLength);
+    }
+    return new type(view.buffer, view.byteOffset, view.byteLength / elementSize);
+}
+export function toViewCopy(data, type) {
+    const copy = toUint8ArrayCopy(data);
+    return toView(copy, type);
+}

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/bytes/concat.js

@@ -0,0 +1,37 @@
+import { isBufferSource, toUint8Array, toView } from "./buffer-source.js";
+export function concatToUint8Array(buffers) {
+    const views = [];
+    let length = 0;
+    for (const buffer of buffers) {
+        const view = toUint8Array(buffer);
+        views.push(view);
+        length += view.byteLength;
+    }
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const view of views) {
+        result.set(view, offset);
+        offset += view.byteLength;
+    }
+    return result;
+}
+export function concat(first, second, ...rest) {
+    let buffers;
+    let type;
+    if (typeof second === "function") {
+        buffers = Array.from(first);
+        type = second;
+    }
+    else if (isBufferSource(first)) {
+        buffers = [first, second, ...rest].filter(isBufferSource);
+    }
+    else {
+        buffers = Array.from(first);
+        if (second) {
+            buffers.push(second);
+        }
+        buffers.push(...rest);
+    }
+    const bytes = concatToUint8Array(buffers);
+    return type ? toView(bytes, type) : bytes.buffer;
+}

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/bytes/equal.js

@@ -0,0 +1,14 @@
+import { toUint8Array } from "./buffer-source.js";
+export function equal(a, b, options = {}) {
+    const left = toUint8Array(a);
+    const right = toUint8Array(b);
+    if (!options.constantTime && left.byteLength !== right.byteLength) {
+        return false;
+    }
+    const length = Math.max(left.byteLength, right.byteLength);
+    let diff = left.byteLength ^ right.byteLength;
+    for (let i = 0; i < length; i++) {
+        diff |= (left[i] ?? 0) ^ (right[i] ?? 0);
+    }
+    return diff === 0;
+}

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/bytes/index.js

@@ -0,0 +1,4 @@
+export { assertBufferSource, isArrayBuffer, isArrayBufferLike, isArrayBufferView, isBufferSource, isSharedArrayBuffer, toArrayBuffer, toArrayBufferLike, toUint8Array, toUint8ArrayCopy, toView, toViewCopy, } from "./buffer-source.js";
+export { concat, concatToUint8Array } from "./concat.js";
+export { equal } from "./equal.js";
+export { compare, copy, endsWith, includes, indexOf, lastIndexOf, slice, startsWith, tail, } from "./sequence.js";

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/bytes/sequence.js

@@ -0,0 +1,150 @@
+import { toUint8Array, toUint8ArrayCopy } from "./buffer-source.js";
+function clampIndex(value, fallback, length) {
+    const normalized = Number.isFinite(value) ? Math.trunc(value) : fallback;
+    if (normalized <= 0) {
+        return 0;
+    }
+    if (normalized >= length) {
+        return length;
+    }
+    return normalized;
+}
+function normalizeForwardRange(length, options) {
+    const start = clampIndex(options?.start, 0, length);
+    const end = clampIndex(options?.end, length, length);
+    return end >= start ? [start, end] : [start, start];
+}
+function normalizeReverseRange(length, options) {
+    const start = clampIndex(options?.start, length, length);
+    const end = clampIndex(options?.end, 0, length);
+    return start >= end ? [end, start] : [start, start];
+}
+function normalizeSliceIndex(value, fallback, length) {
+    const normalized = Number.isFinite(value) ? Math.trunc(value) : fallback;
+    if (normalized < 0) {
+        return Math.max(length + normalized, 0);
+    }
+    if (normalized > length) {
+        return length;
+    }
+    return normalized;
+}
+function encodeAscii(text) {
+    const bytes = new Uint8Array(text.length);
+    for (let i = 0; i < text.length; i++) {
+        bytes[i] = text.charCodeAt(i) & 0xff;
+    }
+    return bytes;
+}
+function encodeUtf8(text) {
+    return new TextEncoder().encode(text);
+}
+function toPatternBytes(pattern, options) {
+    if (typeof pattern === "string") {
+        return options?.encoding === "utf8" ? encodeUtf8(pattern) : encodeAscii(pattern);
+    }
+    return toUint8Array(pattern);
+}
+function bytesEqualAt(data, pattern, offset) {
+    for (let index = 0; index < pattern.byteLength; index++) {
+        if (data[offset + index] !== pattern[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function indexOf(data, pattern, options) {
+    const bytes = toUint8Array(data);
+    const needle = toPatternBytes(pattern, options);
+    const [start, end] = normalizeForwardRange(bytes.byteLength, options);
+    if (needle.byteLength === 0) {
+        return start;
+    }
+    const lastOffset = end - needle.byteLength;
+    if (lastOffset < start) {
+        return -1;
+    }
+    for (let offset = start; offset <= lastOffset; offset++) {
+        if (bytesEqualAt(bytes, needle, offset)) {
+            return offset;
+        }
+    }
+    return -1;
+}
+export function lastIndexOf(data, pattern, options) {
+    const bytes = toUint8Array(data);
+    const needle = toPatternBytes(pattern, options);
+    const [end, start] = normalizeReverseRange(bytes.byteLength, options);
+    if (needle.byteLength === 0) {
+        return start;
+    }
+    const firstOffset = start - needle.byteLength;
+    if (firstOffset < end) {
+        return -1;
+    }
+    for (let offset = firstOffset; offset >= end; offset--) {
+        if (bytesEqualAt(bytes, needle, offset)) {
+            return offset;
+        }
+    }
+    return -1;
+}
+export function includes(data, pattern, options) {
+    return indexOf(data, pattern, options) !== -1;
+}
+export function startsWith(data, pattern, options) {
+    const bytes = toUint8Array(data);
+    const needle = toPatternBytes(pattern, options);
+    if (needle.byteLength > bytes.byteLength) {
+        return false;
+    }
+    return bytesEqualAt(bytes, needle, 0);
+}
+export function endsWith(data, pattern, options) {
+    const bytes = toUint8Array(data);
+    const needle = toPatternBytes(pattern, options);
+    if (needle.byteLength > bytes.byteLength) {
+        return false;
+    }
+    return bytesEqualAt(bytes, needle, bytes.byteLength - needle.byteLength);
+}
+export function slice(data, start, end) {
+    const bytes = toUint8Array(data);
+    const normalizedStart = normalizeSliceIndex(start, 0, bytes.byteLength);
+    const normalizedEnd = normalizeSliceIndex(end, bytes.byteLength, bytes.byteLength);
+    if (normalizedEnd <= normalizedStart) {
+        return bytes.subarray(normalizedStart, normalizedStart);
+    }
+    return bytes.subarray(normalizedStart, normalizedEnd);
+}
+export function tail(data, length) {
+    const bytes = toUint8Array(data);
+    const normalizedLength = Number.isFinite(length) ? Math.max(0, Math.trunc(length)) : 0;
+    if (normalizedLength >= bytes.byteLength) {
+        return bytes;
+    }
+    return bytes.subarray(bytes.byteLength - normalizedLength);
+}
+export function copy(data) {
+    return toUint8ArrayCopy(data);
+}
+export function compare(a, b) {
+    const left = toUint8Array(a);
+    const right = toUint8Array(b);
+    const limit = Math.min(left.byteLength, right.byteLength);
+    for (let index = 0; index < limit; index++) {
+        if (left[index] < right[index]) {
+            return -1;
+        }
+        if (left[index] > right[index]) {
+            return 1;
+        }
+    }
+    if (left.byteLength < right.byteLength) {
+        return -1;
+    }
+    if (left.byteLength > right.byteLength) {
+        return 1;
+    }
+    return 0;
+}

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/bytes/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/converters/convert.js

@@ -0,0 +1,71 @@
+import { toArrayBuffer } from "../bytes/index.js";
+import { base64, base64url, binary, hex, utf8, utf16 } from "../encoding/index.js";
+import { defaultConverterRegistry } from "./defaults.js";
+function encode(name, data, ...args) {
+    return defaultConverterRegistry.encode(name, data, ...args);
+}
+function decode(name, text, ...args) {
+    return defaultConverterRegistry.decode(name, text, ...args);
+}
+function tryDecode(name, text, ...args) {
+    return defaultConverterRegistry.tryDecode(name, text, ...args);
+}
+function normalize(name, text, ...args) {
+    return defaultConverterRegistry.normalize(name, text, ...args);
+}
+function parse(name, text, ...args) {
+    return defaultConverterRegistry.parse(name, text, ...args);
+}
+function format(name, data, value) {
+    return defaultConverterRegistry.format(name, data, value);
+}
+function transcode(text, options) {
+    return defaultConverterRegistry.transcode(text, options);
+}
+function detect(text, options) {
+    return defaultConverterRegistry.detect(text, options);
+}
+function normalizeEncodingName(encoding) {
+    return encoding.toLowerCase();
+}
+export const convert = {
+    encode,
+    decode,
+    tryDecode,
+    normalize,
+    parse,
+    format,
+    transcode,
+    detect,
+    to(format, data, ...args) {
+        return encode(format, data, ...args);
+    },
+    from(format, text, ...args) {
+        return decode(format, text, ...args);
+    },
+    toString(data, encoding = "utf8") {
+        return encode(encoding, data);
+    },
+    fromString(text, encoding = "utf8") {
+        if (normalizeEncodingName(encoding) === "hex") {
+            return toArrayBuffer(hex.decode(text, { allowOddLength: true }));
+        }
+        return toArrayBuffer(decode(encoding, text));
+    },
+    toBase64: base64.encode,
+    fromBase64: (text) => toArrayBuffer(base64.decode(text)),
+    toBase64Url: base64url.encode,
+    fromBase64Url: (text) => toArrayBuffer(base64url.decode(text)),
+    toHex: hex.encode,
+    fromHex: (text) => toArrayBuffer(hex.decode(text, { allowOddLength: true })),
+    toBinary: binary.encode,
+    fromBinary: (text) => toArrayBuffer(binary.decode(text)),
+    toUtf8String: utf8.decode,
+    fromUtf8String: (text) => toArrayBuffer(utf8.encode(text)),
+    toUtf16String: (data, littleEndian = false) => utf16.decode(data, { littleEndian }),
+    fromUtf16String: (text, littleEndian = false) => toArrayBuffer(utf16.encode(text, { littleEndian })),
+    isHex: hex.is,
+    isBase64: base64.is,
+    isBase64Url: base64url.is,
+    formatString: base64.normalize,
+};

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/converters/defaults.js

@@ -0,0 +1,68 @@
+import { base64, base64url, binary, hex, utf8, utf16 } from "../encoding/index.js";
+import { pemConverter } from "../pem/index.js";
+export { pemConverter } from "../pem/index.js";
+import { createConverterRegistry } from "./registry.js";
+export const binaryConverter = {
+    name: "binary",
+    aliases: ["latin1"],
+    encode: binary.encode,
+    decode: binary.decode,
+    is: binary.is,
+};
+export const hexConverter = {
+    name: "hex",
+    encode: hex.encode,
+    decode: hex.decode,
+    format: hex.format,
+    is: hex.is,
+    normalize: hex.normalize,
+    parse: hex.parse,
+};
+export const base64Converter = {
+    name: "base64",
+    aliases: ["b64"],
+    encode: base64.encode,
+    decode: base64.decode,
+    is: base64.is,
+    normalize: base64.normalize,
+};
+export const base64urlConverter = {
+    name: "base64url",
+    aliases: ["base64-url", "b64url"],
+    encode: base64url.encode,
+    decode: base64url.decode,
+    is: base64url.is,
+    normalize: base64url.normalize,
+};
+export const utf8Converter = {
+    name: "utf8",
+    aliases: ["utf-8"],
+    encode: (data) => utf8.decode(data),
+    decode: (text) => utf8.encode(text),
+    is: (text) => typeof text === "string",
+};
+export const utf16beConverter = {
+    name: "utf16be",
+    aliases: ["utf16", "utf-16", "utf-16be"],
+    encode: (data) => utf16.decode(data),
+    decode: (text) => utf16.encode(text),
+    is: (text) => typeof text === "string",
+};
+export const utf16leConverter = {
+    name: "utf16le",
+    aliases: ["utf-16le", "ucs2", "usc2"],
+    encode: (data) => utf16.decode(data, { littleEndian: true }),
+    decode: (text) => utf16.encode(text, { littleEndian: true }),
+    is: (text) => typeof text === "string",
+};
+export const defaultConverters = [
+    binaryConverter,
+    hexConverter,
+    base64Converter,
+    base64urlConverter,
+    utf8Converter,
+    utf16beConverter,
+    utf16leConverter,
+    pemConverter,
+];
+export const defaultConverterRegistry = createConverterRegistry(defaultConverters);

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/converters/index.js

@@ -0,0 +1,3 @@
+export { createConverterRegistry } from "./registry.js";
+export { base64Converter, base64urlConverter, binaryConverter, defaultConverterRegistry, defaultConverters, hexConverter, pemConverter, utf16beConverter, utf16leConverter, utf8Converter, } from "./defaults.js";
+export { convert } from "./convert.js";

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/converters/registry.js

@@ -0,0 +1,185 @@
+function keyOf(name) {
+    return name.trim().toLowerCase();
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function removeConverter(converters, primaryNames, converter) {
+    for (const alias of [converter.name, ...(converter.aliases ?? [])]) {
+        converters.delete(keyOf(alias));
+    }
+    primaryNames.delete(keyOf(converter.name));
+}
+function requireCapability(converter, name, capability) {
+    const method = converter[capability];
+    if (typeof method !== "function") {
+        throw new Error(`Converter '${name}' does not support ${capability}()`);
+    }
+    return method;
+}
+function detectConfidence(name, text, converter) {
+    const normalizedName = keyOf(converter.name || name);
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return 0;
+    }
+    let accepted = false;
+    if (converter.is) {
+        accepted = converter.is(text);
+    }
+    let decodable = false;
+    try {
+        converter.decode(text);
+        decodable = true;
+    }
+    catch {
+        decodable = false;
+    }
+    if (!accepted && !decodable) {
+        return 0;
+    }
+    switch (normalizedName) {
+        case "pem":
+            return /-----BEGIN [^-]+-----/.test(text) ? 1 : 0;
+        case "hex": {
+            const compact = trimmed.replace(/^0x/i, "").replace(/[\s:.-]/g, "");
+            if (!compact || /[^0-9a-f]/i.test(compact) || compact.length % 2 !== 0) {
+                return 0;
+            }
+            if (/^0x/i.test(trimmed) || /[:\s.-]/.test(trimmed)) {
+                return 0.95;
+            }
+            if (/[a-f]/.test(trimmed) || /[A-F]/.test(trimmed)) {
+                return 0.8;
+            }
+            return 0.45;
+        }
+        case "base64url":
+            if (/[-_]/.test(trimmed)) {
+                return 0.95;
+            }
+            if (/=/.test(trimmed)) {
+                return 0.1;
+            }
+            return 0.6;
+        case "base64":
+            if (/[+/=]/.test(trimmed)) {
+                return 0.9;
+            }
+            return 0.55;
+        case "binary":
+        case "utf8":
+        case "utf16be":
+        case "utf16le":
+            return 0;
+        default:
+            return accepted && decodable ? 0.75 : 0.5;
+    }
+}
+export function createConverterRegistry(initialConverters = []) {
+    const converters = new Map();
+    const primaryNames = new Set();
+    const api = {
+        register(converter, options = {}) {
+            if (!converter.name || !keyOf(converter.name)) {
+                throw new TypeError("Converter name is required");
+            }
+            const names = [...new Set([converter.name, ...(converter.aliases ?? [])].map(keyOf))];
+            const conflicts = new Set();
+            for (const name of names) {
+                const existing = converters.get(name);
+                if (!existing) {
+                    continue;
+                }
+                if (!options.override) {
+                    throw new Error(`Converter '${name}' is already registered`);
+                }
+                conflicts.add(existing);
+            }
+            for (const conflicting of conflicts) {
+                removeConverter(converters, primaryNames, conflicting);
+            }
+            for (const name of names) {
+                converters.set(name, converter);
+            }
+            primaryNames.add(keyOf(converter.name));
+            return this;
+        },
+        unregister(name) {
+            const converter = converters.get(keyOf(name));
+            if (!converter) {
+                return false;
+            }
+            removeConverter(converters, primaryNames, converter);
+            return true;
+        },
+        has(name) {
+            return converters.has(keyOf(name));
+        },
+        get(name) {
+            const converter = converters.get(keyOf(name));
+            if (!converter) {
+                throw new Error(`Converter '${name}' is not registered`);
+            }
+            return converter;
+        },
+        list() {
+            return [...primaryNames].map((name) => this.get(name));
+        },
+        encode(name, data, options) {
+            return this.get(name).encode(data, options);
+        },
+        decode(name, text, options) {
+            return this.get(name).decode(text, options);
+        },
+        tryDecode(name, text, options) {
+            try {
+                return { ok: true, bytes: this.decode(name, text, options) };
+            }
+            catch (error) {
+                return { ok: false, error: toError(error) };
+            }
+        },
+        normalize(name, text, options) {
+            const converter = this.get(name);
+            return requireCapability(converter, name, "normalize").call(converter, text, options);
+        },
+        parse(name, text, options) {
+            const converter = this.get(name);
+            return requireCapability(converter, name, "parse").call(converter, text, options);
+        },
+        format(name, data, format) {
+            const converter = this.get(name);
+            return requireCapability(converter, name, "format").call(converter, data, format);
+        },
+        transcode(text, options) {
+            const bytes = this.decode(options.from, text, options.fromOptions);
+            return this.encode(options.to, bytes, options.toOptions);
+        },
+        detect(text, options = {}) {
+            const formatNames = options.formats?.length
+                ? options.formats.map((name) => String(name))
+                : this.list()
+                    .map((converter) => converter.name)
+                    .filter((name) => !["binary", "utf8", "utf16be", "utf16le"].includes(keyOf(name)));
+            const detections = new Map();
+            for (const requestedName of formatNames) {
+                const converter = this.get(requestedName);
+                const confidence = detectConfidence(requestedName, text, converter);
+                if (confidence <= 0) {
+                    continue;
+                }
+                const format = converter.name;
+                const current = detections.get(format);
+                if (!current || confidence > current.confidence) {
+                    detections.set(format, { format, confidence });
+                }
+            }
+            return [...detections.values()].sort((left, right) => right.confidence - left.confidence);
+        },
+    };
+    for (const converter of initialConverters) {
+        api.register(converter);
+    }
+    return api;
+}

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/converters/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-schema/node_modules/@peculiar/utils/build/esm/encoding/base64.js

@@ -0,0 +1,40 @@
+import { toUint8Array } from "../bytes/index.js";
+import { encode as encodeBinary, decode as decodeBinary } from "./binary.js";
+const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function nodeBuffer() {
+    return globalThis.Buffer;
+}
+export function normalize(text) {
+    return text.replace(/[\n\r\t ]/g, "");
+}
+export function pad(text) {
+    const remainder = text.length % 4;
+    return remainder ? text + "=".repeat(4 - remainder) : text;
+}
+export function is(text) {
+    if (typeof text !== "string") {
+        return false;
+    }
+    const normalized = normalize(text);
+    return normalized === "" || BASE64_REGEX.test(normalized);
+}
+export function encode(data, _options) {
+    const bytes = toUint8Array(data);
+    const buffer = nodeBuffer();
+    if (buffer) {
+        return buffer.from(bytes).toString("base64");
+    }
+    return btoa(encodeBinary(bytes));
+}
+export function decode(text, _options) {
+    const normalized = normalize(text);
+    if (!is(normalized)) {
+        throw new TypeError("Input is not valid Base64 text");
+    }
+    const buffer = nodeBuffer();
+    if (buffer) {
+        return new Uint8Array(buffer.from(normalized, "base64"));
+    }
+    return decodeBinary(atob(normalized));
+}
+export const base64 = { encode, decode, is, normalize, pad };