mu-harness 0.16.3

package/script/harness/npm/src/_dnt.polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};

package/script/harness/npm/src/_dnt.polyfills.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}

package/script/harness/npm/src/agents/index.d.ts

@@ -0,0 +1,4 @@
+export type { Agent } from './types.js';
+export { type AgentRegistry, createAgentRegistry } from './registry.js';
+export { parseAgent } from './parser.js';
+export { loadAgents } from './loader.js';

package/script/harness/npm/src/agents/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgents = exports.parseAgent = exports.createAgentRegistry = void 0;
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "createAgentRegistry", { enumerable: true, get: function () { return registry_js_1.createAgentRegistry; } });
+var parser_js_1 = require("./parser.js");
+Object.defineProperty(exports, "parseAgent", { enumerable: true, get: function () { return parser_js_1.parseAgent; } });
+var loader_js_1 = require("./loader.js");
+Object.defineProperty(exports, "loadAgents", { enumerable: true, get: function () { return loader_js_1.loadAgents; } });

package/script/harness/npm/src/agents/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Agent } from './types.js';
+export declare const loadAgents: (dir: string) => Promise<Agent[]>;

package/script/harness/npm/src/agents/loader.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgents = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const parser_js_1 = require("./parser.js");
+const loadAgents = async (dir) => {
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(dir);
+    }
+    catch {
+        return [];
+    }
+    const files = entries.filter((name) => name.endsWith('.md')).sort();
+    const agents = [];
+    for (const file of files) {
+        try {
+            const source = await (0, promises_1.readFile)((0, node_path_1.join)(dir, file), 'utf-8');
+            agents.push((0, parser_js_1.parseAgent)(source, (0, node_path_1.basename)(file, '.md')));
+        }
+        catch {
+            continue;
+        }
+    }
+    return agents;
+};
+exports.loadAgents = loadAgents;

package/script/harness/npm/src/agents/parser.d.ts

@@ -0,0 +1,2 @@
+import type { Agent } from './types.js';
+export declare const parseAgent: (source: string, fallbackName: string) => Agent;

package/script/harness/npm/src/agents/parser.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAgent = void 0;
+const index_js_1 = require("../common/index.js");
+const parseToolList = (raw) => {
+    if (Array.isArray(raw)) {
+        return raw.filter((entry) => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+    }
+    if (typeof raw === 'string')
+        return raw.split(',').map((part) => part.trim()).filter(Boolean);
+    return undefined;
+};
+const parseAgent = (source, fallbackName) => {
+    const { fields, body } = (0, index_js_1.parseFrontmatter)(source);
+    return {
+        name: (0, index_js_1.str)(fields.name) ?? fallbackName,
+        description: (0, index_js_1.str)(fields.description) ?? '',
+        prompt: body,
+        tools: parseToolList(fields.tools),
+        model: (0, index_js_1.str)(fields.model),
+        extends: (0, index_js_1.str)(fields.extends),
+    };
+};
+exports.parseAgent = parseAgent;

package/script/harness/npm/src/agents/registry.d.ts

@@ -0,0 +1,6 @@
+import type { Agent } from './types.js';
+export interface AgentRegistry {
+    list(): Agent[];
+    get(name: string): Agent | undefined;
+}
+export declare const createAgentRegistry: (agents?: Agent[]) => AgentRegistry;

package/script/harness/npm/src/agents/registry.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentRegistry = void 0;
+const merge = (base, child) => ({
+    name: child.name,
+    description: child.description || base.description,
+    prompt: child.prompt || base.prompt,
+    tools: child.tools ?? base.tools,
+    model: child.model ?? base.model,
+});
+const createAgentRegistry = (agents = []) => {
+    const raw = new Map();
+    for (const agent of agents)
+        if (!raw.has(agent.name))
+            raw.set(agent.name, agent);
+    const resolve = (name, seen) => {
+        const agent = raw.get(name);
+        if (!agent.extends)
+            return agent;
+        if (seen.has(name))
+            throw new Error(`AgentRegistry: "extends" cycle at "${name}"`);
+        const base = raw.get(agent.extends);
+        if (!base)
+            throw new Error(`AgentRegistry: "${name}" extends unknown agent "${agent.extends}"`);
+        return merge(resolve(agent.extends, new Set(seen).add(name)), agent);
+    };
+    const byName = new Map();
+    for (const name of raw.keys())
+        byName.set(name, resolve(name, new Set()));
+    return {
+        list: () => [...byName.values()],
+        get: (name) => byName.get(name),
+    };
+};
+exports.createAgentRegistry = createAgentRegistry;

package/script/harness/npm/src/agents/types.d.ts

@@ -0,0 +1,8 @@
+export interface Agent {
+    name: string;
+    description: string;
+    prompt: string;
+    tools?: string[];
+    model?: string;
+    extends?: string;
+}

package/script/harness/npm/src/agents/types.js

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

package/script/harness/npm/src/channels/channel.d.ts

@@ -0,0 +1,7 @@
+import type { AgentSession } from '../session/index.js';
+import type { Channel } from './types.js';
+export declare const createChannel: (config: {
+    id: string;
+    title: string;
+    createSession: () => AgentSession;
+}) => Channel;

package/script/harness/npm/src/channels/channel.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannel = void 0;
+const index_js_1 = require("../common/index.js");
+const createChannel = (config) => {
+    let session;
+    const emitter = (0, index_js_1.createEmitter)();
+    const ensure = () => {
+        if (!session) {
+            session = config.createSession();
+            session.subscribe(emitter.emit);
+        }
+        return session;
+    };
+    return {
+        id: config.id,
+        title: config.title,
+        get started() {
+            return session !== undefined;
+        },
+        get messages() {
+            return session?.messages ?? [];
+        },
+        send: (input) => ensure().send(input),
+        abort: () => session?.abort(),
+        subscribe: emitter.subscribe,
+    };
+};
+exports.createChannel = createChannel;

package/script/harness/npm/src/channels/index.d.ts

@@ -0,0 +1,3 @@
+export type { Channel, ChannelEvent, ChannelManager, ChannelManagerEvent } from './types.js';
+export { createChannel } from './channel.js';
+export { createChannelManager } from './manager.js';

package/script/harness/npm/src/channels/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelManager = exports.createChannel = void 0;
+var channel_js_1 = require("./channel.js");
+Object.defineProperty(exports, "createChannel", { enumerable: true, get: function () { return channel_js_1.createChannel; } });
+var manager_js_1 = require("./manager.js");
+Object.defineProperty(exports, "createChannelManager", { enumerable: true, get: function () { return manager_js_1.createChannelManager; } });

package/script/harness/npm/src/channels/manager.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSession } from '../session/index.js';
+import type { ChannelManager } from './types.js';
+export declare const createChannelManager: (config: {
+    createSession: () => AgentSession;
+    idGen?: () => string;
+}) => ChannelManager;

package/script/harness/npm/src/channels/manager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelManager = void 0;
+const index_js_1 = require("../common/index.js");
+const channel_js_1 = require("./channel.js");
+const createChannelManager = (config) => {
+    const channels = new Map();
+    const unsubs = new Map();
+    const emitter = (0, index_js_1.createEmitter)();
+    const idGen = config.idGen ?? (() => crypto.randomUUID());
+    return {
+        open(opts) {
+            const id = opts?.id ?? idGen();
+            const title = opts?.title ?? id;
+            const channel = (0, channel_js_1.createChannel)({ id, title, createSession: config.createSession });
+            channels.set(id, channel);
+            unsubs.set(id, channel.subscribe((event) => emitter.emit({ channelId: id, ...event })));
+            emitter.emit({ channelId: id, type: 'channel_open', title });
+            return channel;
+        },
+        get: (id) => channels.get(id),
+        list: () => [...channels.values()],
+        close(id) {
+            unsubs.get(id)?.();
+            unsubs.delete(id);
+            if (channels.delete(id))
+                emitter.emit({ channelId: id, type: 'channel_close' });
+        },
+        subscribe: emitter.subscribe,
+    };
+};
+exports.createChannelManager = createChannelManager;

package/script/harness/npm/src/channels/types.d.ts

@@ -0,0 +1,30 @@
+import type { ContentPart, Message } from 'mu-core';
+import type { AgentSessionEvent } from '../session/index.js';
+export type ChannelEvent = AgentSessionEvent | {
+    type: 'channel_open';
+    title: string;
+} | {
+    type: 'channel_close';
+};
+export type ChannelManagerEvent = {
+    channelId: string;
+} & ChannelEvent;
+export interface Channel {
+    readonly id: string;
+    readonly title: string;
+    readonly started: boolean;
+    readonly messages: readonly Message[];
+    send(input: string | ContentPart[]): Promise<void>;
+    abort(): void;
+    subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+}
+export interface ChannelManager {
+    open(opts?: {
+        id?: string;
+        title?: string;
+    }): Channel;
+    get(id: string): Channel | undefined;
+    list(): Channel[];
+    close(id: string): void;
+    subscribe(listener: (event: ChannelManagerEvent) => void): () => void;
+}

package/script/harness/npm/src/channels/types.js

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

package/script/harness/npm/src/commands/defaults.d.ts

@@ -0,0 +1,9 @@
+import type { AgentRegistry } from '../agents/index.js';
+import type { SessionManager } from '../session/index.js';
+import type { SkillRegistry } from '../skills/index.js';
+import type { Command } from './types.js';
+export declare const createAgentsCommand: (agents: AgentRegistry) => Command;
+export declare const createSkillsCommand: (skills: SkillRegistry) => Command;
+export declare const createSessionsCommand: (sessions: SessionManager) => Command;
+export declare const createQuitCommand: (onQuit: () => void | Promise<void>) => Command;
+export declare const createHelpCommand: (list: () => Command[]) => Command;

package/script/harness/npm/src/commands/defaults.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHelpCommand = exports.createQuitCommand = exports.createSessionsCommand = exports.createSkillsCommand = exports.createAgentsCommand = void 0;
+const createAgentsCommand = (agents) => ({
+    name: 'agents',
+    description: 'List available agents',
+    run: () => {
+        const list = agents.list();
+        if (list.length === 0)
+            return { ok: true, output: 'No agents configured.' };
+        const lines = list.map((a) => `- ${a.name}${a.description ? ` — ${a.description}` : ''}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});
+exports.createAgentsCommand = createAgentsCommand;
+const createSkillsCommand = (skills) => ({
+    name: 'skills',
+    description: 'List available skills',
+    run: () => {
+        const list = skills.list();
+        if (list.length === 0)
+            return { ok: true, output: 'No skills configured.' };
+        const lines = list.map((s) => `- ${s.name}${s.description ? ` — ${s.description}` : ''}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});
+exports.createSkillsCommand = createSkillsCommand;
+const createSessionsCommand = (sessions) => ({
+    name: 'sessions',
+    description: 'List saved sessions',
+    run: async () => {
+        const list = await sessions.list();
+        if (list.length === 0)
+            return { ok: true, output: 'No sessions yet.' };
+        const lines = list.map((s) => `- ${s.title || s.id}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});
+exports.createSessionsCommand = createSessionsCommand;
+const createQuitCommand = (onQuit) => ({
+    name: 'quit',
+    description: 'Exit the session',
+    aliases: ['q'],
+    run: async () => {
+        await onQuit();
+        return { ok: true };
+    },
+});
+exports.createQuitCommand = createQuitCommand;
+const createHelpCommand = (list) => ({
+    name: 'help',
+    description: 'Show available commands',
+    run: () => {
+        const commands = list();
+        if (commands.length === 0)
+            return { ok: true, output: 'No commands registered.' };
+        const lines = commands.map((c) => `/${c.name} — ${c.description}`);
+        return { ok: true, output: lines.join('\n') };
+    },
+});
+exports.createHelpCommand = createHelpCommand;

package/script/harness/npm/src/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { createAgentsCommand, createHelpCommand, createQuitCommand, createSessionsCommand, createSkillsCommand, } from './defaults.js';
+export { createCommandRegistry } from './registry.js';
+export type { Command, CommandContext, CommandRegistry, CommandResult } from './types.js';

package/script/harness/npm/src/commands/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandRegistry = exports.createSkillsCommand = exports.createSessionsCommand = exports.createQuitCommand = exports.createHelpCommand = exports.createAgentsCommand = void 0;
+var defaults_js_1 = require("./defaults.js");
+Object.defineProperty(exports, "createAgentsCommand", { enumerable: true, get: function () { return defaults_js_1.createAgentsCommand; } });
+Object.defineProperty(exports, "createHelpCommand", { enumerable: true, get: function () { return defaults_js_1.createHelpCommand; } });
+Object.defineProperty(exports, "createQuitCommand", { enumerable: true, get: function () { return defaults_js_1.createQuitCommand; } });
+Object.defineProperty(exports, "createSessionsCommand", { enumerable: true, get: function () { return defaults_js_1.createSessionsCommand; } });
+Object.defineProperty(exports, "createSkillsCommand", { enumerable: true, get: function () { return defaults_js_1.createSkillsCommand; } });
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "createCommandRegistry", { enumerable: true, get: function () { return registry_js_1.createCommandRegistry; } });

package/script/harness/npm/src/commands/registry.d.ts

@@ -0,0 +1,2 @@
+import type { Command, CommandRegistry } from './types.js';
+export declare const createCommandRegistry: (commands?: Command[]) => CommandRegistry;

package/script/harness/npm/src/commands/registry.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandRegistry = void 0;
+const createCommandRegistry = (commands = []) => {
+    const byName = new Map();
+    const aliasToName = new Map();
+    const resolve = (name) => byName.get(aliasToName.get(name) ?? name);
+    const register = (command, options = {}) => {
+        const taken = byName.has(command.name) || aliasToName.has(command.name);
+        if (taken && !options.override)
+            throw new Error(`Command "${command.name}" is already registered`);
+        const existing = byName.get(command.name);
+        if (existing) {
+            for (const alias of existing.aliases ?? [])
+                aliasToName.delete(alias);
+        }
+        byName.set(command.name, command);
+        for (const alias of command.aliases ?? []) {
+            if ((byName.has(alias) || aliasToName.has(alias)) && !options.override) {
+                throw new Error(`Command alias "${alias}" collides with an existing name or alias`);
+            }
+            aliasToName.set(alias, command.name);
+        }
+    };
+    for (const command of commands)
+        register(command);
+    const parse = (input) => {
+        const trimmed = input.trimStart();
+        if (!trimmed.startsWith('/'))
+            return undefined;
+        const body = trimmed.slice(1);
+        const firstSpace = body.search(/\s/);
+        const name = firstSpace === -1 ? body : body.slice(0, firstSpace);
+        const args = firstSpace === -1 ? '' : body.slice(firstSpace + 1).trim();
+        const command = resolve(name);
+        return command ? { command, args } : undefined;
+    };
+    return {
+        register,
+        unregister: (name) => {
+            const command = byName.get(name);
+            if (!command)
+                return;
+            byName.delete(name);
+            for (const alias of command.aliases ?? [])
+                aliasToName.delete(alias);
+        },
+        list: () => [...byName.values()],
+        get: resolve,
+        run: async (input, ctx = {}) => {
+            const parsed = parse(input);
+            if (!parsed)
+                return { ok: false, error: `Unknown command: "${input}"` };
+            try {
+                return await parsed.command.run(parsed.args, ctx);
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+};
+exports.createCommandRegistry = createCommandRegistry;

package/script/harness/npm/src/commands/types.d.ts

@@ -0,0 +1,23 @@
+export interface CommandResult {
+    ok: boolean;
+    output?: unknown;
+    error?: string;
+}
+export interface CommandContext {
+    sessionId?: string;
+}
+export interface Command {
+    name: string;
+    description: string;
+    aliases?: string[];
+    run: (args: string, ctx: CommandContext) => CommandResult | Promise<CommandResult>;
+}
+export interface CommandRegistry {
+    register(command: Command, options?: {
+        override?: boolean;
+    }): void;
+    unregister(name: string): void;
+    list(): Command[];
+    get(name: string): Command | undefined;
+    run(input: string, ctx?: CommandContext): Promise<CommandResult>;
+}

package/script/harness/npm/src/commands/types.js

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

package/script/harness/npm/src/common/frontmatter.d.ts

@@ -0,0 +1,6 @@
+export interface Frontmatter {
+    fields: Record<string, unknown>;
+    body: string;
+}
+export declare const parseFrontmatter: (source: string) => Frontmatter;
+export declare const str: (value: unknown) => string | undefined;

package/script/harness/npm/src/common/frontmatter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.str = exports.parseFrontmatter = void 0;
+const mod_js_1 = require("../deps/jsr.io/@std/yaml/1.1.0/mod.js");
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+const parseFrontmatter = (source) => {
+    const match = source.match(FRONTMATTER);
+    let fields = {};
+    if (match) {
+        try {
+            const parsed = (0, mod_js_1.parse)(match[1]);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                fields = parsed;
+        }
+        catch {
+            fields = {};
+        }
+    }
+    return { fields, body: (match ? match[2] : source).trim() };
+};
+exports.parseFrontmatter = parseFrontmatter;
+const str = (value) => (typeof value === 'string' ? value : undefined);
+exports.str = str;

package/script/harness/npm/src/common/index.d.ts

@@ -0,0 +1,2 @@
+export { createEmitter, type Emitter } from './utils.js';
+export { type Frontmatter, parseFrontmatter, str } from './frontmatter.js';

package/script/harness/npm/src/common/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.str = exports.parseFrontmatter = exports.createEmitter = void 0;
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "createEmitter", { enumerable: true, get: function () { return utils_js_1.createEmitter; } });
+var frontmatter_js_1 = require("./frontmatter.js");
+Object.defineProperty(exports, "parseFrontmatter", { enumerable: true, get: function () { return frontmatter_js_1.parseFrontmatter; } });
+Object.defineProperty(exports, "str", { enumerable: true, get: function () { return frontmatter_js_1.str; } });

package/script/harness/npm/src/common/utils.d.ts

@@ -0,0 +1,5 @@
+export interface Emitter<T> {
+    emit(event: T): void;
+    subscribe(listener: (event: T) => void): () => void;
+}
+export declare const createEmitter: <T>() => Emitter<T>;

package/script/harness/npm/src/common/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmitter = void 0;
+const createEmitter = () => {
+    const listeners = new Set();
+    return {
+        emit: (event) => {
+            for (const listener of listeners)
+                listener(event);
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+};
+exports.createEmitter = createEmitter;

package/script/harness/npm/src/config/index.d.ts

@@ -0,0 +1,2 @@
+export type { HarnessConfig, HarnessConfigOptions, XdgDirs } from './types.js';
+export { createHarnessConfig } from './resolve.js';

package/script/harness/npm/src/config/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarnessConfig = void 0;
+var resolve_js_1 = require("./resolve.js");
+Object.defineProperty(exports, "createHarnessConfig", { enumerable: true, get: function () { return resolve_js_1.createHarnessConfig; } });

package/script/harness/npm/src/config/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { HarnessConfig, HarnessConfigOptions } from './types.js';
+export declare const createHarnessConfig: (options: HarnessConfigOptions) => HarnessConfig;

package/script/harness/npm/src/config/resolve.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHarnessConfig = void 0;
+const node_path_1 = require("node:path");
+const createHarnessConfig = (options) => {
+    const { hostName, xdg } = options;
+    return {
+        hostName,
+        configDir: (0, node_path_1.join)(xdg.configHome, hostName),
+        dataDir: (0, node_path_1.join)(xdg.dataHome, hostName),
+        stateDir: (0, node_path_1.join)(xdg.stateHome, hostName),
+    };
+};
+exports.createHarnessConfig = createHarnessConfig;

package/script/harness/npm/src/config/types.d.ts

@@ -0,0 +1,15 @@
+export interface XdgDirs {
+    configHome: string;
+    dataHome: string;
+    stateHome: string;
+}
+export interface HarnessConfigOptions {
+    hostName: string;
+    xdg: XdgDirs;
+}
+export interface HarnessConfig {
+    hostName: string;
+    configDir: string;
+    dataDir: string;
+    stateDir: string;
+}

package/script/harness/npm/src/config/types.js

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

package/script/harness/npm/src/deps/jsr.io/@std/yaml/1.1.0/_chars.d.ts

@@ -0,0 +1,32 @@
+export declare const BOM = 65279;
+export declare const TAB = 9;
+export declare const LINE_FEED = 10;
+export declare const CARRIAGE_RETURN = 13;
+export declare const SPACE = 32;
+export declare const EXCLAMATION = 33;
+export declare const DOUBLE_QUOTE = 34;
+export declare const SHARP = 35;
+export declare const PERCENT = 37;
+export declare const AMPERSAND = 38;
+export declare const SINGLE_QUOTE = 39;
+export declare const ASTERISK = 42;
+export declare const PLUS = 43;
+export declare const COMMA = 44;
+export declare const MINUS = 45;
+export declare const DOT = 46;
+export declare const COLON = 58;
+export declare const SMALLER_THAN = 60;
+export declare const GREATER_THAN = 62;
+export declare const QUESTION = 63;
+export declare const COMMERCIAL_AT = 64;
+export declare const LEFT_SQUARE_BRACKET = 91;
+export declare const BACKSLASH = 92;
+export declare const RIGHT_SQUARE_BRACKET = 93;
+export declare const GRAVE_ACCENT = 96;
+export declare const LEFT_CURLY_BRACKET = 123;
+export declare const VERTICAL_LINE = 124;
+export declare const RIGHT_CURLY_BRACKET = 125;
+export declare function isEOL(c: number): boolean;
+export declare function isWhiteSpace(c: number): boolean;
+export declare function isWhiteSpaceOrEOL(c: number): boolean;
+export declare function isFlowIndicator(c: number): boolean;