@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.1.0

package/README.md

@@ -8,6 +8,10 @@ Generic tooling for TypeScript projects: the build, lint, format, spellcheck, te
 npm install --save-dev @mnaoumov/typescript-dev-toolkit
 ```
 
+## Documentation
+
+The guides and the API reference are at <https://mnaoumov.dev/typescript-dev-toolkit/>.
+
 ## Where it fits
 
 It is one of five packages that replace [`obsidian-dev-utils`](https://github.com/mnaoumov/obsidian-dev-utils): [`@mnaoumov/typescript-lib`](https://github.com/mnaoumov/typescript-lib), [`@mnaoumov/typescript-test-toolkit`](https://github.com/mnaoumov/typescript-test-toolkit), [`@mnaoumov/typescript-dev-toolkit`](https://github.com/mnaoumov/typescript-dev-toolkit), [`@mnaoumov/obsidian-lib`](https://github.com/mnaoumov/obsidian-lib) and [`@mnaoumov/obsidian-dev-toolkit`](https://github.com/mnaoumov/obsidian-dev-toolkit). It depends on [`@mnaoumov/typescript-lib`](https://github.com/mnaoumov/typescript-lib). It moved here from that repository with its history.

package/assets/docs-site/components/ConstructorBlock.astro

@@ -0,0 +1,16 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+interface Props {
+  description?: string;
+  signature: string;
+}
+
+const { signature, description } = Astro.props;
+---
+
+<div class="filterable-block" data-inherited="false">
+  <h2><span class="icon-own" title="Defined on this type"></span> Constructor</h2>
+  <Code code={signature} lang="ts" />
+  {description && <p set:html={description} />}
+</div>

package/assets/docs-site/components/ImportStatement.astro

@@ -0,0 +1,12 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+interface Props {
+  text: string;
+}
+
+const { text } = Astro.props;
+---
+
+<p><strong>Import:</strong></p>
+<Code code={text} lang="ts" />

package/assets/docs-site/components/MemberDetail.astro

@@ -0,0 +1,101 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+/** A rendered API parameter. */
+interface ParameterInfo {
+  description: string;
+  name: string;
+  type: string;
+}
+
+interface Props {
+  description?: string;
+  examples?: string[];
+  parameters?: ParameterInfo[];
+  remarks?: string;
+  returnDescription?: string;
+  returnType?: string;
+  signature?: string;
+  since?: string;
+  type?: string;
+}
+
+const {
+  type,
+  description,
+  signature,
+  parameters = [],
+  returnType,
+  returnDescription,
+  remarks,
+  examples = [],
+  since
+} = Astro.props;
+
+/** Strip markdown code fence markers and extract language + code */
+function parseCodeFence(raw: string): { code: string; lang: string } {
+  const match = /^```(\w*)\n([\s\S]*?)(?:\n```)?$/.exec(raw.trim());
+  if (match) {
+    return { code: match[2]?.trimEnd() ?? '', lang: match[1] || 'ts' };
+  }
+  return { code: raw.trim(), lang: 'ts' };
+}
+const parsedExamples = examples.map(parseCodeFence);
+---
+
+{type && <p><strong>Type:</strong> <span set:html={type} /></p>}
+
+{description && <Fragment set:html={description} />}
+
+{signature && (
+  <>
+    <p><strong>Signature:</strong></p>
+    <Code code={signature} lang="ts" />
+  </>
+)}
+
+{parameters.length > 0 && (
+  <>
+    <p><strong>Parameters:</strong></p>
+    <table>
+      <thead>
+        <tr>
+          <th style="text-align: left">Parameter</th>
+          <th style="text-align: left">Type</th>
+          <th style="text-align: left">Description</th>
+        </tr>
+      </thead>
+      <tbody>
+        {parameters.map((param) => (
+          <tr>
+            <td style="text-align: left">{param.name}</td>
+            <td style="text-align: left" set:html={param.type} />
+            <td style="text-align: left" set:html={param.description} />
+          </tr>
+        ))}
+      </tbody>
+    </table>
+  </>
+)}
+
+{returnType && (
+  <p><strong>Returns:</strong> <span set:html={returnType} />
+    {returnDescription && <> — <span set:html={returnDescription} /></>}
+  </p>
+)}
+
+{since && <p><strong>Since:</strong> {since}</p>}
+
+{remarks && (
+  <>
+    <p><strong>Remarks:</strong></p>
+    <Fragment set:html={remarks} />
+  </>
+)}
+
+{parsedExamples.map(({ code, lang }) => (
+  <>
+    <p><strong>Example:</strong></p>
+    <Code code={code} lang={lang} />
+  </>
+))}

package/assets/docs-site/components/MethodTable.astro

@@ -0,0 +1,45 @@
+---
+interface MethodRow {
+  description: string;
+  href: string;
+  inheritedFrom?: string;
+  returns: string;
+  signature: string;
+}
+
+interface Props {
+  rows: MethodRow[];
+}
+
+const { rows } = Astro.props;
+---
+
+<h2>Methods</h2>
+<table>
+  <colgroup>
+    <col style="width: 20%" />
+    <col style="width: 30%" />
+    <col style="width: 50%" />
+  </colgroup>
+  <thead>
+    <tr>
+      <th style="text-align: left">Method</th>
+      <th style="text-align: left">Returns</th>
+      <th style="text-align: left">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    {rows.map((row) => {
+      const inherited = row.inheritedFrom
+        ? `<br/><em>(Inherited from ${row.inheritedFrom})</em>`
+        : '';
+      return (
+        <tr>
+          <td style="text-align: left">{row.href ? <a href={row.href} set:html={row.signature} /> : <span set:html={row.signature} />}</td>
+          <td style="text-align: left" set:html={row.returns} />
+          <td style="text-align: left" set:html={row.description + inherited} />
+        </tr>
+      );
+    })}
+  </tbody>
+</table>

package/assets/docs-site/components/PropertyTable.astro

@@ -0,0 +1,45 @@
+---
+interface PropertyRow {
+  description: string;
+  href: string;
+  inheritedFrom?: string;
+  name: string;
+  type: string;
+}
+
+interface Props {
+  rows: PropertyRow[];
+}
+
+const { rows } = Astro.props;
+---
+
+<h2>Properties</h2>
+<table>
+  <colgroup>
+    <col style="width: 20%" />
+    <col style="width: 30%" />
+    <col style="width: 50%" />
+  </colgroup>
+  <thead>
+    <tr>
+      <th style="text-align: left">Property</th>
+      <th style="text-align: left">Type</th>
+      <th style="text-align: left">Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    {rows.map((row) => {
+      const inherited = row.inheritedFrom
+        ? `<br/><em>(Inherited from ${row.inheritedFrom})</em>`
+        : '';
+      return (
+        <tr>
+          <td style="text-align: left">{row.href ? <a href={row.href}>{row.name}</a> : row.name}</td>
+          <td style="text-align: left" set:html={row.type} />
+          <td style="text-align: left" set:html={row.description + inherited} />
+        </tr>
+      );
+    })}
+  </tbody>
+</table>

package/assets/docs-site/components/SiteTitle.astro

@@ -0,0 +1,43 @@
+---
+/**
+ * Site-title override: renders the title Starlight passes in, plus the documented package's version as an
+ * always-visible badge. `defineDocsSiteConfig` reads the version from the site's root package.json and defines it
+ * as `import.meta.env.DOCS_SITE_PACKAGE_VERSION`.
+ */
+const { siteTitle, siteTitleHref } = Astro.locals.starlightRoute;
+const version = `v${import.meta.env.DOCS_SITE_PACKAGE_VERSION}`;
+---
+
+<a href={siteTitleHref} class="site-title sl-flex">
+	<span translate="no">{siteTitle}</span>
+	<span class="site-version" translate="no">{version}</span>
+</a>
+
+<style>
+	@layer starlight.core {
+		.site-title {
+			align-items: center;
+			gap: 0.5rem;
+			font-size: var(--sl-text-h4);
+			font-weight: 600;
+			color: var(--sl-color-text-accent);
+			text-decoration: none;
+			white-space: nowrap;
+			min-width: 0;
+		}
+		span:first-child {
+			overflow: hidden;
+			text-overflow: ellipsis;
+		}
+		.site-version {
+			flex: none;
+			font-size: var(--sl-text-xs);
+			font-weight: 500;
+			line-height: 1.5;
+			color: var(--sl-color-gray-1);
+			background: var(--sl-color-gray-6);
+			padding: 0.05rem 0.45rem;
+			border-radius: 999px;
+		}
+	}
+</style>

package/assets/docs-site/components/TypeSignature.astro

@@ -0,0 +1,20 @@
+---
+import { Code } from '@astrojs/starlight/components';
+
+interface Props {
+  extends?: string[];
+  implements?: string[];
+  kind: 'class' | 'interface';
+  name: string;
+  typeParams?: string[];
+}
+
+const { kind, name, typeParams = [], extends: baseTypes = [], implements: implTypes = [] } = Astro.props;
+const typeParamsStr = typeParams.length > 0 ? `<${typeParams.join(', ')}>` : '';
+const extendsClause = baseTypes.length > 0 ? ` extends ${baseTypes.join(', ')}` : '';
+const implementsClause = implTypes.length > 0 ? ` implements ${implTypes.join(', ')}` : '';
+const signature = `export ${kind} ${name}${typeParamsStr}${extendsClause}${implementsClause}`;
+---
+
+<p><strong>Signature:</strong></p>
+<Code code={signature} lang="ts" />

package/assets/docs-site/styles/global.css

@@ -0,0 +1,221 @@
+:root {
+    --icon-size-med: 20px;
+
+    .starlight-aside--todo {
+        --sl-color-asides-text-accent: var(--sl-color-red-high);
+        --sl-color-asides-border: var(--sl-color-red);
+        background-color: var(--sl-color-red-low);
+    }
+}
+
+:root[data-theme='dark'] {
+    --sl-color-accent-high: hsl(255, 92%, 82%);
+    --sl-color-accent: hsl(258, 85%, 68%);
+    --sl-color-accent-low: hsl(260, 42%, 38%);
+    --sl-hero-color: hsla(258, 85%, 68%, 30%);
+
+    .starlight-aside--tutorial {
+        --sl-color-asides-text-accent: #157AFF;
+        --sl-color-asides-border: #21385a;
+        background-color: #1e314c;
+    }
+
+    .starlight-aside--remark {
+        --sl-color-asides-text-accent: #ea9f52;
+        --sl-color-asides-border: #af6b32;
+        background-color: #302418;
+    }
+
+    .starlight-aside--todo {
+        --sl-color-asides-text-accent: #d2c7ff;
+        --sl-color-asides-border: #291761;
+        background-color: #321c81;
+    }
+
+    .starlight-aside--note {
+        --sl-color-asides-text-accent: #85d4da;
+        --sl-color-asides-border: #5eb5bd;
+        background-color: #416263;
+    }
+}
+
+:root[data-theme='light'] {
+    --sl-color-accent-high: hsl(260, 55%, 32%);
+    --sl-color-accent: hsl(258, 66%, 55%);
+    --sl-color-accent-low: hsl(256, 82%, 84%);
+    --sl-hero-color: hsla(258, 66%, 55%, 25%);
+
+    .starlight-aside--tutorial {
+        --sl-color-asides-text-accent: #086DDD;
+        --sl-color-asides-border: #1e5a97;
+        background-color: #E6F0FB;
+    }
+
+    .starlight-aside--remark {
+        --sl-color-asides-text-accent: #EC7500;
+        --sl-color-asides-border: #7a390c;
+        background-color: #ffead5;
+    }
+
+    .starlight-aside--todo {
+        --sl-color-asides-text-accent: #6844dc;
+        --sl-color-asides-border: #5f3ad6;
+        background-color: #ddd5f8;
+    }
+
+    .starlight-aside--note {
+        --sl-color-asides-text-accent: #0d9a99;
+        --sl-color-asides-border: #21a6a5;
+        background-color: #cdeded;
+    }
+}
+
+/* Prevent horizontal scroll on mobile — any overflowing element (tables, code blocks,
+   long type names) is clipped at the page level. Individual containers like tables still
+   scroll horizontally via their own overflow:auto. Using `clip` instead of `hidden` avoids
+   creating a new scroll container. */
+html,
+body {
+    overflow-x: clip;
+}
+
+/* Widen content area for API reference tables */
+:root {
+    --sl-content-width: 65rem;
+    --sl-content-pad-x: 1rem;
+}
+
+/* Ensure long content scrolls horizontally within its container on mobile */
+.sl-markdown-content pre {
+    overflow-x: auto;
+}
+
+/* API reference tables */
+.sl-markdown-content table {
+    width: 100%;
+    display: block;
+    overflow-x: auto;
+}
+
+.sl-markdown-content table th,
+.sl-markdown-content table td {
+    text-align: left;
+}
+
+/* Hide graph view on API pages — not useful for reference docs */
+.slsg-graph-panel { /* cspell:disable-line */
+    display: none;
+}
+
+.group-label {
+    text-transform: none;
+}
+
+
+/* Hero style */
+[data-has-hero] .page {
+    height: 100%;
+    background:
+        linear-gradient(215deg, var(--sl-hero-color), transparent 40%),
+        radial-gradient(var(--sl-hero-color), transparent 40%) no-repeat -80vw -70vh / 150vw 200vh,
+        radial-gradient(var(--sl-hero-color), transparent 65%) no-repeat 50% calc(100% + 20rem) /
+			150rem 30rem;
+}
+
+[data-has-hero] header {
+    border-bottom: 1px solid transparent;
+    background-color: transparent;
+    -webkit-backdrop-filter: blur(16px);
+    backdrop-filter: blur(16px);
+}
+
+
+[data-has-hero] .hero > img {
+    filter: drop-shadow(0 0 3rem var(--sl-hero-color));
+}
+
+
+.svg-embed {
+    display: flex;
+}
+
+.starlight-aside {
+    --sl-color-asides-text-accent: var(--sl-color-red-high);
+    --sl-color-asides-border: var(--sl-color-red);
+    background-color: var(--sl-color-red-low);
+    border-radius: 8px;
+    border: unset;
+
+    .starlight-aside__content:has(hr) {
+        display: none;
+    }
+
+    svg {
+        width: var(--icon-size-med);
+        height: var(--icon-size-med);
+    }
+}
+
+.sl-separator {
+    display: flex;
+}
+
+.sl-separator:after {
+    content: "";
+    height: 2rem;
+    border-inline-end: 1px solid var(--sl-color-gray-5);
+}
+
+.obsidian-docs-link {
+    text-decoration: none;
+    color: var(--sl-color-accent);
+    font-weight: 600;
+    padding: 0 8px;
+}
+
+.code-location-icon {
+    display: flex;
+    margin-left: auto;
+}
+
+.code-location-text {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 0.5rem;
+    justify-content: flex-end;
+}
+
+h3, h4, h5 {
+    display: flex;
+}
+
+
+.content-badge {
+    color: white;
+    background-color: var(--badge-color, var(--sl-color-accent));
+    border-radius: 4px;
+    padding: 0.1rem 0.25rem;
+    font-weight: 800;
+    font-size: 0.75rem;
+}
+
+.content-badge--devtools {
+    --badge-color: var(--sl-color-accent);
+}
+.content-badge--css {
+    --badge-color: var(--sl-color-red);
+}
+.content-badge--js {
+    --badge-color: var(--sl-color-purple);
+}
+.content-badge--electron {
+    --badge-color: var(--sl-color-orange);
+}
+.content-badge--html {
+    --badge-color: var(--sl-color-blue);
+}
+
+.content-badge--warning {
+    --badge-color: var(--sl-color-red);
+}

package/dist/lib/cjs/build.cjs

@@ -166,4 +166,4 @@ function shouldKeepProjectFile(params) {
   buildCompileTypeScript,
   buildTemplates
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/build.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides utility functions to handle the build process for static assets and cleaning\n * the build output folder. It includes functions to copy static files to the distribution folder\n * and to remove the existing build output.\n */\n\nimport type {\n  PackageJson,\n  TsConfigJson\n} from 'type-fest';\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { trimStart } from '@mnaoumov/typescript-lib/string';\nimport {\n  cp,\n  glob,\n  rm\n} from 'node:fs/promises';\n\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { readdirPosix } from './fs.ts';\nimport { readJson } from './json.ts';\nimport {\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { readPackageJson } from './npm.ts';\nimport { resolveToolCommand } from './package-manager.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Removes the distribution folder and its contents.\n *\n * This function deletes the entire distribution folder to ensure a clean build environment.\n *\n * @returns A {@link Promise} that resolves when the folder has been removed.\n */\nexport async function buildClean(): Promise<void> {\n  await rm(RepoPaths.Dist, { force: true, recursive: true });\n}\n\n/**\n * Compiles the code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompile(): Promise<void> {\n  if (await npmRunOptional('build:compile:svelte') === NpmRunOptionalResult.Skipped) {\n    await buildCompileSvelte();\n  }\n  if (await npmRunOptional('build:compile:typescript') === NpmRunOptionalResult.Skipped) {\n    await buildCompileTypeScript();\n  }\n}\n\n/**\n * Compiles the Svelte code.\n *\n * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig\n * `include` patterns and filtering that list would never match: `include` lists TypeScript globs\n * (`./src/**\\/*.ts`, …), so no `.svelte` path can ever appear in it and the check would always be skipped.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project has Svelte files but does not declare `svelte-check`.\n */\nexport async function buildCompileSvelte(): Promise<void> {\n  const tsConfigPath = resolvePathFromRootSafe({ path: RepoPaths.TsConfigJson });\n  const tsConfig = await readJson<TsConfigJson>(tsConfigPath);\n  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {\n    cwd: resolvePathFromRootSafe({ path: RepoPaths.CurrentFolder }),\n    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]\n  }));\n\n  const [firstSvelteFile] = svelteFiles;\n\n  if (firstSvelteFile === undefined) {\n    getLibDebugger('build:buildCompileSvelte')('No Svelte files found in the project, skipping Svelte compilation');\n    return;\n  }\n\n  const packageJson = await readPackageJson();\n\n  if (!checkSvelteCheckDeclared(packageJson)) {\n    throw new Error(\n      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \\`${SVELTE_CHECK_PACKAGE_NAME}\\` is not declared in package.json.`\n        + ` Add \\`${SVELTE_CHECK_PACKAGE_NAME}\\` as a devDependency to type-check the Svelte code.`\n    );\n  }\n\n  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), '--tsconfig', RepoPaths.TsConfigJson]);\n}\n\n/**\n * Compiles the TypeScript code.\n *\n * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does\n * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}\n * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the\n * files we own, so the declarations we author are still fully validated.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project's own declarations fail validation.\n */\nexport async function buildCompileTypeScript(): Promise<void> {\n  await execFromRoot([...resolveToolCommand({ tool: 'tsc' }), '--build', '--force']);\n\n  if (!areProjectTypesValid()) {\n    throw new Error('TypeScript declaration validation failed.');\n  }\n}\n\n/**\n * Copies all template files from the templates folder to the `templates` folder within the\n * distribution folder.\n *\n * This function recursively reads the contents of the templates folder and copies each file to the\n * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the\n * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source\n * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as\n * `eslint.config.mts`), so an active config template can live in the repo under a name that the\n * corresponding tool does not auto-discover.\n *\n * @returns A {@link Promise} that resolves when all files have been copied.\n */\nexport async function buildTemplates(): Promise<void> {\n  for (const dirent of await readdirPosix(RepoPaths.Templates, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = trimStart({\n      $string: join(dirent.parentPath, dirent.name),\n      prefix: `${RepoPaths.Templates}/`\n    });\n    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;\n    await cp(join(RepoPaths.Templates, path), join(RepoPaths.DistTemplates, destinationPath));\n  }\n}\n\nconst TEMPLATE_FILE_SUFFIX = '.template';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\n\nconst SVELTE_CHECK_PACKAGE_NAME = 'svelte-check';\n\nconst SVELTE_FILE_PATTERNS = [\n  `${RepoPaths.AnyPath}/*.svelte`,\n  `${RepoPaths.AnyPath}/*.svelte.js`,\n  `${RepoPaths.AnyPath}/*.svelte.ts`\n];\n\n/**\n * `node_modules` must be listed explicitly: a tsconfig that sets `exclude` at all **replaces** TypeScript's\n * default `node_modules` exclusion, so it cannot be relied on to keep dependencies out of the glob.\n */\nconst SVELTE_FILE_EXCLUDE_PATTERNS = [\n  `${RepoPaths.AnyPath}/${RepoPaths.NodeModules}/${RepoPaths.AnyPath}`,\n  `${RepoPaths.AnyPath}/${RepoPaths.Dist}/${RepoPaths.AnyPath}`\n];\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Re-runs the project type-check in-memory with `skipLibCheck: false`, reporting only diagnostics\n * whose source file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @returns `true` when the project's own files have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nfunction areProjectTypesValid(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n  const { fileNames, options } = parseTsConfig(join(root, RepoPaths.TsConfigJson));\n\n  return checkProjectTypes({\n    options,\n    rootNames: fileNames,\n    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n  });\n}\n\n/**\n * Determines whether the project declares `svelte-check`.\n *\n * The declaration is read from `package.json` rather than probed in `node_modules/.bin`, because\n * {@link resolveToolCommand} deliberately falls back to the package manager's exec form for tools that have\n * no bin shim — the only way a locally installed tool resolves under yarn PnP. Treating a missing shim as a\n * missing tool would therefore break PnP projects.\n *\n * @param packageJson - The project's parsed `package.json`.\n * @returns `true` when `svelte-check` is declared as a regular, dev, or peer dependency.\n */\nfunction checkSvelteCheckDeclared(packageJson: PackageJson): boolean {\n  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies]\n    .some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== undefined);\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/build.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides utility functions to handle the build process for static assets and cleaning\n * the build output folder. It includes functions to copy static files to the distribution folder\n * and to remove the existing build output.\n */\n\nimport type {\n  PackageJson,\n  TsConfigJson\n} from 'type-fest';\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { join } from '@mnaoumov/typescript-lib/path';\nimport { trimStart } from '@mnaoumov/typescript-lib/string';\nimport {\n  cp,\n  glob,\n  rm\n} from 'node:fs/promises';\n\nimport {\n  checkProjectTypes,\n  parseTsConfig,\n  toCanonical\n} from './check-project-types.ts';\nimport { readdirPosix } from './fs.ts';\nimport { readJson } from './json.ts';\nimport {\n  npmRunOptional,\n  NpmRunOptionalResult\n} from './npm-run.ts';\nimport { readPackageJson } from './npm.ts';\nimport { resolveToolCommand } from './package-manager.ts';\nimport { RepoPaths } from './repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from './root.ts';\n\n/**\n * Removes the distribution folder and its contents.\n *\n * This function deletes the entire distribution folder to ensure a clean build environment.\n *\n * @returns A {@link Promise} that resolves when the folder has been removed.\n */\nexport async function buildClean(): Promise<void> {\n  await rm(RepoPaths.Dist, { force: true, recursive: true });\n}\n\n/**\n * Compiles the code.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n */\nexport async function buildCompile(): Promise<void> {\n  if (await npmRunOptional('build:compile:svelte') === NpmRunOptionalResult.Skipped) {\n    await buildCompileSvelte();\n  }\n  if (await npmRunOptional('build:compile:typescript') === NpmRunOptionalResult.Skipped) {\n    await buildCompileTypeScript();\n  }\n}\n\n/**\n * Compiles the Svelte code.\n *\n * The project's Svelte files are found by globbing the Svelte extensions directly. Globbing the tsconfig\n * `include` patterns and filtering that list would never match: `include` lists TypeScript globs\n * (`./src/**\\/*.ts`, …), so no `.svelte` path can ever appear in it and the check would always be skipped.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project has Svelte files but does not declare `svelte-check`.\n */\nexport async function buildCompileSvelte(): Promise<void> {\n  const tsConfigPath = resolvePathFromRootSafe({ path: RepoPaths.TsConfigJson });\n  const tsConfig = await readJson<TsConfigJson>(tsConfigPath);\n  const svelteFiles = await toArray(glob(SVELTE_FILE_PATTERNS, {\n    cwd: resolvePathFromRootSafe({ path: RepoPaths.CurrentFolder }),\n    exclude: [...SVELTE_FILE_EXCLUDE_PATTERNS, ...tsConfig.exclude ?? []]\n  }));\n\n  const [firstSvelteFile] = svelteFiles;\n\n  if (firstSvelteFile === undefined) {\n    getLibDebugger('build:buildCompileSvelte')('No Svelte files found in the project, skipping Svelte compilation');\n    return;\n  }\n\n  const packageJson = await readPackageJson();\n\n  if (!checkSvelteCheckDeclared(packageJson)) {\n    throw new Error(\n      `Found Svelte file(s) in the project (e.g. ${firstSvelteFile}), but \\`${SVELTE_CHECK_PACKAGE_NAME}\\` is not declared in package.json.`\n        + ` Add \\`${SVELTE_CHECK_PACKAGE_NAME}\\` as a devDependency to type-check the Svelte code.`\n    );\n  }\n\n  await execFromRoot([...resolveToolCommand({ tool: SVELTE_CHECK_PACKAGE_NAME }), '--tsconfig', RepoPaths.TsConfigJson]);\n}\n\n/**\n * Compiles the TypeScript code.\n *\n * The general `tsc` pass runs with `skipLibCheck: true` (configured in `tsconfig.json`) so it does\n * not fail on broken upstream `.d.ts` files we do not control. Afterwards, {@link areProjectTypesValid}\n * re-runs the type-check in-memory with `skipLibCheck: false`, reporting only diagnostics from the\n * files we own, so the declarations we author are still fully validated.\n *\n * @returns A {@link Promise} that resolves when the code compiles successfully.\n * @throws If the project's own declarations fail validation.\n */\nexport async function buildCompileTypeScript(): Promise<void> {\n  await execFromRoot([...resolveToolCommand({ tool: 'tsc' }), '--build', '--force']);\n\n  if (!areProjectTypesValid()) {\n    throw new Error('TypeScript declaration validation failed.');\n  }\n}\n\n/**\n * Copies all template files from the templates folder to the `templates` folder within the\n * distribution folder.\n *\n * This function recursively reads the contents of the templates folder and copies each file to the\n * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the\n * templates from `node_modules/@mnaoumov/typescript-dev-toolkit/dist/templates`. A trailing `.template` on a source\n * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as\n * `eslint.config.mts`), so an active config template can live in the repo under a name that the\n * corresponding tool does not auto-discover.\n *\n * @returns A {@link Promise} that resolves when all files have been copied.\n */\nexport async function buildTemplates(): Promise<void> {\n  for (const dirent of await readdirPosix(RepoPaths.Templates, { recursive: true, withFileTypes: true })) {\n    if (!dirent.isFile()) {\n      continue;\n    }\n\n    const path = trimStart({\n      $string: join(dirent.parentPath, dirent.name),\n      prefix: `${RepoPaths.Templates}/`\n    });\n    const destinationPath = path.endsWith(TEMPLATE_FILE_SUFFIX) ? path.slice(0, -TEMPLATE_FILE_SUFFIX.length) : path;\n    await cp(join(RepoPaths.Templates, path), join(RepoPaths.DistTemplates, destinationPath));\n  }\n}\n\nconst TEMPLATE_FILE_SUFFIX = '.template';\n\nconst NODE_MODULES_SEGMENT = '/node_modules/';\n\nconst SVELTE_CHECK_PACKAGE_NAME = 'svelte-check';\n\nconst SVELTE_FILE_PATTERNS = [\n  `${RepoPaths.AnyPath}/*.svelte`,\n  `${RepoPaths.AnyPath}/*.svelte.js`,\n  `${RepoPaths.AnyPath}/*.svelte.ts`\n];\n\n/**\n * `node_modules` must be listed explicitly: a tsconfig that sets `exclude` at all **replaces** TypeScript's\n * default `node_modules` exclusion, so it cannot be relied on to keep dependencies out of the glob.\n */\nconst SVELTE_FILE_EXCLUDE_PATTERNS = [\n  `${RepoPaths.AnyPath}/${RepoPaths.NodeModules}/${RepoPaths.AnyPath}`,\n  `${RepoPaths.AnyPath}/${RepoPaths.Dist}/${RepoPaths.AnyPath}`\n];\n\n/**\n * Parameters for {@link shouldKeepProjectFile}.\n */\ninterface ShouldKeepProjectFileParams {\n  /**\n   * Absolute path of the file under consideration.\n   */\n  readonly fileName: string;\n\n  /**\n   * Absolute (canonical) path of the project root.\n   */\n  readonly rootCanonical: string;\n}\n\n/**\n * Re-runs the project type-check in-memory with `skipLibCheck: false`, reporting only diagnostics\n * whose source file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @returns `true` when the project's own files have no type errors, `false` otherwise.\n * @throws If the root folder cannot be found.\n */\nfunction areProjectTypesValid(): boolean {\n  const root = getRootFolder();\n\n  if (!root) {\n    throw new Error('Could not find root folder');\n  }\n\n  const rootCanonical = toCanonical(root);\n  const { fileNames, options } = parseTsConfig(join(root, RepoPaths.TsConfigJson));\n\n  return checkProjectTypes({\n    options,\n    rootNames: fileNames,\n    shouldKeepFile: (fileName) => shouldKeepProjectFile({ fileName, rootCanonical })\n  });\n}\n\n/**\n * Determines whether the project declares `svelte-check`.\n *\n * The declaration is read from `package.json` rather than probed in `node_modules/.bin`, because\n * {@link resolveToolCommand} deliberately falls back to the package manager's exec form for tools that have\n * no bin shim — the only way a locally installed tool resolves under yarn PnP. Treating a missing shim as a\n * missing tool would therefore break PnP projects.\n *\n * @param packageJson - The project's parsed `package.json`.\n * @returns `true` when `svelte-check` is declared as a regular, dev, or peer dependency.\n */\nfunction checkSvelteCheckDeclared(packageJson: PackageJson): boolean {\n  return [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies]\n    .some((dependencies) => dependencies?.[SVELTE_CHECK_PACKAGE_NAME] !== undefined);\n}\n\n/**\n * Determines whether a file belongs to the project (under the root folder, outside `node_modules`).\n *\n * @param params - The parameters for the check.\n * @returns `true` when the file belongs to the project.\n */\nfunction shouldKeepProjectFile(params: ShouldKeepProjectFileParams): boolean {\n  const { fileName, rootCanonical } = params;\n  return fileName.startsWith(`${rootCanonical}/`) && !fileName.includes(NODE_MODULES_SEGMENT);\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/build.d.cts

@@ -49,7 +49,7 @@ export declare function buildCompileTypeScript(): Promise<void>;
  *
  * This function recursively reads the contents of the templates folder and copies each file to the
  * corresponding path under {@link RepoPaths.DistTemplates}, so consumers can copy the
- * templates from `node_modules/obsidian-dev-utils/dist/templates`. A trailing `.template` on a source
+ * templates from `node_modules/@mnaoumov/typescript-dev-toolkit/dist/templates`. A trailing `.template` on a source
  * file name is stripped in the destination (e.g. `eslint.config.mts.template` is copied as
  * `eslint.config.mts`), so an active config template can live in the repo under a name that the
  * corresponding tool does not auto-discover.

package/dist/lib/cjs/commitlint-config.cjs

@@ -56,16 +56,29 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var commitlint_config_exports = {};
 __export(commitlint_config_exports, {
+  commitlintConfig: () => commitlintConfig,
   obsidianDevUtilsConfig: () => obsidianDevUtilsConfig
 });
 module.exports = __toCommonJS(commitlint_config_exports);
 var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_node_module = require('node:module');
 var import_commitlint_forbidden_patterns = require('./commitlint-forbidden-patterns.cjs');
 var import_commitlint_spellcheck_header = require('./commitlint-spellcheck-header.cjs');
+var __import_meta_url = globalThis["import.meta.url"] ?? (function getCjsImportMetaUrl() {
+  if (typeof __filename === "string") {
+    const localRequire = require;
+    const url = localRequire("node:url");
+    if (typeof url.pathToFileURL === "function") {
+      return url.pathToFileURL(__filename).href;
+    }
+  }
+  return globalThis.location?.href ?? "";
+})();
 const ERROR_SEVERITY_LEVEL = 2;
 const ERROR_SEVERITY = (0, import_object_utils.castTo)(ERROR_SEVERITY_LEVEL);
-const obsidianDevUtilsConfig = {
-  extends: ["@commitlint/config-conventional"],
+const CONFIG_CONVENTIONAL_PATH = (0, import_node_module.createRequire)(__import_meta_url).resolve("@commitlint/config-conventional");
+const commitlintConfig = {
+  extends: [CONFIG_CONVENTIONAL_PATH],
   // ONE plugin object, never two: `@commitlint/load` stores every inline plugin under the same `local` key, so a
   // second object silently replaces the first and its rule then fails as "Found rules without implementation".
   plugins: [
@@ -81,8 +94,10 @@ const obsidianDevUtilsConfig = {
     [import_commitlint_spellcheck_header.SPELLCHECK_HEADER_RULE_NAME]: [ERROR_SEVERITY, "always"]
   }
 };
+const obsidianDevUtilsConfig = commitlintConfig;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  commitlintConfig,
   obsidianDevUtilsConfig
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21taXRsaW50LWNvbmZpZy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJ2YXIgX19pbXBvcnRfbWV0YV91cmwgPSBnbG9iYWxUaGlzWydpbXBvcnQubWV0YS51cmwnXSA/PyAoZnVuY3Rpb24gZ2V0Q2pzSW1wb3J0TWV0YVVybCgpIHtcbiAgaWYgKHR5cGVvZiBfX2ZpbGVuYW1lID09PSAnc3RyaW5nJykge1xuICAgIGNvbnN0IGxvY2FsUmVxdWlyZSA9IHJlcXVpcmU7XG4gICAgY29uc3QgdXJsID0gbG9jYWxSZXF1aXJlKCdub2RlOnVybCcpO1xuICAgIGlmICh0eXBlb2YgdXJsLnBhdGhUb0ZpbGVVUkwgPT09ICdmdW5jdGlvbicpIHtcbiAgICAgIHJldHVybiB1cmwucGF0aFRvRmlsZVVSTChfX2ZpbGVuYW1lKS5ocmVmO1xuICAgIH1cbiAgfVxuXG4gIC8vIEZhbGxiYWNrIHRvIHRoZSBwYWdlIFVSTCwgb3IgYW4gZW1wdHkgc3RyaW5nIGlmIHRoZSBlbnZpcm9ubWVudCBpcyB1bmtub3duLlxuICByZXR1cm4gZ2xvYmFsVGhpcy5sb2NhdGlvbj8uaHJlZiA/PyAnJztcbn0pKCk7XG4vKipcbiAqIEBmaWxlXG4gKlxuICogU2hhcmVkIGNvbW1pdGxpbnQgY29uZmlndXJhdGlvbiBmb3IgQ29udmVudGlvbmFsIENvbW1pdHMuXG4gKi9cblxuLyogdjggaWdub3JlIHN0YXJ0IC0tIERlY2xhcmF0aXZlIGNvbW1pdGxpbnQgY29uZmlndXJhdGlvbjsgY29ycmVjdG5lc3MgaXMgdmVyaWZpZWQgYnkgcnVubmluZyBjb21taXRsaW50LCBub3QgdW5pdCB0ZXN0cy4gKi9cblxuaW1wb3J0IHR5cGUge1xuICBSdWxlQ29uZmlnU2V2ZXJpdHksXG4gIFVzZXJDb25maWdcbn0gZnJvbSAnQGNvbW1pdGxpbnQvdHlwZXMnO1xuXG5pbXBvcnQgeyBjYXN0VG8gfSBmcm9tICdAbW5hb3Vtb3YvdHlwZXNjcmlwdC1saWIvb2JqZWN0LXV0aWxzJztcbmltcG9ydCB7IGNyZWF0ZVJlcXVpcmUgfSBmcm9tICdub2RlOm1vZHVsZSc7XG5cbmltcG9ydCB7XG4gIGZvcmJpZGRlblBhdHRlcm5zUGx1Z2luLFxuICBOT19GT1JCSURERU5fUEFUVEVSTlNfUlVMRV9OQU1FXG59IGZyb20gJy4vY29tbWl0bGludC1mb3JiaWRkZW4tcGF0dGVybnMudHMnO1xuaW1wb3J0IHtcbiAgU1BFTExDSEVDS19IRUFERVJfUlVMRV9OQU1FLFxuICBzcGVsbGNoZWNrSGVhZGVyUGx1Z2luXG59IGZyb20gJy4vY29tbWl0bGludC1zcGVsbGNoZWNrLWhlYWRlci50cyc7XG5cbi8qXG4gKiBgUnVsZUNvbmZpZ1NldmVyaXR5LkVycm9yYC4gVGhlIGVudW0gbGl2ZXMgaW4gYSBwYWNrYWdlIHRoaXMgbGlicmFyeSBvbmx5IGhhcyBhcyBhIGRldkRlcGVuZGVuY3ksIHNvIGl0cyB2YWx1ZSBjYW5ub3QgYmUgaW1wb3J0ZWQgYXQgcnVudGltZS5cbiAqL1xuY29uc3QgRVJST1JfU0VWRVJJVFlfTEVWRUwgPSAyO1xuY29uc3QgRVJST1JfU0VWRVJJVFkgPSBjYXN0VG88UnVsZUNvbmZpZ1NldmVyaXR5PihFUlJPUl9TRVZFUklUWV9MRVZFTCk7XG5cbi8qKlxuICogVGhlIGFic29sdXRlIHBhdGggb2YgYEBjb21taXRsaW50L2NvbmZpZy1jb252ZW50aW9uYWxgJ3MgZW50cnksIHJlc29sdmVkIGZyb20gdGhpcyBtb2R1bGUuIENvbW1pdGxpbnQgcmVzb2x2ZXMgYVxuICogYmFyZSBgZXh0ZW5kc2AgbmFtZSBmcm9tIHRoZSBjb25zdW1lcidzIHdvcmtpbmcgZGlyZWN0b3J5LCB3aGljaCBmaW5kcyB0aGlzIHBhY2thZ2UncyBvd24gZGVwZW5kZW5jeSBvbmx5IHdoZW4gdGhlXG4gKiBwYWNrYWdlIG1hbmFnZXIgaGFwcGVuZWQgdG8gaG9pc3QgaXQ7IGFuIGFic29sdXRlIHBhdGggZmluZHMgaXQgd2hlcmV2ZXIgaXQgd2FzIGluc3RhbGxlZC5cbiAqL1xuY29uc3QgQ09ORklHX0NPTlZFTlRJT05BTF9QQVRIID0gY3JlYXRlUmVxdWlyZShpbXBvcnQubWV0YS51cmwpLnJlc29sdmUoJ0Bjb21taXRsaW50L2NvbmZpZy1jb252ZW50aW9uYWwnKTtcblxuLyoqXG4gKiBDb21taXRsaW50IGNvbmZpZ3VyYXRpb24gZXh0ZW5kaW5nIGBAY29tbWl0bGludC9jb25maWctY29udmVudGlvbmFsYCwgcGx1cyBhIHJ1bGUgcmVmdXNpbmcgYSBtZXNzYWdlIHdob3NlXG4gKiBoZWFkZXIsIGJvZHkgb3IgZm9vdGVyIG1hdGNoZXMgdGhlIHVucHVibGlzaGVkIGZvcmJpZGRlbi1wYXR0ZXJucyBsaXN0IChhIG5vLW9wIHdoZW4gbm9uZSBpcyBjb25maWd1cmVkKSwgYW5kXG4gKiBhIHJ1bGUgc3BlbGxjaGVja2luZyB0aGUgaGVhZGVyIHRoZSB3YXkgdGhlIHJlbGVhc2Ugc3BlbGxjaGVja3MgdGhlIGNoYW5nZWxvZyBidWxsZXQgaXQgYmVjb21lcyAoYSBuby1vcCBpbiBhXG4gKiBwcm9qZWN0IHdpdGggbm8gYHNwZWxsY2hlY2tgIHNjcmlwdCkuXG4gKi9cbmV4cG9ydCBjb25zdCBjb21taXRsaW50Q29uZmlnOiBVc2VyQ29uZmlnID0ge1xuICBleHRlbmRzOiBbQ09ORklHX0NPTlZFTlRJT05BTF9QQVRIXSxcbiAgLy8gT05FIHBsdWdpbiBvYmplY3QsIG5ldmVyIHR3bzogYEBjb21taXRsaW50L2xvYWRgIHN0b3JlcyBldmVyeSBpbmxpbmUgcGx1Z2luIHVuZGVyIHRoZSBzYW1lIGBsb2NhbGAga2V5LCBzbyBhXG4gIC8vIHNlY29uZCBvYmplY3Qgc2lsZW50bHkgcmVwbGFjZXMgdGhlIGZpcnN0IGFuZCBpdHMgcnVsZSB0aGVuIGZhaWxzIGFzIFwiRm91bmQgcnVsZXMgd2l0aG91dCBpbXBsZW1lbnRhdGlvblwiLlxuICBwbHVnaW5zOiBbXG4gICAge1xuICAgICAgcnVsZXM6IHtcbiAgICAgICAgLi4uZm9yYmlkZGVuUGF0dGVybnNQbHVnaW4ucnVsZXMsXG4gICAgICAgIC4uLnNwZWxsY2hlY2tIZWFkZXJQbHVnaW4ucnVsZXNcbiAgICAgIH1cbiAgICB9XG4gIF0sXG4gIHJ1bGVzOiB7XG4gICAgW05PX0ZPUkJJRERFTl9QQVRURVJOU19SVUxFX05BTUVdOiBbRVJST1JfU0VWRVJJVFksICdhbHdheXMnXSxcbiAgICBbU1BFTExDSEVDS19IRUFERVJfUlVMRV9OQU1FXTogW0VSUk9SX1NFVkVSSVRZLCAnYWx3YXlzJ11cbiAgfVxufTtcblxuLyoqXG4gKiBUaGUgcHJldmlvdXMgbmFtZSBvZiB7QGxpbmsgY29tbWl0bGludENvbmZpZ30uXG4gKlxuICogQGRlcHJlY2F0ZWQgVXNlIHtAbGluayBjb21taXRsaW50Q29uZmlnfS4gVGhpcyBhbGlhcyBpcyByZW1vdmVkIGluIHRoZSBuZXh0IG1ham9yLlxuICovXG5leHBvcnQgY29uc3Qgb2JzaWRpYW5EZXZVdGlsc0NvbmZpZzogVXNlckNvbmZpZyA9IGNvbW1pdGxpbnRDb25maWc7XG5cbi8qIHY4IGlnbm9yZSBzdG9wICovXG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBeUJBLDBCQUF1QjtBQUN2Qix5QkFBOEI7QUFFOUIsMkNBR087QUFDUCwwQ0FHTztBQW5DUCxJQUFJLG9CQUFvQixXQUFXLGlCQUFpQixNQUFNLFNBQVMsc0JBQXNCO0FBQ3ZGLE1BQUksT0FBTyxlQUFlLFVBQVU7QUFDbEMsVUFBTSxlQUFlO0FBQ3JCLFVBQU0sTUFBTSxhQUFhLFVBQVU7QUFDbkMsUUFBSSxPQUFPLElBQUksa0JBQWtCLFlBQVk7QUFDM0MsYUFBTyxJQUFJLGNBQWMsVUFBVSxFQUFFO0FBQUEsSUFDdkM7QUFBQSxFQUNGO0FBR0EsU0FBTyxXQUFXLFVBQVUsUUFBUTtBQUN0QyxHQUFHO0FBNkJILE1BQU0sdUJBQXVCO0FBQzdCLE1BQU0scUJBQWlCLDRCQUEyQixvQkFBb0I7QUFPdEUsTUFBTSwrQkFBMkIsa0NBQWMsaUJBQWUsRUFBRSxRQUFRLGlDQUFpQztBQVFsRyxNQUFNLG1CQUErQjtBQUFBLEVBQzFDLFNBQVMsQ0FBQyx3QkFBd0I7QUFBQTtBQUFBO0FBQUEsRUFHbEMsU0FBUztBQUFBLElBQ1A7QUFBQSxNQUNFLE9BQU87QUFBQSxRQUNMLEdBQUcsNkRBQXdCO0FBQUEsUUFDM0IsR0FBRywyREFBdUI7QUFBQSxNQUM1QjtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQUEsRUFDQSxPQUFPO0FBQUEsSUFDTCxDQUFDLG9FQUErQixHQUFHLENBQUMsZ0JBQWdCLFFBQVE7QUFBQSxJQUM1RCxDQUFDLCtEQUEyQixHQUFHLENBQUMsZ0JBQWdCLFFBQVE7QUFBQSxFQUMxRDtBQUNGO0FBT08sTUFBTSx5QkFBcUM7IiwibmFtZXMiOltdfQ==