ventojs 0.6.0

package/esm/deps/deno.land/std@0.190.0/testing/asserts.d.ts

@@ -0,0 +1,284 @@
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ */
+export declare function equal(c: unknown, d: unknown): boolean;
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+/** Make an assertion, error will be thrown if `expr` have truthy value. */
+type Falsy = false | 0 | 0n | "" | null | undefined;
+export declare function assertFalse(expr: unknown, msg?: string): asserts expr is Falsy;
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("example", function (): void {
+ *   assertEquals("world", "world");
+ *   assertEquals({ hello: "world" }, { hello: "world" });
+ * });
+ * ```
+ */
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertNotEquals<number>(1, 2)
+ * ```
+ */
+export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal. If
+ * not then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("isStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = a;
+ *   assertStrictEquals(a, b);
+ * });
+ *
+ * // This test fails
+ * Deno.test("isNotStrictlyEqual", function (): void {
+ *   const a = {};
+ *   const b = {};
+ *   assertStrictEquals(a, b);
+ * });
+ * ```
+ */
+export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal.
+ * If the values are strictly equal then throw.
+ *
+ * ```ts
+ * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertNotStrictEquals(1, 1)
+ * ```
+ */
+export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers through
+ * a given tolerance. It can be used to take into account IEEE-754 double-precision
+ * floating-point representation limitations.
+ * If the values are not almost equal then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertAlmostEquals, assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertAlmostEquals(0.1, 0.2);
+ *
+ * // Using a custom tolerance value
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
+ * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
+ * ```
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+type AnyConstructor = new (...args: any[]) => any;
+type GetConstructorType<T extends AnyConstructor> = T extends new (...args: any) => infer C ? C : never;
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ */
+export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is GetConstructorType<T>;
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ */
+export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+/**
+ * Make an assertion that `actual` includes the `expected` values.
+ * If not then an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ *
+ * @example
+ * ```ts
+ * import { assertArrayIncludes } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * assertArrayIncludes<number>([1, 2], [2])
+ * ```
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ */
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;
+/**
+ * Forcefully throws a failed assertion
+ */
+export declare function fail(msg?: string): never;
+/**
+ * Make an assertion that `error` is an `Error`.
+ * If not then an error will be thrown.
+ * An error class and a string that should be included in the
+ * error message can also be asserted.
+ */
+export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): asserts error is E;
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws.
+ *
+ * @example
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   });
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ */
+export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws. An error class and a string that should be included in the
+ * error message can also be asserted.
+ *
+ * @example
+ *
+ * ```ts
+ * import { assertThrows } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", function (): void {
+ *   assertThrows((): void => {
+ *     throw new TypeError("hello world!");
+ *   }, TypeError);
+ *   assertThrows(
+ *     (): void => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *     TypeError,
+ *     "hello",
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", function (): void {
+ *   assertThrows((): void => {
+ *     console.log("Hello world");
+ *   });
+ * });
+ * ```
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *   );
+ *   await assertRejects(
+ *     async () => {
+ *       return Promise.reject(new Error());
+ *     },
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       console.log("Hello world");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+export declare function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ * If it does not, then it throws. An error class and a string that should be
+ * included in the error message can also be asserted.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * Deno.test("doesThrow", async function () {
+ *   await assertRejects(async () => {
+ *     throw new TypeError("hello world!");
+ *   }, TypeError);
+ *   await assertRejects(
+ *     async () => {
+ *       throw new TypeError("hello world!");
+ *     },
+ *     TypeError,
+ *     "hello",
+ *   );
+ * });
+ *
+ * // This test will not pass.
+ * Deno.test("fails", async function () {
+ *   await assertRejects(
+ *     async () => {
+ *       console.log("Hello world");
+ *     },
+ *   );
+ * });
+ * ```
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;
+/** Use this to stub out methods that will throw when invoked. */
+export declare function unimplemented(msg?: string): never;
+/** Use this to assert unreachable code. */
+export declare function unreachable(): never;
+export {};

package/esm/deps/deno.land/std@0.190.0/yaml/_error.d.ts

@@ -0,0 +1,6 @@
+import type { Mark } from "./_mark.js";
+export declare class YAMLError extends Error {
+    protected mark: Mark | string;
+    constructor(message?: string, mark?: Mark | string);
+    toString(_compact: boolean): string;
+}

package/esm/deps/deno.land/std@0.190.0/yaml/_loader/loader.d.ts

@@ -0,0 +1,4 @@
+import { LoaderStateOptions } from "./loader_state.js";
+export type CbFunction = (doc: unknown) => void;
+export declare function loadAll<T extends CbFunction | LoaderStateOptions>(input: string, iteratorOrOption?: T, options?: LoaderStateOptions): T extends CbFunction ? void : unknown[];
+export declare function load(input: string, options?: LoaderStateOptions): unknown;

package/esm/deps/deno.land/std@0.190.0/yaml/_loader/loader_state.d.ts

@@ -0,0 +1,43 @@
+import type { YAMLError } from "../_error.js";
+import type { SchemaDefinition, TypeMap } from "../schema.js";
+import { State } from "../_state.js";
+import type { Type } from "../type.js";
+import type { Any, ArrayObject } from "../_utils.js";
+export interface LoaderStateOptions {
+    legacy?: boolean;
+    listener?: ((...args: Any[]) => void) | null;
+    /** string to be used as a file path in error/warning messages. */
+    filename?: string;
+    /** specifies a schema to use. */
+    schema?: SchemaDefinition;
+    /** compatibility with JSON.parse behaviour. */
+    json?: boolean;
+    /** function to call on warning messages. */
+    onWarning?(this: null, e?: YAMLError): void;
+}
+export type ResultType = any[] | Record<string, any> | string;
+export declare class LoaderState extends State {
+    input: string;
+    documents: Any[];
+    length: number;
+    lineIndent: number;
+    lineStart: number;
+    position: number;
+    line: number;
+    filename?: string;
+    onWarning?: (...args: Any[]) => void;
+    legacy: boolean;
+    json: boolean;
+    listener?: ((...args: Any[]) => void) | null;
+    implicitTypes: Type[];
+    typeMap: TypeMap;
+    version?: string | null;
+    checkLineBreaks?: boolean;
+    tagMap?: ArrayObject;
+    anchorMap?: ArrayObject;
+    tag?: string | null;
+    anchor?: string | null;
+    kind?: string | null;
+    result: ResultType | null;
+    constructor(input: string, { filename, schema, onWarning, legacy, json, listener, }: LoaderStateOptions);
+}

package/esm/deps/deno.land/std@0.190.0/yaml/_mark.d.ts

@@ -0,0 +1,10 @@
+export declare class Mark {
+    name: string;
+    buffer: string;
+    position: number;
+    line: number;
+    column: number;
+    constructor(name: string, buffer: string, position: number, line: number, column: number);
+    getSnippet(indent?: number, maxLength?: number): string | null;
+    toString(compact?: boolean): string;
+}

package/esm/deps/deno.land/std@0.190.0/yaml/_state.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaDefinition } from "./schema.js";
+export declare abstract class State {
+    schema: SchemaDefinition;
+    constructor(schema?: SchemaDefinition);
+}

package/esm/deps/deno.land/std@0.190.0/yaml/_type/binary.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const binary: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/bool.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const bool: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/float.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const float: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/function.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const func: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/int.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const int: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/map.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const map: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/merge.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const merge: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/mod.d.ts

@@ -0,0 +1,16 @@
+export { binary } from "./binary.js";
+export { bool } from "./bool.js";
+export { float } from "./float.js";
+export { func } from "./function.js";
+export { int } from "./int.js";
+export { map } from "./map.js";
+export { merge } from "./merge.js";
+export { nil } from "./nil.js";
+export { omap } from "./omap.js";
+export { pairs } from "./pairs.js";
+export { regexp } from "./regexp.js";
+export { seq } from "./seq.js";
+export { set } from "./set.js";
+export { str } from "./str.js";
+export { timestamp } from "./timestamp.js";
+export { undefinedType } from "./undefined.js";

package/esm/deps/deno.land/std@0.190.0/yaml/_type/nil.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const nil: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/omap.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const omap: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/pairs.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const pairs: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/regexp.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const regexp: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/seq.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const seq: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/set.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const set: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/str.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const str: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/timestamp.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const timestamp: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_type/undefined.d.ts

@@ -0,0 +1,2 @@
+import { Type } from "../type.js";
+export declare const undefinedType: Type;

package/esm/deps/deno.land/std@0.190.0/yaml/_utils.d.ts

@@ -0,0 +1,19 @@
+export type Any = any;
+export declare function isNothing(subject: unknown): subject is never;
+export declare function isArray(value: unknown): value is Any[];
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isNull(value: unknown): value is null;
+export declare function isNumber(value: unknown): value is number;
+export declare function isString(value: unknown): value is string;
+export declare function isSymbol(value: unknown): value is symbol;
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function isError(e: unknown): boolean;
+export declare function isFunction(value: unknown): value is () => void;
+export declare function isRegExp(value: unknown): value is RegExp;
+export declare function toArray<T>(sequence: T): T | [] | [T];
+export declare function repeat(str: string, count: number): string;
+export declare function isNegativeZero(i: number): boolean;
+export interface ArrayObject<T = Any> {
+    [P: string]: T;
+}

package/esm/deps/deno.land/std@0.190.0/yaml/parse.d.ts

@@ -0,0 +1,35 @@
+import { CbFunction } from "./_loader/loader.js";
+import type { LoaderStateOptions } from "./_loader/loader_state.js";
+export type ParseOptions = LoaderStateOptions;
+/**
+ * Parses `content` as single YAML document.
+ *
+ * Returns a JavaScript object or throws `YAMLError` on error.
+ * By default, does not support regexps, functions and undefined. This method is safe for untrusted data.
+ */
+export declare function parse(content: string, options?: ParseOptions): unknown;
+/**
+ * Same as `parse()`, but understands multi-document sources.
+ * Applies iterator to each document if specified, or returns array of documents.
+ *
+ * @example
+ * ```ts
+ * import { parseAll } from "https://deno.land/std@$STD_VERSION/yaml/parse.ts";
+ *
+ * const data = parseAll(`
+ * ---
+ * id: 1
+ * name: Alice
+ * ---
+ * id: 2
+ * name: Bob
+ * ---
+ * id: 3
+ * name: Eve
+ * `);
+ * console.log(data);
+ * // => [ { id: 1, name: "Alice" }, { id: 2, name: "Bob" }, { id: 3, name: "Eve" } ]
+ * ```
+ */
+export declare function parseAll(content: string, iterator: CbFunction, options?: ParseOptions): void;
+export declare function parseAll(content: string, options?: ParseOptions): unknown;

package/esm/deps/deno.land/std@0.190.0/yaml/schema/core.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../schema.js";
+export declare const core: Schema;

package/esm/deps/deno.land/std@0.190.0/yaml/schema/default.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../schema.js";
+export declare const def: Schema;

package/esm/deps/deno.land/std@0.190.0/yaml/schema/extended.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from "../schema.js";
+/***
+ * Extends JS-YAML default schema with additional JavaScript types
+ * It is not described in the YAML specification.
+ * Functions are no longer supported for security reasons.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   EXTENDED_SCHEMA,
+ *   parse,
+ * } from "https://deno.land/std@$STD_VERSION/yaml/mod.ts";
+ *
+ * const data = parse(
+ *   `
+ *   regexp:
+ *     simple: !!js/regexp foobar
+ *     modifiers: !!js/regexp /foobar/mi
+ *   undefined: !!js/undefined ~
+ * # Disabled, see: https://github.com/denoland/deno_std/pull/1275
+ * #  function: !!js/function >
+ * #    function foobar() {
+ * #      return 'hello world!';
+ * #    }
+ * `,
+ *   { schema: EXTENDED_SCHEMA },
+ * );
+ * ```
+ */
+export declare const extended: Schema;

package/esm/deps/deno.land/std@0.190.0/yaml/schema/failsafe.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../schema.js";
+export declare const failsafe: Schema;

package/esm/deps/deno.land/std@0.190.0/yaml/schema/json.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../schema.js";
+export declare const json: Schema;

package/esm/deps/deno.land/std@0.190.0/yaml/schema/mod.d.ts

@@ -0,0 +1,5 @@
+export { core as CORE_SCHEMA } from "./core.js";
+export { def as DEFAULT_SCHEMA } from "./default.js";
+export { extended as EXTENDED_SCHEMA } from "./extended.js";
+export { failsafe as FAILSAFE_SCHEMA } from "./failsafe.js";
+export { json as JSON_SCHEMA } from "./json.js";

package/esm/deps/deno.land/std@0.190.0/yaml/schema.d.ts

@@ -0,0 +1,22 @@
+import type { KindType, Type } from "./type.js";
+import type { Any, ArrayObject } from "./_utils.js";
+export type TypeMap = {
+    [k in KindType | "fallback"]: ArrayObject<Type>;
+};
+export declare class Schema implements SchemaDefinition {
+    static SCHEMA_DEFAULT?: Schema;
+    implicit: Type[];
+    explicit: Type[];
+    include: Schema[];
+    compiledImplicit: Type[];
+    compiledExplicit: Type[];
+    compiledTypeMap: TypeMap;
+    constructor(definition: SchemaDefinition);
+    extend(definition: SchemaDefinition): Schema;
+    static create(): void;
+}
+export interface SchemaDefinition {
+    implicit?: Any[];
+    explicit?: Type[];
+    include?: Schema[];
+}

package/esm/deps/deno.land/std@0.190.0/yaml/type.d.ts

@@ -0,0 +1,28 @@
+import type { Any, ArrayObject } from "./_utils.js";
+export type KindType = "sequence" | "scalar" | "mapping";
+export type StyleVariant = "lowercase" | "uppercase" | "camelcase" | "decimal";
+export type RepresentFn = (data: Any, style?: StyleVariant) => Any;
+interface TypeOptions {
+    kind: KindType;
+    resolve?: (data: Any) => boolean;
+    construct?: (data: string) => Any;
+    instanceOf?: Any;
+    predicate?: (data: Record<string, unknown>) => boolean;
+    represent?: RepresentFn | ArrayObject<RepresentFn>;
+    defaultStyle?: StyleVariant;
+    styleAliases?: ArrayObject;
+}
+export declare class Type {
+    tag: string;
+    kind: KindType | null;
+    instanceOf: Any;
+    predicate?: (data: Record<string, unknown>) => boolean;
+    represent?: RepresentFn | ArrayObject<RepresentFn>;
+    defaultStyle?: StyleVariant;
+    styleAliases?: ArrayObject;
+    loadKind?: KindType;
+    constructor(tag: string, options?: TypeOptions);
+    resolve: (data?: Any) => boolean;
+    construct: (data?: Any) => Any;
+}
+export {};

package/esm/deps.d.ts

@@ -0,0 +1 @@
+export * as path from "./deps/deno.land/std@0.178.0/path/mod.js";

package/esm/deps.js

@@ -0,0 +1 @@
+export * as path from "./deps/deno.land/std@0.178.0/path/mod.js";

package/esm/mod.d.ts

@@ -0,0 +1,7 @@
+import { Environment } from "./src/environment.js";
+import { Loader } from "./src/loader.js";
+export interface Options {
+    includes?: string | Loader;
+    dataVarname?: string;
+}
+export default function (options?: Options): Environment;

package/esm/mod.js

@@ -0,0 +1,28 @@
+import * as dntShim from "./_dnt.shims.js";
+import { Environment } from "./src/environment.js";
+import { FileLoader } from "./src/loader.js";
+import ifTag from "./plugins/if.js";
+import forTag from "./plugins/for.js";
+import includeTag from "./plugins/include.js";
+import setTag from "./plugins/set.js";
+import jsTag from "./plugins/js.js";
+import layoutTag from "./plugins/layout.js";
+import escape from "./plugins/escape.js";
+export default function (options = {}) {
+    const loader = typeof options.includes === "object"
+        ? options.includes
+        : new FileLoader(options.includes || dntShim.Deno.cwd());
+    const env = new Environment({
+        loader,
+        dataVarname: options.dataVarname || "it",
+    });
+    // Register basic plugins
+    env.use(ifTag());
+    env.use(forTag());
+    env.use(jsTag());
+    env.use(includeTag());
+    env.use(setTag());
+    env.use(layoutTag());
+    env.use(escape());
+    return env;
+}

package/esm/package.json

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

package/esm/plugins/escape.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;