keep-a-changelog 2.6.0 → 2.6.2

package/script/deps/jsr.io/@std/ini/0.225.2/mod.d.ts

@@ -0,0 +1,127 @@
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://en.wikipedia.org/wiki/INI_file | INI} encoded data, such as the
+ * {@link https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s03.html | Desktop Entry specification}.
+ * Values are parsed as strings by default to preserve data parity from the original.
+ * Customization is possible in the form of reviver/replacer functions like those in `JSON.parse` and `JSON.stringify`.
+ * Nested sections, repeated key names within a section, and key/value arrays are not supported,
+ * but will be preserved when using {@linkcode IniMap}. Multi-line values are not supported and will throw a syntax error.
+ * White space padding and lines starting with '#', ';', or '//' will be treated as comments.
+ *
+ * ```ts
+ * import * as ini from "@std/ini";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const iniFile = `# Example configuration file
+ * Global Key=Some data here
+ *
+ * [Section #1]
+ * Section Value=42
+ * Section Date=1977-05-25`;
+ *
+ * const parsed = ini.parse(iniFile, {
+ *   reviver(key, value, section) {
+ *     if (section === "Section #1") {
+ *       if (key === "Section Value") return Number(value);
+ *       if (key === "Section Date") return new Date(value);
+ *     }
+ *     return value;
+ *   },
+ * });
+ *
+ * assertEquals(parsed, {
+ *   "Global Key": "Some data here",
+ *   "Section #1": {
+ *     "Section Value": 42,
+ *     "Section Date": new Date("1977-05-25T00:00:00.000Z"),
+ *   },
+ * });
+ *
+ * const text = ini.stringify(parsed, {
+ *   replacer(key, value, section) {
+ *     if (section === "Section #1" && key === "Section Date") {
+ *       return (value as Date).toISOString().split("T")[0];
+ *     }
+ *     return value;
+ *   },
+ * });
+ *
+ * assertEquals(text, `Global Key=Some data here
+ * [Section #1]
+ * Section Value=42
+ * Section Date=1977-05-25`);
+ * ```
+ *
+ * Optionally, {@linkcode IniMap} may be used for finer INI handling. Using this class will permit preserving
+ * comments, accessing values like a map, iterating over key/value/section entries, and more.
+ *
+ * ```ts
+ * import { IniMap } from "@std/ini/ini-map";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const ini = new IniMap();
+ * ini.set("section1", "keyA", 100);
+ * assertEquals(ini.toString(), `[section1]
+ * keyA=100`);
+ *
+ * ini.set('keyA', 25)
+ * assertEquals(ini.toObject(), {
+ *   keyA: 25,
+ *   section1: {
+ *     keyA: 100
+ *   }
+ * });
+ * ```
+ *
+ * The reviver and replacer APIs can be used to extend the behavior of IniMap, such as adding support
+ * for duplicate keys as if they were arrays of values.
+ *
+ * ```ts
+ * import { IniMap } from "@std/ini/ini-map";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const iniFile = `# Example of key/value arrays
+ * [section1]
+ * key1=This key
+ * key1=is non-standard
+ * key1=but can be captured!`;
+ *
+ * const ini = new IniMap({ assignment: "=", deduplicate: true });
+ * ini.parse(iniFile, (key, value, section) => {
+ *   if (section) {
+ *     if (ini.has(section, key)) {
+ *       const exists = ini.get(section, key);
+ *       if (Array.isArray(exists)) {
+ *         exists.push(value);
+ *         return exists;
+ *       } else {
+ *         return [exists, value];
+ *       }
+ *     }
+ *   }
+ *   return value;
+ * });
+ *
+ * assertEquals(
+ *   ini.get("section1", "key1"),
+ *   ["This key", "is non-standard", "but can be captured!"]
+ * );
+ *
+ * const result = ini.toString((key, value) => {
+ *   if (Array.isArray(value)) {
+ *     return value.join(
+ *       `${ini.formatting.lineBreak}${key}${ini.formatting.assignment}`,
+ *     );
+ *   }
+ *   return value;
+ * });
+ *
+ * assertEquals(result, iniFile);
+ * ```
+ *
+ * @module
+ */
+export * from "./ini_map.js";
+export * from "./parse.js";
+export * from "./stringify.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/deps/jsr.io/@std/ini/0.225.2/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ini/0.225.2/mod.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0HG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC"}

package/script/deps/jsr.io/@std/ini/0.225.2/mod.js

@@ -0,0 +1,144 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * {@linkcode parse} and {@linkcode stringify} for handling
+ * {@link https://en.wikipedia.org/wiki/INI_file | INI} encoded data, such as the
+ * {@link https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s03.html | Desktop Entry specification}.
+ * Values are parsed as strings by default to preserve data parity from the original.
+ * Customization is possible in the form of reviver/replacer functions like those in `JSON.parse` and `JSON.stringify`.
+ * Nested sections, repeated key names within a section, and key/value arrays are not supported,
+ * but will be preserved when using {@linkcode IniMap}. Multi-line values are not supported and will throw a syntax error.
+ * White space padding and lines starting with '#', ';', or '//' will be treated as comments.
+ *
+ * ```ts
+ * import * as ini from "@std/ini";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const iniFile = `# Example configuration file
+ * Global Key=Some data here
+ *
+ * [Section #1]
+ * Section Value=42
+ * Section Date=1977-05-25`;
+ *
+ * const parsed = ini.parse(iniFile, {
+ *   reviver(key, value, section) {
+ *     if (section === "Section #1") {
+ *       if (key === "Section Value") return Number(value);
+ *       if (key === "Section Date") return new Date(value);
+ *     }
+ *     return value;
+ *   },
+ * });
+ *
+ * assertEquals(parsed, {
+ *   "Global Key": "Some data here",
+ *   "Section #1": {
+ *     "Section Value": 42,
+ *     "Section Date": new Date("1977-05-25T00:00:00.000Z"),
+ *   },
+ * });
+ *
+ * const text = ini.stringify(parsed, {
+ *   replacer(key, value, section) {
+ *     if (section === "Section #1" && key === "Section Date") {
+ *       return (value as Date).toISOString().split("T")[0];
+ *     }
+ *     return value;
+ *   },
+ * });
+ *
+ * assertEquals(text, `Global Key=Some data here
+ * [Section #1]
+ * Section Value=42
+ * Section Date=1977-05-25`);
+ * ```
+ *
+ * Optionally, {@linkcode IniMap} may be used for finer INI handling. Using this class will permit preserving
+ * comments, accessing values like a map, iterating over key/value/section entries, and more.
+ *
+ * ```ts
+ * import { IniMap } from "@std/ini/ini-map";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const ini = new IniMap();
+ * ini.set("section1", "keyA", 100);
+ * assertEquals(ini.toString(), `[section1]
+ * keyA=100`);
+ *
+ * ini.set('keyA', 25)
+ * assertEquals(ini.toObject(), {
+ *   keyA: 25,
+ *   section1: {
+ *     keyA: 100
+ *   }
+ * });
+ * ```
+ *
+ * The reviver and replacer APIs can be used to extend the behavior of IniMap, such as adding support
+ * for duplicate keys as if they were arrays of values.
+ *
+ * ```ts
+ * import { IniMap } from "@std/ini/ini-map";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const iniFile = `# Example of key/value arrays
+ * [section1]
+ * key1=This key
+ * key1=is non-standard
+ * key1=but can be captured!`;
+ *
+ * const ini = new IniMap({ assignment: "=", deduplicate: true });
+ * ini.parse(iniFile, (key, value, section) => {
+ *   if (section) {
+ *     if (ini.has(section, key)) {
+ *       const exists = ini.get(section, key);
+ *       if (Array.isArray(exists)) {
+ *         exists.push(value);
+ *         return exists;
+ *       } else {
+ *         return [exists, value];
+ *       }
+ *     }
+ *   }
+ *   return value;
+ * });
+ *
+ * assertEquals(
+ *   ini.get("section1", "key1"),
+ *   ["This key", "is non-standard", "but can be captured!"]
+ * );
+ *
+ * const result = ini.toString((key, value) => {
+ *   if (Array.isArray(value)) {
+ *     return value.join(
+ *       `${ini.formatting.lineBreak}${key}${ini.formatting.assignment}`,
+ *     );
+ *   }
+ *   return value;
+ * });
+ *
+ * assertEquals(result, iniFile);
+ * ```
+ *
+ * @module
+ */
+__exportStar(require("./ini_map.js"), exports);
+__exportStar(require("./parse.js"), exports);
+__exportStar(require("./stringify.js"), exports);

package/script/deps/jsr.io/@std/ini/0.225.2/parse.d.ts

@@ -0,0 +1,56 @@
+import { type ParseOptions } from "./ini_map.js";
+/**
+ * Parse an INI config string into an object. Provide formatting options to override the default assignment operator.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/ini/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const parsed = parse(`
+ * key = value
+ *
+ * [section 1]
+ * foo = Hello
+ * baz = World
+ * `);
+ *
+ * assertEquals(parsed, { key: "value", "section 1": { foo: "Hello", baz: "World" } })
+ * ```
+ *
+ * @example Using custom reviver
+ * ```ts
+ * import { parse } from "@std/ini/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const parsed = parse(`
+ * [section Foo]
+ * date = 2012-10-10
+ * amount = 12345
+ * `, {
+ *   reviver(key, value, section) {
+ *     if (section === "section Foo") {
+ *       if (key === "date") {
+ *         return new Date(value);
+ *       } else if (key === "amount") {
+ *         return +value;
+ *       }
+ *     }
+ *     return value;
+ *   }
+ * });
+ *
+ * assertEquals(parsed, {
+ *   "section Foo": {
+ *     date: new Date("2012-10-10"),
+ *     amount: 12345,
+ *   }
+ * })
+ * ```
+ *
+ * @param text The text to parse
+ * @param options The options to use
+ * @return The parsed object
+ */
+export declare function parse(text: string, options?: ParseOptions): Record<string, unknown | Record<string, unknown>>;
+//# sourceMappingURL=parse.d.ts.map

package/script/deps/jsr.io/@std/ini/0.225.2/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ini/0.225.2/parse.ts"],"names":[],"mappings":"AAGA,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,YAAY,GACrB,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAEnD"}

package/script/deps/jsr.io/@std/ini/0.225.2/parse.js

@@ -0,0 +1,62 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = parse;
+const ini_map_js_1 = require("./ini_map.js");
+/**
+ * Parse an INI config string into an object. Provide formatting options to override the default assignment operator.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse } from "@std/ini/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const parsed = parse(`
+ * key = value
+ *
+ * [section 1]
+ * foo = Hello
+ * baz = World
+ * `);
+ *
+ * assertEquals(parsed, { key: "value", "section 1": { foo: "Hello", baz: "World" } })
+ * ```
+ *
+ * @example Using custom reviver
+ * ```ts
+ * import { parse } from "@std/ini/parse";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const parsed = parse(`
+ * [section Foo]
+ * date = 2012-10-10
+ * amount = 12345
+ * `, {
+ *   reviver(key, value, section) {
+ *     if (section === "section Foo") {
+ *       if (key === "date") {
+ *         return new Date(value);
+ *       } else if (key === "amount") {
+ *         return +value;
+ *       }
+ *     }
+ *     return value;
+ *   }
+ * });
+ *
+ * assertEquals(parsed, {
+ *   "section Foo": {
+ *     date: new Date("2012-10-10"),
+ *     amount: 12345,
+ *   }
+ * })
+ * ```
+ *
+ * @param text The text to parse
+ * @param options The options to use
+ * @return The parsed object
+ */
+function parse(text, options) {
+    return ini_map_js_1.IniMap.from(text, options).toObject();
+}

package/script/deps/jsr.io/@std/ini/0.225.2/stringify.d.ts

@@ -0,0 +1,66 @@
+import { type FormattingOptions, type ReplacerFunction } from "./ini_map.js";
+/** Options for constructing INI strings. */
+export interface StringifyOptions extends FormattingOptions {
+    /** Provide custom string conversion for the value in a key/value pair. */
+    replacer?: ReplacerFunction;
+}
+/**
+ * Compile an object into an INI config string. Provide formatting options to modify the output.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/ini/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const str = stringify({
+ *   key1: "value1",
+ *   key2: "value2",
+ *   section1: {
+ *     foo: "bar",
+ *   },
+ *   section2: {
+ *     hello: "world",
+ *   },
+ * });
+ *
+ * assertEquals(str, `key1=value1
+ * key2=value2
+ * [section1]
+ * foo=bar
+ * [section2]
+ * hello=world`);
+ * ```
+ *
+ * @example Using replacer option
+ * ```ts
+ * import { stringify } from "@std/ini/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const str = stringify({
+ *   "section X": {
+ *     date: new Date("2024-06-10"),
+ *   },
+ *   "section Y": {
+ *     name: "John"
+ *   }
+ * }, {
+ *   replacer(key, value, section) {
+ *     if (section === "section X" && key === "date") {
+ *       return value.toISOString().slice(0, 10);
+ *     }
+ *     return value;
+ *   },
+ * });
+ *
+ * assertEquals(str, `[section X]
+ * date=2024-06-10
+ * [section Y]
+ * name=John`);
+ * ```
+ *
+ * @param object The object to stringify
+ * @param options The option to use
+ * @returns The INI string
+ */
+export declare function stringify(object: any, options?: StringifyOptions): string;
+//# sourceMappingURL=stringify.d.ts.map

package/script/deps/jsr.io/@std/ini/0.225.2/stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringify.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ini/0.225.2/stringify.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EACtB,MAAM,cAAc,CAAC;AAEtB,4CAA4C;AAC5C,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IACzD,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,wBAAgB,SAAS,CAEvB,MAAM,EAAE,GAAG,EACX,OAAO,CAAC,EAAE,gBAAgB,GACzB,MAAM,CAER"}

package/script/deps/jsr.io/@std/ini/0.225.2/stringify.js

@@ -0,0 +1,69 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = stringify;
+const ini_map_js_1 = require("./ini_map.js");
+/**
+ * Compile an object into an INI config string. Provide formatting options to modify the output.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/ini/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const str = stringify({
+ *   key1: "value1",
+ *   key2: "value2",
+ *   section1: {
+ *     foo: "bar",
+ *   },
+ *   section2: {
+ *     hello: "world",
+ *   },
+ * });
+ *
+ * assertEquals(str, `key1=value1
+ * key2=value2
+ * [section1]
+ * foo=bar
+ * [section2]
+ * hello=world`);
+ * ```
+ *
+ * @example Using replacer option
+ * ```ts
+ * import { stringify } from "@std/ini/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const str = stringify({
+ *   "section X": {
+ *     date: new Date("2024-06-10"),
+ *   },
+ *   "section Y": {
+ *     name: "John"
+ *   }
+ * }, {
+ *   replacer(key, value, section) {
+ *     if (section === "section X" && key === "date") {
+ *       return value.toISOString().slice(0, 10);
+ *     }
+ *     return value;
+ *   },
+ * });
+ *
+ * assertEquals(str, `[section X]
+ * date=2024-06-10
+ * [section Y]
+ * name=John`);
+ * ```
+ *
+ * @param object The object to stringify
+ * @param options The option to use
+ * @returns The INI string
+ */
+function stringify(
+// deno-lint-ignore no-explicit-any
+object, options) {
+    return ini_map_js_1.IniMap.from(object, options).toString(options?.replacer);
+}

package/script/deps/jsr.io/@std/internal/1.0.5/build_message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_message.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.5/build_message.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ;AAClB;;;GAGG;AACH,UAAU,UAAQ,GACjB,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CASvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CASrD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,OAAO,GAAE,mBAAwB,GAChC,MAAM,EAAE,CAsBV"}

package/script/deps/jsr.io/@std/internal/1.0.5/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.5/diff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAanD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAWvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,GACzB,KAAK,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAgCD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,aAAa,GACnB,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAwEvD"}

package/script/deps/jsr.io/@std/internal/1.0.5/diff_str.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff_str.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.5/diff_str.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAW/C;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,MAAM,EAAE,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,GAC3B,UAAU,CAAC,MAAM,CAAC,EAAE,CAetB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAkDlE"}

package/script/deps/jsr.io/@std/internal/1.0.5/format.d.ts.map

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

package/script/deps/jsr.io/@std/internal/1.0.5/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.5/styles.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAWD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/script/deps/jsr.io/@std/internal/1.0.5/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.5/types.ts"],"names":[],"mappings":"AAEA,kDAAkD;AAClD,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,4BAA4B;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,6BAA6B;IAC7B,KAAK,EAAE,CAAC,CAAC;IACT,+BAA+B;IAC/B,OAAO,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;CAC3B"}

package/script/deps/jsr.io/@std/path/1.0.8/_common/assert_path.d.ts

@@ -0,0 +1,2 @@
+export declare function assertPath(path?: string): void;
+//# sourceMappingURL=assert_path.d.ts.map

package/script/deps/jsr.io/@std/path/1.0.8/_common/assert_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/_common/assert_path.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,QAMvC"}

package/script/deps/jsr.io/@std/path/1.0.8/_common/assert_path.js

@@ -0,0 +1,10 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPath = assertPath;
+function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string, received "${JSON.stringify(path)}"`);
+    }
+}

package/script/deps/jsr.io/@std/path/1.0.8/_common/basename.d.ts

@@ -0,0 +1,4 @@
+export declare function stripSuffix(name: string, suffix: string): string;
+export declare function lastPathSegment(path: string, isSep: (char: number) => boolean, start?: number): string;
+export declare function assertArgs(path: string, suffix: string): string | undefined;
+//# sourceMappingURL=basename.d.ts.map

package/script/deps/jsr.io/@std/path/1.0.8/_common/basename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basename.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/_common/basename.ts"],"names":[],"mappings":"AAKA,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAchE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAChC,KAAK,SAAI,GACR,MAAM,CAiBR;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,sBAQtD"}

package/script/deps/jsr.io/@std/path/1.0.8/_common/basename.js

@@ -0,0 +1,45 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripSuffix = stripSuffix;
+exports.lastPathSegment = lastPathSegment;
+exports.assertArgs = assertArgs;
+const assert_path_js_1 = require("./assert_path.js");
+function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; --i) {
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
+}
+function lastPathSegment(path, isSep, start = 0) {
+    let matchedNonSeparator = false;
+    let end = path.length;
+    for (let i = path.length - 1; i >= start; --i) {
+        if (isSep(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (!matchedNonSeparator) {
+            matchedNonSeparator = true;
+            end = i + 1;
+        }
+    }
+    return path.slice(start, end);
+}
+function assertArgs(path, suffix) {
+    (0, assert_path_js_1.assertPath)(path);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string, received "${JSON.stringify(suffix)}"`);
+    }
+}

package/script/deps/jsr.io/@std/path/1.0.8/_common/common.d.ts

@@ -0,0 +1,2 @@
+export declare function common(paths: string[], sep: string): string;
+//# sourceMappingURL=common.d.ts.map

package/script/deps/jsr.io/@std/path/1.0.8/_common/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.8/_common/common.ts"],"names":[],"mappings":"AAGA,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAsB3D"}

package/script/deps/jsr.io/@std/path/1.0.8/_common/common.js

@@ -0,0 +1,26 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.common = common;
+function common(paths, sep) {
+    const [first = "", ...remaining] = paths;
+    const parts = first.split(sep);
+    let endOfPrefix = parts.length;
+    let append = "";
+    for (const path of remaining) {
+        const compare = path.split(sep);
+        if (compare.length <= endOfPrefix) {
+            endOfPrefix = compare.length;
+            append = "";
+        }
+        for (let i = 0; i < endOfPrefix; i++) {
+            if (compare[i] !== parts[i]) {
+                endOfPrefix = i;
+                append = i === 0 ? "" : sep;
+                break;
+            }
+        }
+    }
+    return parts.slice(0, endOfPrefix).join(sep) + append;
+}