@logtape/file 0.9.0-dev.1

package/script/logtape/logger.js

@@ -0,0 +1,511 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerCtx = exports.LoggerImpl = void 0;
+exports.getLogger = getLogger;
+exports.parseMessageTemplate = parseMessageTemplate;
+exports.renderMessage = renderMessage;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const level_js_1 = require("./level.js");
+/**
+ * Get a logger with the given category.
+ *
+ * ```typescript
+ * const logger = getLogger(["my-app"]);
+ * ```
+ *
+ * @param category The category of the logger.  It can be a string or an array
+ *                 of strings.  If it is a string, it is equivalent to an array
+ *                 with a single element.
+ * @returns The logger.
+ */
+function getLogger(category = []) {
+    return LoggerImpl.getLogger(category);
+}
+/**
+ * The symbol for the global root logger.
+ */
+const globalRootLoggerSymbol = Symbol.for("logtape.rootLogger");
+/**
+ * A logger implementation.  Do not use this directly; use {@link getLogger}
+ * instead.  This class is exported for testing purposes.
+ */
+class LoggerImpl {
+    static getLogger(category = []) {
+        let rootLogger = globalRootLoggerSymbol in dntShim.dntGlobalThis
+            ? (dntShim.dntGlobalThis[globalRootLoggerSymbol] ??
+                null)
+            : null;
+        if (rootLogger == null) {
+            rootLogger = new LoggerImpl(null, []);
+            dntShim.dntGlobalThis[globalRootLoggerSymbol] =
+                rootLogger;
+        }
+        if (typeof category === "string")
+            return rootLogger.getChild(category);
+        if (category.length === 0)
+            return rootLogger;
+        return rootLogger.getChild(category);
+    }
+    constructor(parent, category) {
+        Object.defineProperty(this, "parent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "children", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "category", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sinks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "parentSinks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "inherit"
+        });
+        Object.defineProperty(this, "filters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lowestLevel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "debug"
+        });
+        Object.defineProperty(this, "contextLocalStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.parent = parent;
+        this.children = {};
+        this.category = category;
+        this.sinks = [];
+        this.filters = [];
+    }
+    getChild(subcategory) {
+        const name = typeof subcategory === "string" ? subcategory : subcategory[0];
+        const childRef = this.children[name];
+        let child = childRef instanceof LoggerImpl
+            ? childRef
+            : childRef?.deref();
+        if (child == null) {
+            child = new LoggerImpl(this, [...this.category, name]);
+            this.children[name] = "WeakRef" in dntShim.dntGlobalThis
+                ? new WeakRef(child)
+                : child;
+        }
+        if (typeof subcategory === "string" || subcategory.length === 1) {
+            return child;
+        }
+        return child.getChild(subcategory.slice(1));
+    }
+    /**
+     * Reset the logger.  This removes all sinks and filters from the logger.
+     */
+    reset() {
+        while (this.sinks.length > 0)
+            this.sinks.shift();
+        this.parentSinks = "inherit";
+        while (this.filters.length > 0)
+            this.filters.shift();
+        this.lowestLevel = "debug";
+    }
+    /**
+     * Reset the logger and all its descendants.  This removes all sinks and
+     * filters from the logger and all its descendants.
+     */
+    resetDescendants() {
+        for (const child of Object.values(this.children)) {
+            const logger = child instanceof LoggerImpl ? child : child.deref();
+            if (logger != null)
+                logger.resetDescendants();
+        }
+        this.reset();
+    }
+    with(properties) {
+        return new LoggerCtx(this, { ...properties });
+    }
+    filter(record) {
+        for (const filter of this.filters) {
+            if (!filter(record))
+                return false;
+        }
+        if (this.filters.length < 1)
+            return this.parent?.filter(record) ?? true;
+        return true;
+    }
+    *getSinks(level) {
+        if (this.lowestLevel === null || (0, level_js_1.compareLogLevel)(level, this.lowestLevel) < 0) {
+            return;
+        }
+        if (this.parent != null && this.parentSinks === "inherit") {
+            for (const sink of this.parent.getSinks(level))
+                yield sink;
+        }
+        for (const sink of this.sinks)
+            yield sink;
+    }
+    emit(record, bypassSinks) {
+        if (this.lowestLevel === null ||
+            (0, level_js_1.compareLogLevel)(record.level, this.lowestLevel) < 0 ||
+            !this.filter(record)) {
+            return;
+        }
+        for (const sink of this.getSinks(record.level)) {
+            if (bypassSinks?.has(sink))
+                continue;
+            try {
+                sink(record);
+            }
+            catch (error) {
+                const bypassSinks2 = new Set(bypassSinks);
+                bypassSinks2.add(sink);
+                metaLogger.log("fatal", "Failed to emit a log record to sink {sink}: {error}", { sink, error, record }, bypassSinks2);
+            }
+        }
+    }
+    log(level, rawMessage, properties, bypassSinks) {
+        const implicitContext = LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};
+        let cachedProps = undefined;
+        const record = typeof properties === "function"
+            ? {
+                category: this.category,
+                level,
+                timestamp: Date.now(),
+                get message() {
+                    return parseMessageTemplate(rawMessage, this.properties);
+                },
+                rawMessage,
+                get properties() {
+                    if (cachedProps == null) {
+                        cachedProps = {
+                            ...implicitContext,
+                            ...properties(),
+                        };
+                    }
+                    return cachedProps;
+                },
+            }
+            : {
+                category: this.category,
+                level,
+                timestamp: Date.now(),
+                message: parseMessageTemplate(rawMessage, {
+                    ...implicitContext,
+                    ...properties,
+                }),
+                rawMessage,
+                properties: { ...implicitContext, ...properties },
+            };
+        this.emit(record, bypassSinks);
+    }
+    logLazily(level, callback, properties = {}) {
+        const implicitContext = LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};
+        let rawMessage = undefined;
+        let msg = undefined;
+        function realizeMessage() {
+            if (msg == null || rawMessage == null) {
+                msg = callback((tpl, ...values) => {
+                    rawMessage = tpl;
+                    return renderMessage(tpl, values);
+                });
+                if (rawMessage == null)
+                    throw new TypeError("No log record was made.");
+            }
+            return [msg, rawMessage];
+        }
+        this.emit({
+            category: this.category,
+            level,
+            get message() {
+                return realizeMessage()[0];
+            },
+            get rawMessage() {
+                return realizeMessage()[1];
+            },
+            timestamp: Date.now(),
+            properties: { ...implicitContext, ...properties },
+        });
+    }
+    logTemplate(level, messageTemplate, values, properties = {}) {
+        const implicitContext = LoggerImpl.getLogger().contextLocalStorage?.getStore() ?? {};
+        this.emit({
+            category: this.category,
+            level,
+            message: renderMessage(messageTemplate, values),
+            rawMessage: messageTemplate,
+            timestamp: Date.now(),
+            properties: { ...implicitContext, ...properties },
+        });
+    }
+    debug(message, ...values) {
+        if (typeof message === "string") {
+            this.log("debug", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("debug", message);
+        }
+        else {
+            this.logTemplate("debug", message, values);
+        }
+    }
+    info(message, ...values) {
+        if (typeof message === "string") {
+            this.log("info", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("info", message);
+        }
+        else {
+            this.logTemplate("info", message, values);
+        }
+    }
+    warn(message, ...values) {
+        if (typeof message === "string") {
+            this.log("warning", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("warning", message);
+        }
+        else {
+            this.logTemplate("warning", message, values);
+        }
+    }
+    error(message, ...values) {
+        if (typeof message === "string") {
+            this.log("error", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("error", message);
+        }
+        else {
+            this.logTemplate("error", message, values);
+        }
+    }
+    fatal(message, ...values) {
+        if (typeof message === "string") {
+            this.log("fatal", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("fatal", message);
+        }
+        else {
+            this.logTemplate("fatal", message, values);
+        }
+    }
+}
+exports.LoggerImpl = LoggerImpl;
+/**
+ * A logger implementation with contextual properties.  Do not use this
+ * directly; use {@link Logger.with} instead.  This class is exported
+ * for testing purposes.
+ */
+class LoggerCtx {
+    constructor(logger, properties) {
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "properties", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.logger = logger;
+        this.properties = properties;
+    }
+    get category() {
+        return this.logger.category;
+    }
+    get parent() {
+        return this.logger.parent;
+    }
+    getChild(subcategory) {
+        return this.logger.getChild(subcategory).with(this.properties);
+    }
+    with(properties) {
+        return new LoggerCtx(this.logger, { ...this.properties, ...properties });
+    }
+    log(level, message, properties, bypassSinks) {
+        this.logger.log(level, message, typeof properties === "function"
+            ? () => ({
+                ...this.properties,
+                ...properties(),
+            })
+            : { ...this.properties, ...properties }, bypassSinks);
+    }
+    logLazily(level, callback) {
+        this.logger.logLazily(level, callback, this.properties);
+    }
+    logTemplate(level, messageTemplate, values) {
+        this.logger.logTemplate(level, messageTemplate, values, this.properties);
+    }
+    debug(message, ...values) {
+        if (typeof message === "string") {
+            this.log("debug", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("debug", message);
+        }
+        else {
+            this.logTemplate("debug", message, values);
+        }
+    }
+    info(message, ...values) {
+        if (typeof message === "string") {
+            this.log("info", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("info", message);
+        }
+        else {
+            this.logTemplate("info", message, values);
+        }
+    }
+    warn(message, ...values) {
+        if (typeof message === "string") {
+            this.log("warning", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("warning", message);
+        }
+        else {
+            this.logTemplate("warning", message, values);
+        }
+    }
+    error(message, ...values) {
+        if (typeof message === "string") {
+            this.log("error", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("error", message);
+        }
+        else {
+            this.logTemplate("error", message, values);
+        }
+    }
+    fatal(message, ...values) {
+        if (typeof message === "string") {
+            this.log("fatal", message, (values[0] ?? {}));
+        }
+        else if (typeof message === "function") {
+            this.logLazily("fatal", message);
+        }
+        else {
+            this.logTemplate("fatal", message, values);
+        }
+    }
+}
+exports.LoggerCtx = LoggerCtx;
+/**
+ * The meta logger.  It is a logger with the category `["logtape", "meta"]`.
+ */
+const metaLogger = LoggerImpl.getLogger(["logtape", "meta"]);
+/**
+ * Parse a message template into a message template array and a values array.
+ * @param template The message template.
+ * @param properties The values to replace placeholders with.
+ * @returns The message template array and the values array.
+ */
+function parseMessageTemplate(template, properties) {
+    const message = [];
+    let part = "";
+    for (let i = 0; i < template.length; i++) {
+        const char = template.charAt(i);
+        const nextChar = template.charAt(i + 1);
+        if (char === "{" && nextChar === "{") {
+            // Escaped { character
+            part = part + char;
+            i++;
+        }
+        else if (char === "}" && nextChar === "}") {
+            // Escaped } character
+            part = part + char;
+            i++;
+        }
+        else if (char === "{") {
+            // Start of a placeholder
+            message.push(part);
+            part = "";
+        }
+        else if (char === "}") {
+            // End of a placeholder
+            let prop;
+            if (part.match(/^\s|\s$/)) {
+                prop = part in properties ? properties[part] : properties[part.trim()];
+            }
+            else {
+                prop = properties[part];
+            }
+            message.push(prop);
+            part = "";
+        }
+        else {
+            // Default case
+            part = part + char;
+        }
+    }
+    message.push(part);
+    return message;
+}
+/**
+ * Render a message template with values.
+ * @param template The message template.
+ * @param values The message template values.
+ * @returns The message template values interleaved between the substitution
+ *          values.
+ */
+function renderMessage(template, values) {
+    const args = [];
+    for (let i = 0; i < template.length; i++) {
+        args.push(template[i]);
+        if (i < values.length)
+            args.push(values[i]);
+    }
+    return args;
+}

package/script/logtape/mod.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFilter = exports.getStreamSink = exports.getConsoleSink = exports.getLogger = exports.parseLogLevel = exports.isLogLevel = exports.compareLogLevel = exports.getTextFormatter = exports.getAnsiColorFormatter = exports.defaultTextFormatter = exports.defaultConsoleFormatter = exports.ansiColorFormatter = exports.toFilter = exports.getLevelFilter = exports.withContext = exports.resetSync = exports.reset = exports.getConfig = exports.disposeSync = exports.dispose = exports.configureSync = exports.configure = exports.ConfigError = void 0;
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "ConfigError", { enumerable: true, get: function () { return config_js_1.ConfigError; } });
+Object.defineProperty(exports, "configure", { enumerable: true, get: function () { return config_js_1.configure; } });
+Object.defineProperty(exports, "configureSync", { enumerable: true, get: function () { return config_js_1.configureSync; } });
+Object.defineProperty(exports, "dispose", { enumerable: true, get: function () { return config_js_1.dispose; } });
+Object.defineProperty(exports, "disposeSync", { enumerable: true, get: function () { return config_js_1.disposeSync; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_js_1.getConfig; } });
+Object.defineProperty(exports, "reset", { enumerable: true, get: function () { return config_js_1.reset; } });
+Object.defineProperty(exports, "resetSync", { enumerable: true, get: function () { return config_js_1.resetSync; } });
+var context_js_1 = require("./context.js");
+Object.defineProperty(exports, "withContext", { enumerable: true, get: function () { return context_js_1.withContext; } });
+var filter_js_1 = require("./filter.js");
+Object.defineProperty(exports, "getLevelFilter", { enumerable: true, get: function () { return filter_js_1.getLevelFilter; } });
+Object.defineProperty(exports, "toFilter", { enumerable: true, get: function () { return filter_js_1.toFilter; } });
+var formatter_js_1 = require("./formatter.js");
+Object.defineProperty(exports, "ansiColorFormatter", { enumerable: true, get: function () { return formatter_js_1.ansiColorFormatter; } });
+Object.defineProperty(exports, "defaultConsoleFormatter", { enumerable: true, get: function () { return formatter_js_1.defaultConsoleFormatter; } });
+Object.defineProperty(exports, "defaultTextFormatter", { enumerable: true, get: function () { return formatter_js_1.defaultTextFormatter; } });
+Object.defineProperty(exports, "getAnsiColorFormatter", { enumerable: true, get: function () { return formatter_js_1.getAnsiColorFormatter; } });
+Object.defineProperty(exports, "getTextFormatter", { enumerable: true, get: function () { return formatter_js_1.getTextFormatter; } });
+var level_js_1 = require("./level.js");
+Object.defineProperty(exports, "compareLogLevel", { enumerable: true, get: function () { return level_js_1.compareLogLevel; } });
+Object.defineProperty(exports, "isLogLevel", { enumerable: true, get: function () { return level_js_1.isLogLevel; } });
+Object.defineProperty(exports, "parseLogLevel", { enumerable: true, get: function () { return level_js_1.parseLogLevel; } });
+var logger_js_1 = require("./logger.js");
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return logger_js_1.getLogger; } });
+var sink_js_1 = require("./sink.js");
+Object.defineProperty(exports, "getConsoleSink", { enumerable: true, get: function () { return sink_js_1.getConsoleSink; } });
+Object.defineProperty(exports, "getStreamSink", { enumerable: true, get: function () { return sink_js_1.getStreamSink; } });
+Object.defineProperty(exports, "withFilter", { enumerable: true, get: function () { return sink_js_1.withFilter; } });
+// cSpell: ignore filesink

package/script/logtape/nodeUtil.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_util_1 = __importDefault(require("node:util"));
+exports.default = node_util_1.default;

package/script/logtape/record.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/logtape/sink.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFilter = withFilter;
+exports.getStreamSink = getStreamSink;
+exports.getConsoleSink = getConsoleSink;
+const filter_js_1 = require("./filter.js");
+const formatter_js_1 = require("./formatter.js");
+/**
+ * Turns a sink into a filtered sink.  The returned sink only logs records that
+ * pass the filter.
+ *
+ * @example Filter a console sink to only log records with the info level
+ * ```typescript
+ * const sink = withFilter(getConsoleSink(), "info");
+ * ```
+ *
+ * @param sink A sink to be filtered.
+ * @param filter A filter to apply to the sink.  It can be either a filter
+ *               function or a {@link LogLevel} string.
+ * @returns A sink that only logs records that pass the filter.
+ */
+function withFilter(sink, filter) {
+    const filterFunc = (0, filter_js_1.toFilter)(filter);
+    return (record) => {
+        if (filterFunc(record))
+            sink(record);
+    };
+}
+/**
+ * A factory that returns a sink that writes to a {@link WritableStream}.
+ *
+ * Note that the `stream` is of Web Streams API, which is different from
+ * Node.js streams.  You can convert a Node.js stream to a Web Streams API
+ * stream using [`stream.Writable.toWeb()`] method.
+ *
+ * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable
+ *
+ * @example Sink to the standard error in Deno
+ * ```typescript
+ * const stderrSink = getStreamSink(Deno.stderr.writable);
+ * ```
+ *
+ * @example Sink to the standard error in Node.js
+ * ```typescript
+ * import stream from "node:stream";
+ * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));
+ * ```
+ *
+ * @param stream The stream to write to.
+ * @param options The options for the sink.
+ * @returns A sink that writes to the stream.
+ */
+function getStreamSink(stream, options = {}) {
+    const formatter = options.formatter ?? formatter_js_1.defaultTextFormatter;
+    const encoder = options.encoder ?? new TextEncoder();
+    const writer = stream.getWriter();
+    let lastPromise = Promise.resolve();
+    const sink = (record) => {
+        const bytes = encoder.encode(formatter(record));
+        lastPromise = lastPromise
+            .then(() => writer.ready)
+            .then(() => writer.write(bytes));
+    };
+    sink[Symbol.asyncDispose] = async () => {
+        await lastPromise;
+        await writer.close();
+    };
+    return sink;
+}
+/**
+ * A console sink factory that returns a sink that logs to the console.
+ *
+ * @param options The options for the sink.
+ * @returns A sink that logs to the console.
+ */
+function getConsoleSink(options = {}) {
+    const formatter = options.formatter ?? formatter_js_1.defaultConsoleFormatter;
+    const levelMap = {
+        debug: "debug",
+        info: "info",
+        warning: "warn",
+        error: "error",
+        fatal: "error",
+        ...(options.levelMap ?? {}),
+    };
+    const console = options.console ?? globalThis.console;
+    return (record) => {
+        const args = formatter(record);
+        const method = levelMap[record.level];
+        if (method === undefined) {
+            throw new TypeError(`Invalid log level: ${record.level}.`);
+        }
+        if (typeof args === "string") {
+            const msg = args.replace(/\r?\n$/, "");
+            console[method](msg);
+        }
+        else {
+            console[method](...args);
+        }
+    };
+}

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/types/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/types/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/types/_dnt.test_shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.test_shims.d.ts","sourceRoot":"","sources":["../src/_dnt.test_shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/types/deps/jsr.io/@david/which-runtime/0.2.1/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@david/which-runtime/0.2.1/mod.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,MAAM,EAAE,OAA4C,CAAC;AAClE,eAAO,MAAM,MAAM,EAAE,OAAsB,CAAC"}

package/types/deps/jsr.io/@std/assert/0.222.1/_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/0.222.1/_constants.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,qBAAqB,CAAC"}

package/types/deps/jsr.io/@std/assert/0.222.1/_diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/0.222.1/_diff.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,QAAQ;;;;CAIX,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,QAAQ,CAAC;AAE7C,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;IACT,OAAO,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;CAChC;AA4BD;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CA+L5D;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,wBAsI3C;AAwCD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,EAAE,UAAkB,EAAE;;CAAK,GAC1B,MAAM,EAAE,CAyBV"}

package/types/deps/jsr.io/@std/assert/0.222.1/_format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_format.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/0.222.1/_format.ts"],"names":[],"mappings":"AAYA,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAezC"}