pi-umbra 0.1.4 → 0.2.0

package/node_modules/@shikijs/core/dist/textmate.d.mts

@@ -0,0 +1 @@
+export * from "@shikijs/vscode-textmate";

package/node_modules/@shikijs/core/dist/textmate.mjs

@@ -0,0 +1,2 @@
+export * from "@shikijs/vscode-textmate";
+export {};

package/node_modules/@shikijs/core/dist/types.d.mts

@@ -0,0 +1 @@
+export * from "@shikijs/types";

package/node_modules/@shikijs/core/dist/types.mjs

@@ -0,0 +1,2 @@
+export * from "@shikijs/types";
+export {};

package/node_modules/@shikijs/core/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@shikijs/core",
+  "type": "module",
+  "version": "4.4.3",
+  "description": "Core of Shiki",
+  "author": "Pine Wu <octref@gmail.com>; Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/shikijs/shiki#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shikijs/shiki.git",
+    "directory": "packages/core"
+  },
+  "bugs": "https://github.com/shikijs/shiki/issues",
+  "keywords": [
+    "shiki"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./textmate": {
+      "types": "./dist/textmate.d.mts",
+      "default": "./dist/textmate.mjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.mts"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json",
+    "./*": "./dist/*"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "typesVersions": {
+    "*": {
+      "types": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@shikijs/vscode-textmate": "^10.0.2",
+    "@types/hast": "^3.0.5",
+    "hast-util-to-html": "^9.0.5",
+    "@shikijs/primitive": "4.4.3",
+    "@shikijs/types": "4.4.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest"
+  }
+}

package/node_modules/@shikijs/engine-javascript/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Pine Wu
+Copyright (c) 2023 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@shikijs/engine-javascript/README.md

@@ -0,0 +1,9 @@
+# @shikijs/engine-javascript
+
+Engine for Shiki using JavaScript's native RegExp. Uses [Oniguruma-To-ES](https://github.com/slevithan/oniguruma-to-es) to transpile regex syntax and behavior.
+
+[Documentation](https://shiki.style/guide/regex-engines)
+
+## License
+
+MIT

package/node_modules/@shikijs/engine-javascript/dist/engine-compile-Bdn9ihA2.d.mts

@@ -0,0 +1,63 @@
+import { ToRegExpOptions } from "oniguruma-to-es";
+import { PatternScanner, RegexEngine, RegexEngineString } from "@shikijs/types";
+import { IOnigMatch } from "@shikijs/vscode-textmate";
+//#region src/scanner.d.ts
+interface JavaScriptRegexScannerOptions {
+  /**
+   * Whether to allow invalid regex patterns.
+   *
+   * @default false
+   */
+  forgiving?: boolean;
+  /**
+   * Cache for regex patterns.
+   */
+  cache?: Map<string, RegExp | Error> | null;
+  /**
+   * Custom pattern to RegExp constructor.
+   *
+   * By default `oniguruma-to-es` is used.
+   */
+  regexConstructor?: (pattern: string) => RegExp;
+}
+declare class JavaScriptScanner implements PatternScanner {
+  patterns: (string | RegExp)[];
+  options: JavaScriptRegexScannerOptions;
+  regexps: (RegExp | null)[];
+  constructor(patterns: (string | RegExp)[], options?: JavaScriptRegexScannerOptions);
+  findNextMatchSync(string: string | RegexEngineString, startPosition: number, _options: number): IOnigMatch | null;
+}
+//#endregion
+//#region src/engine-compile.d.ts
+interface JavaScriptRegexEngineOptions extends JavaScriptRegexScannerOptions {
+  /**
+   * The target ECMAScript version.
+   *
+   * Oniguruma-To-ES uses RegExp features from later versions of ECMAScript to add support for a
+   * few more grammars. If using target `ES2024` or later, the RegExp `v` flag is used which
+   * requires Node.js 20+ or Chrome 112+.
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicodeSets
+   *
+   * For maximum compatibility, you can set it to `ES2018` which uses the RegExp `u` flag.
+   *
+   * Set to `auto` to automatically detect the latest version supported by the environment.
+   *
+   * @default 'auto'
+   */
+  target?: 'auto' | 'ES2025' | 'ES2024' | 'ES2018';
+}
+/**
+ * The default regex constructor for the JavaScript RegExp engine.
+ */
+declare function defaultJavaScriptRegexConstructor(pattern: string, options?: ToRegExpOptions): RegExp;
+/**
+ * Use the modern JavaScript RegExp engine to implement the OnigScanner.
+ *
+ * As Oniguruma supports some features that can't be emulated using native JavaScript regexes, some
+ * patterns are not supported. Errors will be thrown when parsing TextMate grammars with
+ * unsupported patterns, and when the grammar includes patterns that use invalid Oniguruma syntax.
+ * Set `forgiving` to `true` to ignore these errors and skip any unsupported or invalid patterns.
+ */
+declare function createJavaScriptRegexEngine(options?: JavaScriptRegexEngineOptions): RegexEngine;
+//#endregion
+export { JavaScriptScanner as a, JavaScriptRegexScannerOptions as i, createJavaScriptRegexEngine as n, defaultJavaScriptRegexConstructor as r, JavaScriptRegexEngineOptions as t };

package/node_modules/@shikijs/engine-javascript/dist/engine-compile.d.mts

@@ -0,0 +1,2 @@
+import { n as createJavaScriptRegexEngine, r as defaultJavaScriptRegexConstructor, t as JavaScriptRegexEngineOptions } from "./engine-compile-Bdn9ihA2.mjs";
+export { JavaScriptRegexEngineOptions, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/node_modules/@shikijs/engine-javascript/dist/engine-compile.mjs

@@ -0,0 +1,47 @@
+import { t as JavaScriptScanner } from "./scanner-DX8LRFGE.mjs";
+import { toRegExp } from "oniguruma-to-es";
+//#region src/engine-compile.ts
+/**
+* The default regex constructor for the JavaScript RegExp engine.
+*/
+function defaultJavaScriptRegexConstructor(pattern, options) {
+	return toRegExp(pattern, {
+		global: true,
+		hasIndices: true,
+		lazyCompileLength: 3e3,
+		rules: {
+			allowOrphanBackrefs: true,
+			asciiWordBoundaries: true,
+			captureGroup: true,
+			recursionLimit: 5,
+			singleline: true
+		},
+		...options
+	});
+}
+/**
+* Use the modern JavaScript RegExp engine to implement the OnigScanner.
+*
+* As Oniguruma supports some features that can't be emulated using native JavaScript regexes, some
+* patterns are not supported. Errors will be thrown when parsing TextMate grammars with
+* unsupported patterns, and when the grammar includes patterns that use invalid Oniguruma syntax.
+* Set `forgiving` to `true` to ignore these errors and skip any unsupported or invalid patterns.
+*/
+function createJavaScriptRegexEngine(options = {}) {
+	const _options = {
+		target: "auto",
+		cache: /* @__PURE__ */ new Map(),
+		...options
+	};
+	_options.regexConstructor ||= (pattern) => defaultJavaScriptRegexConstructor(pattern, { target: _options.target });
+	return {
+		createScanner(patterns) {
+			return new JavaScriptScanner(patterns, _options);
+		},
+		createString(s) {
+			return { content: s };
+		}
+	};
+}
+//#endregion
+export { createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/node_modules/@shikijs/engine-javascript/dist/engine-raw.d.mts

@@ -0,0 +1,12 @@
+import { RegexEngine } from "@shikijs/types";
+//#region src/engine-raw.d.ts
+/**
+ * Raw JavaScript regex engine that only supports precompiled grammars.
+ *
+ * This further simplifies the engine by excluding the regex compilation step.
+ *
+ * Zero dependencies.
+ */
+declare function createJavaScriptRawEngine(): RegexEngine;
+//#endregion
+export { createJavaScriptRawEngine };

package/node_modules/@shikijs/engine-javascript/dist/engine-raw.mjs

@@ -0,0 +1,27 @@
+import { t as JavaScriptScanner } from "./scanner-DX8LRFGE.mjs";
+//#region src/engine-raw.ts
+/**
+* Raw JavaScript regex engine that only supports precompiled grammars.
+*
+* This further simplifies the engine by excluding the regex compilation step.
+*
+* Zero dependencies.
+*/
+function createJavaScriptRawEngine() {
+	const options = {
+		cache: /* @__PURE__ */ new Map(),
+		regexConstructor: () => {
+			throw new Error("JavaScriptRawEngine: only support precompiled grammar");
+		}
+	};
+	return {
+		createScanner(patterns) {
+			return new JavaScriptScanner(patterns, options);
+		},
+		createString(s) {
+			return { content: s };
+		}
+	};
+}
+//#endregion
+export { createJavaScriptRawEngine };

package/node_modules/@shikijs/engine-javascript/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { a as JavaScriptScanner, i as JavaScriptRegexScannerOptions, n as createJavaScriptRegexEngine, r as defaultJavaScriptRegexConstructor, t as JavaScriptRegexEngineOptions } from "./engine-compile-Bdn9ihA2.mjs";
+import { createJavaScriptRawEngine } from "./engine-raw.mjs";
+export { JavaScriptRegexEngineOptions, JavaScriptRegexScannerOptions, JavaScriptScanner, createJavaScriptRawEngine, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/node_modules/@shikijs/engine-javascript/dist/index.mjs

@@ -0,0 +1,4 @@
+import { t as JavaScriptScanner } from "./scanner-DX8LRFGE.mjs";
+import { createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor } from "./engine-compile.mjs";
+import { createJavaScriptRawEngine } from "./engine-raw.mjs";
+export { JavaScriptScanner, createJavaScriptRawEngine, createJavaScriptRegexEngine, defaultJavaScriptRegexConstructor };

package/node_modules/@shikijs/engine-javascript/dist/scanner-DX8LRFGE.mjs

@@ -0,0 +1,77 @@
+//#region src/scanner.ts
+const MAX = 4294967295;
+var JavaScriptScanner = class {
+	patterns;
+	options;
+	regexps;
+	constructor(patterns, options = {}) {
+		this.patterns = patterns;
+		this.options = options;
+		const { forgiving = false, cache, regexConstructor } = options;
+		if (!regexConstructor) throw new Error("Option `regexConstructor` is not provided");
+		this.regexps = patterns.map((p) => {
+			if (typeof p !== "string") return p;
+			const cached = cache?.get(p);
+			if (cached) {
+				if (cached instanceof RegExp) return cached;
+				if (forgiving) return null;
+				throw cached;
+			}
+			try {
+				const regex = regexConstructor(p);
+				cache?.set(p, regex);
+				return regex;
+			} catch (e) {
+				cache?.set(p, e);
+				if (forgiving) return null;
+				throw e;
+			}
+		});
+	}
+	findNextMatchSync(string, startPosition, _options) {
+		const str = typeof string === "string" ? string : string.content;
+		const pending = [];
+		function toResult(index, match, offset = 0) {
+			return {
+				index,
+				captureIndices: match.indices.map((indice) => {
+					if (indice == null) return {
+						start: MAX,
+						end: MAX,
+						length: 0
+					};
+					return {
+						start: indice[0] + offset,
+						end: indice[1] + offset,
+						length: indice[1] - indice[0]
+					};
+				})
+			};
+		}
+		for (let i = 0; i < this.regexps.length; i++) {
+			const regexp = this.regexps[i];
+			if (!regexp) continue;
+			try {
+				regexp.lastIndex = startPosition;
+				const match = regexp.exec(str);
+				if (!match) continue;
+				if (match.index === startPosition) return toResult(i, match, 0);
+				pending.push([
+					i,
+					match,
+					0
+				]);
+			} catch (e) {
+				if (this.options.forgiving) continue;
+				throw e;
+			}
+		}
+		if (pending.length) {
+			const minIndex = Math.min(...pending.map((m) => m[1].index));
+			for (const [i, match, offset] of pending) if (match.index === minIndex) return toResult(i, match, offset);
+		}
+		return null;
+	}
+};
+//#endregion
+export { JavaScriptScanner as t };

package/node_modules/@shikijs/engine-javascript/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@shikijs/engine-javascript",
+  "type": "module",
+  "version": "4.4.3",
+  "description": "Engine for Shiki using JavaScript's native RegExp",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/shikijs/shiki#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shikijs/shiki.git",
+    "directory": "packages/engine-javascript"
+  },
+  "bugs": "https://github.com/shikijs/shiki/issues",
+  "keywords": [
+    "shiki",
+    "shiki-engine"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./raw": "./dist/engine-raw.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@shikijs/vscode-textmate": "^10.0.2",
+    "oniguruma-to-es": "^4.3.6",
+    "@shikijs/types": "4.4.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  }
+}

package/node_modules/@shikijs/engine-oniguruma/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Pine Wu
+Copyright (c) 2023 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@shikijs/engine-oniguruma/README.md

@@ -0,0 +1,9 @@
+# @shikijs/engine-oniguruma
+
+Engine for Shiki using Oniguruma RegExp engine in WebAssembly.
+
+[Documentation](https://shiki.style/guide/regex-engines)
+
+## License
+
+MIT

package/node_modules/@shikijs/engine-oniguruma/dist/chunk-index.d.d.mts

@@ -0,0 +1,70 @@
+interface IOnigCaptureIndex {
+    start: number;
+    end: number;
+    length: number;
+}
+interface IOnigMatch {
+    index: number;
+    captureIndices: IOnigCaptureIndex[];
+}
+declare const enum FindOption {
+    None = 0,
+    /**
+     * equivalent of ONIG_OPTION_NOT_BEGIN_STRING: (str) isn't considered as begin of string (* fail \A)
+     */
+    NotBeginString = 1,
+    /**
+     * equivalent of ONIG_OPTION_NOT_END_STRING: (end) isn't considered as end of string (* fail \z, \Z)
+     */
+    NotEndString = 2,
+    /**
+     * equivalent of ONIG_OPTION_NOT_BEGIN_POSITION: (start) isn't considered as start position of search (* fail \G)
+     */
+    NotBeginPosition = 4,
+    /**
+     * used for debugging purposes.
+     */
+    DebugCall = 8
+}
+interface OnigScanner {
+    findNextMatchSync(string: string | OnigString, startPosition: number, options: OrMask<FindOption>): IOnigMatch | null;
+    dispose?(): void;
+}
+interface OnigString {
+    readonly content: string;
+    dispose?(): void;
+}
+
+/**
+ * A union of given const enum values.
+*/
+type OrMask<T extends number> = number;
+
+//#region src/utils.d.ts
+type Awaitable<T> = T | Promise<T>;
+//#endregion
+//#region src/engines.d.ts
+interface PatternScanner extends OnigScanner {}
+interface RegexEngineString extends OnigString {}
+/**
+ * Engine for RegExp matching and scanning.
+ */
+interface RegexEngine {
+  createScanner: (patterns: (string | RegExp)[]) => PatternScanner;
+  createString: (s: string) => RegexEngineString;
+}
+interface WebAssemblyInstantiator {
+  (importObject: Record<string, Record<string, WebAssembly.ImportValue>> | undefined): Promise<WebAssemblyInstance>;
+}
+type WebAssemblyInstance = WebAssembly.WebAssemblyInstantiatedSource | WebAssembly.Instance | WebAssembly.Instance['exports'];
+type OnigurumaLoadOptions = {
+  instantiator: WebAssemblyInstantiator;
+} | {
+  default: WebAssemblyInstantiator;
+} | {
+  data: ArrayBufferView | ArrayBuffer | Response;
+};
+type LoadWasmOptionsPlain = OnigurumaLoadOptions | WebAssemblyInstantiator | ArrayBufferView | ArrayBuffer | Response;
+type LoadWasmOptions = Awaitable<LoadWasmOptionsPlain> | (() => Awaitable<LoadWasmOptionsPlain>);
+
+export type { LoadWasmOptions as L, RegexEngine as R, WebAssemblyInstantiator as W };

package/node_modules/@shikijs/engine-oniguruma/dist/index.d.mts

@@ -0,0 +1,16 @@
+import { L as LoadWasmOptions, R as RegexEngine } from './chunk-index.d.mjs';
+
+declare function loadWasm(options: LoadWasmOptions): Promise<void>;
+
+/**
+ * Set the default wasm loader for `loadWasm`.
+ * @internal
+ */
+declare function setDefaultWasmLoader(_loader: LoadWasmOptions): void;
+/**
+ * @internal
+ */
+declare function getDefaultWasmLoader(): LoadWasmOptions | undefined;
+declare function createOnigurumaEngine(options?: LoadWasmOptions | null): Promise<RegexEngine>;
+
+export { createOnigurumaEngine, getDefaultWasmLoader, loadWasm, setDefaultWasmLoader };